1

server/gameserver/mtb/BattleBasicAttribute.h

@@ -0,0 +1,112 @@
+#pragma once
+
+#include <bitset>
+
+namespace mtb
+{
+
+  class BattleBasicAttribute
+  {
+  public:
+
+    std::shared_ptr<a8::reflect::Class> GetClass() const;
+    int id() const { return id_; };
+    float pBaseHealth() const { return pBaseHealth_; };
+    float pOrigHealth() const { return pOrigHealth_; };
+    float vOrigHealth() const { return vOrigHealth_; };
+    float pBaseAttack() const { return pBaseAttack_; };
+    float pOrigAttack() const { return pOrigAttack_; };
+    float vOrigAttack() const { return vOrigAttack_; };
+    float pBaseDefend() const { return pBaseDefend_; };
+    float pOrigDefend() const { return pOrigDefend_; };
+    float vOrigDefend() const { return vOrigDefend_; };
+    float pBaseBlock() const { return pBaseBlock_; };
+    float pOrigBlock() const { return pOrigBlock_; };
+    float vOrigBlock() const { return vOrigBlock_; };
+    float vOrigEvaDef() const { return vOrigEvaDef_; };
+    float pBaseCrit() const { return pBaseCrit_; };
+    float pOrigCrit() const { return pOrigCrit_; };
+    float vOrigCrit() const { return vOrigCrit_; };
+    float vOrigCriBon() const { return vOrigCriBon_; };
+    float vOrigDamageTakenRateIn() const { return vOrigDamageTakenRateIn_; };
+    float vOrigDamageDealtRateIn() const { return vOrigDamageDealtRateIn_; };
+    float vOrigNormalDamageTakenRateIn() const { return vOrigNormalDamageTakenRateIn_; };
+    float vOrigNormalDamageDealtRateIn() const { return vOrigNormalDamageDealtRateIn_; };
+    float vOrigSkillDamageTakenRateIn() const { return vOrigSkillDamageTakenRateIn_; };
+    float vOrigSkillDamageDealtRateIn() const { return vOrigSkillDamageDealtRateIn_; };
+    float vOrigHealthGainRateIn() const { return vOrigHealthGainRateIn_; };
+    float vOrigHealDealtRateIn() const { return vOrigHealDealtRateIn_; };
+    float vOrigSpeed() const { return vOrigSpeed_; };
+    float vOrigHaste() const { return vOrigHaste_; };
+    float vOrigDrain() const { return vOrigDrain_; };
+    float vOrigTenacity() const { return vOrigTenacity_; };
+
+    bool has_id() const { return __flags__.test(0);};
+    bool has_pBaseHealth() const { return __flags__.test(1);};
+    bool has_pOrigHealth() const { return __flags__.test(2);};
+    bool has_vOrigHealth() const { return __flags__.test(3);};
+    bool has_pBaseAttack() const { return __flags__.test(4);};
+    bool has_pOrigAttack() const { return __flags__.test(5);};
+    bool has_vOrigAttack() const { return __flags__.test(6);};
+    bool has_pBaseDefend() const { return __flags__.test(7);};
+    bool has_pOrigDefend() const { return __flags__.test(8);};
+    bool has_vOrigDefend() const { return __flags__.test(9);};
+    bool has_pBaseBlock() const { return __flags__.test(10);};
+    bool has_pOrigBlock() const { return __flags__.test(11);};
+    bool has_vOrigBlock() const { return __flags__.test(12);};
+    bool has_vOrigEvaDef() const { return __flags__.test(13);};
+    bool has_pBaseCrit() const { return __flags__.test(14);};
+    bool has_pOrigCrit() const { return __flags__.test(15);};
+    bool has_vOrigCrit() const { return __flags__.test(16);};
+    bool has_vOrigCriBon() const { return __flags__.test(17);};
+    bool has_vOrigDamageTakenRateIn() const { return __flags__.test(18);};
+    bool has_vOrigDamageDealtRateIn() const { return __flags__.test(19);};
+    bool has_vOrigNormalDamageTakenRateIn() const { return __flags__.test(20);};
+    bool has_vOrigNormalDamageDealtRateIn() const { return __flags__.test(21);};
+    bool has_vOrigSkillDamageTakenRateIn() const { return __flags__.test(22);};
+    bool has_vOrigSkillDamageDealtRateIn() const { return __flags__.test(23);};
+    bool has_vOrigHealthGainRateIn() const { return __flags__.test(24);};
+    bool has_vOrigHealDealtRateIn() const { return __flags__.test(25);};
+    bool has_vOrigSpeed() const { return __flags__.test(26);};
+    bool has_vOrigHaste() const { return __flags__.test(27);};
+    bool has_vOrigDrain() const { return __flags__.test(28);};
+    bool has_vOrigTenacity() const { return __flags__.test(29);};
+
+  protected:
+
+    int id_ = 0;
+    float pBaseHealth_ = 0.0f;
+    float pOrigHealth_ = 0.0f;
+    float vOrigHealth_ = 0.0f;
+    float pBaseAttack_ = 0.0f;
+    float pOrigAttack_ = 0.0f;
+    float vOrigAttack_ = 0.0f;
+    float pBaseDefend_ = 0.0f;
+    float pOrigDefend_ = 0.0f;
+    float vOrigDefend_ = 0.0f;
+    float pBaseBlock_ = 0.0f;
+    float pOrigBlock_ = 0.0f;
+    float vOrigBlock_ = 0.0f;
+    float vOrigEvaDef_ = 0.0f;
+    float pBaseCrit_ = 0.0f;
+    float pOrigCrit_ = 0.0f;
+    float vOrigCrit_ = 0.0f;
+    float vOrigCriBon_ = 0.0f;
+    float vOrigDamageTakenRateIn_ = 0.0f;
+    float vOrigDamageDealtRateIn_ = 0.0f;
+    float vOrigNormalDamageTakenRateIn_ = 0.0f;
+    float vOrigNormalDamageDealtRateIn_ = 0.0f;
+    float vOrigSkillDamageTakenRateIn_ = 0.0f;
+    float vOrigSkillDamageDealtRateIn_ = 0.0f;
+    float vOrigHealthGainRateIn_ = 0.0f;
+    float vOrigHealDealtRateIn_ = 0.0f;
+    float vOrigSpeed_ = 0.0f;
+    float vOrigHaste_ = 0.0f;
+    float vOrigDrain_ = 0.0f;
+    float vOrigTenacity_ = 0.0f;
+
+public:
+    std::bitset<30> __flags__;
+  };
+
+};

server/gameserver/mtb/BattleLevelAttribute.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <bitset>
+
+namespace mtb
+{
+
+  class BattleLevelAttribute
+  {
+  public:
+
+    std::shared_ptr<a8::reflect::Class> GetClass() const;
+    int id() const { return id_; };
+    int invoke() const { return invoke_; };
+    const std::string cost() const { return cost_; };
+    const std::string levelAttribute() const { return levelAttribute_; };
+
+    bool has_id() const { return __flags__.test(0);};
+    bool has_invoke() const { return __flags__.test(1);};
+    bool has_cost() const { return __flags__.test(2);};
+    bool has_levelAttribute() const { return __flags__.test(3);};
+
+  protected:
+
+    int id_ = 0;
+    int invoke_ = 0;
+    std::string cost_;
+    std::string levelAttribute_;
+
+public:
+    std::bitset<4> __flags__;
+  };
+
+};

server/gameserver/mtb/BattleRandAttribute.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <bitset>
+
+namespace mtb
+{
+
+  class BattleRandAttribute
+  {
+  public:
+
+    std::shared_ptr<a8::reflect::Class> GetClass() const;
+    int id() const { return id_; };
+    int invoke() const { return invoke_; };
+    const std::string qualityWeight() const { return qualityWeight_; };
+    const std::string distribution() const { return distribution_; };
+    const std::string attributeRange() const { return attributeRange_; };
+
+    bool has_id() const { return __flags__.test(0);};
+    bool has_invoke() const { return __flags__.test(1);};
+    bool has_qualityWeight() const { return __flags__.test(2);};
+    bool has_distribution() const { return __flags__.test(3);};
+    bool has_attributeRange() const { return __flags__.test(4);};
+
+  protected:
+
+    int id_ = 0;
+    int invoke_ = 0;
+    std::string qualityWeight_;
+    std::string distribution_;
+    std::string attributeRange_;
+
+public:
+    std::bitset<5> __flags__;
+  };
+
+};

server/gameserver/mtb/BattleWeaponAttribute.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <bitset>
+
+namespace mtb
+{
+
+  class BattleWeaponAttribute
+  {
+  public:
+
+    std::shared_ptr<a8::reflect::Class> GetClass() const;
+    int id() const { return id_; };
+    int weapon() const { return weapon_; };
+    int level() const { return level_; };
+    const std::string levelAttribute() const { return levelAttribute_; };
+    const std::string cost() const { return cost_; };
+
+    bool has_id() const { return __flags__.test(0);};
+    bool has_weapon() const { return __flags__.test(1);};
+    bool has_level() const { return __flags__.test(2);};
+    bool has_levelAttribute() const { return __flags__.test(3);};
+    bool has_cost() const { return __flags__.test(4);};
+
+  protected:
+
+    int id_ = 0;
+    int weapon_ = 0;
+    int level_ = 0;
+    std::string levelAttribute_;
+    std::string cost_;
+
+public:
+    std::bitset<5> __flags__;
+  };
+
+};

server/gameserver/mtb/Condition.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <bitset>
+
+namespace mtb
+{
+
+  class Condition
+  {
+  public:
+
+    std::shared_ptr<a8::reflect::Class> GetClass() const;
+    int id() const { return id_; };
+    const std::string template() const { return template_; };
+    const std::string param1() const { return param1_; };
+    const std::string param2() const { return param2_; };
+    const std::string param3() const { return param3_; };
+    const std::string param4() const { return param4_; };
+    const std::string param5() const { return param5_; };
+
+    bool has_id() const { return __flags__.test(0);};
+    bool has_template() const { return __flags__.test(1);};
+    bool has_param1() const { return __flags__.test(2);};
+    bool has_param2() const { return __flags__.test(3);};
+    bool has_param3() const { return __flags__.test(4);};
+    bool has_param4() const { return __flags__.test(5);};
+    bool has_param5() const { return __flags__.test(6);};
+
+  protected:
+
+    int id_ = 0;
+    std::string template_;
+    std::string param1_;
+    std::string param2_;
+    std::string param3_;
+    std::string param4_;
+    std::string param5_;
+
+public:
+    std::bitset<7> __flags__;
+  };
+
+};

server/gameserver/mtb/Distribution.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <bitset>
+
+namespace mtb
+{
+
+  class Distribution
+  {
+  public:
+
+    std::shared_ptr<a8::reflect::Class> GetClass() const;
+    int id() const { return id_; };
+    const std::string point() const { return point_; };
+    const std::string value() const { return value_; };
+
+    bool has_id() const { return __flags__.test(0);};
+    bool has_point() const { return __flags__.test(1);};
+    bool has_value() const { return __flags__.test(2);};
+
+  protected:
+
+    int id_ = 0;
+    std::string point_;
+    std::string value_;
+
+public:
+    std::bitset<3> __flags__;
+  };
+
+};

server/gameserver/mtb/LootConfig.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <bitset>
+
+namespace mtb
+{
+
+  class LootConfig
+  {
+  public:
+
+    std::shared_ptr<a8::reflect::Class> GetClass() const;
+    int id() const { return id_; };
+    int method() const { return method_; };
+    const std::string numPara() const { return numPara_; };
+    const std::string content() const { return content_; };
+
+    bool has_id() const { return __flags__.test(0);};
+    bool has_method() const { return __flags__.test(1);};
+    bool has_numPara() const { return __flags__.test(2);};
+    bool has_content() const { return __flags__.test(3);};
+
+  protected:
+
+    int id_ = 0;
+    int method_ = 0;
+    std::string numPara_;
+    std::string content_;
+
+public:
+    std::bitset<4> __flags__;
+  };
+
+};

server/gameserver/mtb/mtb.all.cc

@@ -41,6 +41,13 @@
 #include "mtb/WorldObject.h"
 #include "mtb/MergeItem.h"
 #include "mtb/MapThingGroup.h"
+#include "mtb/BattleBasicAttribute.h"
+#include "mtb/BattleLevelAttribute.h"
+#include "mtb/BattleRandAttribute.h"
+#include "mtb/BattleWeaponAttribute.h"
+#include "mtb/Condition.h"
+#include "mtb/Distribution.h"
+#include "mtb/LootConfig.h"
 
 namespace mtb
 {
@@ -889,4 +896,125 @@ namespace mtb
       return meta_class;
     }
 
+    std::shared_ptr<a8::reflect::Class> BattleBasicAttribute::GetClass() const
+    {
+      std::shared_ptr<a8::reflect::Class> meta_class = nullptr;
+      if (!meta_class) {
+        meta_class = std::make_shared<a8::reflect::Class>("BattleBasicAttribute", 30, 0);
+        meta_class->SetSimpleField(0, "id", a8::reflect::ET_INT32, my_offsetof2(BattleBasicAttribute, id_));
+        meta_class->SetSimpleField(1, "pBaseHealth", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, pBaseHealth_));
+        meta_class->SetSimpleField(2, "pOrigHealth", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, pOrigHealth_));
+        meta_class->SetSimpleField(3, "vOrigHealth", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigHealth_));
+        meta_class->SetSimpleField(4, "pBaseAttack", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, pBaseAttack_));
+        meta_class->SetSimpleField(5, "pOrigAttack", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, pOrigAttack_));
+        meta_class->SetSimpleField(6, "vOrigAttack", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigAttack_));
+        meta_class->SetSimpleField(7, "pBaseDefend", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, pBaseDefend_));
+        meta_class->SetSimpleField(8, "pOrigDefend", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, pOrigDefend_));
+        meta_class->SetSimpleField(9, "vOrigDefend", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigDefend_));
+        meta_class->SetSimpleField(10, "pBaseBlock", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, pBaseBlock_));
+        meta_class->SetSimpleField(11, "pOrigBlock", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, pOrigBlock_));
+        meta_class->SetSimpleField(12, "vOrigBlock", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigBlock_));
+        meta_class->SetSimpleField(13, "vOrigEvaDef", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigEvaDef_));
+        meta_class->SetSimpleField(14, "pBaseCrit", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, pBaseCrit_));
+        meta_class->SetSimpleField(15, "pOrigCrit", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, pOrigCrit_));
+        meta_class->SetSimpleField(16, "vOrigCrit", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigCrit_));
+        meta_class->SetSimpleField(17, "vOrigCriBon", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigCriBon_));
+        meta_class->SetSimpleField(18, "vOrigDamageTakenRateIn", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigDamageTakenRateIn_));
+        meta_class->SetSimpleField(19, "vOrigDamageDealtRateIn", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigDamageDealtRateIn_));
+        meta_class->SetSimpleField(20, "vOrigNormalDamageTakenRateIn", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigNormalDamageTakenRateIn_));
+        meta_class->SetSimpleField(21, "vOrigNormalDamageDealtRateIn", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigNormalDamageDealtRateIn_));
+        meta_class->SetSimpleField(22, "vOrigSkillDamageTakenRateIn", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigSkillDamageTakenRateIn_));
+        meta_class->SetSimpleField(23, "vOrigSkillDamageDealtRateIn", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigSkillDamageDealtRateIn_));
+        meta_class->SetSimpleField(24, "vOrigHealthGainRateIn", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigHealthGainRateIn_));
+        meta_class->SetSimpleField(25, "vOrigHealDealtRateIn", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigHealDealtRateIn_));
+        meta_class->SetSimpleField(26, "vOrigSpeed", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigSpeed_));
+        meta_class->SetSimpleField(27, "vOrigHaste", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigHaste_));
+        meta_class->SetSimpleField(28, "vOrigDrain", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigDrain_));
+        meta_class->SetSimpleField(29, "vOrigTenacity", a8::reflect::ET_FLOAT, my_offsetof2(BattleBasicAttribute, vOrigTenacity_));
+      }
+      return meta_class;
+    }
+
+    std::shared_ptr<a8::reflect::Class> BattleLevelAttribute::GetClass() const
+    {
+      std::shared_ptr<a8::reflect::Class> meta_class = nullptr;
+      if (!meta_class) {
+        meta_class = std::make_shared<a8::reflect::Class>("BattleLevelAttribute", 4, 0);
+        meta_class->SetSimpleField(0, "id", a8::reflect::ET_INT32, my_offsetof2(BattleLevelAttribute, id_));
+        meta_class->SetSimpleField(1, "invoke", a8::reflect::ET_INT32, my_offsetof2(BattleLevelAttribute, invoke_));
+        meta_class->SetSimpleField(2, "cost", a8::reflect::ET_STRING, my_offsetof2(BattleLevelAttribute, cost_));
+        meta_class->SetSimpleField(3, "levelAttribute", a8::reflect::ET_STRING, my_offsetof2(BattleLevelAttribute, levelAttribute_));
+      }
+      return meta_class;
+    }
+
+    std::shared_ptr<a8::reflect::Class> BattleRandAttribute::GetClass() const
+    {
+      std::shared_ptr<a8::reflect::Class> meta_class = nullptr;
+      if (!meta_class) {
+        meta_class = std::make_shared<a8::reflect::Class>("BattleRandAttribute", 5, 0);
+        meta_class->SetSimpleField(0, "id", a8::reflect::ET_INT32, my_offsetof2(BattleRandAttribute, id_));
+        meta_class->SetSimpleField(1, "invoke", a8::reflect::ET_INT32, my_offsetof2(BattleRandAttribute, invoke_));
+        meta_class->SetSimpleField(2, "qualityWeight", a8::reflect::ET_STRING, my_offsetof2(BattleRandAttribute, qualityWeight_));
+        meta_class->SetSimpleField(3, "distribution", a8::reflect::ET_STRING, my_offsetof2(BattleRandAttribute, distribution_));
+        meta_class->SetSimpleField(4, "attributeRange", a8::reflect::ET_STRING, my_offsetof2(BattleRandAttribute, attributeRange_));
+      }
+      return meta_class;
+    }
+
+    std::shared_ptr<a8::reflect::Class> BattleWeaponAttribute::GetClass() const
+    {
+      std::shared_ptr<a8::reflect::Class> meta_class = nullptr;
+      if (!meta_class) {
+        meta_class = std::make_shared<a8::reflect::Class>("BattleWeaponAttribute", 5, 0);
+        meta_class->SetSimpleField(0, "id", a8::reflect::ET_INT32, my_offsetof2(BattleWeaponAttribute, id_));
+        meta_class->SetSimpleField(1, "weapon", a8::reflect::ET_INT32, my_offsetof2(BattleWeaponAttribute, weapon_));
+        meta_class->SetSimpleField(2, "level", a8::reflect::ET_INT32, my_offsetof2(BattleWeaponAttribute, level_));
+        meta_class->SetSimpleField(3, "levelAttribute", a8::reflect::ET_STRING, my_offsetof2(BattleWeaponAttribute, levelAttribute_));
+        meta_class->SetSimpleField(4, "cost", a8::reflect::ET_STRING, my_offsetof2(BattleWeaponAttribute, cost_));
+      }
+      return meta_class;
+    }
+
+    std::shared_ptr<a8::reflect::Class> Condition::GetClass() const
+    {
+      std::shared_ptr<a8::reflect::Class> meta_class = nullptr;
+      if (!meta_class) {
+        meta_class = std::make_shared<a8::reflect::Class>("Condition", 7, 0);
+        meta_class->SetSimpleField(0, "id", a8::reflect::ET_INT32, my_offsetof2(Condition, id_));
+        meta_class->SetSimpleField(1, "template", a8::reflect::ET_STRING, my_offsetof2(Condition, template_));
+        meta_class->SetSimpleField(2, "param1", a8::reflect::ET_STRING, my_offsetof2(Condition, param1_));
+        meta_class->SetSimpleField(3, "param2", a8::reflect::ET_STRING, my_offsetof2(Condition, param2_));
+        meta_class->SetSimpleField(4, "param3", a8::reflect::ET_STRING, my_offsetof2(Condition, param3_));
+        meta_class->SetSimpleField(5, "param4", a8::reflect::ET_STRING, my_offsetof2(Condition, param4_));
+        meta_class->SetSimpleField(6, "param5", a8::reflect::ET_STRING, my_offsetof2(Condition, param5_));
+      }
+      return meta_class;
+    }
+
+    std::shared_ptr<a8::reflect::Class> Distribution::GetClass() const
+    {
+      std::shared_ptr<a8::reflect::Class> meta_class = nullptr;
+      if (!meta_class) {
+        meta_class = std::make_shared<a8::reflect::Class>("Distribution", 3, 0);
+        meta_class->SetSimpleField(0, "id", a8::reflect::ET_INT32, my_offsetof2(Distribution, id_));
+        meta_class->SetSimpleField(1, "point", a8::reflect::ET_STRING, my_offsetof2(Distribution, point_));
+        meta_class->SetSimpleField(2, "value", a8::reflect::ET_STRING, my_offsetof2(Distribution, value_));
+      }
+      return meta_class;
+    }
+
+    std::shared_ptr<a8::reflect::Class> LootConfig::GetClass() const
+    {
+      std::shared_ptr<a8::reflect::Class> meta_class = nullptr;
+      if (!meta_class) {
+        meta_class = std::make_shared<a8::reflect::Class>("LootConfig", 4, 0);
+        meta_class->SetSimpleField(0, "id", a8::reflect::ET_INT32, my_offsetof2(LootConfig, id_));
+        meta_class->SetSimpleField(1, "method", a8::reflect::ET_INT32, my_offsetof2(LootConfig, method_));
+        meta_class->SetSimpleField(2, "numPara", a8::reflect::ET_STRING, my_offsetof2(LootConfig, numPara_));
+        meta_class->SetSimpleField(3, "content", a8::reflect::ET_STRING, my_offsetof2(LootConfig, content_));
+      }
+      return meta_class;
+    }
+
 }

server/tools/protobuild/mt.proto

@@ -663,4 +663,90 @@ message MapThingGroup
     optional string rule = 2;
     optional string mapThings = 3;
     optional string heroes = 4;
-}
+}
+
+message BattleBasicAttribute
+{
+    optional int32 id = 1;
+    optional float pBaseHealth = 2;
+    optional float pOrigHealth = 3;
+    optional float vOrigHealth = 4;
+    optional float pBaseAttack = 5;
+    optional float pOrigAttack = 6;
+    optional float vOrigAttack = 7;
+    optional float pBaseDefend = 8;
+    optional float pOrigDefend = 9;
+    optional float vOrigDefend = 10;
+    optional float pBaseBlock = 11;
+    optional float pOrigBlock = 12;
+    optional float vOrigBlock = 13;
+    optional float vOrigEvaDef = 14;
+    optional float pBaseCrit = 15;
+    optional float pOrigCrit = 16;
+    optional float vOrigCrit = 17;
+    optional float vOrigCriBon = 18;
+    optional float vOrigDamageTakenRateIn = 19;
+    optional float vOrigDamageDealtRateIn = 20;
+    optional float vOrigNormalDamageTakenRateIn = 21;
+    optional float vOrigNormalDamageDealtRateIn = 22;
+    optional float vOrigSkillDamageTakenRateIn = 23;
+    optional float vOrigSkillDamageDealtRateIn = 24;
+    optional float vOrigHealthGainRateIn = 25;
+    optional float vOrigHealDealtRateIn = 26;
+    optional float vOrigSpeed = 27;
+    optional float vOrigHaste = 28;
+    optional float vOrigDrain = 29;
+    optional float vOrigTenacity = 30;
+}
+
+message BattleLevelAttribute
+{
+    optional int32 id = 1;
+    optional int32 invoke = 2;
+    optional string cost = 3;
+    optional string levelAttribute = 4;
+}
+
+message BattleRandAttribute
+{
+    optional int32 id = 1;
+    optional int32 invoke = 2;
+    optional string qualityWeight = 3;
+    optional string distribution = 4;
+    optional string attributeRange = 5;
+}
+
+message BattleWeaponAttribute
+{
+    optional int32 id = 1;
+    optional int32 weapon = 2;
+    optional int32 level = 3;
+    optional string levelAttribute = 4;
+    optional string cost = 5;
+}
+
+message Condition
+{
+    optional int32 id = 1;
+    optional string template = 2;
+    optional string param1 = 3;
+    optional string param2 = 4;
+    optional string param3 = 5;
+    optional string param4 = 6;
+    optional string param5 = 7;
+}
+
+message Distribution
+{
+    optional int32 id = 1;
+    optional string point = 2;
+    optional string value = 3;
+}
+
+message LootConfig
+{
+    optional int32 id = 1;
+    optional int32 method = 2;
+    optional string numPara = 3;
+    optional string content = 4;
+}