Struct PrepareFightWaves

pub struct PrepareFightWaves {
    pub entities: Vec<PrepareFightEntityPower>,
    pub waves: Vec<Vec<PrepareFightSpawn>>,
    pub time: f64,
    pub power: f64,
    pub stream_active_count: Option<u64>,
    pub summon_wave_at_hp_fraction: Option<f64>,
    pub reward_mob_budget: Option<u64>,
    pub enemy_damage_mult: Option<f64>,
}

Typed, config-level mirror of overlord_event_system’s WaveFightData (the shape prepare_fight_script builds inline and passes to ctx.spawn_wave). Holds the wave data as typed config — pure data, no combat and no RNG. Field optionality mirrors WaveFightData exactly.

Fields

entities: Vec<PrepareFightEntityPower>

waves: Vec<Vec<PrepareFightSpawn>>

time: f64

power: f64

stream_active_count: Option<u64>

Streaming wave entry (docs/combat-feel-porting-plan.md, phase 3): when set, only this many mobs of a wave are on the field at once — the rest wait in a pool and run in one-per-death. None (null in config) = the previous behaviour bit-for-bit (the whole wave spawns at once).

summon_wave_at_hp_fraction: Option<f64>

Boss summon (owner 2026-07-10): when set, the LAST wave of the template is a summon wave — it never spawns on wave clear; it spawns the moment a boss drops below this fraction of max HP (anchored at the player, normal entrance runs). Boss killed before the trigger ⇒ the wave is skipped and the fight ends. None = no summon wave, all waves behave as before.

reward_mob_budget: Option<u64>

Reward/weight budget for the fight (growing-enemy-waves plan §2): “this fight pays out / weighs as if it had N mobs”. The content migrator writes each fight’s ORIGINAL total mob count here when it inflates concurrency. spawn_wave stamps each mob with wave_share = reward_mob_budget / actual_total_mob_count (per-10000 i64) so per-kill drop chance, pet-ult charge fill and counterattack procs stay count-invariant. None (null) ⇒ share 1.0 (all existing content bit-identical). Does NOT touch mob HP/attack — the wave normalization already handles stats.

enemy_damage_mult: Option<f64>

Per-fight enemy damage multiplier: scales this fight’s DAMAGE budget (eff_hp in spawn_wave) only — mob HP, fight length and loot pacing stay unchanged. Compensates fight shapes whose sustained concurrency (many mobs on field at once) delivers the same total damage in a less survivable profile. None (null) ⇒ 1.0 (no change).

Trait Implementations

impl Clone for PrepareFightWaves

fn clone(&self) -> PrepareFightWaves

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PrepareFightWaves

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PrepareFightWaves

fn default() -> PrepareFightWaves

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PrepareFightWaves

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for PrepareFightWaves

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl PartialEq for PrepareFightWaves

fn eq(&self, other: &PrepareFightWaves) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for PrepareFightWaves

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Tsify for PrepareFightWaves

const DECL: &'static str = "/**\n * Typed, config-level mirror of `overlord_event_system`\\\'s `WaveFightData` (the\n * shape `prepare_fight_script` builds inline and passes to `ctx.spawn_wave`).\n * Holds the wave data as typed config \u{2014} pure data, no combat and no RNG. Field\n * optionality mirrors `WaveFightData` exactly.\n */\nexport interface PrepareFightWaves {\n entities: PrepareFightEntityPower[];\n waves: PrepareFightSpawn[][];\n time: number;\n power?: number;\n /**\n * Streaming wave entry (docs/combat-feel-porting-plan.md, phase 3): when set, only this many\n * mobs of a wave are on the field at once \u{2014} the rest wait in a pool and run in one-per-death.\n * `None` (`null` in config) = the previous behaviour bit-for-bit (the whole wave spawns at\n * once).\n */\n stream_active_count: number | null;\n /**\n * Boss summon (owner 2026-07-10): when set, the LAST wave of the template\n * is a summon wave \u{2014} it never spawns on wave clear; it spawns the moment a\n * boss drops below this fraction of max HP (anchored at the player, normal\n * entrance runs). Boss killed before the trigger \u{21d2} the wave is skipped and\n * the fight ends. `None` = no summon wave, all waves behave as before.\n */\n summon_wave_at_hp_fraction: number | null;\n /**\n * Reward/weight budget for the fight (growing-enemy-waves plan \u{a7}2): \\\"this\n * fight pays out / weighs as if it had N mobs\\\". The content migrator writes\n * each fight\\\'s ORIGINAL total mob count here when it inflates concurrency.\n * `spawn_wave` stamps each mob with `wave_share = reward_mob_budget /\n * actual_total_mob_count` (per-10000 i64) so per-kill drop chance, pet-ult\n * charge fill and counterattack procs stay count-invariant. `None` (`null`)\n * \u{21d2} share 1.0 (all existing content bit-identical). Does NOT touch mob\n * HP/attack \u{2014} the wave normalization already handles stats.\n */\n reward_mob_budget: number | null;\n /**\n * Per-fight enemy damage multiplier: scales this fight\\\'s DAMAGE budget\n * (`eff_hp` in `spawn_wave`) only \u{2014} mob HP, fight length and loot pacing\n * stay unchanged. Compensates fight shapes whose sustained concurrency\n * (many mobs on field at once) delivers the same total damage in a less\n * survivable profile. `None` (`null`) \u{21d2} 1.0 (no change).\n */\n enemy_damage_mult: number | null;\n}"

const SERIALIZATION_CONFIG: SerializationConfig

type JsType = JsType

fn into_js(&self) -> Result<Self::JsType, Error>

where Self: Serialize,

fn from_js<T>(js: T) -> Result<Self, Error>

where T: Into<JsValue>, Self: DeserializeOwned,

impl StructuralPartialEq for PrepareFightWaves