game2006/server/gameserver/selfchecker.cc

#include "precompile.h"

#include <a8/magicenum.h>

#include "selfchecker.h"

#include "mt/Equip.h"
#include "mt/Buff.h"
#include "mt/Hero.h"
#include "mt/Map.h"
#include "mt/Skill.h"
#include "mt/SkillNumber.h"
#include "mt/MapThing.h"

std::set<int> SelfChecker::used_buffs;

void SelfChecker::Init()
{
    {
        AddBuff(1005);
        AddBuff(1025);
        AddBuff(1039);
        AddBuff(202013);
        AddBuff(204014);
        AddBuff(209016);
        AddBuff(208014);
    }
    auto fields = a8::GetEnumFields<SpecBuffId_e>();
    for (auto& pair : *fields) {
        AddBuff(pair.second);
    }
    mt::Equip::Traverse
        (
         [] (const mt::Equip* meta, bool& stop)
         {
             if (meta->buffid()) {
                 SelfChecker::AddBuff(meta->buffid());
             }
             if (meta->equip_type() == EQUIP_TYPE_WEAPON &&
                 meta->equip_subtype() == GUN_SUB_EQUIP_TYPE_FLY_HOOk) {
                 if (meta->id() != 30915) {
                     SelfChecker::AddBuff(meta->_int_param1);
                     SelfChecker::AddBuff(meta->_int_param2);
                 }
             }
             if (meta->equip_type() == EQUIP_TYPE_THROW &&
                 meta->equip_subtype() == THROW_EQUIP_TYPE_ADD_BUFF) {
                 SelfChecker::AddBuff(meta->_int_param1);
             }
             switch (meta->_inventory_slot()) {
             case IS_C4:
                 {
                     SelfChecker::AddBuff(meta->_int_param1);
                 }
                 break;
             default:
                 {
                 }
                 break;
             }
             for (auto& tuple : meta->_power_charge) {
                 SelfChecker::AddBuff(std::get<2>(tuple));
             }
             if (meta->_car_active_buff_id) {
                 SelfChecker::AddBuff(meta->_car_active_buff_id);
             }
             if (meta->_car_deactive_buff_id) {
                 SelfChecker::AddBuff(meta->_car_deactive_buff_id);
             }
             for (auto& tuple : meta->_car_buff_list) {
                 SelfChecker::AddBuff(std::get<1>(tuple));
             }
             for (int buff_id : meta->_hit_buff_list) {
                 SelfChecker::AddBuff(buff_id);
             }
         });
    mt::Hero::Traverse
        (
         [] (const mt::Hero* meta, bool& stop)
         {
             for (int buff_id : meta->_init_buffs) {
                 SelfChecker::AddBuff(buff_id);
             }
         });
    mt::Map::Traverse
        (
         [] (const mt::Map* meta, bool& stop)
         {
             for (int buff_id : meta->buff_list) {
                 SelfChecker::AddBuff(buff_id);
             }
         });
    mt::SkillNumber::Traverse
        (
         [] (const mt::SkillNumber* meta, bool& stop)
         {
             if (meta->buff_id()) {
                 SelfChecker::AddBuff(meta->buff_id());
             }
         });
    mt::Skill::Traverse
        (
         [] (const mt::Skill* meta, bool& stop)
         {
             for (int buff_id : meta->_buff_list) {
                 SelfChecker::AddBuff(buff_id);
             }
             for (auto& phase : meta->_phases) {
                 switch (phase.func_id) {
                 case kSkill_ForthBackJump:
                     {
                         for (int buff_id : phase.phase_param3_ints) {
                             SelfChecker::AddBuff(buff_id);
                         }
                     }
                     break;
                 default:
                     {
                     }
                     break;
                 }
             }
         });
    mt::Buff::Traverse
        (
         [] (const mt::Buff* meta, bool& stop)
         {
             for (int buff_id : meta->_child_buff_list) {
                 SelfChecker::AddBuff(buff_id);
             }
             switch (meta->buff_effect()) {
             case kBET_AddCarBuff:
                 {
                     SelfChecker::AddBuff(meta->_int_buff_param1);
                 }
                 break;
             case kBET_TurnOver:
                 {
                     for (int buff_id : meta->_buff_param1_int_list) {
                         SelfChecker::AddBuff(buff_id);
                     }
                 }
                 break;
             case kBET_Disperse:
             case kBET_SelectTargetWithSelfPos:
                 {
                     for (int buff_id : meta->_buff_param2_int_list) {
                         SelfChecker::AddBuff(buff_id);
                     }
                 }
                 break;
             case kBET_DelayAddBuff:
             case kBET_IntervalAddBuff:
                 {
                     SelfChecker::AddBuff(meta->_int_buff_param2);
                 }
                 break;
             case kBET_CallFunc:
                 {
                     if (meta->_int_buff_param1 == 3) {
                         for (int buff_id : meta->_buff_param3_int_list) {
                             SelfChecker::AddBuff(buff_id);
                         }
                     }
                 }
                 break;
             case kBET_Sprint:
                 {
                     for (int buff_id : meta->_buff_param3_int_list) {
                         SelfChecker::AddBuff(buff_id);
                     }
                 }
                 break;
             case kBET_BatchAddBuff:
                 {
                     for (auto& tuple : meta->_batch_add_list) {
                         for (auto& tuple1 : std::get<1>(tuple)) {
                             SelfChecker::AddBuff(std::get<0>(tuple1));
                         }
                     }
                 }
                 break;
             case kBET_CondAddBuff:
                 {
                     for (int buff_id : meta->_buff_param4_int_list) {
                         SelfChecker::AddBuff(buff_id);
                     }
                 }
                 break;
             default:
                 {
                 }
                 break;
             }//end switch
             for (const auto& tuple : meta->_post_remove_action) {
                 switch (std::get<0>(tuple)) {
                 case kAddBuffAction:
                     {
                         for (int buff_id :std::get<1>(tuple)) {
                             SelfChecker::AddBuff(buff_id);
                         }
                     }
                     break;
                 default:
                     {
                     }
                     break;
                 }
             }
         });
    mt::MapThing::Traverse
        (
         [] (const mt::MapThing* meta, bool& stop)
         {
             for (int buff_id : meta->_buff_list) {
                 if (buff_id != 201017) {
                     SelfChecker::AddBuff(buff_id);
                 }
             }
         });
    Check();
}

void SelfChecker::UnInit()
{

}

void SelfChecker::Check()
{
    mt::Buff::Traverse
        (
         [] (const mt::Buff* meta, bool& stop)
         {
             if (SelfChecker::used_buffs.find(meta->buff_id()) == SelfChecker::used_buffs.end()) {
                 a8::XPrintf("unuse buff:%d %d %s %s\n",
                             {meta->buff_id(),
                                     meta->buff_effect(),
                                     meta->name(),
                                     a8::GetEnumName<BuffEffectType_e>(meta->buff_effect())
                                     }
                             );
             }
         });
}

void SelfChecker::AddBuff(int buff_id)
{
    if (!mt::Buff::GetById(buff_id)) {
        abort();
    }
    used_buffs.insert(buff_id);
}