添加吉利服处理

server/gameserver/android.cc

@@ -26,8 +26,7 @@ void Android::Initialize()
 {
     Human::Initialize();
     health = meta->i->health();
-    skin.skin_id = 14001;
+    SetSkinInfo(14001);
-    skin.skin_lv = 1;
 }
 
 void Android::Update(int delta_time)

server/gameserver/bullet.cc

@@ -72,7 +72,7 @@ void Bullet::OnHit(std::set<Entity*>& objects)
                     player->stats.damage_amount_out += finaly_dmg;
                     hum->DecHP(finaly_dmg, player->entity_uniid, player->name, gun_meta->i->id());
                     if (a8::HasBitFlag(hum->status, HS_ReflectDamage) && hum->skill_meta) {
-                        float reflect_dmg = finaly_dmg * hum->skill_meta->GetValue1(hum->skin.skin_lv);
+                        float reflect_dmg = finaly_dmg * hum->skill_meta->value1;
                         if (reflect_dmg > 1.0f) {
                             player->DecHP(reflect_dmg, hum->entity_uniid, hum->name, gun_meta->i->id());
                         }

server/gameserver/human.cc

@@ -122,7 +122,11 @@ void Human::FillMFObjectFull(cs::MFObjectFull* full_data)
     p->set_disconnected(disconnected);
     p->set_anim_type(anim_type);
     p->set_anim_seq(anim_seq);
-    skin.ToPB(p->mutable_skin());
+    if (skin_jlf.skin_id != 0) {
+        skin_jlf.ToPB(p->mutable_skin());
+    } else {
+        skin.ToPB(p->mutable_skin());
+    }
     p->set_backpack(backpack);
     p->set_helmet(helmet);
     p->set_chest(chest);
@@ -572,12 +576,11 @@ void Human::UpdatePoisoning()
 
 void Human::SyncAroundPlayers()
 {
-    room->TouchHumanList(a8::XParams(),
+    for (auto& cell : grid_list) {
-                         [this] (Human* hum, a8::XParams& param) -> bool
+        for (Human* hum : cell->human_list) {
-                         {
+            hum->new_objects.insert(this);
-                             hum->new_objects.insert(this);
+        }
-                             return true;
+    }
-                         });
 }
 
 void Human::AutoLoadingBullet(bool manual)
@@ -972,7 +975,7 @@ void Human::DoSkill()
 {
     if (skill_meta && skill_meta->i->condition() == SC_Active) {
         int passed_time = (room->frame_no - last_use_skill_frameno_) * FRAME_RATE_MS;
-        int skill_left_time = std::max(0, skill_meta->GetLastTime(skin.skin_lv) * 1000 - passed_time);
+        int skill_left_time = std::max(0, skill_meta->last_time * 1000 - passed_time);
         if (skill_left_time <= 0 || last_use_skill_frameno_ == 0) {
             skill_xtimer_attacher_.ClearTimerList();
             switch (skill_meta->i->type()) {
@@ -980,7 +983,7 @@ void Human::DoSkill()
                 {
                     hide_frameno_ = room->frame_no;
                     a8::SetBitFlag(status, HS_Hide);
-                    room->xtimer.AddDeadLineTimerAndAttach(skill_meta->GetLastTime(skin.skin_lv) * SERVER_FRAME_RATE,
+                    room->xtimer.AddDeadLineTimerAndAttach(skill_meta->last_time * SERVER_FRAME_RATE,
                                                            a8::XParams()
                                                            .SetSender(this),
                                                            [] (const a8::XParams& param)
@@ -1008,8 +1011,8 @@ void Human::DoSkill()
                 {
                     accelerate_frameno_ = room->frame_no;
                     a8::SetBitFlag(status, HS_Accelerate);
-                    buff.speed += skill_meta->GetValue1(skin.skin_lv);
+                    buff.speed += skill_meta->value1;
-                    room->xtimer.AddDeadLineTimerAndAttach(skill_meta->GetLastTime(skin.skin_lv) * SERVER_FRAME_RATE,
+                    room->xtimer.AddDeadLineTimerAndAttach(skill_meta->last_time * SERVER_FRAME_RATE,
                                                            a8::XParams()
                                                            .SetSender(this),
                                                            [] (const a8::XParams& param)
@@ -1033,7 +1036,7 @@ void Human::DoSkill()
                 {
                     damageadd_frameno_ = room->frame_no;
                     a8::SetBitFlag(status, HS_DamageAdd);
-                    room->xtimer.AddDeadLineTimerAndAttach(skill_meta->GetLastTime(skin.skin_lv) * SERVER_FRAME_RATE,
+                    room->xtimer.AddDeadLineTimerAndAttach(skill_meta->last_time * SERVER_FRAME_RATE,
                                                            a8::XParams()
                                                            .SetSender(this),
                                                            [] (const a8::XParams& param)
@@ -1056,7 +1059,7 @@ void Human::DoSkill()
                 {
                     defadd_frameno_ = room->frame_no;
                     a8::SetBitFlag(status, HS_DefAdd);
-                    room->xtimer.AddDeadLineTimerAndAttach(skill_meta->GetLastTime(skin.skin_lv) * SERVER_FRAME_RATE,
+                    room->xtimer.AddDeadLineTimerAndAttach(skill_meta->last_time * SERVER_FRAME_RATE,
                                                            a8::XParams()
                                                            .SetSender(this),
                                                            [] (const a8::XParams& param)
@@ -1093,7 +1096,7 @@ void Human::DoSkill()
                                                          },
                                                          &skill_xtimer_attacher_.timer_list_
                                                          );
-                    room->xtimer.AddDeadLineTimerAndAttach(skill_meta->GetLastTime(skin.skin_lv) * SERVER_FRAME_RATE,
+                    room->xtimer.AddDeadLineTimerAndAttach(skill_meta->last_time * SERVER_FRAME_RATE,
                                                            a8::XParams()
                                                            .SetSender(this),
                                                            [] (const a8::XParams& param)
@@ -1116,7 +1119,7 @@ void Human::DoSkill()
                 {
                     reflect_damage_frameno_ = room->frame_no;
                     a8::SetBitFlag(status, HS_ReflectDamage);
-                    room->xtimer.AddDeadLineTimerAndAttach(skill_meta->GetLastTime(skin.skin_lv) * SERVER_FRAME_RATE,
+                    room->xtimer.AddDeadLineTimerAndAttach(skill_meta->last_time * SERVER_FRAME_RATE,
                                                            a8::XParams()
                                                            .SetSender(this),
                                                            [] (const a8::XParams& param)
@@ -1419,8 +1422,14 @@ void Human::RecalcVolume()
 void Human::RecalcBuff()
 {
     buff = HumanAbility();
-    if (skin_meta) {
+    if (skin_jlf_meta) {
-
+        buff.damage_add += skin_jlf_meta->i->atk_add();
+        buff.def_add += skin_jlf_meta->i->def_add();
+        buff.speed += skin_jlf_meta->i->speed_add();
+    } else if (skin_meta) {
+        buff.damage_add += skin_meta->i->atk_add();
+        buff.def_add += skin_meta->i->def_add();
+        buff.speed += skin_meta->i->speed_add();
     }
 }
 
@@ -1494,50 +1503,50 @@ void Human::FillBodyState(::google::protobuf::RepeatedPtrField<::cs::MFBodyState
         int passed_time = (room->frame_no - hide_frameno_) * FRAME_RATE_MS;
         cs::MFBodyState* state = states->Add();
         state->set_state_type(HS_Hide);
-        state->set_left_time(std::max(0, skill_meta->GetLastTime(skin.skin_lv) * 1000 - passed_time));
+        state->set_left_time(std::max(0, skill_meta->last_time * 1000 - passed_time));
-        state->set_lasting_time(skill_meta->GetLastTime(skin.skin_lv) * 1000);
+        state->set_lasting_time(skill_meta->last_time * 1000);
     }
     if (a8::HasBitFlag(status, HS_Accelerate) && skill_meta) {
         int passed_time = (room->frame_no - accelerate_frameno_) * FRAME_RATE_MS;
         cs::MFBodyState* state = states->Add();
         state->set_state_type(HS_Accelerate);
-        state->set_left_time(std::max(0, skill_meta->GetLastTime(skin.skin_lv) * 1000 - passed_time));
+        state->set_left_time(std::max(0, skill_meta->last_time * 1000 - passed_time));
-        state->set_lasting_time(skill_meta->GetLastTime(skin.skin_lv) * 1000);
+        state->set_lasting_time(skill_meta->last_time * 1000);
     }
     if (a8::HasBitFlag(status, HS_DamageAdd) && skill_meta) {
         int passed_time = (room->frame_no - damageadd_frameno_) * FRAME_RATE_MS;
         cs::MFBodyState* state = states->Add();
         state->set_state_type(HS_DamageAdd);
-        state->set_left_time(std::max(0, skill_meta->GetLastTime(skin.skin_lv) * 1000 - passed_time));
+        state->set_left_time(std::max(0, skill_meta->last_time * 1000 - passed_time));
-        state->set_lasting_time(skill_meta->GetLastTime(skin.skin_lv) * 1000);
+        state->set_lasting_time(skill_meta->last_time * 1000);
     }
     if (a8::HasBitFlag(status, HS_DefAdd) && skill_meta) {
         int passed_time = (room->frame_no - defadd_frameno_) * FRAME_RATE_MS;
         cs::MFBodyState* state = states->Add();
         state->set_state_type(HS_DefAdd);
-        state->set_left_time(std::max(0, skill_meta->GetLastTime(skin.skin_lv) * 1000 - passed_time));
+        state->set_left_time(std::max(0, skill_meta->last_time * 1000 - passed_time));
-        state->set_lasting_time(skill_meta->GetLastTime(skin.skin_lv) * 1000);
+        state->set_lasting_time(skill_meta->last_time * 1000);
     }
     if (a8::HasBitFlag(status, HS_RecoverHP) && skill_meta) {
         int passed_time = (room->frame_no - recover_hp_frameno_) * FRAME_RATE_MS;
         cs::MFBodyState* state = states->Add();
         state->set_state_type(HS_RecoverHP);
-        state->set_left_time(std::max(0, skill_meta->GetLastTime(skin.skin_lv) * 1000 - passed_time));
+        state->set_left_time(std::max(0, skill_meta->last_time * 1000 - passed_time));
-        state->set_lasting_time(skill_meta->GetLastTime(skin.skin_lv) * 1000);
+        state->set_lasting_time(skill_meta->last_time * 1000);
     }
     if (a8::HasBitFlag(status, HS_ReflectDamage) && skill_meta) {
         int passed_time = (room->frame_no - reflect_damage_frameno_) * FRAME_RATE_MS;
         cs::MFBodyState* state = states->Add();
         state->set_state_type(HS_ReflectDamage);
-        state->set_left_time(std::max(0, skill_meta->GetLastTime(skin.skin_lv) * 1000 - passed_time));
+        state->set_left_time(std::max(0, skill_meta->last_time * 1000 - passed_time));
-        state->set_lasting_time(skill_meta->GetLastTime(skin.skin_lv) * 1000);
+        state->set_lasting_time(skill_meta->last_time * 1000);
     }
     if (a8::HasBitFlag(status, HS_SummonHero) && skill_meta) {
         int passed_time = (room->frame_no - summon_hero_frameno_) * FRAME_RATE_MS;
         cs::MFBodyState* state = states->Add();
         state->set_state_type(HS_SummonHero);
-        state->set_left_time(std::max(0, skill_meta->GetLastTime(skin.skin_lv) * 1000 - passed_time));
+        state->set_left_time(std::max(0, skill_meta->last_time * 1000 - passed_time));
-        state->set_lasting_time(skill_meta->GetLastTime(skin.skin_lv) * 1000);
+        state->set_lasting_time(skill_meta->last_time * 1000);
     }
 }
 
@@ -1547,7 +1556,7 @@ void Human::SummonHero()
     if (hero) {
         summon_hero_frameno_ = room->frame_no;
         a8::SetBitFlag(status, HS_SummonHero);
-        room->xtimer.AddDeadLineTimerAndAttach(skill_meta->GetLastTime(skin.skin_lv) * SERVER_FRAME_RATE,
+        room->xtimer.AddDeadLineTimerAndAttach(skill_meta->last_time * SERVER_FRAME_RATE,
                                                a8::XParams()
                                                .SetSender(this)
                                                .SetParam1(hero->entity_uniid),
@@ -1882,6 +1891,38 @@ int Human::GetSkinConfigLv(int skin_id)
     return itr != skin_configs.end() ? itr->second : 0;
 }
 
+void Human::SetSkinInfo(int skin_id)
+{
+    skin.skin_id = skin_id;
+    if (skin.skin_id != 0){
+        skin.skin_lv = std::max(1, GetSkinConfigLv(skin.skin_id));
+    }
+}
+
+const Skin& Human::GetSkin()
+{
+    if (skin_jlf.skin_id != 0) {
+        return skin_jlf;
+    }
+    return skin;
+}
+
+int Human::SkinId()
+{
+    if (skin_jlf.skin_id != 0) {
+        return skin_jlf.skin_id;
+    }
+    return skin.skin_id;
+}
+
+int Human::SkinLv()
+{
+    if (skin_jlf.skin_id != 0) {
+        return skin_jlf.skin_lv;
+    }
+    return skin.skin_lv;
+}
+
 void Human::GenerateWalkZone()
 {
     in_walk_zone = true;

server/gameserver/human.h

@@ -47,6 +47,7 @@ class Human : public Entity
     MetaData::Equip* chest_meta = nullptr;
     MetaData::Dress* skin_meta = nullptr;
     MetaData::Skill* skill_meta = nullptr;
+    MetaData::Dress* skin_jlf_meta = nullptr;
     HumanAbility buff;
 
     Vector2D move_dir;
@@ -65,7 +66,7 @@ class Human : public Entity
     int action_duration = 0;
     int action_item_id = 0;
     int action_target_id = 0;
-    Skin skin;
+    Skin skin_jlf;
     int backpack = 0;
     int helmet = 0;
     int chest = 0;
@@ -193,6 +194,10 @@ class Human : public Entity
     void SendWxVoip();
     int GetWeaponConfigLv(int weapon_id);
     int GetSkinConfigLv(int skin_id);
+    void SetSkinInfo(int skin_id);
+    const Skin& GetSkin();
+    int SkinId();
+    int SkinLv();
 
 protected:
     void GenerateWalkZone();
@@ -254,6 +259,8 @@ private:
     bool sent_game_end_ = false;
     int send_gameover_trycount_ = 0;
 
+    Skin skin;
+
     friend class FrameMaker;
     friend class FrameEvent;
 };

server/gameserver/metadata.cc

@@ -339,90 +339,10 @@ namespace MetaData
 
     void Skill::Init()
     {
-        {
+        value1 = a8::XValue(i->value1()).GetDouble();
-            std::vector<std::string> strings;
+        value2 = a8::XValue(i->value2()).GetDouble();
-            a8::Split(i->value1(), strings, '|');
+        area = a8::XValue(i->area()).GetDouble();
-            assert(i->value1() == "" || strings.size() == MAX_SKIN_LV);
+        last_time = a8::XValue(i->last_time()).GetInt();
-            for (size_t i = 0; i < strings.size(); ++i) {
-                if (i < MAX_SKIN_LV) {
-                    value1[i] = a8::XValue(strings[i]).GetDouble();
-                }
-            }
-        }
-        {
-            std::vector<std::string> strings;
-            a8::Split(i->value2(), strings, '|');
-            assert(i->value2() == "" || strings.size() == MAX_SKIN_LV);
-            for (size_t i = 0; i < strings.size(); ++i) {
-                if (i < MAX_SKIN_LV) {
-                    value2[i] = a8::XValue(strings[i]).GetDouble();
-                }
-            }
-        }
-        {
-            std::vector<std::string> strings;
-            a8::Split(i->area(), strings, '|');
-            assert(i->area() == "" || strings.size() == MAX_SKIN_LV);
-            for (size_t i = 0; i < strings.size(); ++i) {
-                if (i < MAX_SKIN_LV) {
-                    area[i] = a8::XValue(strings[i]).GetDouble();
-                }
-            }
-        }
-        {
-            std::vector<std::string> strings;
-            a8::Split(i->last_time(), strings, '|');
-            assert(i->last_time() == "" || strings.size() == MAX_SKIN_LV);
-            for (size_t i = 0; i < strings.size(); ++i) {
-                if (i < MAX_SKIN_LV) {
-                    last_time[i] = a8::XValue(strings[i]);
-                }
-            }
-        }
-    }
-
-    float Skill::GetValue1(int skin_lv)
-    {
-        if (skin_lv < 1) {
-            return value1[0];
-        }
-        if (skin_lv > MAX_SKIN_LV) {
-            return value1[MAX_SKIN_LV - 1];
-        }
-        return value1[skin_lv - 1];
-    }
-
-    float Skill::GetValue2(int skin_lv)
-    {
-        if (skin_lv < 1) {
-            return value2[0];
-        }
-        if (skin_lv > MAX_SKIN_LV) {
-            return value2[MAX_SKIN_LV - 1];
-        }
-        return value2[skin_lv - 1];
-    }
-
-    float Skill::GetArea(int skin_lv)
-    {
-        if (skin_lv < 1) {
-            return area[0];
-        }
-        if (skin_lv > MAX_SKIN_LV) {
-            return area[MAX_SKIN_LV - 1];
-        }
-        return area[skin_lv - 1];
-    }
-
-    int Skill::GetLastTime(int skin_lv)
-    {
-        if (skin_lv < 1) {
-            return last_time[0];
-        }
-        if (skin_lv > MAX_SKIN_LV) {
-            return last_time[MAX_SKIN_LV - 1];
-        }
-        return last_time[skin_lv - 1];
     }
 
 }

server/gameserver/metadata.h

@@ -140,17 +140,10 @@ namespace MetaData
         const metatable::Skill* i = nullptr;
 
         void Init();
-        float GetValue1(int skin_lv);
+        float value1 = 0.0f;
-        float GetValue2(int skin_lv);
+        float value2 = 0.0f;
-        float GetArea(int skin_lv);
+        float area = 0.0f;
-        int GetLastTime(int skin_lv);
+        int last_time = 0;
-
-    private:
-        std::array<float, MAX_SKIN_LV> value1 = {};
-        std::array<float, MAX_SKIN_LV> value2 = {};
-        std::array<float, MAX_SKIN_LV> area = {};
-        std::array<int, MAX_SKIN_LV> last_time = {};
-
     };
 
     struct Dress

server/gameserver/metamgr.cc

@@ -58,7 +58,7 @@ public:
     std::map<int, MetaData::Drop*> drop_hash;
     std::map<std::string, std::list<metatable::MapTplThingJson>> maptpl_meta_hash;
     std::map<std::string, std::vector<MetaData::MapTplThing>> maptpl_hash;
-    std::map<int, MetaData::Dress*> dress_hash;
+    std::map<long long, MetaData::Dress*> dress_hash;
     std::map<int, MetaData::Skill*> skill_hash;
     std::map<int, MetaData::RankReward*> rankreward_hash;
     std::map<int, MetaData::KillReward*> killreward_hash;
@@ -232,7 +232,15 @@ private:
         for (auto& meta : dress_meta_list) {
             MetaData::Dress& item = a8::FastAppend(dress_list);
             item.i = &meta;
-            dress_hash[item.i->id()] = &item;
+            dress_hash[a8::MakeInt64(item.i->id(),
+                                     item.i->level()
+                                     )] = &item;
+        }
+        for (auto& meta : dress_meta_list) {
+            MetaData::Dress* dress_meta = MetaMgr::Instance()->GetDress(meta.id(), 1);
+            if (dress_meta) {
+                meta.set_skill_id(dress_meta->i->skill_id());
+            }
         }
 
         for (auto& meta : skill_meta_list) {
@@ -391,9 +399,9 @@ MetaData::Skill* MetaMgr::GetSkill(int skill_id)
     return itr != loader_->skill_hash.end() ? itr->second : nullptr;
 }
 
-MetaData::Dress* MetaMgr::GetDress(int dress_id)
+MetaData::Dress* MetaMgr::GetDress(int dress_id, int level)
 {
-    auto itr = loader_->dress_hash.find(dress_id);
+    auto itr = loader_->dress_hash.find(a8::MakeInt64(dress_id, level));
     return itr != loader_->dress_hash.end() ? itr->second : nullptr;
 }
 

server/gameserver/metamgr.h

@@ -32,7 +32,7 @@ class MetaMgr : public a8::Singleton<MetaMgr>
     std::list<MetaData::AirDrop>& GetAirDrops();
     MetaData::AirLine* RandAirLine();
     MetaData::Skill* GetSkill(int skill_id);
-    MetaData::Dress* GetDress(int dress_id);
+    MetaData::Dress* GetDress(int dress_id, int level);
     float GetRankRewardParam(int rank);
     float GetKillRewardParam(int kill_num);
     std::vector<MetaData::Robot>* GetRobotList();

server/gameserver/player.cc

@@ -32,7 +32,7 @@ void Player::Initialize()
     Human::Initialize();
     health = meta->i->health();
     max_energy_shield = energy_shield;
-    skin_meta = MetaMgr::Instance()->GetDress(skin.skin_id);
+    skin_meta = MetaMgr::Instance()->GetDress(SkinId(), SkinLv());
     if (skin_meta) {
         skill_meta = MetaMgr::Instance()->GetSkill(skin_meta->i->skill_id());
     } else {
@@ -546,19 +546,21 @@ void Player::LootInteraction(Loot* entity)
         break;
     case 8:
         {
-            if (skin.skin_id != 0) {
+            if (item_meta->i->is_luck()) {
-                room->DropItem(pos, skin.skin_id, 1, skin.skin_lv);
+                if (skin_jlf.skin_id != 0) {
+                    room->DropItem(pos, skin_jlf.skin_id, 1, skin_jlf.skin_lv);
+                }
+                skin_jlf.skin_id = entity->item_id;
+                skin_jlf.skin_lv = std::max(1, GetSkinConfigLv(skin_jlf.skin_id));
+                skin_jlf_meta = MetaMgr::Instance()->GetDress(skin_jlf.skin_id, skin_jlf.skin_lv);
+                if (skin_jlf_meta) {
+                    skill_meta = MetaMgr::Instance()->GetSkill(skin_jlf_meta->i->skill_id());
+                } else {
+                    skill_meta = nullptr;
+                }
+                RecalcBuff();
+                SyncAroundPlayers();
             }
-            skin.skin_id = entity->item_id;
-            skin.skin_lv = std::max(1, GetSkinConfigLv(skin.skin_id));
-            skin_meta = MetaMgr::Instance()->GetDress(skin.skin_id);
-            if (skin_meta) {
-                skill_meta = MetaMgr::Instance()->GetSkill(skin_meta->i->skill_id());
-            } else {
-                skill_meta = nullptr;
-            }
-            RecalcBuff();
-            SyncAroundPlayers();
         }
         break;
     default:

server/gameserver/playermgr.cc

@@ -59,12 +59,7 @@ Player* PlayerMgr::CreatePlayerByCMJoin(long ip_saddr, int socket, const cs::CMJ
             hum->skin_configs[skin.skin_id()] = skin.skin_lv();
         }
     }
-    #if 1
+    hum->SetSkinInfo(msg.baseskin());
-    hum->skin.skin_id = msg.baseskin();
-    if (hum->skin.skin_id != 0){
-        hum->skin.skin_lv = std::max(1, hum->GetSkinConfigLv(hum->skin.skin_id));
-    }
-    #endif
     hum->ProcPrepareItems(msg.prepare_items());
     socket_hash_[socket] = hum;
     return hum;

server/gameserver/room.cc

@@ -536,7 +536,7 @@ Hero* Room::CreateHero(Human* hum)
     hero->move_dir = hum->move_dir;
     hero->attack_dir = hum->attack_dir;
     hero->master = hum;
-    hero->skin = hum->skin;
+    hero->skin = hum->GetSkin();
     hero->backpack = hum->backpack;
     hero->helmet = hum->helmet;
     hero->chest = hum->chest;
@@ -670,8 +670,8 @@ void Room::OnHumanDie(Human* hum)
         for (auto& pair : human_hash_) {
             if (pair.second != hum && (pair.second->team_id == 0 || pair.second->team_id != hum->team_id)) {
                 float distance = (hum->pos - pair.second->pos).Norm();
-                if (distance <= hum->skill_meta->GetArea(hum->skin.skin_lv)) {
+                if (distance <= hum->skill_meta->area) {
-                    pair.second->DecHP(hum->skill_meta->GetValue1(hum->skin.skin_lv),
+                    pair.second->DecHP(hum->skill_meta->value1,
                                        hum->entity_uniid,
                                        hum->name,
                                        VW_SelfDetonate);

server/tools/protobuild/metatable.proto

@@ -73,6 +73,7 @@ message Equip
     optional string volume = 19; //装备容量
     optional int32 bullet_rad = 20; //子弹半径
     optional int32 group_num = 21; //每组数量
+    optional int32 is_luck = 22; //是否吉利服
     optional string bullet_born_offset = 30; //子弹出生偏移
     optional float bullet_angle = 34; //子弹浮动方向
     optional string name = 35; //装备名字
@@ -154,7 +155,11 @@ message AirLine
 message Dress
 {
     optional int32 id = 1;
-    optional int32 skill_id = 2;
+    optional int32 level = 2;
+    optional int32 skill_id = 3;
+    optional int32 atk_add = 10;
+    optional int32 def_add = 11;
+    optional int32 speed_add = 12;
 }
 
 message RankReward