Properties calc port for 1.7beta (#7)

Reviewed-on: #7
Co-authored-by: traffic95 <traffic95@xeondev.com>
Co-committed-by: traffic95 <traffic95@xeondev.com>

crates/battle-server/src/logic/dungeon.rs

@@ -1,7 +1,10 @@
+use std::collections::HashMap;
+
 use trigger_protocol::DungeonEquipInfo;
 
 pub struct AvatarUnit {
     pub avatar_id: u32,
+    pub properties: HashMap<u32, i32>,
 }
 
 pub struct BuddyUnit {
@@ -29,6 +32,7 @@ impl Dungeon {
                 .iter()
                 .map(|unit| AvatarUnitInfo {
                     avatar_id: unit.avatar_id,
+                    properties: unit.properties.clone(),
                 })
                 .collect(),
             buddy_list: self

crates/battle-server/src/logic/mod.rs

@@ -1,4 +1,5 @@
 mod dungeon;
+mod property_util;
 
 pub use dungeon::*;
 pub mod scene;
@@ -39,7 +40,14 @@ impl GameState {
                     quest_id: *quest_id,
                     avatar_list: avatar_id_list
                         .iter()
-                        .map(|&avatar_id| AvatarUnit { avatar_id })
+                        .map(|&avatar_id| AvatarUnit {
+                            avatar_id,
+                            properties: property_util::calculate_for_avatar(
+                                avatar_id,
+                                filecfg,
+                                dungeon_equip,
+                            ),
+                        })
                         .collect(),
                     buddy_list: vec![BuddyUnit {
                         buddy_type: 0,
@@ -71,7 +79,14 @@ impl GameState {
                     quest_id: *quest_id,
                     avatar_list: avatar_id_list
                         .iter()
-                        .map(|&avatar_id| AvatarUnit { avatar_id })
+                        .map(|&avatar_id| AvatarUnit {
+                            avatar_id,
+                            properties: property_util::calculate_for_avatar(
+                                avatar_id,
+                                filecfg,
+                                dungeon_equip,
+                            ),
+                        })
                         .collect(),
                     buddy_list: vec![BuddyUnit {
                         buddy_type: 0,

crates/battle-server/src/logic/property_util.rs

@@ -0,0 +1,717 @@
+use std::collections::HashMap;
+
+use trigger_fileconfig::{
+    AvatarBattleTemplate, AvatarLevelAdvanceTemplate, AvatarPassiveSkillTemplate, NapFileCfg,
+    WeaponLevelTemplate, WeaponStarTemplate, WeaponTemplate,
+};
+use trigger_logic::{battle::EPropertyType, skill::EAvatarSkillType};
+use trigger_protocol::{Avatar, DungeonEquipInfo, Equip, Weapon};
+
+struct AvatarFileCfg<'a> {
+    pub avatar_battle_template: AvatarBattleTemplate<'a>,
+    pub avatar_passive_skill_templates: Vec<AvatarPassiveSkillTemplate<'a>>,
+    pub avatar_level_advances: Vec<AvatarLevelAdvanceTemplate<'a>>,
+}
+
+struct WeaponFileCfg<'a> {
+    pub weapon_template: WeaponTemplate<'a>,
+    pub weapon_level_template: WeaponLevelTemplate<'a>,
+    pub weapon_star_template: WeaponStarTemplate<'a>,
+}
+
+const BEN_AVATAR_ID: u32 = 1121;
+const BEN_CORE_PASSIVE_PERCENTAGE: [i32; 7] = [40, 46, 52, 60, 66, 72, 80];
+
+pub fn calculate_for_avatar(
+    avatar_id: u32,
+    filecfg: &'static NapFileCfg,
+    dungeon_equip: &DungeonEquipInfo,
+) -> HashMap<u32, i32> {
+    let mut calculated_properties = HashMap::<_, _>::new();
+    let Some(player_avatar) = dungeon_equip
+        .avatar_list
+        .iter()
+        .find(|a| (*a).id == avatar_id)
+    else {
+        return calculated_properties;
+    };
+    let Some(avatar_file_cfg) = get_avatar_filecfg(avatar_id, filecfg) else {
+        return calculated_properties;
+    };
+    insert_avatar_battle_template_properties(&avatar_file_cfg, &mut calculated_properties);
+    insert_avatar_battle_level_advance_properties(
+        &avatar_file_cfg,
+        player_avatar,
+        &mut calculated_properties,
+    );
+    perform_avatar_growth_promotion_calculations(player_avatar, &mut calculated_properties);
+    add_avatar_passive_skill_properties(
+        &avatar_file_cfg,
+        player_avatar,
+        &mut calculated_properties,
+    );
+    let player_weapon = dungeon_equip
+        .weapon_list
+        .iter()
+        .find(|w| w.uid == player_avatar.cur_weapon_uid);
+    if player_weapon.is_some() {
+        match get_weapon_filecfg(player_weapon.unwrap(), filecfg) {
+            Some(weapon_file_cfg) => {
+                add_weapon_template_properties(&weapon_file_cfg, &mut calculated_properties);
+            }
+            None => {}
+        };
+    }
+    let player_dressed_equip_uids: Vec<u32> = player_avatar
+        .dressed_equip_list
+        .iter()
+        .map(|de| de.equip_uid)
+        .collect();
+    let player_equips: Vec<&Equip> = dungeon_equip
+        .equip_list
+        .iter()
+        .filter(|e| player_dressed_equip_uids.contains(&e.uid))
+        .collect();
+    if player_equips.len() > 0 {
+        add_player_equip_properties(&player_equips, filecfg, &mut calculated_properties);
+        add_equipment_suit_properties(&player_equips, filecfg, &mut calculated_properties);
+    }
+    calculate_final_properties(&mut calculated_properties);
+    add_ben_core_passive(avatar_id, player_avatar, &mut calculated_properties);
+    remove_custom_properties(&mut calculated_properties);
+    set_battle_properties(&mut calculated_properties);
+
+    calculated_properties
+}
+
+fn get_avatar_filecfg(
+    avatar_id: u32,
+    filecfg: &'static NapFileCfg,
+) -> Option<AvatarFileCfg<'static>> {
+    let Some(avatar_battle_template) = filecfg
+        .avatar_battle_template_tb()
+        .data()
+        .unwrap()
+        .iter()
+        .find(|tmpl| tmpl.id() == avatar_id as i32)
+    else {
+        return None;
+    };
+
+    let avatar_passive_skill_templates: Vec<AvatarPassiveSkillTemplate> = filecfg
+        .avatar_passive_skill_template_tb()
+        .data()
+        .unwrap()
+        .iter()
+        .filter(|tmpl| tmpl.avatar_id() == avatar_id as i32)
+        .collect();
+    if avatar_passive_skill_templates.len() == 0 {
+        return None;
+    }
+
+    let avatar_level_advances: Vec<AvatarLevelAdvanceTemplate> = filecfg
+        .avatar_level_advance_template_tb()
+        .data()
+        .unwrap()
+        .iter()
+        .filter(|tmpl| tmpl.avatar_id() == avatar_id as i32)
+        .collect();
+    if avatar_level_advances.len() == 0 {
+        return None;
+    }
+
+    Some(AvatarFileCfg {
+        avatar_battle_template,
+        avatar_passive_skill_templates,
+        avatar_level_advances,
+    })
+}
+
+fn insert_avatar_battle_template_properties(
+    avatar_file_cfg: &AvatarFileCfg,
+    properties: &mut HashMap<u32, i32>,
+) {
+    properties.insert(
+        EPropertyType::HpMaxBase.into(),
+        avatar_file_cfg.avatar_battle_template.hp_max(),
+    );
+    properties.insert(
+        EPropertyType::HpMaxGrowth.into(),
+        avatar_file_cfg.avatar_battle_template.health_growth(),
+    );
+    properties.insert(
+        EPropertyType::AtkBase.into(),
+        avatar_file_cfg.avatar_battle_template.attack(),
+    );
+    properties.insert(
+        EPropertyType::AtkGrowth.into(),
+        avatar_file_cfg.avatar_battle_template.attack_growth(),
+    );
+    properties.insert(
+        EPropertyType::BreakStunBase.into(),
+        avatar_file_cfg.avatar_battle_template.break_stun(),
+    );
+    properties.insert(
+        EPropertyType::DefBase.into(),
+        avatar_file_cfg.avatar_battle_template.defence(),
+    );
+    properties.insert(
+        EPropertyType::DefGrowth.into(),
+        avatar_file_cfg.avatar_battle_template.defence_growth(),
+    );
+    properties.insert(
+        EPropertyType::CritBase.into(),
+        avatar_file_cfg.avatar_battle_template.crit(),
+    );
+    properties.insert(
+        EPropertyType::CritDmgBase.into(),
+        avatar_file_cfg.avatar_battle_template.crit_damage(),
+    );
+    properties.insert(
+        EPropertyType::PenBase.into(),
+        avatar_file_cfg.avatar_battle_template.pen_rate(),
+    );
+    properties.insert(
+        EPropertyType::PenValueBase.into(),
+        avatar_file_cfg.avatar_battle_template.pen_delta(),
+    );
+    properties.insert(
+        EPropertyType::SpRecoverBase.into(),
+        avatar_file_cfg.avatar_battle_template.sp_recover(),
+    );
+    properties.insert(
+        EPropertyType::ElementMysteryBase.into(),
+        avatar_file_cfg.avatar_battle_template.element_mystery(),
+    );
+    properties.insert(
+        EPropertyType::ElementAbnormalPowerBase.into(),
+        avatar_file_cfg
+            .avatar_battle_template
+            .element_abnormal_power(),
+    );
+}
+
+fn insert_avatar_battle_level_advance_properties(
+    avatar_file_cfg: &AvatarFileCfg,
+    player_avatar: &Avatar,
+    properties: &mut HashMap<u32, i32>,
+) {
+    let Some(avatar_level_advance) = avatar_file_cfg
+        .avatar_level_advances
+        .iter()
+        .find(|tmpl| tmpl.id() == player_avatar.rank as i32)
+    else {
+        properties.insert(EPropertyType::HpMaxAdvance.into(), 0);
+        properties.insert(EPropertyType::AtkAdvance.into(), 0);
+        properties.insert(EPropertyType::DefAdvance.into(), 0);
+
+        return;
+    };
+
+    properties.insert(
+        EPropertyType::HpMaxAdvance.into(),
+        avatar_level_advance.hp_max(),
+    );
+    properties.insert(
+        EPropertyType::AtkAdvance.into(),
+        avatar_level_advance.attack(),
+    );
+    properties.insert(
+        EPropertyType::DefAdvance.into(),
+        avatar_level_advance.defence(),
+    );
+}
+
+fn perform_avatar_growth_promotion_calculations(
+    player_avatar: &Avatar,
+    properties: &mut HashMap<u32, i32>,
+) {
+    properties.insert(
+        EPropertyType::HpMaxBase.into(),
+        properties.get(&EPropertyType::HpMaxBase.into()).unwrap()
+            + (((player_avatar.level - 1) as f32
+                * *properties.get(&EPropertyType::HpMaxGrowth.into()).unwrap() as f32)
+                / 10000f32) as i32
+            + properties.get(&EPropertyType::HpMaxAdvance.into()).unwrap(),
+    );
+    properties.insert(
+        EPropertyType::AtkBase.into(),
+        properties.get(&EPropertyType::AtkBase.into()).unwrap()
+            + (((player_avatar.level - 1) as f32
+                * *properties.get(&EPropertyType::AtkGrowth.into()).unwrap() as f32)
+                / 10000f32) as i32
+            + properties.get(&EPropertyType::AtkAdvance.into()).unwrap(),
+    );
+    properties.insert(
+        EPropertyType::DefBase.into(),
+        properties.get(&EPropertyType::DefBase.into()).unwrap()
+            + (((player_avatar.level - 1) as f32
+                * *properties.get(&EPropertyType::DefGrowth.into()).unwrap() as f32)
+                / 10000f32) as i32
+            + properties.get(&EPropertyType::DefAdvance.into()).unwrap(),
+    );
+}
+
+fn add_avatar_passive_skill_properties(
+    avatar_file_cfg: &AvatarFileCfg,
+    player_avatar: &Avatar,
+    properties: &mut HashMap<u32, i32>,
+) {
+    let passive_skill_level = player_avatar
+        .skill_type_level
+        .iter()
+        .find(|s| s.skill_type == EAvatarSkillType::CoreSkill as u32)
+        .unwrap()
+        .level;
+
+    avatar_file_cfg
+        .avatar_passive_skill_templates
+        .iter()
+        .find(|a| a.unlock_passive_skill_level() == passive_skill_level as i32)
+        .map(|tmpl| tmpl.propertys().unwrap())
+        .unwrap()
+        .iter()
+        .for_each(|p| {
+            properties.insert(
+                p.property() as u32,
+                properties.get(&(p.property() as u32)).unwrap_or(&0) + p.value(),
+            );
+        });
+}
+
+fn get_weapon_filecfg(
+    player_weapon: &Weapon,
+    filecfg: &'static NapFileCfg,
+) -> Option<WeaponFileCfg<'static>> {
+    let Some(weapon_template) = filecfg
+        .weapon_template_tb()
+        .data()
+        .unwrap()
+        .iter()
+        .find(|tmpl| tmpl.item_id() == player_weapon.id as i32)
+    else {
+        return None;
+    };
+
+    let Some(weapon_level_template) = filecfg
+        .weapon_level_template_tb()
+        .data()
+        .unwrap()
+        .iter()
+        .find(|tmpl| tmpl.level() == player_weapon.level as i32)
+    else {
+        return None;
+    };
+
+    let Some(weapon_star_template) = filecfg
+        .weapon_star_template_tb()
+        .data()
+        .unwrap()
+        .iter()
+        .find(|tmpl| tmpl.star() == player_weapon.star as i32)
+    else {
+        return None;
+    };
+
+    Some(WeaponFileCfg {
+        weapon_template,
+        weapon_level_template,
+        weapon_star_template,
+    })
+}
+
+fn add_weapon_template_properties(
+    weapon_file_cfg: &WeaponFileCfg,
+    properties: &mut HashMap<u32, i32>,
+) {
+    let base_property = weapon_file_cfg.weapon_template.base_property().unwrap();
+    let base_property_value = base_property.value()
+        + (base_property.value() as f32 * weapon_file_cfg.weapon_level_template.rate() as f32
+            / 10000f32) as i32
+        + (base_property.value() as f32 * weapon_file_cfg.weapon_star_template.star_rate() as f32
+            / 10000f32) as i32;
+    properties.insert(
+        base_property.property() as u32,
+        *properties
+            .get(&(base_property.property() as u32))
+            .unwrap_or(&0)
+            + base_property_value,
+    );
+    let rand_property = weapon_file_cfg.weapon_template.rand_property().unwrap();
+    let rand_property_value = rand_property.value()
+        + (rand_property.value() as f32 * weapon_file_cfg.weapon_star_template.rand_rate() as f32
+            / 10000f32) as i32;
+    properties.insert(
+        rand_property.property() as u32,
+        *properties
+            .get(&(rand_property.property() as u32))
+            .unwrap_or(&0)
+            + rand_property_value,
+    );
+}
+
+fn add_player_equip_properties(
+    player_equips: &Vec<&Equip>,
+    filecfg: &'static NapFileCfg,
+    properties: &mut HashMap<u32, i32>,
+) {
+    player_equips.iter().for_each(|pe| {
+        let equip_rarity = (pe.id / 10) % 10;
+        let property_rate = filecfg
+            .equipment_level_template_tb()
+            .data()
+            .unwrap()
+            .iter()
+            .find(|tmpl| tmpl.rarity() == equip_rarity as i32 && tmpl.level() == pe.level as i32)
+            .map(|tmpl| tmpl.property_rate())
+            .unwrap_or(1);
+        pe.propertys.iter().for_each(|p| {
+            properties.insert(
+                p.key,
+                properties.get(&p.key).unwrap_or(&0)
+                    + p.base_value as i32
+                    + (p.base_value as f32 * property_rate as f32 / 10000f32) as i32,
+            );
+        });
+        pe.sub_propertys.iter().for_each(|p| {
+            properties.insert(
+                p.key,
+                properties.get(&p.key).unwrap_or(&0)
+                    + (p.base_value as f32 * p.add_value as f32) as i32,
+            );
+        });
+    });
+}
+
+fn add_equipment_suit_properties(
+    player_equips: &Vec<&Equip>,
+    filecfg: &'static NapFileCfg,
+    properties: &mut HashMap<u32, i32>,
+) {
+    let mut suit_counts = HashMap::<i32, i32>::new();
+    player_equips.iter().for_each(|pe| {
+        let suit_id = pe.id as i32 / 100 * 100;
+        suit_counts.insert(suit_id, *suit_counts.get(&suit_id).unwrap_or(&0) + 1);
+    });
+    suit_counts.iter().for_each(|sc| {
+        let Some(equipment_suit_template) = filecfg
+            .equipment_suit_template_tb()
+            .data()
+            .unwrap()
+            .iter()
+            .find(|tmpl| tmpl.id() == *sc.0)
+        else {
+            return;
+        };
+        if equipment_suit_template.primary_condition() <= *sc.1 {
+            equipment_suit_template
+                .primary_suit_propertys()
+                .unwrap()
+                .iter()
+                .for_each(|p| {
+                    properties.insert(
+                        p.property() as u32,
+                        properties.get(&(p.property() as u32)).unwrap_or(&0) + p.value(),
+                    );
+                });
+        }
+    });
+}
+
+fn calculate_final_properties(properties: &mut HashMap<u32, i32>) {
+    properties.insert(
+        EPropertyType::HpMax.into(),
+        properties.get(&EPropertyType::HpMaxBase.into()).unwrap()
+            + (*properties.get(&EPropertyType::HpMaxBase.into()).unwrap() as f32
+                * *properties
+                    .get(&EPropertyType::HpMaxRatio.into())
+                    .unwrap_or(&0) as f32
+                / 10000f32)
+                .ceil() as i32
+            + properties
+                .get(&EPropertyType::HpMaxDelta.into())
+                .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::Atk.into(),
+        properties.get(&EPropertyType::AtkBase.into()).unwrap()
+            + (*properties.get(&EPropertyType::AtkBase.into()).unwrap() as f32
+                * *properties
+                    .get(&EPropertyType::AtkRatio.into())
+                    .unwrap_or(&0) as f32
+                / 10000f32) as i32
+            + properties
+                .get(&EPropertyType::AtkDelta.into())
+                .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::BreakStun.into(),
+        properties
+            .get(&EPropertyType::BreakStunBase.into())
+            .unwrap()
+            + (*properties
+                .get(&EPropertyType::BreakStunBase.into())
+                .unwrap() as f32
+                * *properties
+                    .get(&EPropertyType::BreakStunRatio.into())
+                    .unwrap_or(&0) as f32
+                / 10000f32) as i32
+            + properties
+                .get(&EPropertyType::BreakStunDelta.into())
+                .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::Def.into(),
+        properties.get(&EPropertyType::DefBase.into()).unwrap()
+            + (*properties.get(&EPropertyType::DefBase.into()).unwrap() as f32
+                * *properties
+                    .get(&EPropertyType::DefRatio.into())
+                    .unwrap_or(&0) as f32
+                / 10000f32) as i32
+            + properties
+                .get(&EPropertyType::DefDelta.into())
+                .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::Crit.into(),
+        properties.get(&EPropertyType::CritBase.into()).unwrap()
+            + properties
+                .get(&EPropertyType::CritDelta.into())
+                .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::CritDmg.into(),
+        properties.get(&EPropertyType::CritDmgBase.into()).unwrap()
+            + properties
+                .get(&EPropertyType::CritDmgDelta.into())
+                .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::Pen.into(),
+        properties.get(&EPropertyType::PenBase.into()).unwrap()
+            + properties
+                .get(&EPropertyType::PenDelta.into())
+                .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::PenValue.into(),
+        properties.get(&EPropertyType::PenValueBase.into()).unwrap()
+            + properties
+                .get(&EPropertyType::PenValueDelta.into())
+                .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::SpRecover.into(),
+        properties
+            .get(&EPropertyType::SpRecoverBase.into())
+            .unwrap()
+            + (*properties
+                .get(&EPropertyType::SpRecoverBase.into())
+                .unwrap() as f32
+                * *properties
+                    .get(&EPropertyType::SpRecoverRatio.into())
+                    .unwrap_or(&0) as f32
+                / 10000f32) as i32
+            + properties
+                .get(&EPropertyType::SpRecoverDelta.into())
+                .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::ElementMystery.into(),
+        properties
+            .get(&EPropertyType::ElementMysteryBase.into())
+            .unwrap()
+            + properties
+                .get(&EPropertyType::ElementMysteryDelta.into())
+                .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::ElementAbnormalPower.into(),
+        properties
+            .get(&EPropertyType::ElementAbnormalPowerBase.into())
+            .unwrap()
+            + (*properties
+                .get(&EPropertyType::ElementAbnormalPowerBase.into())
+                .unwrap() as f32
+                * *properties
+                    .get(&EPropertyType::ElementAbnormalPowerRatio.into())
+                    .unwrap_or(&0) as f32
+                / 10000f32) as i32
+            + properties
+                .get(&EPropertyType::ElementAbnormalPowerDelta.into())
+                .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::AddedDamageRatioPhysics.into(),
+        properties
+            .get(&EPropertyType::AddedDamageRatioPhysics1.into())
+            .unwrap_or(&0)
+            + properties
+                .get(&EPropertyType::AddedDamageRatioPhysics3.into())
+                .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::AddedDamageRatioFire.into(),
+        properties
+            .get(&EPropertyType::AddedDamageRatioFire1.into())
+            .unwrap_or(&0)
+            + properties
+                .get(&EPropertyType::AddedDamageRatioFire3.into())
+                .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::AddedDamageRatioIce.into(),
+        properties
+            .get(&EPropertyType::AddedDamageRatioIce1.into())
+            .unwrap_or(&0)
+            + properties
+                .get(&EPropertyType::AddedDamageRatioIce3.into())
+                .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::AddedDamageRatioElec.into(),
+        properties
+            .get(&EPropertyType::AddedDamageRatioElec1.into())
+            .unwrap_or(&0)
+            + properties
+                .get(&EPropertyType::AddedDamageRatioElec3.into())
+                .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::AddedDamageRatioEther.into(),
+        properties
+            .get(&EPropertyType::AddedDamageRatioEther1.into())
+            .unwrap_or(&0)
+            + properties
+                .get(&EPropertyType::AddedDamageRatioEther3.into())
+                .unwrap_or(&0),
+    );
+}
+
+fn add_ben_core_passive(
+    avatar_id: u32,
+    player_avatar: &Avatar,
+    properties: &mut HashMap<u32, i32>,
+) {
+    if avatar_id != BEN_AVATAR_ID {
+        return;
+    }
+    let core_level = player_avatar
+        .skill_type_level
+        .iter()
+        .find(|sl| sl.skill_type == EAvatarSkillType::CoreSkill as u32)
+        .unwrap()
+        .level as usize;
+    let def_atk_bonus = match core_level {
+        1..=7 => {
+            *properties.get(&EPropertyType::Def.into()).unwrap_or(&0)
+                * BEN_CORE_PASSIVE_PERCENTAGE[core_level - 1]
+                / 100
+        }
+        _ => 0,
+    };
+    properties.insert(
+        EPropertyType::Atk.into(),
+        *properties.get(&EPropertyType::Atk.into()).unwrap_or(&0) + def_atk_bonus,
+    );
+}
+
+fn remove_custom_properties(properties: &mut HashMap<u32, i32>) {
+    properties.remove(&EPropertyType::HpMaxGrowth.into());
+    properties.remove(&EPropertyType::AtkGrowth.into());
+    properties.remove(&EPropertyType::DefGrowth.into());
+    properties.remove(&EPropertyType::HpMaxAdvance.into());
+    properties.remove(&EPropertyType::AtkAdvance.into());
+    properties.remove(&EPropertyType::DefAdvance.into());
+}
+
+fn set_battle_properties(properties: &mut HashMap<u32, i32>) {
+    properties.insert(
+        EPropertyType::Hp.into(),
+        *properties.get(&EPropertyType::HpMax.into()).unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::HpMaxBattle.into(),
+        *properties.get(&EPropertyType::HpMax.into()).unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::AtkBattle.into(),
+        *properties.get(&EPropertyType::Atk.into()).unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::BreakStunBattle.into(),
+        *properties
+            .get(&EPropertyType::BreakStun.into())
+            .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::DefBattle.into(),
+        *properties.get(&EPropertyType::Def.into()).unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::CritBattle.into(),
+        *properties.get(&EPropertyType::Crit.into()).unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::CritDmgBattle.into(),
+        *properties.get(&EPropertyType::CritDmg.into()).unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::PenRatioBattle.into(),
+        *properties.get(&EPropertyType::Pen.into()).unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::PenDeltaBattle.into(),
+        *properties
+            .get(&EPropertyType::PenValue.into())
+            .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::SpRecoverBattle.into(),
+        *properties
+            .get(&EPropertyType::SpRecover.into())
+            .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::ElementMysteryBattle.into(),
+        *properties
+            .get(&EPropertyType::ElementMystery.into())
+            .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::ElementAbnormalPowerBattle.into(),
+        *properties
+            .get(&EPropertyType::ElementAbnormalPower.into())
+            .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::AddedDamageRatioPhysicsBattle.into(),
+        *properties
+            .get(&EPropertyType::AddedDamageRatioPhysics.into())
+            .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::AddedDamageRatioFireBattle.into(),
+        *properties
+            .get(&EPropertyType::AddedDamageRatioFire.into())
+            .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::AddedDamageRatioIceBattle.into(),
+        *properties
+            .get(&EPropertyType::AddedDamageRatioIce.into())
+            .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::AddedDamageRatioElecBattle.into(),
+        *properties
+            .get(&EPropertyType::AddedDamageRatioElec.into())
+            .unwrap_or(&0),
+    );
+    properties.insert(
+        EPropertyType::AddedDamageRatioEtherBattle.into(),
+        *properties
+            .get(&EPropertyType::AddedDamageRatioEther.into())
+            .unwrap_or(&0),
+    );
+}

crates/battle-server/src/server_message_handler.rs

@@ -10,7 +10,7 @@ use trigger_sv::{
     net::ServerType,
 };
 
-use crate::{logic::GameState, session::BattleSession, AppState};
+use crate::{AppState, logic::GameState, session::BattleSession};
 
 pub async fn handle_message(state: &'static AppState, packet: trigger_sv::message::NetworkPacket) {
     match packet.opcode {

crates/battle-server/src/session/message.rs

@@ -1,5 +1,5 @@
 use trigger_encoding::Decodeable;
-use trigger_protocol::{util::ProtocolUnit, ClientCmdID, EndBattleCsReq};
+use trigger_protocol::{ClientCmdID, EndBattleCsReq, util::ProtocolUnit};
 use trigger_sv::message::GameStateCallback;
 
 use super::BattleSession;

crates/dispatch-server/src/main.rs

@@ -3,7 +3,7 @@ use std::{
     sync::{LazyLock, OnceLock},
 };
 
-use axum::{routing::get, Router};
+use axum::{Router, routing::get};
 use config::DispatchConfig;
 use tokio::net::TcpListener;
 use tracing::error;

crates/dispatch-server/src/query_dispatch.rs

@@ -1,8 +1,8 @@
-use axum::{extract::State, Json};
+use axum::{Json, extract::State};
 
 use crate::{
-    data::{QueryDispatchRsp, ServerListInfo},
     AppState,
+    data::{QueryDispatchRsp, ServerListInfo},
 };
 
 pub const ROUTE_ENDPOINT: &str = "/query_dispatch";

crates/dispatch-server/src/query_gateway.rs

@@ -1,20 +1,20 @@
 use axum::{
+    Json,
     extract::{Query, State},
     response::IntoResponse,
-    Json,
 };
-use base64::{display::Base64Display, engine::general_purpose::STANDARD, Engine};
+use base64::{Engine, display::Base64Display, engine::general_purpose::STANDARD};
 use serde::{Deserialize, Serialize, Serializer};
 use tracing::debug;
 use trigger_cryptography::rsa;
 use trigger_sv::config::RsaSetting;
 
 use crate::{
+    AppState,
     data::{
         CdnConfExt, CdnDesignData, CdnGameRes, CdnSilenceData, RegionExtension, RegionSwitchFunc,
         ServerDispatchData, ServerGateway,
     },
-    AppState,
 };
 
 pub const ROUTE_ENDPOINT: &str = "/query_gateway";
@@ -127,7 +127,10 @@ fn internal_process(
             msg: String::with_capacity(0),
             region_name: Borrowed(&server.name),
             title: Borrowed(&server.title),
-            client_secret_key: Owned(base64::engine::general_purpose::STANDARD.encode(&state.environment.security.static_key.seed_buf)),
+            client_secret_key: Owned(
+                base64::engine::general_purpose::STANDARD
+                    .encode(&state.environment.security.static_key.seed_buf),
+            ),
             cdn_check_url: String::with_capacity(0),
             gateway: Some(ServerGateway {
                 ip: Borrowed(&server.addr),
@@ -139,20 +142,32 @@ fn internal_process(
             cdn_conf_ext: Some(CdnConfExt {
                 // TODO: unhardcode this
                 design_data: CdnDesignData {
-                    base_url: Borrowed("https://autopatchcn.juequling.com/design_data/beta_live/output_7054632_323d17319c/client/"),
+                    base_url: Borrowed(
+                        "https://autopatchcn.juequling.com/design_data/beta_live/output_7054632_323d17319c/client/",
+                    ),
                     data_revision: Borrowed("7054632"),
-                    md5_files: Borrowed(r#"[{"fileName": "data_version", "fileSize": 4503, "fileMD5": "419987357302147246"}]"#),
+                    md5_files: Borrowed(
+                        r#"[{"fileName": "data_version", "fileSize": 4503, "fileMD5": "419987357302147246"}]"#,
+                    ),
                 },
                 game_res: CdnGameRes {
                     audio_revision: Borrowed("7025371"),
-                    base_url: Borrowed("https://autopatchcn.juequling.com/game_res/beta_live/output_7054632_323d17319c/client/"),
+                    base_url: Borrowed(
+                        "https://autopatchcn.juequling.com/game_res/beta_live/output_7054632_323d17319c/client/",
+                    ),
                     branch: Borrowed("beta_live"),
-                    md5_files: Borrowed(r#"[{"fileName": "res_version", "fileSize": 2379030, "fileMD5": "15840336186912297231"}, {"fileName": "audio_version", "fileSize": 30435, "fileMD5": "15675397132378459243"}, {"fileName": "base_revision", "fileSize": 18, "fileMD5": "18079377284431001248"}]"#),
+                    md5_files: Borrowed(
+                        r#"[{"fileName": "res_version", "fileSize": 2379030, "fileMD5": "15840336186912297231"}, {"fileName": "audio_version", "fileSize": 30435, "fileMD5": "15675397132378459243"}, {"fileName": "base_revision", "fileSize": 18, "fileMD5": "18079377284431001248"}]"#,
+                    ),
                     res_revision: Borrowed("7054632"),
                 },
                 silence_data: CdnSilenceData {
-                    base_url: Borrowed("https://autopatchcn.juequling.com/design_data/beta_live/output_7054632_323d17319c/client_silence/"),
+                    base_url: Borrowed(
-                    md5_files: Borrowed(r#"[{"fileName": "silence_version", "fileSize": 647, "fileMD5": "15019531890587528788"}]"#),
+                        "https://autopatchcn.juequling.com/design_data/beta_live/output_7054632_323d17319c/client_silence/",
+                    ),
+                    md5_files: Borrowed(
+                        r#"[{"fileName": "silence_version", "fileSize": 647, "fileMD5": "15019531890587528788"}]"#,
+                    ),
                     silence_revision: Borrowed("7042559"),
                 },
                 pre_download: None,
@@ -174,7 +189,7 @@ fn internal_process(
                 url_check_nap: String::new(),
                 url_check_sdk: String::new(),
             }),
-        }
+        },
     })
 }
 

crates/game-server/src/logic/gm_util.rs

@@ -1,11 +1,11 @@
 use tracing::{debug, warn};
 use trigger_logic::quest::EQuestType;
-use trigger_protocol::{util::ProtocolUnit, AvatarSync, CafeSync, ItemSync, PlayerSyncScNotify};
+use trigger_protocol::{AvatarSync, CafeSync, ItemSync, PlayerSyncScNotify, util::ProtocolUnit};
 use trigger_sv::gm_command::GMCommand;
 
 use crate::AppState;
 
-use super::{player::AvatarPropertyChanges, NapPlayer};
+use super::{NapPlayer, player::AvatarPropertyChanges};
 
 pub struct CommandContext<'player> {
     pub player: &'player mut NapPlayer,

crates/game-server/src/logic/player/mod.rs

@@ -6,7 +6,7 @@ use quest::QuestModel;
 use ramen::RamenModel;
 use role::RoleModel;
 use scene::SceneModel;
-use trigger_database::{entity::*, prelude::*, DatabaseConnection};
+use trigger_database::{DatabaseConnection, entity::*, prelude::*};
 use trigger_fileconfig::NapFileCfg;
 use trigger_logic::scene::ESceneType;
 use trigger_protocol::PlayerBasicInfo;

crates/game-server/src/logic/player/player_util.rs

@@ -1,6 +1,6 @@
+use trigger_database::DatabaseConnection;
 use trigger_database::entity::*;
 use trigger_database::prelude::*;
-use trigger_database::DatabaseConnection;
 
 pub async fn load_player_basic_info(
     db: &DatabaseConnection,

crates/game-server/src/main.rs

@@ -12,7 +12,7 @@ use tracing::{error, info};
 use trigger_database::DatabaseConnection;
 use trigger_fileconfig::NapFileCfg;
 use trigger_sv::{
-    config::{load_json_config, ServerEnvironmentConfiguration, TomlConfig},
+    config::{ServerEnvironmentConfiguration, TomlConfig, load_json_config},
     die, logging,
     net::{ServerNetworkManager, ServerType},
     print_banner,

crates/game-server/src/server_message_handler.rs

@@ -1,9 +1,9 @@
 use std::sync::Arc;
 
 use crate::{
-    logic::{gm_util, NapPlayer},
-    session::GameSession,
     AppState,
+    logic::{NapPlayer, gm_util},
+    session::GameSession,
 };
 use tokio::sync::Mutex;
 use tracing::{debug, info, warn};

crates/game-server/src/session/message/mod.rs

@@ -1,5 +1,5 @@
 use trigger_encoding::Encodeable;
-use trigger_protocol::{util::ProtocolUnit, ClientCmdID};
+use trigger_protocol::{ClientCmdID, util::ProtocolUnit};
 
 use super::GameSession;
 use crate::AppState;

crates/game-server/src/session/mod.rs

@@ -15,7 +15,7 @@ use trigger_sv::{
     net::{ServerNetworkManager, ServerType},
 };
 
-use crate::logic::{scene_util, NapPlayer};
+use crate::logic::{NapPlayer, scene_util};
 
 pub mod message;
 

crates/gate-server/src/handlers/client.rs

@@ -12,10 +12,10 @@ use trigger_sv::{
 };
 
 use crate::{
+    AppState,
     net::{Connection, NetPacket},
     session::SessionState,
     util::BinExt,
-    AppState,
 };
 
 pub async fn handle_message(connection: &Connection, state: &'static AppState, packet: NetPacket) {
@@ -41,20 +41,33 @@ pub async fn handle_message(connection: &Connection, state: &'static AppState, p
             on_keep_alive(
                 connection,
                 state,
-                KeepAliveNotify::decode(&*packet.body).unwrap_or_default()
+                KeepAliveNotify::decode(&*packet.body).unwrap_or_default(),
-            ).await
+            )
+            .await
         }
         cmd_id if connection.session.is_logged_in() => {
             match trigger_protobuf::pb_to_common_protocol_unit(cmd_id, &packet.body) {
-                Ok(Some(unit)) => state.network_mgr.send_to(ServerType::GameServer, 0, ForwardClientProtocolMessage {
+                Ok(Some(unit)) => {
-                    session_id: connection.session.id,
+                    state
-                    request_id: head.packet_id,
+                        .network_mgr
-                    message: unit,
+                        .send_to(
-                }).await,
+                            ServerType::GameServer,
+                            0,
+                            ForwardClientProtocolMessage {
+                                session_id: connection.session.id,
+                                request_id: head.packet_id,
+                                message: unit,
+                            },
+                        )
+                        .await
+                }
                 Ok(None) => warn!("ignoring message with unknown cmd_id: {cmd_id}"),
                 Err(err) => error!(
                     "failed to decode a message with cmd_id: {} from {} (player_uid: {}), error: {}",
-                    cmd_id, connection.addr(), connection.session.player_uid(), err
+                    cmd_id,
+                    connection.addr(),
+                    connection.session.player_uid(),
+                    err
                 ),
             }
         }

crates/gate-server/src/message_handler.rs

@@ -1,7 +1,7 @@
 use tokio::sync::mpsc;
 use tracing::warn;
 
-use crate::{net::NetPacket, AppState};
+use crate::{AppState, net::NetPacket};
 
 #[derive(Clone)]
 pub struct MessageHandler(mpsc::UnboundedSender<(u64, NetPacket)>);

crates/gate-server/src/net/connection.rs

@@ -2,8 +2,8 @@ use std::{
     io,
     net::SocketAddr,
     sync::{
-        atomic::{AtomicU32, Ordering::SeqCst},
         Arc, OnceLock,
+        atomic::{AtomicU32, Ordering::SeqCst},
     },
     time::Duration,
 };

crates/gate-server/src/net/packet.rs

@@ -1,6 +1,6 @@
 use std::io::{Cursor, Write};
 
-use byteorder::{WriteBytesExt, BE};
+use byteorder::{BE, WriteBytesExt};
 use trigger_protobuf::PacketHead;
 
 pub struct NetPacket {

crates/gate-server/src/net/tcp_gateway.rs

@@ -3,7 +3,7 @@ use std::{io, net::SocketAddr};
 use tokio::net::TcpListener;
 use tracing::info;
 
-use crate::{message_handler::MessageHandler, AppState};
+use crate::{AppState, message_handler::MessageHandler};
 
 pub async fn serve(
     addr: SocketAddr,

crates/gate-server/src/session/mod.rs

@@ -1,6 +1,6 @@
 use std::sync::{
-    atomic::{AtomicI64, Ordering::SeqCst},
     OnceLock,
+    atomic::{AtomicI64, Ordering::SeqCst},
 };
 
 use atomic_enum::atomic_enum;

crates/hall-server/src/logic/ecs/event_graph.rs

@@ -107,6 +107,6 @@ use trigger_protocol::{
 };
 use trigger_sv::message::GameStateCallback;
 
-use crate::logic::{message::RunEventGraphEvent, GameStateListener};
+use crate::logic::{GameStateListener, message::RunEventGraphEvent};
 
 use super::scene_unit::{InteractContainer, SceneUnitTag};

crates/hall-server/src/logic/ecs/hall.rs

@@ -1,6 +1,6 @@
 use bevy_ecs::{prelude::*, query::QueryData};
 use tracing::warn;
-use trigger_fileconfig::{main_city_script::MainCityConfig, NapFileCfg};
+use trigger_fileconfig::{NapFileCfg, main_city_script::MainCityConfig};
 
 use crate::logic::save::HallSceneSaveData;
 

crates/hall-server/src/logic/ecs/interaction.rs

@@ -3,13 +3,13 @@ use tracing::{debug, warn};
 use trigger_protocol::InteractWithUnitScRsp;
 use trigger_sv::message::GameStateCallback;
 
-use crate::logic::{message::InteractWithUnitEvent, GameStateListener};
+use crate::logic::{GameStateListener, message::InteractWithUnitEvent};
 
 use super::{
+    NapResources,
     event_graph::{ActionChangeInteractCfgEvent, EventGraph, GraphEvent},
     hall::MainCitySection,
     scene_unit::{InteractContainer, SceneUnitTag},
-    NapResources,
 };
 
 pub fn tick_change_interact(

crates/hall-server/src/logic/ecs/mod.rs

@@ -8,11 +8,11 @@ use scene::PlayerEnterScene;
 use trigger_fileconfig::main_city_script::MainCityConfig;
 
 use super::{
+    GameStateListener,
     message::{
         EnterSectionEvent, InteractWithUnitEvent, PlayerMoveEvent, RunEventGraphEvent,
         SwitchRoleEvent,
     },
-    GameStateListener,
 };
 
 pub mod event_graph;

crates/hall-server/src/logic/ecs/scene_save.rs

@@ -1,8 +1,8 @@
 use bevy_ecs::prelude::*;
 
 use crate::logic::{
-    save::{HallSceneSaveData, MainCityPositionSave},
     GameStateListener,
+    save::{HallSceneSaveData, MainCityPositionSave},
 };
 
 use super::{

crates/hall-server/src/logic/listener.rs

@@ -1,6 +1,6 @@
 use bevy_ecs::system::Resource;
 use trigger_encoding::Encodeable;
-use trigger_protocol::{util::ProtocolUnit, ClientCmdID};
+use trigger_protocol::{ClientCmdID, util::ProtocolUnit};
 use trigger_sv::{
     message::{GameStateCallback, GameStateCallbackMessage},
     net::{ServerNetworkManager, ServerType},

crates/hall-server/src/logic/message.rs

@@ -2,8 +2,8 @@ use bevy_ecs::event::Event;
 use trigger_encoding::Decodeable;
 use trigger_logic::scene::Transform;
 use trigger_protocol::{
-    util::ProtocolUnit, ClientCmdID, EnterSectionCsReq, InteractWithUnitCsReq, RunEventGraphCsReq,
+    ClientCmdID, EnterSectionCsReq, InteractWithUnitCsReq, RunEventGraphCsReq,
-    SavePosInMainCityCsReq, SwitchRoleCsReq,
+    SavePosInMainCityCsReq, SwitchRoleCsReq, util::ProtocolUnit,
 };
 
 use super::ecs::NapEcs;

crates/hall-server/src/logic/mod.rs

@@ -1,6 +1,6 @@
 use std::{collections::HashMap, sync::mpsc, thread};
 
-use ecs::{scene::PlayerEnterScene, NapEcs};
+use ecs::{NapEcs, scene::PlayerEnterScene};
 use message::ProtocolEventHandler;
 use tracing::debug;
 use trigger_protocol::util::ProtocolUnit;
@@ -11,8 +11,8 @@ mod listener;
 mod message;
 
 pub mod save;
-pub use ecs::hall::HallInitData;
 pub use ecs::NapResources;
+pub use ecs::hall::HallInitData;
 pub use listener::GameStateListener;
 
 #[derive(Clone)]

crates/hall-server/src/main.rs

@@ -8,9 +8,9 @@ use dashmap::DashMap;
 use logic::{GameRunner, NapResources};
 use session::HallSession;
 use tracing::{error, info};
-use trigger_fileconfig::{main_city_script::MainCityConfig, NapFileCfg};
+use trigger_fileconfig::{NapFileCfg, main_city_script::MainCityConfig};
 use trigger_sv::{
-    config::{load_json_config, ServerEnvironmentConfiguration, TomlConfig},
+    config::{ServerEnvironmentConfiguration, TomlConfig, load_json_config},
     die, logging,
     net::{ServerNetworkManager, ServerType},
     print_banner,

crates/hall-server/src/server_message_handler.rs

@@ -5,9 +5,9 @@ use trigger_sv::message::{
 };
 
 use crate::{
+    AppState,
     logic::{GameStateListener, HallInitData},
     session::HallSession,
-    AppState,
 };
 
 pub async fn handle_message(state: &'static AppState, packet: trigger_sv::message::NetworkPacket) {

crates/muip-server/src/http_server.rs

@@ -1,9 +1,9 @@
 use std::borrow::Cow;
 
 use axum::{
+    Json, Router,
     extract::{Query, State},
     routing::get,
-    Json, Router,
 };
 use serde::{Deserialize, Serialize};
 use tokio::net::TcpListener;
@@ -64,7 +64,7 @@ async fn gm_api(
             return Json(Response {
                 retcode: 2,
                 message: Some(Cow::Owned(format!("invalid command format: {err}"))),
-            })
+            });
         }
     };
 

crates/trigger-codegen/src/commands.rs

@@ -1,8 +1,8 @@
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{
-    parse_macro_input, Data, DeriveInput, Field, Fields, GenericArgument, PathArguments, Type,
+    Data, DeriveInput, Field, Fields, GenericArgument, PathArguments, Type, TypePath,
-    TypePath,
+    parse_macro_input,
 };
 
 pub fn impl_gm_input(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
@@ -114,7 +114,7 @@ pub fn impl_gm_input(input: proc_macro::TokenStream) -> proc_macro::TokenStream
             fn from_str(input: &str) -> Result<Self, GMInputParseError> {
                 use GMInputParseError::*;
 
-                static CMD_TYPE_MAP: ::std::sync::LazyLock<::std::collections::HashMap<&'static str, #internal_enum_name>> = 
+                static CMD_TYPE_MAP: ::std::sync::LazyLock<::std::collections::HashMap<&'static str, #internal_enum_name>> =
                     ::std::sync::LazyLock::new(|| ::std::collections::HashMap::from([#internal_enum_mapping]));
 
                 let mut data = input.split(' ');
@@ -165,4 +165,3 @@ fn get_field_sub_type(field: &Field) -> String {
         _ => panic!("Unsupported field type"),
     }
 }
-

crates/trigger-codegen/src/decodeable.rs

@@ -1,6 +1,6 @@
 use proc_macro2::TokenStream;
 use quote::quote;
-use syn::{parse_macro_input, Data, DeriveInput, Fields, Ident};
+use syn::{Data, DeriveInput, Fields, Ident, parse_macro_input};
 
 pub fn impl_decodeable(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input = parse_macro_input!(item as DeriveInput);

crates/trigger-codegen/src/encodeable.rs

@@ -1,6 +1,6 @@
 use proc_macro2::TokenStream;
 use quote::quote;
-use syn::{parse_macro_input, Data, DeriveInput, Fields, Ident};
+use syn::{Data, DeriveInput, Fields, Ident, parse_macro_input};
 
 pub fn impl_encodeable(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input = parse_macro_input!(item as DeriveInput);

crates/trigger-codegen/src/handler_module_attribute.rs

@@ -1,6 +1,6 @@
 use proc_macro2::TokenStream;
-use quote::{quote, ToTokens};
+use quote::{ToTokens, quote};
-use syn::{parse_macro_input, FnArg, Item, ItemMod, ReturnType};
+use syn::{FnArg, Item, ItemMod, ReturnType, parse_macro_input};
 
 pub fn imp(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     const INVALID_FUNCTION_SIGNATURE_MSG: &str = "functions in message handler module should have following signature: fn(&mut MessageContext<'_>, CsReq) -> ScRsp";

crates/trigger-codegen/src/lib.rs

@@ -1,6 +1,6 @@
 use proc_macro::TokenStream;
-use quote::{quote, ToTokens};
+use quote::{ToTokens, quote};
-use syn::{parse_macro_input, DeriveInput, Meta, MetaList};
+use syn::{DeriveInput, Meta, MetaList, parse_macro_input};
 
 mod commands;
 mod decodeable;

crates/trigger-cryptography/src/mhy/aes.rs

@@ -1,7 +1,7 @@
 #![allow(unused)]
 
 use super::tables::{
-    LOOKUP_G11, LOOKUP_G13, LOOKUP_G14, LOOKUP_G2, LOOKUP_G3, LOOKUP_G9, LOOKUP_RCON, LOOKUP_SBOX,
+    LOOKUP_G2, LOOKUP_G3, LOOKUP_G9, LOOKUP_G11, LOOKUP_G13, LOOKUP_G14, LOOKUP_RCON, LOOKUP_SBOX,
     LOOKUP_SBOX_INV, SHIFT_ROWS_TABLE, SHIFT_ROWS_TABLE_INV,
 };
 

crates/trigger-cryptography/src/rsa.rs

@@ -1,6 +1,6 @@
 use rsa::{
-    pkcs1v15::SigningKey, sha2::Sha256, signature::RandomizedSigner, Pkcs1v15Encrypt,
+    Pkcs1v15Encrypt, RsaPrivateKey, RsaPublicKey, pkcs1v15::SigningKey, sha2::Sha256,
-    RsaPrivateKey, RsaPublicKey,
+    signature::RandomizedSigner,
 };
 
 const RSA_CHUNK_SIZE: usize = 117;

crates/trigger-database/src/lib.rs

@@ -10,10 +10,10 @@ pub use sea_orm::DbErr;
 use tracing::error;
 
 pub mod prelude {
-    pub use sea_orm::entity::prelude::*;
-    pub use sea_orm::entity::ActiveValue::*;
-    pub use sea_orm::query::Condition;
     pub use sea_orm::TransactionTrait;
+    pub use sea_orm::entity::ActiveValue::*;
+    pub use sea_orm::entity::prelude::*;
+    pub use sea_orm::query::Condition;
 }
 
 #[derive(Debug, Deserialize)]

crates/trigger-encoding/src/lib.rs

@@ -1,4 +1,4 @@
-use byteorder::{ReadBytesExt, WriteBytesExt, BE};
+use byteorder::{BE, ReadBytesExt, WriteBytesExt};
 use std::collections::HashMap;
 use std::io::{self, Read, Write};
 

crates/trigger-fileconfig/fbs/tables.fbs

@@ -215,17 +215,32 @@ table EquipmentSuitTemplate {
 	id: int;
 	name: string;
 	primary_condition: int;
-	primary_suit_propertys: [Property];
+	unk_3: int;
 	primary_suit_ability: int;
 	primary_description: string;
 	secondary_condition: int;
-	secondary_suit_propertys: [Property];
+	unk_7: int;
 	secondary_suit_ability: int;
 	secondary_description: string;
-	suit_item_icon: string;
+	suit_icon: string;
 	suit_story: string;
 	suit_filter_option: string;
-	suit_icon: string;
+	suit_item_icon: string;
+	unk_14: int;
+	order: int;
+	unk_16: int;
+	unk_17: int;
+	unk_18: int;
+	unk_19: int;
+	unk_20: int;
+	unk_21: int;
+	primary_suit_propertys: [Property];
+	unk_23: [int];
+	unk_24: int;
+	unk_25: [int];
+	unk_26: [int];
+	unk_27: [int];
+	tag: string;
 }
 
 table HollowConfigTemplate {
@@ -380,6 +395,160 @@ table ConditionConfigTemplate {
 	type: int;
 }
 
+table AvatarBattleTemplate {
+	id: int;
+	unk_1: [int];
+	unk_2: [int];
+	unk_3: [int];
+	unk_4: [int];
+	unk_5: [int];
+	unk_6: [int];
+	unk_7: [int];
+	unk_8: int;
+	unk_9: int;
+	unk_10: int;
+	avatar_piece_id: int;
+	unk_12: int;
+	unk_13: int;
+	hp_max: int;
+	health_growth: int;
+	unk_16: int;
+	unk_17: int;
+	unk_18: int;
+	unk_19: int;
+	unk_20: int;
+	attack: int;
+	attack_growth: int;
+	defence: int;
+	defence_growth: int;
+	crit: int;
+	crit_damage: int;
+	crit_res: int;
+	crit_damage_res: int;
+	pen_rate: int;
+	pen_delta: int;
+	luck: int;
+	stun: int;
+	break_stun: int;
+	element_abnormal_power: int;
+	sp_bar_point: int;
+	sp_recover: int;
+	element_mystery: int;
+	rbl: int;
+	rbl_correction_factor: int;
+	rbl_probability: int;
+	unk_41: int;
+	unk_42: int;
+	unk_43: int;
+	unk_44: int;
+	unk_45: int;
+	unk_46: int;
+	unk_47: int;
+	unk_48: int;
+	unk_49: int;
+	unk_50: int;
+	unk_51: int;
+	unk_52: int;
+	unk_53: int;
+	unk_54: int;
+	unk_55: int;
+	unk_56: int;
+	unk_57: int;
+	unk_58: int;
+	unk_59: int;
+	unk_60: int;
+	unk_61: int;
+	unk_62: int;
+	unk_63: int;
+	unk_64: int;
+	unk_65: int;
+	unk_66: int;
+	tags: [string];
+	unk_68: [int];
+	unk_69: [int];
+	unk_70: int;
+	unk_71: int;
+	element: [int];
+	hit_type: [int];
+	unk_element_camp: [string];
+	unk_75: int;
+	unk_76: short;
+}
+
+table AvatarLevelAdvanceTemplate {
+	avatar_id: int;
+	id: int;
+	min_level: int;
+	max_level: int;
+	hp_max: int;
+	unk_5: int;
+	unk_6: int;
+	attack: int;
+	defence: int;
+	unk_9: int;
+	unk_10: int;
+	unk_11: int;
+	unk_12: int;
+	unk_13: int;
+	unk_14: int;
+	unk_15: int;
+	unk_16: int;
+	unk_17: int;
+	unk_18: [int];
+	promotion_costs: [RefineCost];
+}
+
+table WeaponLevelTemplate {
+	rarity: int;
+	level: int;
+	rate: int;
+	exp: int;
+}
+
+table WeaponStarTemplate {
+	rarity: int;
+	star: int;
+	min_level: int;
+	max_level: int;
+	star_rate: int;
+	rand_rate: int;
+	unk_6: int;
+	unk_7: int;
+	unk_8: int;
+	unk_9: int;
+	unk_10: int;
+	unk_11: int;
+	unk_12: int;
+}
+
+table AvatarPassiveSkillTemplate {
+	skill_id: int;
+	avatar_id: int;
+	min_avatar_level: int;
+	min_passive_skill_level: int;
+	unlock_passive_skill_level: int;
+	unk_5: int;
+	unk_levelup: string;
+	unk_7: int;
+	unk_8: int;
+	unk_9: int;
+	unk_10: int;
+	propertys: [Property];
+	names: [string];
+	descriptions: [string];
+	materials_costs: [RefineCost];
+}
+
+table EquipmentLevelTemplate {
+	rarity: int;
+	level: int;
+	property_rate: int;
+	unk_3: int;
+	unk_4: int;
+	unk_5: int;
+	unk_6: int;
+}
+
 table AvatarBaseTemplateTb {
 	data: [AvatarBaseTemplate];
 }
@@ -451,3 +620,27 @@ table TeleportConfigTemplateTb {
 table ConditionConfigTemplateTb {
 	data: [ConditionConfigTemplate];
 }
+
+table AvatarBattleTemplateTb {
+	data: [AvatarBattleTemplate];
+}
+
+table AvatarLevelAdvanceTemplateTb {
+	data: [AvatarLevelAdvanceTemplate];
+}
+
+table WeaponLevelTemplateTb {
+	data: [WeaponLevelTemplate];
+}
+
+table WeaponStarTemplateTb {
+	data: [WeaponStarTemplate];
+}
+
+table AvatarPassiveSkillTemplateTb {
+	data: [AvatarPassiveSkillTemplate];
+}
+
+table EquipmentLevelTemplateTb {
+	data: [EquipmentLevelTemplate];
+}

crates/trigger-fileconfig/src/lib.rs

@@ -58,4 +58,10 @@ file_cfg! {
     BattleGroupConfigTemplateTb;
     MusicPlayerConfigTemplateTb;
     TeleportConfigTemplateTb;
+    AvatarBattleTemplateTb;
+    AvatarLevelAdvanceTemplateTb;
+    WeaponLevelTemplateTb;
+    WeaponStarTemplateTb;
+    AvatarPassiveSkillTemplateTb;
+    EquipmentLevelTemplateTb;
 }

crates/trigger-logic/src/battle.rs

@@ -0,0 +1,91 @@
+use num_enum::{IntoPrimitive, TryFromPrimitive};
+
+#[repr(u32)]
+#[derive(IntoPrimitive, TryFromPrimitive)]
+pub enum EPropertyType {
+    Hp = 1,
+    HpMax = 111,
+    Atk = 121,
+    BreakStun = 122,
+    Def = 131,
+    Crit = 201,
+    CritDmg = 211,
+    Pen = 231,
+    PenValue = 232,
+    SpRecover = 305,
+    ElementMystery = 312,
+    ElementAbnormalPower = 314,
+    AddedDamageRatioPhysics = 315,
+    AddedDamageRatioFire = 316,
+    AddedDamageRatioIce = 317,
+    AddedDamageRatioElec = 318,
+    AddedDamageRatioEther = 319,
+    // battle
+    HpMaxBattle = 1111,
+    AtkBattle = 1121,
+    BreakStunBattle = 1122,
+    DefBattle = 1131,
+    CritBattle = 1201,
+    CritDmgBattle = 1211,
+    PenRatioBattle = 1231,
+    PenDeltaBattle = 1232,
+    SpRecoverBattle = 1305,
+    ElementMysteryBattle = 1312,
+    ElementAbnormalPowerBattle = 1314,
+    AddedDamageRatioPhysicsBattle = 1315,
+    AddedDamageRatioFireBattle = 1316,
+    AddedDamageRatioIceBattle = 1317,
+    AddedDamageRatioElecBattle = 1318,
+    AddedDamageRatioEtherBattle = 1319,
+    // base
+    HpMaxBase = 11101,
+    AtkBase = 12101,
+    BreakStunBase = 12201,
+    DefBase = 13101,
+    CritBase = 20101,
+    CritDmgBase = 21101,
+    PenBase = 23101,
+    PenValueBase = 23201,
+    SpRecoverBase = 30501,
+    ElementMysteryBase = 31201,
+    ElementAbnormalPowerBase = 31401,
+    // ratio
+    HpMaxRatio = 11102,
+    AtkRatio = 12102,
+    BreakStunRatio = 12202,
+    DefRatio = 13102,
+    SpRecoverRatio = 30502,
+    ElementAbnormalPowerRatio = 31402,
+    // delta
+    HpMaxDelta = 11103,
+    AtkDelta = 12103,
+    BreakStunDelta = 12203,
+    DefDelta = 13103,
+    CritDelta = 20103,
+    CritDmgDelta = 21103,
+    PenDelta = 23103,
+    PenValueDelta = 23203,
+    SpRecoverDelta = 30503,
+    ElementMysteryDelta = 31203,
+    ElementAbnormalPowerDelta = 31403,
+    // damage ratios 1/3
+    AddedDamageRatioPhysics1 = 31501,
+    AddedDamageRatioPhysics3 = 31503,
+    AddedDamageRatioFire1 = 31601,
+    AddedDamageRatioFire3 = 31603,
+    AddedDamageRatioIce1 = 31701,
+    AddedDamageRatioIce3 = 31703,
+    AddedDamageRatioElec1 = 31801,
+    AddedDamageRatioElec3 = 31803,
+    AddedDamageRatioEther1 = 31901,
+    AddedDamageRatioEther3 = 31903,
+    // --- custom
+    // growth
+    HpMaxGrowth = 9999_111_0,
+    AtkGrowth = 9999_121_0,
+    DefGrowth = 9999_131_0,
+    // advance
+    HpMaxAdvance = 9999_111_1,
+    AtkAdvance = 9999_121_1,
+    DefAdvance = 9999_131_1,
+}

crates/trigger-logic/src/lib.rs

@@ -1,4 +1,5 @@
 pub mod action_pb;
+pub mod battle;
 pub mod item;
 pub mod quest;
 pub mod scene;

crates/trigger-protobuf/build.rs

@@ -5,7 +5,7 @@ use std::{
     path::Path,
 };
 
-use quote::{quote, ToTokens};
+use quote::{ToTokens, quote};
 use syn::{Field, GenericArgument, Item, PathArguments, Type, TypePath};
 
 fn main() {

crates/trigger-protobuf/out/_.rs

@@ -1039,6 +1039,8 @@ pub struct GetResourceDataScRsp {
 #[derive(trigger_protobuf_derive::XorFields)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct BuddyUnitInfo {
+    #[prost(map = "uint32, int32", tag = "15")]
+    pub properties: ::std::collections::HashMap<u32, i32>,
     #[xor(2099)]
     #[prost(uint32, tag = "14")]
     pub buddy_id: u32,
@@ -1710,6 +1712,8 @@ pub struct AvatarUnitInfo {
     #[xor(11167)]
     #[prost(uint32, tag = "12")]
     pub avatar_id: u32,
+    #[prost(map = "uint32, int32", tag = "2")]
+    pub properties: ::std::collections::HashMap<u32, i32>,
 }
 #[derive(trigger_protobuf_derive::CmdID)]
 #[cmdid(6984)]

crates/trigger-protobuf/out/protocol_map.rs

@@ -4956,6 +4956,11 @@ impl From<AvatarUnitInfo> for ::trigger_protocol::AvatarUnitInfo {
     fn from(value: AvatarUnitInfo) -> Self {
         Self {
             avatar_id: value.avatar_id.into(),
+            properties: value
+                .properties
+                .into_iter()
+                .map(|(k, v)| (k.into(), v.into()))
+                .collect(),
             ..Default::default()
         }
     }
@@ -4965,6 +4970,11 @@ impl From<::trigger_protocol::AvatarUnitInfo> for AvatarUnitInfo {
     fn from(value: ::trigger_protocol::AvatarUnitInfo) -> Self {
         Self {
             avatar_id: value.avatar_id.into(),
+            properties: value
+                .properties
+                .into_iter()
+                .map(|(k, v)| (k.into(), v.into()))
+                .collect(),
             ..Default::default()
         }
     }

crates/trigger-protocol/src/lib.rs

@@ -355,6 +355,7 @@ pub struct DungeonEquipInfo {
 #[derive(Default, Debug, Clone, Encodeable, Decodeable)]
 pub struct AvatarUnitInfo {
     pub avatar_id: u32,
+    pub properties: HashMap<u32, i32>,
 }
 
 #[derive(Default, Debug, Clone, Encodeable, Decodeable)]
@@ -1792,4 +1793,4 @@ pub struct GetFlowerShopDataCsReq {}
 #[id(7151)]
 pub struct GetFlowerShopDataScRsp {
     pub retcode: i32,
-}
+}

crates/trigger-sv/src/config.rs

@@ -1,4 +1,4 @@
-use serde::{de::DeserializeOwned, Deserialize, Deserializer};
+use serde::{Deserialize, Deserializer, de::DeserializeOwned};
 use std::net::SocketAddr;
 use tracing::error;
 use trigger_database::DatabaseSetting;

crates/trigger-sv/src/message/session.rs

@@ -1,6 +1,6 @@
 use crate::message::opcode;
 use trigger_codegen::{Decodeable, Encodeable};
-use trigger_protocol::{util::ProtocolUnit, DungeonEquipInfo};
+use trigger_protocol::{DungeonEquipInfo, util::ProtocolUnit};
 
 #[derive(Debug, Encodeable, Decodeable)]
 pub struct BindClientSessionMessage {

crates/trigger-sv/src/net/listener.rs

@@ -4,7 +4,7 @@ use futures::future::BoxFuture;
 use tokio::task::JoinHandle;
 use tracing::warn;
 use trigger_encoding::Decodeable;
-use zeromq::{prelude::*, PullSocket, ZmqError};
+use zeromq::{PullSocket, ZmqError, prelude::*};
 
 use crate::message::NetworkPacket;
 

crates/trigger-sv/src/net/mod.rs

@@ -3,7 +3,7 @@ mod socket;
 
 use std::{collections::HashMap, io::Cursor, net::SocketAddr};
 
-pub use listener::{listen, RecvCallback};
+pub use listener::{RecvCallback, listen};
 use num_enum::{IntoPrimitive, TryFromPrimitive};
 pub use socket::ServerSocket;
 

crates/trigger-sv/src/net/socket.rs

@@ -5,8 +5,8 @@ use std::time::Duration;
 use tokio::sync::mpsc;
 use tracing::warn;
 use trigger_encoding::Encodeable;
-use zeromq::prelude::*;
 use zeromq::PushSocket;
+use zeromq::prelude::*;
 
 use crate::message::NetworkPacket;