1111 删除旧榜单相关；

hxp

2025-09-03 efaf363493930c5148271e5a50bbddd07909e110

1111 删除旧榜单相关；

 PySysDB/PySysDBPY.h

@@ -2130,112 +2130,6 @@
    BYTE        NeedNotify;        //是否需要广播

};



//垃圾分类活动时间表



struct tagActGarbageSorting

{

    DWORD        _CfgID;    //配置ID

    char        StartDate;    //开启日期

    char        EndDate;    //结束日期

    BYTE        ResetType;    //重置类型，0-0点重置；1-5点重置

    WORD        LVLimit;    //限制等级

    BYTE        CTGTypeEffValue;    //充值有效类型值

};



//垃圾分类任务产出表



struct tagActGarbageTask

{

    DWORD        _GarbageTasklD;    //垃圾任务ID

    DWORD        FinishNeedValue;    //完成所需进度值

    DWORD        FinishTimeMax;    //总可完成次数，0不限

    BYTE        AutoProduce;        //自动产生垃圾

    list        ProduceGarbageRateList;    //随机产生垃圾概率饼图

};



//Boss历练活动表



struct tagActBossTrial

{

    DWORD        _CfgID;    //配置ID

    char        StartDate;    //开启日期

    char        EndDate;    //结束日期

    char        JoinStartTime;    //参与开始时间点

    char        JoinEndTime;    //参与结束时间点

    WORD        LVLimit;    //限制等级

    BYTE        IsDayReset;    //是否每天重置

    BYTE        ResetType;    //重置类型，0-0点重置；1-5点重置

    dict        SubmitItemAwardInfo;    //提交凭证个数对应奖励

    BYTE        SubmitAwardResetType;    //提交凭证每日重置类型，0-跟随活动； 1-0点重置；2-5点重置

    WORD        ActShopType;    //开放商店类型，为0时不开放

    list        TemplateIDList;    //榜单模板编号列表

    list        FamilyTemplateIDList;    //仙盟榜单模板编号列表

};



//Boss历练榜单模版表



struct tagActBossTrialTemplate

{

    DWORD        _TemplateID;    //模板编号

    BYTE        Rank;    //名次

    list        AwardItemList;    //奖励物品列表[[物品ID,个数,是否拍品], ...] 仙盟榜时为盟主奖励，如果没有配置，则统一取成员奖励

    list        MemAwardItemList;    //仙盟榜成员奖励物品信息列表[[物品ID,个数,是否拍品], ...]

    DWORD        NeedScore;    //上榜所需积分

    dict        ScoreAwardEx;    //达标积分额外奖励 {积分:[[物品ID,个数,是否拍品], ...], ...}

};



//骑宠养成活动时间表



struct tagActHorsePetTrain

{

    DWORD        _CfgID;    //配置ID

    char        StartDate;    //开启日期

    char        EndDate;    //结束日期

    char        JoinStartTime;    //参与开始时间点

    char        JoinEndTime;    //参与结束时间点

    WORD        LVLimit;    //限制等级

    WORD        ActShopType;    //开放商店类型，为0时不开放

    WORD        PersonalTemplateID;    //个人排行模板编号

    BYTE        IsRelationCrossAct;    //是否关联跨服活动

};



//骑宠养成榜单模版表



struct tagActHorsePetTrainBillTemp

{

    DWORD        _TemplateID;    //模板编号

    BYTE        Rank;    //名次

    list        AwardItemList;    //奖励物品列表[[物品ID,个数,是否拍品], ...]

    DWORD        NeedScore;    //上榜所需积分

    dict        ScoreAwardEx;    //达标积分额外奖励 {积分:[[物品ID,个数,是否拍品], ...], ...}

};



//古宝养成活动时间表



struct tagActGubao

{

    DWORD        _CfgID;    //配置ID

    char        StartDate;    //开启日期

    char        EndDate;    //结束日期

    char        JoinStartTime;    //参与开始时间点

    char        JoinEndTime;    //参与结束时间点

    WORD        LVLimit;    //限制等级

    WORD        ActShopType;    //开放商店类型，为0时不开放

    WORD        PersonalTemplateID;    //个人排行模板编号

    BYTE        IsRelationCrossAct;    //是否关联跨服活动

};



//古宝养成榜单模版表



struct tagActGubaoBillTemp

{

    DWORD        _TemplateID;    //模板编号

    BYTE        Rank;    //名次

    list        AwardItemList;    //奖励物品列表[[物品ID,个数,是否拍品], ...]

    DWORD        NeedScore;    //上榜所需积分

    dict        ScoreAwardEx;    //达标积分额外奖励 {积分:[[物品ID,个数,是否拍品], ...], ...}

};



//炼器榜单模版表



struct tagActLianqiBillTemp

@@ -2258,51 +2152,6 @@
    list        GridWeightItemList;    //格子物品权重随机库 [[权重,物品ID,个数], ...]

    list        LayerAwardItemList;    //通关该层固定奖励 [[物品ID,个数,是否拍品], ...]

    list        LayerWeightItemList;    //通关该层额外随机奖励 [[权重,物品ID,个数], ...]

};



//仙匣秘境活动时间表



struct tagActXianXiaMJ

{

    DWORD        _CfgID;    //配置ID

    char        StartDate;    //开启日期

    char        EndDate;    //结束日期

    char        JoinStartTime;    //参与开始时间点

    char        JoinEndTime;    //参与结束时间点

    BYTE        IsDayReset;    //是否每天重置

    WORD        LVLimit;    //限制等级

    DWORD        UseItemID;    //消耗物品ID

    list        UseMoneyInfo;    //消耗货币信息

    BYTE        TemplateID;    //模板ID

    WORD        PersonalTemplateID;    //个人排行模板编号

    WORD        LotteryAddScore;    //每次抽奖加积分

    WORD        LayerAddScore;    //每次跨层加积分

    BYTE        IsRelationCrossAct;    //是否关联跨服活动

};



//仙匣秘境榜单模版表



struct tagActXianXiaMJBillTemp

{

    DWORD        _TemplateID;    //模板编号

    BYTE        Rank;    //名次

    list        AwardItemList;    //奖励物品列表[[物品ID,个数,是否拍品], ...]

    DWORD        NeedScore;    //上榜所需积分

    dict        ScoreAwardEx;    //达标积分额外奖励 {积分:[[物品ID,个数,是否拍品], ...], ...}

};



//仙匣秘境奖池表



struct tagActXianXiaMJAward

{

    DWORD        _TemplateID;    //奖池模板编号

    BYTE        AwardLibType;    //奖励库类型

    list        AwardItemCountList;    //层选择个数列表  层1物品数|层2|…

    list        UnlockAwardLimitTimesList;    //层抽X次后可产出（本层） 层1限制|层2|…

    list        AwardLibWeightList;    //产出该库外权重

    dict        LibItemInfo;    //本库物品随机库内权重（先随机库外权重，若产出再随机库内权重）

    dict        ItemLayerLimitInfo;    //物品产出奖池层限制 {物品ID:大于等于X层可产出, ...}

    dict        ItemAwardTimesTotalInfo;    //物品产出次数限制（所有层）{物品ID:总产出次数, ...}

};



//天帝礼包活动时间表

@@ -2333,18 +2182,6 @@
    BYTE        ChooseItemCount;    //选择个数

    dict        LibItemInfo;    //物品编号对应物品信息 {物品编号:[物品ID,个数,是否拍品,可选次数], ...}  0不限次数

    list        NotifyItemNumList;    //需要广播的编号列表

};



//骑宠盛宴活动



struct tagActHorsePetFeast

{

    DWORD        _CfgID;    //配置ID

    char        StartDate;    //开启日期

    char        EndDate;    //结束日期

    list        StartTimeList;    //开启时间列表, 支持多个时段

    list        EndTimeList;    //结束时间列表, 支持多个时段

    WORD        LVLimit;    //限制等级

};



//BOSS复活活动时间表


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/PyNetPack.ini

@@ -1264,58 +1264,6 @@
PacketSubCMD_2=0x06

PacketCallFunc_2=OnActWishingDrag



;boss历练活动

[PlayerActBossTrial]

ScriptName = Player\PlayerActBossTrial.py

Writer = hxp

Releaser = hxp

RegType = 0

RegisterPackCount = 2



PacketCMD_1=0xAA

PacketSubCMD_1=0x23

PacketCallFunc_1=OnActBossTrialSubmit



PacketCMD_2=0xAA

PacketSubCMD_2=0x24

PacketCallFunc_2=OnActBossTrialGetAward



;垃圾分类活动

[PlayerActGarbageSorting]

ScriptName = Player\PlayerActGarbageSorting.py

Writer = hxp

Releaser = hxp

RegType = 0

RegisterPackCount = 2



PacketCMD_1=0xAA

PacketSubCMD_1=0x14

PacketCallFunc_1=OnActGarbageSorting



PacketCMD_2=0xAA

PacketSubCMD_2=0x15

PacketCallFunc_2=OnActGarbageGetTaskAward



;仙匣秘境活动

[PlayerActXianXiaMJ]

ScriptName = Player\PlayerActXianXiaMJ.py

Writer = hxp

Releaser = hxp

RegType = 0

RegisterPackCount = 3



PacketCMD_1=0xAA

PacketSubCMD_1=0x16

PacketCallFunc_1=OnActXianXiaMJSuperItem



PacketCMD_2=0xAA

PacketSubCMD_2=0x17

PacketCallFunc_2=OnActXianXiaMJLottery



PacketCMD_3=0xAA

PacketSubCMD_3=0x18

PacketCallFunc_3=OnActXianXiaMJAwardPoolRefresh



;天帝礼包活动

[PlayerActGodGift]

ScriptName = Player\PlayerActGodGift.py


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/ChConfig.py

@@ -3785,14 +3785,6 @@
Def_PDict_LoginAwardGotTimes = "LoginAwardGotTimes_%s_%s" #当前已领次数 参数(第X天,模板ID)

Def_PDict_LoginAwardWorldLV = "LoginAwardWorldLV%s" #活动开启时世界等级参数(第X天)



#boss历练

Def_PDict_BossTrialRecycleState = "BossTrialRecycleState"  # 活动物品回收状态，该活动所有的本服、跨服活动结束才回收 1-标记等待回收；2-已回收过

Def_PDict_CA_BossTrialID = "CA_BossTrialID"  # 玩家身上的活动ID，唯一标识，取活动开始日期time值

Def_PDict_BossTrialID = "BossTrialID_%s"  # 玩家身上的活动ID，唯一标识，取活动开始日期time，参数（活动编号）

Def_PDict_BossTrialSubmitCount = "BossTrialSubmitCount_%s"  # 提交凭证物品个数，参数（活动编号）

Def_PDict_BossTrialSubmitAwardCount = "BossTrialAwardCount_%s"  # 关联提交凭证奖励提交物品个数，参数（活动编号）

Def_PDict_BossTrialSubmitAward = "BossTrialSubmitAward_%s"  # 提交凭证奖励状态，参数（活动编号）



#幸运鉴宝

Def_PDict_LuckyTreasureID = "LuckyTreasureID"  # 玩家身上的活动ID，唯一标识，取活动开始日期time值

Def_PDict_LuckyTreasureFree = "LuckyTreasureFree" #是否免费过

@@ -3840,34 +3832,6 @@
Def_PDict_TurntableItemID = "TurntableItemID_%s_%s"  # 转盘物品ID*10+物品库类型，参数：(活动编号, 物品编号)

Def_PDict_TurntableItemCount = "TurntableCount_%s_%s"  # 转盘物品个数，参数：(活动编号, 物品编号)

Def_PDict_TurntableItemState = "TurntableItemState_%s"  # 转盘物品是否已抽中，按物品编号二进制位代表是否已抽中，参数：(活动编号)



#垃圾分类活动

Def_PDict_GarbageSortingID = "ActGSID_%s"  # 玩家身上的活动ID，唯一标识，取活动开始日期time值，参数：(活动编号)

Def_PDict_GarbageSortingWorldLV = "ActGSWorldLV_%s" #玩家身上的活动世界等级，参数：(活动编号)

Def_PDict_GarbageTaskValue = "ActGSTaskValue_%s_%s" # 任务总进度值，参数(活动编号, 任务ID)

Def_PDict_GarbageTaskFinishCount = "ActGSTaskFinishCount_%s_%s" # 任务已完成次数，参数(活动编号, 任务ID)

Def_PDict_GarbageEnvironmentValue = "ActGSEnvValue_%s" # 活动累计获得环保值，参数(活动编号)

Def_PDict_GarbageGJSeconds = "ActGSGJSeconds_%s"  # 挂机未处理收益的秒数，参数(活动编号)



#仙匣秘境活动

Def_PDict_CA_XianXiaMJID = "CA_XianXiaMJID"  # 玩家身上的活动ID，唯一标识，取活动开始日期time值

Def_PDict_XianXiaMJID = "ActXXMJID_%s"  # 玩家身上的活动ID，唯一标识，取活动开始日期time值，参数：(活动编号)

Def_PDict_XianXiaMJWorldLV = "ActXXMJWorldLV_%s" #玩家身上的活动世界等级，参数：(活动编号)

Def_PDict_XianXiaMJLayerNum = "ActXianXiaMJLayerNum_%s" # 当前层数，参数：(活动编号)

Def_PDict_XianXiaMJPlayCount = "ActXianXiaMJPlayCount_%s" # 当前层累计抽奖次数，参数：(活动编号)

Def_PDict_XianXiaMJAwardItemInfo = "ActXXMJItemInfo_%s_%s_%s"  # 奖池物品ID*100+抽中位置编号，参数：(活动编号, 库类型, 物品编号)

Def_PDict_XianXiaMJAwardItemTimes = "ActXXMJItemTimes_%s_%s_%s"  # 奖池物品累计产出次数，有限制次数的才记录，参数：(活动编号, 库类型, 物品ID)

Def_PDict_XianXiaMJScore = "XianXiaMJScore_%s"  # 抽奖积分，参数：(活动编号)



#古宝养成活动

Def_PDict_CA_GubaoID = "CA_GubaoID"  # 玩家身上的活动ID，唯一标识，取活动开始日期time值

Def_PDict_ActGubaoID = "ActGubaoID_%s"  # 玩家身上的活动ID，唯一标识，取活动开始日期time值，参数：(活动编号)

Def_PDict_ActGubaoScore = "ActGubaoScore_%s"  # 养成积分，参数：(活动编号)



#骑宠养成活动

Def_PDict_CA_HorsePetTrainID = "CA_HorsePetTrainID"  # 玩家身上的活动ID，唯一标识，取活动开始日期time值

Def_PDict_ActHorsePetTrainID = "ActHorsePetTrainID_%s"  # 玩家身上的活动ID，唯一标识，取活动开始日期time值，参数：(活动编号)

Def_PDict_ActHorsePetTrainScore = "ActHorsePetTrainScore_%s"  # 累计获得活动养成积分，参数：(活动编号)



#炼器活动

Def_PDict_CA_LianqiID = "CA_LianqiID"  # 玩家身上的活动ID，唯一标识，取活动开始日期time值

@@ -5372,8 +5336,8 @@
ActTaskType_Activity, # 累计获得活跃度 3

ActTaskType_CrossPenglaiBoss, # 击杀蓬莱boss 4

ActTaskType_CrossDemonLandBoss, # 击杀魔化之地boss 5

ActTaskType_XianXiaMJLottery, # 仙匣秘境寻宝x次 6

ActTaskType_XianXiaMJLayer, # 仙匣秘境达到x层 7

ActTaskType_6, # 仙匣秘境寻宝x次 6

ActTaskType_7, # 仙匣秘境达到x层 7

ActTaskType_TreasureGubao, # 古宝寻宝x次 8

ActTaskType_HorseUpItem, # 消耗X个坐骑经验丹 9

ActTaskType_PetUpItem, # 消耗X个灵宠经验丹 10


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/ChPyNetPack.py

@@ -11555,118 +11555,6 @@




#------------------------------------------------------

# AA 24 Boss历练领奖 #tagCMActBossTrialGetAward



class  tagCMActBossTrialGetAward(Structure):

    _pack_ = 1

    _fields_ = [

                  ("Cmd", c_ubyte),

                  ("SubCmd", c_ubyte),

                  ("ActNum", c_ubyte),    #活动编号

                  ("SubmitCount", c_ushort),    #领取凭证个数对应奖励

                  ]



    def __init__(self):

        self.Clear()

        self.Cmd = 0xAA

        self.SubCmd = 0x24

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.Cmd = 0xAA

        self.SubCmd = 0x24

        self.ActNum = 0

        self.SubmitCount = 0

        return



    def GetLength(self):

        return sizeof(tagCMActBossTrialGetAward)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 24 Boss历练领奖 //tagCMActBossTrialGetAward:

                                Cmd:%s,

                                SubCmd:%s,

                                ActNum:%d,

                                SubmitCount:%d

                                '''\

                                %(

                                self.Cmd,

                                self.SubCmd,

                                self.ActNum,

                                self.SubmitCount

                                )

        return DumpString





m_NAtagCMActBossTrialGetAward=tagCMActBossTrialGetAward()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagCMActBossTrialGetAward.Cmd,m_NAtagCMActBossTrialGetAward.SubCmd))] = m_NAtagCMActBossTrialGetAward





#------------------------------------------------------

# AA 23 Boss历练提交凭证 #tagCMActBossTrialSubmit



class  tagCMActBossTrialSubmit(Structure):

    _pack_ = 1

    _fields_ = [

                  ("Cmd", c_ubyte),

                  ("SubCmd", c_ubyte),

                  ("ActNum", c_ubyte),    #活动编号

                  ("SubmitCount", c_ushort),    #提交凭证个数

                  ]



    def __init__(self):

        self.Clear()

        self.Cmd = 0xAA

        self.SubCmd = 0x23

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.Cmd = 0xAA

        self.SubCmd = 0x23

        self.ActNum = 0

        self.SubmitCount = 0

        return



    def GetLength(self):

        return sizeof(tagCMActBossTrialSubmit)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 23 Boss历练提交凭证 //tagCMActBossTrialSubmit:

                                Cmd:%s,

                                SubCmd:%s,

                                ActNum:%d,

                                SubmitCount:%d

                                '''\

                                %(

                                self.Cmd,

                                self.SubCmd,

                                self.ActNum,

                                self.SubmitCount

                                )

        return DumpString





m_NAtagCMActBossTrialSubmit=tagCMActBossTrialSubmit()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagCMActBossTrialSubmit.Cmd,m_NAtagCMActBossTrialSubmit.SubCmd))] = m_NAtagCMActBossTrialSubmit





#------------------------------------------------------

# AA 09 集字活动兑换 #tagCMActCollectWordsExchange



class  tagCMActCollectWordsExchange(Structure):

@@ -11720,143 +11608,6 @@


m_NAtagCMActCollectWordsExchange=tagCMActCollectWordsExchange()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagCMActCollectWordsExchange.Cmd,m_NAtagCMActCollectWordsExchange.SubCmd))] = m_NAtagCMActCollectWordsExchange





#------------------------------------------------------

# AA 15 垃圾分类活动收集已完成的任务垃圾 #tagCMActGarbageGetTaskAward



class  tagCMActGarbageGetTaskAward(Structure):

    _pack_ = 1

    _fields_ = [

                  ("Cmd", c_ubyte),

                  ("SubCmd", c_ubyte),

                  ("ActNum", c_ubyte),    #活动编号

                  ("GarbageTaskID", c_ubyte),    #垃圾任务ID

                  ]



    def __init__(self):

        self.Clear()

        self.Cmd = 0xAA

        self.SubCmd = 0x15

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.Cmd = 0xAA

        self.SubCmd = 0x15

        self.ActNum = 0

        self.GarbageTaskID = 0

        return



    def GetLength(self):

        return sizeof(tagCMActGarbageGetTaskAward)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 15 垃圾分类活动收集已完成的任务垃圾 //tagCMActGarbageGetTaskAward:

                                Cmd:%s,

                                SubCmd:%s,

                                ActNum:%d,

                                GarbageTaskID:%d

                                '''\

                                %(

                                self.Cmd,

                                self.SubCmd,

                                self.ActNum,

                                self.GarbageTaskID

                                )

        return DumpString





m_NAtagCMActGarbageGetTaskAward=tagCMActGarbageGetTaskAward()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagCMActGarbageGetTaskAward.Cmd,m_NAtagCMActGarbageGetTaskAward.SubCmd))] = m_NAtagCMActGarbageGetTaskAward





#------------------------------------------------------

# AA 14 垃圾分类活动分类垃圾 #tagCMActGarbageSorting



class  tagCMActGarbageSorting(Structure):

    Head = tagHead()

    ActNum = 0    #(BYTE ActNum)//活动编号

    GarbageSortingType = 0    #(BYTE GarbageSortingType)//垃圾分类类型，即属于哪种垃圾

    ItemIndexCount = 0    #(BYTE ItemIndexCount)//垃圾背包中的物品索引数

    ItemIndexList = list()    #(vector<BYTE> ItemIndexList)//垃圾背包中的物品索引列表

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x14

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.GarbageSortingType,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.ItemIndexCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.ItemIndexCount):

            value,_pos=CommFunc.ReadBYTE(_lpData,_pos)

            self.ItemIndexList.append(value)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x14

        self.ActNum = 0

        self.GarbageSortingType = 0

        self.ItemIndexCount = 0

        self.ItemIndexList = list()

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 1

        length += 1

        length += 1

        length += 1 * self.ItemIndexCount



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteBYTE(data, self.ActNum)

        data = CommFunc.WriteBYTE(data, self.GarbageSortingType)

        data = CommFunc.WriteBYTE(data, self.ItemIndexCount)

        for i in range(self.ItemIndexCount):

            data = CommFunc.WriteBYTE(data, self.ItemIndexList[i])

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                ActNum:%d,

                                GarbageSortingType:%d,

                                ItemIndexCount:%d,

                                ItemIndexList:%s

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.ActNum,

                                self.GarbageSortingType,

                                self.ItemIndexCount,

                                "..."

                                )

        return DumpString





m_NAtagCMActGarbageSorting=tagCMActGarbageSorting()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagCMActGarbageSorting.Head.Cmd,m_NAtagCMActGarbageSorting.Head.SubCmd))] = m_NAtagCMActGarbageSorting





#------------------------------------------------------

@@ -12351,188 +12102,6 @@


m_NAtagCMActWishingRefresh=tagCMActWishingRefresh()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagCMActWishingRefresh.Cmd,m_NAtagCMActWishingRefresh.SubCmd))] = m_NAtagCMActWishingRefresh





#------------------------------------------------------

# AA 18 仙匣秘境活动奖池刷新 #tagCMActXianXiaMJAwardPoolRefresh



class  tagCMActXianXiaMJAwardPoolRefresh(Structure):

    _pack_ = 1

    _fields_ = [

                  ("Cmd", c_ubyte),

                  ("SubCmd", c_ubyte),

                  ("ActNum", c_ubyte),    #活动编号

                  ]



    def __init__(self):

        self.Clear()

        self.Cmd = 0xAA

        self.SubCmd = 0x18

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.Cmd = 0xAA

        self.SubCmd = 0x18

        self.ActNum = 0

        return



    def GetLength(self):

        return sizeof(tagCMActXianXiaMJAwardPoolRefresh)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 18 仙匣秘境活动奖池刷新 //tagCMActXianXiaMJAwardPoolRefresh:

                                Cmd:%s,

                                SubCmd:%s,

                                ActNum:%d

                                '''\

                                %(

                                self.Cmd,

                                self.SubCmd,

                                self.ActNum

                                )

        return DumpString





m_NAtagCMActXianXiaMJAwardPoolRefresh=tagCMActXianXiaMJAwardPoolRefresh()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagCMActXianXiaMJAwardPoolRefresh.Cmd,m_NAtagCMActXianXiaMJAwardPoolRefresh.SubCmd))] = m_NAtagCMActXianXiaMJAwardPoolRefresh





#------------------------------------------------------

# AA 17 仙匣秘境活动抽奖 #tagCMActXianXiaMJLottery



class  tagCMActXianXiaMJLottery(Structure):

    _pack_ = 1

    _fields_ = [

                  ("Cmd", c_ubyte),

                  ("SubCmd", c_ubyte),

                  ("ActNum", c_ubyte),    #活动编号

                  ("PosNum", c_ubyte),    #玩家点击的奖励位置编号，从1开始

                  ]



    def __init__(self):

        self.Clear()

        self.Cmd = 0xAA

        self.SubCmd = 0x17

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.Cmd = 0xAA

        self.SubCmd = 0x17

        self.ActNum = 0

        self.PosNum = 0

        return



    def GetLength(self):

        return sizeof(tagCMActXianXiaMJLottery)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 17 仙匣秘境活动抽奖 //tagCMActXianXiaMJLottery:

                                Cmd:%s,

                                SubCmd:%s,

                                ActNum:%d,

                                PosNum:%d

                                '''\

                                %(

                                self.Cmd,

                                self.SubCmd,

                                self.ActNum,

                                self.PosNum

                                )

        return DumpString





m_NAtagCMActXianXiaMJLottery=tagCMActXianXiaMJLottery()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagCMActXianXiaMJLottery.Cmd,m_NAtagCMActXianXiaMJLottery.SubCmd))] = m_NAtagCMActXianXiaMJLottery





#------------------------------------------------------

# AA 16 仙匣秘境活动选择大奖 #tagCMActXianXiaMJSuperItem



class  tagCMActXianXiaMJSuperItem(Structure):

    Head = tagHead()

    ActNum = 0    #(BYTE ActNum)//活动编号

    SuperItemCount = 0    #(BYTE SuperItemCount)//选择物品数量

    SuperItemIDList = list()    #(vector<DWORD> SuperItemIDList)//选择的大奖库物品ID列表，每次重新选择需要发送全部已选择的大奖物品ID，不能只发单个物品ID;

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x16

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.SuperItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.SuperItemCount):

            value,_pos=CommFunc.ReadDWORD(_lpData,_pos)

            self.SuperItemIDList.append(value)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x16

        self.ActNum = 0

        self.SuperItemCount = 0

        self.SuperItemIDList = list()

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 1

        length += 1

        length += 4 * self.SuperItemCount



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteBYTE(data, self.ActNum)

        data = CommFunc.WriteBYTE(data, self.SuperItemCount)

        for i in range(self.SuperItemCount):

            data = CommFunc.WriteDWORD(data, self.SuperItemIDList[i])

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                ActNum:%d,

                                SuperItemCount:%d,

                                SuperItemIDList:%s

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.ActNum,

                                self.SuperItemCount,

                                "..."

                                )

        return DumpString





m_NAtagCMActXianXiaMJSuperItem=tagCMActXianXiaMJSuperItem()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagCMActXianXiaMJSuperItem.Head.Cmd,m_NAtagCMActXianXiaMJSuperItem.Head.SubCmd))] = m_NAtagCMActXianXiaMJSuperItem





#------------------------------------------------------


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/ChPyNetSendPack.py

@@ -22113,513 +22113,6 @@




#------------------------------------------------------

# AA 67 Boss历练活动信息 #tagMCActBossTrialInfo



class  tagMCActBossTrialItem(Structure):

    _pack_ = 1

    _fields_ = [

                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.ItemID = 0

        self.ItemCount = 0

        self.IsBind = 0

        return



    def GetLength(self):

        return sizeof(tagMCActBossTrialItem)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 67 Boss历练活动信息 //tagMCActBossTrialInfo:

                                ItemID:%d,

                                ItemCount:%d,

                                IsBind:%d

                                '''\

                                %(

                                self.ItemID,

                                self.ItemCount,

                                self.IsBind

                                )

        return DumpString





class  tagMCActBossTrialAwardEx(Structure):

    NeedScore = 0    #(DWORD NeedScore)// 额外奖励所需积分

    Count = 0    #(BYTE Count)// 额外奖励物品数

    AwardItemList = list()    #(vector<tagMCActBossTrialItem> AwardItemList)// 额外奖励物品列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCActBossTrialItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        return _pos



    def Clear(self):

        self.NeedScore = 0

        self.Count = 0

        self.AwardItemList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                NeedScore:%d,

                                Count:%d,

                                AwardItemList:%s

                                '''\

                                %(

                                self.NeedScore,

                                self.Count,

                                "..."

                                )

        return DumpString





class  tagMCActBossTrialBillard(Structure):

    Rank = 0    #(DWORD Rank)// 名次，1-代表第一名；支持夸段，如1，3 代表第1名，第2~3名

    Count = 0    #(BYTE Count)// 奖励物品数

    AwardItemList = list()    #(vector<tagMCActBossTrialItem> AwardItemList)// 奖励物品列表，当仙盟榜时，如果有该奖励则代表盟主奖励，否则默认均为成员奖励

    MemCount = 0    #(BYTE MemCount)// 成员奖励物品数

    MemAwardItemList = list()    #(vector<tagMCActBossTrialItem> MemAwardItemList)// 成员奖励物品列表，仅仙盟榜时有效

    NeedScore = 0    #(DWORD NeedScore)// 上榜所需积分

    CountEx = 0    #(BYTE CountEx)// 额外奖励数

    AwardItemExList = list()    #(vector<tagMCActBossTrialAwardEx> AwardItemExList)// 额外奖励列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCActBossTrialItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        self.MemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.MemCount):

            temMemAwardItemList = tagMCActBossTrialItem()

            _pos = temMemAwardItemList.ReadData(_lpData, _pos)

            self.MemAwardItemList.append(temMemAwardItemList)

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.CountEx):

            temAwardItemExList = tagMCActBossTrialAwardEx()

            _pos = temAwardItemExList.ReadData(_lpData, _pos)

            self.AwardItemExList.append(temAwardItemExList)

        return _pos



    def Clear(self):

        self.Rank = 0

        self.Count = 0

        self.AwardItemList = list()

        self.MemCount = 0

        self.MemAwardItemList = list()

        self.NeedScore = 0

        self.CountEx = 0

        self.AwardItemExList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()

        length += 1

        for i in range(self.MemCount):

            length += self.MemAwardItemList[i].GetLength()

        length += 4

        length += 1

        for i in range(self.CountEx):

            length += self.AwardItemExList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.Rank)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        data = CommFunc.WriteBYTE(data, self.MemCount)

        for i in range(self.MemCount):

            data = CommFunc.WriteString(data, self.MemAwardItemList[i].GetLength(), self.MemAwardItemList[i].GetBuffer())

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.CountEx)

        for i in range(self.CountEx):

            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Rank:%d,

                                Count:%d,

                                AwardItemList:%s,

                                MemCount:%d,

                                MemAwardItemList:%s,

                                NeedScore:%d,

                                CountEx:%d,

                                AwardItemExList:%s

                                '''\

                                %(

                                self.Rank,

                                self.Count,

                                "...",

                                self.MemCount,

                                "...",

                                self.NeedScore,

                                self.CountEx,

                                "..."

                                )

        return DumpString





class  tagMCActBossTrialSubmitInfo(Structure):

    RecordIndex = 0    #(BYTE RecordIndex)// 记录索引

    NeedCount = 0    #(WORD NeedCount)// 所需提交个数

    Count = 0    #(BYTE Count)// 奖励物品数

    AwardItemList = list()    #(vector<tagMCActBossTrialItem> AwardItemList)// 奖励物品列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.RecordIndex,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.NeedCount,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCActBossTrialItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        return _pos



    def Clear(self):

        self.RecordIndex = 0

        self.NeedCount = 0

        self.Count = 0

        self.AwardItemList = list()

        return



    def GetLength(self):

        length = 0

        length += 1

        length += 2

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteBYTE(data, self.RecordIndex)

        data = CommFunc.WriteWORD(data, self.NeedCount)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                RecordIndex:%d,

                                NeedCount:%d,

                                Count:%d,

                                AwardItemList:%s

                                '''\

                                %(

                                self.RecordIndex,

                                self.NeedCount,

                                self.Count,

                                "..."

                                )

        return DumpString





class  tagMCActBossTrialInfo(Structure):

    Head = tagHead()

    ActNum = 0    #(BYTE ActNum)// 活动编号

    StartDate = ""    #(char StartDate[10])// 开始日期 y-m-d

    EndtDate = ""    #(char EndtDate[10])// 结束日期 y-m-d

    JoinStartTime = ""    #(char JoinStartTime[5])// 参与开始时间点 mm:ss

    JoinEndTime = ""    #(char JoinEndTime[5])// 参与结束时间点 mm:ss

    IsDayReset = 0    #(BYTE IsDayReset)// 是否每天重置

    ResetType = 0    #(BYTE ResetType)// 重置类型，0-0点重置；1-5点重置

    LimitLV = 0    #(WORD LimitLV)// 限制等级

    ShopType = 0    #(WORD ShopType)// 开放商店类型，可能为0不开放

    SubResetType = 0    #(BYTE SubResetType)// 提交凭证奖励重置类型，0-跟随活动； 1-0点重置；2-5点重置

    SubmitCount = 0    #(BYTE SubmitCount)

    SubmitInfoList = list()    #(vector<tagMCActBossTrialSubmitInfo> SubmitInfoList)// 提交凭证信息列表

    PersonalBillCount = 0    #(BYTE PersonalBillCount)

    PersonalBillboardInfoList = list()    #(vector<tagMCActBossTrialBillard> PersonalBillboardInfoList)// 个人榜单奖励信息列表，如果没有代表本次活动没有该榜奖励

    FamilyBillCount = 0    #(BYTE FamilyBillCount)

    FamilyBillboardInfoList = list()    #(vector<tagMCActBossTrialBillard> FamilyBillboardInfoList)// 仙盟榜单奖励信息列表，如果没有代表本次活动没有该榜奖励

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x67

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.ShopType,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.SubResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.SubmitCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.SubmitCount):

            temSubmitInfoList = tagMCActBossTrialSubmitInfo()

            _pos = temSubmitInfoList.ReadData(_lpData, _pos)

            self.SubmitInfoList.append(temSubmitInfoList)

        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.PersonalBillCount):

            temPersonalBillboardInfoList = tagMCActBossTrialBillard()

            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)

            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)

        self.FamilyBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.FamilyBillCount):

            temFamilyBillboardInfoList = tagMCActBossTrialBillard()

            _pos = temFamilyBillboardInfoList.ReadData(_lpData, _pos)

            self.FamilyBillboardInfoList.append(temFamilyBillboardInfoList)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x67

        self.ActNum = 0

        self.StartDate = ""

        self.EndtDate = ""

        self.JoinStartTime = ""

        self.JoinEndTime = ""

        self.IsDayReset = 0

        self.ResetType = 0

        self.LimitLV = 0

        self.ShopType = 0

        self.SubResetType = 0

        self.SubmitCount = 0

        self.SubmitInfoList = list()

        self.PersonalBillCount = 0

        self.PersonalBillboardInfoList = list()

        self.FamilyBillCount = 0

        self.FamilyBillboardInfoList = list()

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 1

        length += 10

        length += 10

        length += 5

        length += 5

        length += 1

        length += 1

        length += 2

        length += 2

        length += 1

        length += 1

        for i in range(self.SubmitCount):

            length += self.SubmitInfoList[i].GetLength()

        length += 1

        for i in range(self.PersonalBillCount):

            length += self.PersonalBillboardInfoList[i].GetLength()

        length += 1

        for i in range(self.FamilyBillCount):

            length += self.FamilyBillboardInfoList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteBYTE(data, self.ActNum)

        data = CommFunc.WriteString(data, 10, self.StartDate)

        data = CommFunc.WriteString(data, 10, self.EndtDate)

        data = CommFunc.WriteString(data, 5, self.JoinStartTime)

        data = CommFunc.WriteString(data, 5, self.JoinEndTime)

        data = CommFunc.WriteBYTE(data, self.IsDayReset)

        data = CommFunc.WriteBYTE(data, self.ResetType)

        data = CommFunc.WriteWORD(data, self.LimitLV)

        data = CommFunc.WriteWORD(data, self.ShopType)

        data = CommFunc.WriteBYTE(data, self.SubResetType)

        data = CommFunc.WriteBYTE(data, self.SubmitCount)

        for i in range(self.SubmitCount):

            data = CommFunc.WriteString(data, self.SubmitInfoList[i].GetLength(), self.SubmitInfoList[i].GetBuffer())

        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)

        for i in range(self.PersonalBillCount):

            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())

        data = CommFunc.WriteBYTE(data, self.FamilyBillCount)

        for i in range(self.FamilyBillCount):

            data = CommFunc.WriteString(data, self.FamilyBillboardInfoList[i].GetLength(), self.FamilyBillboardInfoList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                ActNum:%d,

                                StartDate:%s,

                                EndtDate:%s,

                                JoinStartTime:%s,

                                JoinEndTime:%s,

                                IsDayReset:%d,

                                ResetType:%d,

                                LimitLV:%d,

                                ShopType:%d,

                                SubResetType:%d,

                                SubmitCount:%d,

                                SubmitInfoList:%s,

                                PersonalBillCount:%d,

                                PersonalBillboardInfoList:%s,

                                FamilyBillCount:%d,

                                FamilyBillboardInfoList:%s

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.ActNum,

                                self.StartDate,

                                self.EndtDate,

                                self.JoinStartTime,

                                self.JoinEndTime,

                                self.IsDayReset,

                                self.ResetType,

                                self.LimitLV,

                                self.ShopType,

                                self.SubResetType,

                                self.SubmitCount,

                                "...",

                                self.PersonalBillCount,

                                "...",

                                self.FamilyBillCount,

                                "..."

                                )

        return DumpString





m_NAtagMCActBossTrialInfo=tagMCActBossTrialInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActBossTrialInfo.Head.Cmd,m_NAtagMCActBossTrialInfo.Head.SubCmd))] = m_NAtagMCActBossTrialInfo





#------------------------------------------------------

# AA 68 Boss历练活动玩家信息 #tagMCActBossTrialPlayerInfo



class  tagMCActBossTrialPlayerInfo(Structure):

    _pack_ = 1

    _fields_ = [

                  ("Cmd", c_ubyte),

                  ("SubCmd", c_ubyte),

                  ("ActNum", c_ubyte),    # 活动编号

                  ("SubmitCount", c_int),    # 已提交凭证个数，总个数

                  ("SubmitAwardCount", c_int),    # 已提交凭证个数，关联提交奖励的个数，领奖使用该个数判断

                  ("SubmitAwardState", c_int),    # 提交凭证奖励领奖状态

                  ]



    def __init__(self):

        self.Clear()

        self.Cmd = 0xAA

        self.SubCmd = 0x68

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.Cmd = 0xAA

        self.SubCmd = 0x68

        self.ActNum = 0

        self.SubmitCount = 0

        self.SubmitAwardCount = 0

        self.SubmitAwardState = 0

        return



    def GetLength(self):

        return sizeof(tagMCActBossTrialPlayerInfo)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 68 Boss历练活动玩家信息 //tagMCActBossTrialPlayerInfo:

                                Cmd:%s,

                                SubCmd:%s,

                                ActNum:%d,

                                SubmitCount:%d,

                                SubmitAwardCount:%d,

                                SubmitAwardState:%d

                                '''\

                                %(

                                self.Cmd,

                                self.SubCmd,

                                self.ActNum,

                                self.SubmitCount,

                                self.SubmitAwardCount,

                                self.SubmitAwardState

                                )

        return DumpString





m_NAtagMCActBossTrialPlayerInfo=tagMCActBossTrialPlayerInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActBossTrialPlayerInfo.Cmd,m_NAtagMCActBossTrialPlayerInfo.SubCmd))] = m_NAtagMCActBossTrialPlayerInfo





#------------------------------------------------------

# AA 74 购买次数礼包活动信息 #tagMCActBuyCountGiftInfo



class  tagMCActBuyCountGiftItem(Structure):

@@ -23891,285 +23384,6 @@




#------------------------------------------------------

# AA 55 垃圾收集活动信息 #tagMCActGarbageSortingInfo



class  tagMCActGarbageSortingInfo(Structure):

    Head = tagHead()

    ActNum = 0    #(BYTE ActNum)// 活动编号

    StartDate = ""    #(char StartDate[10])// 开始日期 y-m-d

    EndtDate = ""    #(char EndtDate[10])// 结束日期 y-m-d

    LimitLV = 0    #(WORD LimitLV)// 限制等级

    ResetType = 0    #(BYTE ResetType)// 重置类型，0-0点重置；1-5点开，5点重置；2-5点开，0点重置

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x55

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x55

        self.ActNum = 0

        self.StartDate = ""

        self.EndtDate = ""

        self.LimitLV = 0

        self.ResetType = 0

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 1

        length += 10

        length += 10

        length += 2

        length += 1



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteBYTE(data, self.ActNum)

        data = CommFunc.WriteString(data, 10, self.StartDate)

        data = CommFunc.WriteString(data, 10, self.EndtDate)

        data = CommFunc.WriteWORD(data, self.LimitLV)

        data = CommFunc.WriteBYTE(data, self.ResetType)

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                ActNum:%d,

                                StartDate:%s,

                                EndtDate:%s,

                                LimitLV:%d,

                                ResetType:%d

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.ActNum,

                                self.StartDate,

                                self.EndtDate,

                                self.LimitLV,

                                self.ResetType

                                )

        return DumpString





m_NAtagMCActGarbageSortingInfo=tagMCActGarbageSortingInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActGarbageSortingInfo.Head.Cmd,m_NAtagMCActGarbageSortingInfo.Head.SubCmd))] = m_NAtagMCActGarbageSortingInfo





#------------------------------------------------------

# AA 57 垃圾收集活动分类结果 #tagMCActGarbageSortingResult



class  tagMCActGarbageSortingResult(Structure):

    _pack_ = 1

    _fields_ = [

                  ("Cmd", c_ubyte),

                  ("SubCmd", c_ubyte),

                  ("ActNum", c_ubyte),    #活动编号

                  ("GarbageSortingType", c_ubyte),    #垃圾分类类型

                  ("IsRight", c_ubyte),    #是否正确

                  ("AddEnvValue", c_int),    #增加环保值

                  ("HisEnvValueTotal", c_int),    # 当前活动累计获得环保值

                  ]



    def __init__(self):

        self.Clear()

        self.Cmd = 0xAA

        self.SubCmd = 0x57

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.Cmd = 0xAA

        self.SubCmd = 0x57

        self.ActNum = 0

        self.GarbageSortingType = 0

        self.IsRight = 0

        self.AddEnvValue = 0

        self.HisEnvValueTotal = 0

        return



    def GetLength(self):

        return sizeof(tagMCActGarbageSortingResult)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 57 垃圾收集活动分类结果 //tagMCActGarbageSortingResult:

                                Cmd:%s,

                                SubCmd:%s,

                                ActNum:%d,

                                GarbageSortingType:%d,

                                IsRight:%d,

                                AddEnvValue:%d,

                                HisEnvValueTotal:%d

                                '''\

                                %(

                                self.Cmd,

                                self.SubCmd,

                                self.ActNum,

                                self.GarbageSortingType,

                                self.IsRight,

                                self.AddEnvValue,

                                self.HisEnvValueTotal

                                )

        return DumpString





m_NAtagMCActGarbageSortingResult=tagMCActGarbageSortingResult()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActGarbageSortingResult.Cmd,m_NAtagMCActGarbageSortingResult.SubCmd))] = m_NAtagMCActGarbageSortingResult





#------------------------------------------------------

# AA 56 垃圾收集活动任务进度信息 #tagMCActGarbageTaskInfo



class  tagMCActGarbageTask(Structure):

    _pack_ = 1

    _fields_ = [

                  ("GarbageTaskID", c_ubyte),    #垃圾任务ID

                  ("GarbageTaskValue", c_int),    #当前进度值，一直累加

                  ("GarbageTaskFinishCount", c_int),    #当前已完成次数; 前端计算未完成次数的进度值=max(0, 当前进度值 - (完成次数 * 单次所需进度))

                  ]



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.GarbageTaskID = 0

        self.GarbageTaskValue = 0

        self.GarbageTaskFinishCount = 0

        return



    def GetLength(self):

        return sizeof(tagMCActGarbageTask)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 56 垃圾收集活动任务进度信息 //tagMCActGarbageTaskInfo:

                                GarbageTaskID:%d,

                                GarbageTaskValue:%d,

                                GarbageTaskFinishCount:%d

                                '''\

                                %(

                                self.GarbageTaskID,

                                self.GarbageTaskValue,

                                self.GarbageTaskFinishCount

                                )

        return DumpString





class  tagMCActGarbageTaskInfo(Structure):

    Head = tagHead()

    ActNum = 0    #(BYTE ActNum)// 活动编号

    HisEnvValueTotal = 0    #(DWORD HisEnvValueTotal)// 当前活动累计获得环保值

    GarbageTaskCount = 0    #(BYTE GarbageTaskCount)//任务数

    GarbageTaskList = list()    #(vector<tagMCActGarbageTask> GarbageTaskList)//任务信息列表

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x56

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.HisEnvValueTotal,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.GarbageTaskCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.GarbageTaskCount):

            temGarbageTaskList = tagMCActGarbageTask()

            _pos = temGarbageTaskList.ReadData(_lpData, _pos)

            self.GarbageTaskList.append(temGarbageTaskList)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x56

        self.ActNum = 0

        self.HisEnvValueTotal = 0

        self.GarbageTaskCount = 0

        self.GarbageTaskList = list()

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 1

        length += 4

        length += 1

        for i in range(self.GarbageTaskCount):

            length += self.GarbageTaskList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteBYTE(data, self.ActNum)

        data = CommFunc.WriteDWORD(data, self.HisEnvValueTotal)

        data = CommFunc.WriteBYTE(data, self.GarbageTaskCount)

        for i in range(self.GarbageTaskCount):

            data = CommFunc.WriteString(data, self.GarbageTaskList[i].GetLength(), self.GarbageTaskList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                ActNum:%d,

                                HisEnvValueTotal:%d,

                                GarbageTaskCount:%d,

                                GarbageTaskList:%s

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.ActNum,

                                self.HisEnvValueTotal,

                                self.GarbageTaskCount,

                                "..."

                                )

        return DumpString





m_NAtagMCActGarbageTaskInfo=tagMCActGarbageTaskInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActGarbageTaskInfo.Head.Cmd,m_NAtagMCActGarbageTaskInfo.Head.SubCmd))] = m_NAtagMCActGarbageTaskInfo





#------------------------------------------------------

# AA 60 天帝礼包活动信息 #tagMCActGodGiftInfo



class  tagMCActGodGiftItem(Structure):

@@ -24832,862 +24046,6 @@


m_NAtagMCActGrowupBuyInfo=tagMCActGrowupBuyInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActGrowupBuyInfo.Head.Cmd,m_NAtagMCActGrowupBuyInfo.Head.SubCmd))] = m_NAtagMCActGrowupBuyInfo





#------------------------------------------------------

# AA 81 古宝养成活动信息 #tagMCActGubaoInfo



class  tagMCActGubaoItem(Structure):

    _pack_ = 1

    _fields_ = [

                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.ItemID = 0

        self.ItemCount = 0

        self.IsBind = 0

        return



    def GetLength(self):

        return sizeof(tagMCActGubaoItem)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 81 古宝养成活动信息 //tagMCActGubaoInfo:

                                ItemID:%d,

                                ItemCount:%d,

                                IsBind:%d

                                '''\

                                %(

                                self.ItemID,

                                self.ItemCount,

                                self.IsBind

                                )

        return DumpString





class  tagMCActGubaoAwardEx(Structure):

    NeedScore = 0    #(DWORD NeedScore)// 额外奖励所需积分

    Count = 0    #(BYTE Count)// 额外奖励物品数

    AwardItemList = list()    #(vector<tagMCActGubaoItem> AwardItemList)// 额外奖励物品列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCActGubaoItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        return _pos



    def Clear(self):

        self.NeedScore = 0

        self.Count = 0

        self.AwardItemList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                NeedScore:%d,

                                Count:%d,

                                AwardItemList:%s

                                '''\

                                %(

                                self.NeedScore,

                                self.Count,

                                "..."

                                )

        return DumpString





class  tagMCActGubaoBillard(Structure):

    Rank = 0    #(DWORD Rank)// 名次，1-代表第一名；支持夸段，如1，3 代表第1名，第2~3名

    Count = 0    #(BYTE Count)// 奖励物品数

    AwardItemList = list()    #(vector<tagMCActGubaoItem> AwardItemList)// 奖励物品列表

    NeedScore = 0    #(DWORD NeedScore)// 上榜所需积分

    CountEx = 0    #(BYTE CountEx)// 额外奖励数

    AwardItemExList = list()    #(vector<tagMCActGubaoAwardEx> AwardItemExList)// 额外奖励列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCActGubaoItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.CountEx):

            temAwardItemExList = tagMCActGubaoAwardEx()

            _pos = temAwardItemExList.ReadData(_lpData, _pos)

            self.AwardItemExList.append(temAwardItemExList)

        return _pos



    def Clear(self):

        self.Rank = 0

        self.Count = 0

        self.AwardItemList = list()

        self.NeedScore = 0

        self.CountEx = 0

        self.AwardItemExList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()

        length += 4

        length += 1

        for i in range(self.CountEx):

            length += self.AwardItemExList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.Rank)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.CountEx)

        for i in range(self.CountEx):

            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Rank:%d,

                                Count:%d,

                                AwardItemList:%s,

                                NeedScore:%d,

                                CountEx:%d,

                                AwardItemExList:%s

                                '''\

                                %(

                                self.Rank,

                                self.Count,

                                "...",

                                self.NeedScore,

                                self.CountEx,

                                "..."

                                )

        return DumpString





class  tagMCActGubaoInfo(Structure):

    Head = tagHead()

    ActNum = 0    #(BYTE ActNum)// 活动编号

    StartDate = ""    #(char StartDate[10])// 开始日期 y-m-d

    EndtDate = ""    #(char EndtDate[10])// 结束日期 y-m-d

    JoinStartTime = ""    #(char JoinStartTime[5])// 参与开始时间点 mm:ss

    JoinEndTime = ""    #(char JoinEndTime[5])// 参与结束时间点 mm:ss

    LimitLV = 0    #(WORD LimitLV)// 限制等级

    ShopType = 0    #(WORD ShopType)// 开放商店类型，可能为0不开放

    PersonalBillCount = 0    #(BYTE PersonalBillCount)

    PersonalBillboardInfoList = list()    #(vector<tagMCActGubaoBillard> PersonalBillboardInfoList)// 个人榜单奖励信息列表，如果没有代表本次活动没有该榜奖励

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x81

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.ShopType,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.PersonalBillCount):

            temPersonalBillboardInfoList = tagMCActGubaoBillard()

            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)

            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x81

        self.ActNum = 0

        self.StartDate = ""

        self.EndtDate = ""

        self.JoinStartTime = ""

        self.JoinEndTime = ""

        self.LimitLV = 0

        self.ShopType = 0

        self.PersonalBillCount = 0

        self.PersonalBillboardInfoList = list()

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 1

        length += 10

        length += 10

        length += 5

        length += 5

        length += 2

        length += 2

        length += 1

        for i in range(self.PersonalBillCount):

            length += self.PersonalBillboardInfoList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteBYTE(data, self.ActNum)

        data = CommFunc.WriteString(data, 10, self.StartDate)

        data = CommFunc.WriteString(data, 10, self.EndtDate)

        data = CommFunc.WriteString(data, 5, self.JoinStartTime)

        data = CommFunc.WriteString(data, 5, self.JoinEndTime)

        data = CommFunc.WriteWORD(data, self.LimitLV)

        data = CommFunc.WriteWORD(data, self.ShopType)

        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)

        for i in range(self.PersonalBillCount):

            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                ActNum:%d,

                                StartDate:%s,

                                EndtDate:%s,

                                JoinStartTime:%s,

                                JoinEndTime:%s,

                                LimitLV:%d,

                                ShopType:%d,

                                PersonalBillCount:%d,

                                PersonalBillboardInfoList:%s

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.ActNum,

                                self.StartDate,

                                self.EndtDate,

                                self.JoinStartTime,

                                self.JoinEndTime,

                                self.LimitLV,

                                self.ShopType,

                                self.PersonalBillCount,

                                "..."

                                )

        return DumpString





m_NAtagMCActGubaoInfo=tagMCActGubaoInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActGubaoInfo.Head.Cmd,m_NAtagMCActGubaoInfo.Head.SubCmd))] = m_NAtagMCActGubaoInfo





#------------------------------------------------------

# AA 82 古宝养成活动玩家信息 #tagMCActGubaoPlayerInfo



class  tagMCActGubaoPlayerInfo(Structure):

    _pack_ = 1

    _fields_ = [

                  ("Cmd", c_ubyte),

                  ("SubCmd", c_ubyte),

                  ("ActNum", c_ubyte),    # 活动编号

                  ("Score", c_int),    # 当前积分

                  ]



    def __init__(self):

        self.Clear()

        self.Cmd = 0xAA

        self.SubCmd = 0x82

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.Cmd = 0xAA

        self.SubCmd = 0x82

        self.ActNum = 0

        self.Score = 0

        return



    def GetLength(self):

        return sizeof(tagMCActGubaoPlayerInfo)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 82 古宝养成活动玩家信息 //tagMCActGubaoPlayerInfo:

                                Cmd:%s,

                                SubCmd:%s,

                                ActNum:%d,

                                Score:%d

                                '''\

                                %(

                                self.Cmd,

                                self.SubCmd,

                                self.ActNum,

                                self.Score

                                )

        return DumpString





m_NAtagMCActGubaoPlayerInfo=tagMCActGubaoPlayerInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActGubaoPlayerInfo.Cmd,m_NAtagMCActGubaoPlayerInfo.SubCmd))] = m_NAtagMCActGubaoPlayerInfo





#------------------------------------------------------

# AA 54 骑宠盛宴活动信息 #tagMCActHorsePetFeastInfo



class  tagMCActHorsePetFeastTime(Structure):

    StartTime = ""    #(char StartTime[5])// 开始时间 H:M

    EndtTime = ""    #(char EndtTime[5])// 结束时间 H:M

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.StartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.EndtTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        return _pos



    def Clear(self):

        self.StartTime = ""

        self.EndtTime = ""

        return



    def GetLength(self):

        length = 0

        length += 5

        length += 5



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, 5, self.StartTime)

        data = CommFunc.WriteString(data, 5, self.EndtTime)

        return data



    def OutputString(self):

        DumpString = '''

                                StartTime:%s,

                                EndtTime:%s

                                '''\

                                %(

                                self.StartTime,

                                self.EndtTime

                                )

        return DumpString





class  tagMCActHorsePetFeastInfo(Structure):

    Head = tagHead()

    ActNum = 0    #(BYTE ActNum)//活动编号

    StartDate = ""    #(char StartDate[10])// 开始日期 y-m-d

    EndtDate = ""    #(char EndtDate[10])// 结束日期 y-m-d

    TimeCount = 0    #(BYTE TimeCount)

    ActTimeList = list()    #(vector<tagMCActHorsePetFeastTime> ActTimeList)// 活动时间 H:M 列表

    LimitLV = 0    #(WORD LimitLV)// 限制等级

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x54

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.TimeCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.TimeCount):

            temActTimeList = tagMCActHorsePetFeastTime()

            _pos = temActTimeList.ReadData(_lpData, _pos)

            self.ActTimeList.append(temActTimeList)

        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x54

        self.ActNum = 0

        self.StartDate = ""

        self.EndtDate = ""

        self.TimeCount = 0

        self.ActTimeList = list()

        self.LimitLV = 0

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 1

        length += 10

        length += 10

        length += 1

        for i in range(self.TimeCount):

            length += self.ActTimeList[i].GetLength()

        length += 2



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteBYTE(data, self.ActNum)

        data = CommFunc.WriteString(data, 10, self.StartDate)

        data = CommFunc.WriteString(data, 10, self.EndtDate)

        data = CommFunc.WriteBYTE(data, self.TimeCount)

        for i in range(self.TimeCount):

            data = CommFunc.WriteString(data, self.ActTimeList[i].GetLength(), self.ActTimeList[i].GetBuffer())

        data = CommFunc.WriteWORD(data, self.LimitLV)

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                ActNum:%d,

                                StartDate:%s,

                                EndtDate:%s,

                                TimeCount:%d,

                                ActTimeList:%s,

                                LimitLV:%d

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.ActNum,

                                self.StartDate,

                                self.EndtDate,

                                self.TimeCount,

                                "...",

                                self.LimitLV

                                )

        return DumpString





m_NAtagMCActHorsePetFeastInfo=tagMCActHorsePetFeastInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActHorsePetFeastInfo.Head.Cmd,m_NAtagMCActHorsePetFeastInfo.Head.SubCmd))] = m_NAtagMCActHorsePetFeastInfo





#------------------------------------------------------

# AA 84 骑宠养成活动信息 #tagMCActHorsePetTrainInfo



class  tagMCActHorsePetTrainItem(Structure):

    _pack_ = 1

    _fields_ = [

                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.ItemID = 0

        self.ItemCount = 0

        self.IsBind = 0

        return



    def GetLength(self):

        return sizeof(tagMCActHorsePetTrainItem)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 84 骑宠养成活动信息 //tagMCActHorsePetTrainInfo:

                                ItemID:%d,

                                ItemCount:%d,

                                IsBind:%d

                                '''\

                                %(

                                self.ItemID,

                                self.ItemCount,

                                self.IsBind

                                )

        return DumpString





class  tagMCActHorsePetTrainAwardEx(Structure):

    NeedScore = 0    #(DWORD NeedScore)// 额外奖励所需积分

    Count = 0    #(BYTE Count)// 额外奖励物品数

    AwardItemList = list()    #(vector<tagMCActHorsePetTrainItem> AwardItemList)// 额外奖励物品列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCActHorsePetTrainItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        return _pos



    def Clear(self):

        self.NeedScore = 0

        self.Count = 0

        self.AwardItemList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                NeedScore:%d,

                                Count:%d,

                                AwardItemList:%s

                                '''\

                                %(

                                self.NeedScore,

                                self.Count,

                                "..."

                                )

        return DumpString





class  tagMCActHorsePetTrainBillard(Structure):

    Rank = 0    #(DWORD Rank)// 名次，1-代表第一名；支持夸段，如1，3 代表第1名，第2~3名

    Count = 0    #(BYTE Count)// 奖励物品数

    AwardItemList = list()    #(vector<tagMCActHorsePetTrainItem> AwardItemList)// 奖励物品列表

    NeedScore = 0    #(DWORD NeedScore)// 上榜所需积分

    CountEx = 0    #(BYTE CountEx)// 额外奖励数

    AwardItemExList = list()    #(vector<tagMCActHorsePetTrainAwardEx> AwardItemExList)// 额外奖励列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCActHorsePetTrainItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.CountEx):

            temAwardItemExList = tagMCActHorsePetTrainAwardEx()

            _pos = temAwardItemExList.ReadData(_lpData, _pos)

            self.AwardItemExList.append(temAwardItemExList)

        return _pos



    def Clear(self):

        self.Rank = 0

        self.Count = 0

        self.AwardItemList = list()

        self.NeedScore = 0

        self.CountEx = 0

        self.AwardItemExList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()

        length += 4

        length += 1

        for i in range(self.CountEx):

            length += self.AwardItemExList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.Rank)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.CountEx)

        for i in range(self.CountEx):

            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Rank:%d,

                                Count:%d,

                                AwardItemList:%s,

                                NeedScore:%d,

                                CountEx:%d,

                                AwardItemExList:%s

                                '''\

                                %(

                                self.Rank,

                                self.Count,

                                "...",

                                self.NeedScore,

                                self.CountEx,

                                "..."

                                )

        return DumpString





class  tagMCActHorsePetTrainInfo(Structure):

    Head = tagHead()

    ActNum = 0    #(BYTE ActNum)// 活动编号

    StartDate = ""    #(char StartDate[10])// 开始日期 y-m-d

    EndtDate = ""    #(char EndtDate[10])// 结束日期 y-m-d

    JoinStartTime = ""    #(char JoinStartTime[5])// 参与开始时间点 mm:ss

    JoinEndTime = ""    #(char JoinEndTime[5])// 参与结束时间点 mm:ss

    LimitLV = 0    #(WORD LimitLV)// 限制等级

    ShopType = 0    #(WORD ShopType)// 开放商店类型，可能为0不开放

    PersonalBillCount = 0    #(BYTE PersonalBillCount)

    PersonalBillboardInfoList = list()    #(vector<tagMCActHorsePetTrainBillard> PersonalBillboardInfoList)// 个人榜单奖励信息列表，如果没有代表本次活动没有该榜奖励

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x84

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.ShopType,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.PersonalBillCount):

            temPersonalBillboardInfoList = tagMCActHorsePetTrainBillard()

            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)

            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x84

        self.ActNum = 0

        self.StartDate = ""

        self.EndtDate = ""

        self.JoinStartTime = ""

        self.JoinEndTime = ""

        self.LimitLV = 0

        self.ShopType = 0

        self.PersonalBillCount = 0

        self.PersonalBillboardInfoList = list()

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 1

        length += 10

        length += 10

        length += 5

        length += 5

        length += 2

        length += 2

        length += 1

        for i in range(self.PersonalBillCount):

            length += self.PersonalBillboardInfoList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteBYTE(data, self.ActNum)

        data = CommFunc.WriteString(data, 10, self.StartDate)

        data = CommFunc.WriteString(data, 10, self.EndtDate)

        data = CommFunc.WriteString(data, 5, self.JoinStartTime)

        data = CommFunc.WriteString(data, 5, self.JoinEndTime)

        data = CommFunc.WriteWORD(data, self.LimitLV)

        data = CommFunc.WriteWORD(data, self.ShopType)

        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)

        for i in range(self.PersonalBillCount):

            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                ActNum:%d,

                                StartDate:%s,

                                EndtDate:%s,

                                JoinStartTime:%s,

                                JoinEndTime:%s,

                                LimitLV:%d,

                                ShopType:%d,

                                PersonalBillCount:%d,

                                PersonalBillboardInfoList:%s

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.ActNum,

                                self.StartDate,

                                self.EndtDate,

                                self.JoinStartTime,

                                self.JoinEndTime,

                                self.LimitLV,

                                self.ShopType,

                                self.PersonalBillCount,

                                "..."

                                )

        return DumpString





m_NAtagMCActHorsePetTrainInfo=tagMCActHorsePetTrainInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActHorsePetTrainInfo.Head.Cmd,m_NAtagMCActHorsePetTrainInfo.Head.SubCmd))] = m_NAtagMCActHorsePetTrainInfo





#------------------------------------------------------

# AA 85 骑宠养成活动玩家信息 #tagMCActHorsePetTrainPlayerInfo



class  tagMCActHorsePetTrainPlayerInfo(Structure):

    _pack_ = 1

    _fields_ = [

                  ("Cmd", c_ubyte),

                  ("SubCmd", c_ubyte),

                  ("ActNum", c_ubyte),    # 活动编号

                  ("Score", c_int),    # 当前活动积分

                  ]



    def __init__(self):

        self.Clear()

        self.Cmd = 0xAA

        self.SubCmd = 0x85

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.Cmd = 0xAA

        self.SubCmd = 0x85

        self.ActNum = 0

        self.Score = 0

        return



    def GetLength(self):

        return sizeof(tagMCActHorsePetTrainPlayerInfo)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 85 骑宠养成活动玩家信息 //tagMCActHorsePetTrainPlayerInfo:

                                Cmd:%s,

                                SubCmd:%s,

                                ActNum:%d,

                                Score:%d

                                '''\

                                %(

                                self.Cmd,

                                self.SubCmd,

                                self.ActNum,

                                self.Score

                                )

        return DumpString





m_NAtagMCActHorsePetTrainPlayerInfo=tagMCActHorsePetTrainPlayerInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActHorsePetTrainPlayerInfo.Cmd,m_NAtagMCActHorsePetTrainPlayerInfo.SubCmd))] = m_NAtagMCActHorsePetTrainPlayerInfo





#------------------------------------------------------

@@ -29573,593 +27931,6 @@




#------------------------------------------------------

# AA 59 仙匣秘境抽奖结果 #tagMCActXianXiaMJAwardItemResult



class  tagMCActXianXiaMJAwardItemResult(Structure):

    _pack_ = 1

    _fields_ = [

                  ("Cmd", c_ubyte),

                  ("SubCmd", c_ubyte),

                  ("ActNum", c_ubyte),    # 活动编号

                  ("ItemLibType", c_ubyte),    #物品库类型；9-固定为大奖库，非9-策划自定义库

                  ("ItemID", c_int),    # 注意： 不同库物品ID可能相同，但个数不同

                  ("ItemCount", c_ushort),    
                  ("PosNum", c_ubyte),    # 被抽中时的位置编号，1~99，前端自定义展示位置编号，0代表未被抽中；

                  ("TotalTimesNow", c_ubyte),    #当前已产出次数，不限制次数时不记录，即同样为0

                  ("LotteryScore", c_int),    #当前抽奖积分

                  ]



    def __init__(self):

        self.Clear()

        self.Cmd = 0xAA

        self.SubCmd = 0x59

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.Cmd = 0xAA

        self.SubCmd = 0x59

        self.ActNum = 0

        self.ItemLibType = 0

        self.ItemID = 0

        self.ItemCount = 0

        self.PosNum = 0

        self.TotalTimesNow = 0

        self.LotteryScore = 0

        return



    def GetLength(self):

        return sizeof(tagMCActXianXiaMJAwardItemResult)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 59 仙匣秘境抽奖结果 //tagMCActXianXiaMJAwardItemResult:

                                Cmd:%s,

                                SubCmd:%s,

                                ActNum:%d,

                                ItemLibType:%d,

                                ItemID:%d,

                                ItemCount:%d,

                                PosNum:%d,

                                TotalTimesNow:%d,

                                LotteryScore:%d

                                '''\

                                %(

                                self.Cmd,

                                self.SubCmd,

                                self.ActNum,

                                self.ItemLibType,

                                self.ItemID,

                                self.ItemCount,

                                self.PosNum,

                                self.TotalTimesNow,

                                self.LotteryScore

                                )

        return DumpString





m_NAtagMCActXianXiaMJAwardItemResult=tagMCActXianXiaMJAwardItemResult()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActXianXiaMJAwardItemResult.Cmd,m_NAtagMCActXianXiaMJAwardItemResult.SubCmd))] = m_NAtagMCActXianXiaMJAwardItemResult





#------------------------------------------------------

# AA 58 仙匣秘境活动信息 #tagMCActXianXiaMJInfo



class  tagMCActXianXiaMJItem(Structure):

    _pack_ = 1

    _fields_ = [

                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.ItemID = 0

        self.ItemCount = 0

        self.IsBind = 0

        return



    def GetLength(self):

        return sizeof(tagMCActXianXiaMJItem)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 58 仙匣秘境活动信息 //tagMCActXianXiaMJInfo:

                                ItemID:%d,

                                ItemCount:%d,

                                IsBind:%d

                                '''\

                                %(

                                self.ItemID,

                                self.ItemCount,

                                self.IsBind

                                )

        return DumpString





class  tagMCActXianXiaMJAwardEx(Structure):

    NeedScore = 0    #(DWORD NeedScore)// 额外奖励所需积分

    Count = 0    #(BYTE Count)// 额外奖励物品数

    AwardItemList = list()    #(vector<tagMCActXianXiaMJItem> AwardItemList)// 额外奖励物品列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCActXianXiaMJItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        return _pos



    def Clear(self):

        self.NeedScore = 0

        self.Count = 0

        self.AwardItemList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                NeedScore:%d,

                                Count:%d,

                                AwardItemList:%s

                                '''\

                                %(

                                self.NeedScore,

                                self.Count,

                                "..."

                                )

        return DumpString





class  tagMCActXianXiaMJBillard(Structure):

    Rank = 0    #(DWORD Rank)// 名次，1-代表第一名；支持夸段，如1，3 代表第1名，第2~3名

    Count = 0    #(BYTE Count)// 奖励物品数

    AwardItemList = list()    #(vector<tagMCActXianXiaMJItem> AwardItemList)// 奖励物品列表

    NeedScore = 0    #(DWORD NeedScore)// 上榜所需积分

    CountEx = 0    #(BYTE CountEx)// 额外奖励数

    AwardItemExList = list()    #(vector<tagMCActXianXiaMJAwardEx> AwardItemExList)// 额外奖励列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCActXianXiaMJItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.CountEx):

            temAwardItemExList = tagMCActXianXiaMJAwardEx()

            _pos = temAwardItemExList.ReadData(_lpData, _pos)

            self.AwardItemExList.append(temAwardItemExList)

        return _pos



    def Clear(self):

        self.Rank = 0

        self.Count = 0

        self.AwardItemList = list()

        self.NeedScore = 0

        self.CountEx = 0

        self.AwardItemExList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()

        length += 4

        length += 1

        for i in range(self.CountEx):

            length += self.AwardItemExList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.Rank)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.CountEx)

        for i in range(self.CountEx):

            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Rank:%d,

                                Count:%d,

                                AwardItemList:%s,

                                NeedScore:%d,

                                CountEx:%d,

                                AwardItemExList:%s

                                '''\

                                %(

                                self.Rank,

                                self.Count,

                                "...",

                                self.NeedScore,

                                self.CountEx,

                                "..."

                                )

        return DumpString





class  tagMCActXianXiaMJInfo(Structure):

    Head = tagHead()

    ActNum = 0    #(BYTE ActNum)// 活动编号

    StartDate = ""    #(char StartDate[10])// 开始日期 y-m-d

    EndtDate = ""    #(char EndtDate[10])// 结束日期 y-m-d

    JoinStartTime = ""    #(char JoinStartTime[5])// 参与开始时间点 mm:ss

    JoinEndTime = ""    #(char JoinEndTime[5])// 参与结束时间点 mm:ss

    IsDayReset = 0    #(BYTE IsDayReset)// 是否每天重置

    LimitLV = 0    #(WORD LimitLV)// 限制等级

    UseItemID = 0    #(DWORD UseItemID)//消耗物品ID，默认1个；消耗物品或货币二选一即可，或都配则先消耗道具，不足则消耗货币

    MoneyType = 0    #(BYTE MoneyType)//消耗货币类型

    MoneyValue = 0    #(WORD MoneyValue)//消耗货币值

    LotteryAddScore = 0    #(WORD LotteryAddScore)//每次抽奖加积分

    LayerAddScore = 0    #(WORD LayerAddScore)//每次跨层加积分

    PersonalBillCount = 0    #(BYTE PersonalBillCount)

    PersonalBillboardInfoList = list()    #(vector<tagMCActXianXiaMJBillard> PersonalBillboardInfoList)// 个人榜单奖励信息列表，如果没有代表本次活动没有该榜奖励

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x58

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.LimitLV,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.UseItemID,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.MoneyType,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.MoneyValue,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.LotteryAddScore,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.LayerAddScore,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.PersonalBillCount):

            temPersonalBillboardInfoList = tagMCActXianXiaMJBillard()

            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)

            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x58

        self.ActNum = 0

        self.StartDate = ""

        self.EndtDate = ""

        self.JoinStartTime = ""

        self.JoinEndTime = ""

        self.IsDayReset = 0

        self.LimitLV = 0

        self.UseItemID = 0

        self.MoneyType = 0

        self.MoneyValue = 0

        self.LotteryAddScore = 0

        self.LayerAddScore = 0

        self.PersonalBillCount = 0

        self.PersonalBillboardInfoList = list()

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 1

        length += 10

        length += 10

        length += 5

        length += 5

        length += 1

        length += 2

        length += 4

        length += 1

        length += 2

        length += 2

        length += 2

        length += 1

        for i in range(self.PersonalBillCount):

            length += self.PersonalBillboardInfoList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteBYTE(data, self.ActNum)

        data = CommFunc.WriteString(data, 10, self.StartDate)

        data = CommFunc.WriteString(data, 10, self.EndtDate)

        data = CommFunc.WriteString(data, 5, self.JoinStartTime)

        data = CommFunc.WriteString(data, 5, self.JoinEndTime)

        data = CommFunc.WriteBYTE(data, self.IsDayReset)

        data = CommFunc.WriteWORD(data, self.LimitLV)

        data = CommFunc.WriteDWORD(data, self.UseItemID)

        data = CommFunc.WriteBYTE(data, self.MoneyType)

        data = CommFunc.WriteWORD(data, self.MoneyValue)

        data = CommFunc.WriteWORD(data, self.LotteryAddScore)

        data = CommFunc.WriteWORD(data, self.LayerAddScore)

        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)

        for i in range(self.PersonalBillCount):

            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                ActNum:%d,

                                StartDate:%s,

                                EndtDate:%s,

                                JoinStartTime:%s,

                                JoinEndTime:%s,

                                IsDayReset:%d,

                                LimitLV:%d,

                                UseItemID:%d,

                                MoneyType:%d,

                                MoneyValue:%d,

                                LotteryAddScore:%d,

                                LayerAddScore:%d,

                                PersonalBillCount:%d,

                                PersonalBillboardInfoList:%s

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.ActNum,

                                self.StartDate,

                                self.EndtDate,

                                self.JoinStartTime,

                                self.JoinEndTime,

                                self.IsDayReset,

                                self.LimitLV,

                                self.UseItemID,

                                self.MoneyType,

                                self.MoneyValue,

                                self.LotteryAddScore,

                                self.LayerAddScore,

                                self.PersonalBillCount,

                                "..."

                                )

        return DumpString





m_NAtagMCActXianXiaMJInfo=tagMCActXianXiaMJInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActXianXiaMJInfo.Head.Cmd,m_NAtagMCActXianXiaMJInfo.Head.SubCmd))] = m_NAtagMCActXianXiaMJInfo





#------------------------------------------------------

# AA 79 仙匣秘境层信息 #tagMCActXianXiaMJLayerInfo



class  tagMCActXianXiaMJLayerItem(Structure):

    _pack_ = 1

    _fields_ = [

                  ("ItemLibType", c_ubyte),    #物品库类型；9-固定为大奖库，非9-策划自定义库

                  ("ItemID", c_int),    # 注意： 不同库物品ID可能相同，但个数不同

                  ("ItemCount", c_ushort),    
                  ("PosNum", c_ubyte),    # 被抽中时的位置编号，1~99，前端自定义展示位置编号，0代表未被抽中；

                  ("TotalTimesNow", c_ubyte),    #当前已产出次数，不限制次数时不记录，即同样为0

                  ("TotalTimesMax", c_ubyte),    #最大可产出次数，0不限

                  ("LayerLimit", c_ubyte),    #大于等于X层后可产出，0不限

                  ]



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.ItemLibType = 0

        self.ItemID = 0

        self.ItemCount = 0

        self.PosNum = 0

        self.TotalTimesNow = 0

        self.TotalTimesMax = 0

        self.LayerLimit = 0

        return



    def GetLength(self):

        return sizeof(tagMCActXianXiaMJLayerItem)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 79 仙匣秘境层信息 //tagMCActXianXiaMJLayerInfo:

                                ItemLibType:%d,

                                ItemID:%d,

                                ItemCount:%d,

                                PosNum:%d,

                                TotalTimesNow:%d,

                                TotalTimesMax:%d,

                                LayerLimit:%d

                                '''\

                                %(

                                self.ItemLibType,

                                self.ItemID,

                                self.ItemCount,

                                self.PosNum,

                                self.TotalTimesNow,

                                self.TotalTimesMax,

                                self.LayerLimit

                                )

        return DumpString





class  tagMCActXianXiaMJLayerInfo(Structure):

    Head = tagHead()

    ActNum = 0    #(BYTE ActNum)// 活动编号

    LayerNum = 0    #(WORD LayerNum)//当前奖池第几层

    LotteryScore = 0    #(DWORD LotteryScore)//当前抽奖积分

    AwardItemCount = 0    #(BYTE AwardItemCount)

    AwardItemList = list()    #(vector<tagMCActXianXiaMJLayerItem> AwardItemList)// 奖池物品列表，已生成的，包含已选择的大奖物品

    SuperItemCount = 0    #(BYTE SuperItemCount)

    SuperItemList = list()    #(vector<tagMCActXianXiaMJLayerItem> SuperItemList)// 大奖物品待选择库，由玩家从库中选择放入奖池的物品；

    SuperItemCanChooseCount = 0    #(BYTE SuperItemCanChooseCount)// 大奖物品可选择个数

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x79

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.ActNum,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.LayerNum,_pos = CommFunc.ReadWORD(_lpData, _pos)

        self.LotteryScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.AwardItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.AwardItemCount):

            temAwardItemList = tagMCActXianXiaMJLayerItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        self.SuperItemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.SuperItemCount):

            temSuperItemList = tagMCActXianXiaMJLayerItem()

            _pos = temSuperItemList.ReadData(_lpData, _pos)

            self.SuperItemList.append(temSuperItemList)

        self.SuperItemCanChooseCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x79

        self.ActNum = 0

        self.LayerNum = 0

        self.LotteryScore = 0

        self.AwardItemCount = 0

        self.AwardItemList = list()

        self.SuperItemCount = 0

        self.SuperItemList = list()

        self.SuperItemCanChooseCount = 0

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 1

        length += 2

        length += 4

        length += 1

        for i in range(self.AwardItemCount):

            length += self.AwardItemList[i].GetLength()

        length += 1

        for i in range(self.SuperItemCount):

            length += self.SuperItemList[i].GetLength()

        length += 1



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteBYTE(data, self.ActNum)

        data = CommFunc.WriteWORD(data, self.LayerNum)

        data = CommFunc.WriteDWORD(data, self.LotteryScore)

        data = CommFunc.WriteBYTE(data, self.AwardItemCount)

        for i in range(self.AwardItemCount):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        data = CommFunc.WriteBYTE(data, self.SuperItemCount)

        for i in range(self.SuperItemCount):

            data = CommFunc.WriteString(data, self.SuperItemList[i].GetLength(), self.SuperItemList[i].GetBuffer())

        data = CommFunc.WriteBYTE(data, self.SuperItemCanChooseCount)

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                ActNum:%d,

                                LayerNum:%d,

                                LotteryScore:%d,

                                AwardItemCount:%d,

                                AwardItemList:%s,

                                SuperItemCount:%d,

                                SuperItemList:%s,

                                SuperItemCanChooseCount:%d

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.ActNum,

                                self.LayerNum,

                                self.LotteryScore,

                                self.AwardItemCount,

                                "...",

                                self.SuperItemCount,

                                "...",

                                self.SuperItemCanChooseCount

                                )

        return DumpString





m_NAtagMCActXianXiaMJLayerInfo=tagMCActXianXiaMJLayerInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActXianXiaMJLayerInfo.Head.Cmd,m_NAtagMCActXianXiaMJLayerInfo.Head.SubCmd))] = m_NAtagMCActXianXiaMJLayerInfo





#------------------------------------------------------

# AA 87 运势活动信息 #tagMCActYunshiInfo



class  tagMCActYunshiInfo(Structure):

@@ -31172,961 +28943,6 @@




#------------------------------------------------------

# AA 76 Boss历练跨服活动信息 #tagMCCrossActBossTrialInfo



class  tagMCCrossActBossTrialItem(Structure):

    _pack_ = 1

    _fields_ = [

                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.ItemID = 0

        self.ItemCount = 0

        self.IsBind = 0

        return



    def GetLength(self):

        return sizeof(tagMCCrossActBossTrialItem)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 76 Boss历练跨服活动信息 //tagMCCrossActBossTrialInfo:

                                ItemID:%d,

                                ItemCount:%d,

                                IsBind:%d

                                '''\

                                %(

                                self.ItemID,

                                self.ItemCount,

                                self.IsBind

                                )

        return DumpString





class  tagMCCrossActBossTrialAwardEx(Structure):

    NeedScore = 0    #(DWORD NeedScore)// 额外奖励所需积分

    Count = 0    #(BYTE Count)// 额外奖励物品数

    AwardItemList = list()    #(vector<tagMCCrossActBossTrialItem> AwardItemList)// 额外奖励物品列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCCrossActBossTrialItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        return _pos



    def Clear(self):

        self.NeedScore = 0

        self.Count = 0

        self.AwardItemList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                NeedScore:%d,

                                Count:%d,

                                AwardItemList:%s

                                '''\

                                %(

                                self.NeedScore,

                                self.Count,

                                "..."

                                )

        return DumpString





class  tagMCCrossActBossTrialBillard(Structure):

    Rank = 0    #(DWORD Rank)// 名次，1-代表第一名；支持夸段，如1，3 代表第1名，第2~3名

    Count = 0    #(BYTE Count)// 奖励物品数

    AwardItemList = list()    #(vector<tagMCCrossActBossTrialItem> AwardItemList)// 奖励物品列表，当仙盟榜时，如果有该奖励则代表盟主奖励，否则默认均为成员奖励

    MemCount = 0    #(BYTE MemCount)// 成员奖励物品数

    MemAwardItemList = list()    #(vector<tagMCCrossActBossTrialItem> MemAwardItemList)// 成员奖励物品列表，仅仙盟榜时有效

    NeedScore = 0    #(DWORD NeedScore)// 上榜所需积分

    CountEx = 0    #(BYTE CountEx)// 额外奖励数

    AwardItemExList = list()    #(vector<tagMCCrossActBossTrialAwardEx> AwardItemExList)// 额外奖励列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCCrossActBossTrialItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        self.MemCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.MemCount):

            temMemAwardItemList = tagMCCrossActBossTrialItem()

            _pos = temMemAwardItemList.ReadData(_lpData, _pos)

            self.MemAwardItemList.append(temMemAwardItemList)

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.CountEx):

            temAwardItemExList = tagMCCrossActBossTrialAwardEx()

            _pos = temAwardItemExList.ReadData(_lpData, _pos)

            self.AwardItemExList.append(temAwardItemExList)

        return _pos



    def Clear(self):

        self.Rank = 0

        self.Count = 0

        self.AwardItemList = list()

        self.MemCount = 0

        self.MemAwardItemList = list()

        self.NeedScore = 0

        self.CountEx = 0

        self.AwardItemExList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()

        length += 1

        for i in range(self.MemCount):

            length += self.MemAwardItemList[i].GetLength()

        length += 4

        length += 1

        for i in range(self.CountEx):

            length += self.AwardItemExList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.Rank)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        data = CommFunc.WriteBYTE(data, self.MemCount)

        for i in range(self.MemCount):

            data = CommFunc.WriteString(data, self.MemAwardItemList[i].GetLength(), self.MemAwardItemList[i].GetBuffer())

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.CountEx)

        for i in range(self.CountEx):

            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Rank:%d,

                                Count:%d,

                                AwardItemList:%s,

                                MemCount:%d,

                                MemAwardItemList:%s,

                                NeedScore:%d,

                                CountEx:%d,

                                AwardItemExList:%s

                                '''\

                                %(

                                self.Rank,

                                self.Count,

                                "...",

                                self.MemCount,

                                "...",

                                self.NeedScore,

                                self.CountEx,

                                "..."

                                )

        return DumpString





class  tagMCCrossActBossTrialInfo(Structure):

    Head = tagHead()

    ServerInfoLen = 0    #(BYTE ServerInfoLen)

    ServerIDRangeInfo = ""    #(String ServerIDRangeInfo)//开放该活动的服务器ID范围列表，json格式 [[IDA, IDB], ...]， [] 为全服

    GroupValue1 = 0    #(BYTE GroupValue1)// 活动榜单分组值1，用于查询对应榜单

    StartDate = ""    #(char StartDate[10])// 开始日期 y-m-d

    EndtDate = ""    #(char EndtDate[10])// 结束日期 y-m-d

    JoinStartTime = ""    #(char JoinStartTime[5])// 参与开始时间点 mm:ss

    JoinEndTime = ""    #(char JoinEndTime[5])// 参与结束时间点 mm:ss

    IsDayReset = 0    #(BYTE IsDayReset)// 是否每天重置

    ResetType = 0    #(BYTE ResetType)// 重置类型，0-0点重置；1-5点重置

    PersonalBillCount = 0    #(BYTE PersonalBillCount)

    PersonalBillboardInfoList = list()    #(vector<tagMCCrossActBossTrialBillard> PersonalBillboardInfoList)// 个人榜单奖励信息列表，如果没有代表本次活动没有该榜奖励

    FamilyBillCount = 0    #(BYTE FamilyBillCount)

    FamilyBillboardInfoList = list()    #(vector<tagMCCrossActBossTrialBillard> FamilyBillboardInfoList)// 仙盟榜单奖励信息列表，如果没有代表本次活动没有该榜奖励

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x76

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.ServerInfoLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.ServerIDRangeInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.ServerInfoLen)

        self.GroupValue1,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.ResetType,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.PersonalBillCount):

            temPersonalBillboardInfoList = tagMCCrossActBossTrialBillard()

            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)

            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)

        self.FamilyBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.FamilyBillCount):

            temFamilyBillboardInfoList = tagMCCrossActBossTrialBillard()

            _pos = temFamilyBillboardInfoList.ReadData(_lpData, _pos)

            self.FamilyBillboardInfoList.append(temFamilyBillboardInfoList)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x76

        self.ServerInfoLen = 0

        self.ServerIDRangeInfo = ""

        self.GroupValue1 = 0

        self.StartDate = ""

        self.EndtDate = ""

        self.JoinStartTime = ""

        self.JoinEndTime = ""

        self.IsDayReset = 0

        self.ResetType = 0

        self.PersonalBillCount = 0

        self.PersonalBillboardInfoList = list()

        self.FamilyBillCount = 0

        self.FamilyBillboardInfoList = list()

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 1

        length += len(self.ServerIDRangeInfo)

        length += 1

        length += 10

        length += 10

        length += 5

        length += 5

        length += 1

        length += 1

        length += 1

        for i in range(self.PersonalBillCount):

            length += self.PersonalBillboardInfoList[i].GetLength()

        length += 1

        for i in range(self.FamilyBillCount):

            length += self.FamilyBillboardInfoList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteBYTE(data, self.ServerInfoLen)

        data = CommFunc.WriteString(data, self.ServerInfoLen, self.ServerIDRangeInfo)

        data = CommFunc.WriteBYTE(data, self.GroupValue1)

        data = CommFunc.WriteString(data, 10, self.StartDate)

        data = CommFunc.WriteString(data, 10, self.EndtDate)

        data = CommFunc.WriteString(data, 5, self.JoinStartTime)

        data = CommFunc.WriteString(data, 5, self.JoinEndTime)

        data = CommFunc.WriteBYTE(data, self.IsDayReset)

        data = CommFunc.WriteBYTE(data, self.ResetType)

        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)

        for i in range(self.PersonalBillCount):

            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())

        data = CommFunc.WriteBYTE(data, self.FamilyBillCount)

        for i in range(self.FamilyBillCount):

            data = CommFunc.WriteString(data, self.FamilyBillboardInfoList[i].GetLength(), self.FamilyBillboardInfoList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                ServerInfoLen:%d,

                                ServerIDRangeInfo:%s,

                                GroupValue1:%d,

                                StartDate:%s,

                                EndtDate:%s,

                                JoinStartTime:%s,

                                JoinEndTime:%s,

                                IsDayReset:%d,

                                ResetType:%d,

                                PersonalBillCount:%d,

                                PersonalBillboardInfoList:%s,

                                FamilyBillCount:%d,

                                FamilyBillboardInfoList:%s

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.ServerInfoLen,

                                self.ServerIDRangeInfo,

                                self.GroupValue1,

                                self.StartDate,

                                self.EndtDate,

                                self.JoinStartTime,

                                self.JoinEndTime,

                                self.IsDayReset,

                                self.ResetType,

                                self.PersonalBillCount,

                                "...",

                                self.FamilyBillCount,

                                "..."

                                )

        return DumpString





m_NAtagMCCrossActBossTrialInfo=tagMCCrossActBossTrialInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCrossActBossTrialInfo.Head.Cmd,m_NAtagMCCrossActBossTrialInfo.Head.SubCmd))] = m_NAtagMCCrossActBossTrialInfo





#------------------------------------------------------

# AA 83 古宝养成跨服活动信息 #tagMCCrossActGubaoInfo



class  tagMCCrossActGubaoItem(Structure):

    _pack_ = 1

    _fields_ = [

                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.ItemID = 0

        self.ItemCount = 0

        self.IsBind = 0

        return



    def GetLength(self):

        return sizeof(tagMCCrossActGubaoItem)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 83 古宝养成跨服活动信息 //tagMCCrossActGubaoInfo:

                                ItemID:%d,

                                ItemCount:%d,

                                IsBind:%d

                                '''\

                                %(

                                self.ItemID,

                                self.ItemCount,

                                self.IsBind

                                )

        return DumpString





class  tagMCCrossActGubaoAwardEx(Structure):

    NeedScore = 0    #(DWORD NeedScore)// 额外奖励所需积分

    Count = 0    #(BYTE Count)// 额外奖励物品数

    AwardItemList = list()    #(vector<tagMCCrossActGubaoItem> AwardItemList)// 额外奖励物品列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCCrossActGubaoItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        return _pos



    def Clear(self):

        self.NeedScore = 0

        self.Count = 0

        self.AwardItemList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                NeedScore:%d,

                                Count:%d,

                                AwardItemList:%s

                                '''\

                                %(

                                self.NeedScore,

                                self.Count,

                                "..."

                                )

        return DumpString





class  tagMCCrossActGubaoBillard(Structure):

    Rank = 0    #(DWORD Rank)// 名次，1-代表第一名；支持夸段，如1，3 代表第1名，第2~3名

    Count = 0    #(BYTE Count)// 奖励物品数

    AwardItemList = list()    #(vector<tagMCCrossActGubaoItem> AwardItemList)// 奖励物品列表

    NeedScore = 0    #(DWORD NeedScore)// 上榜所需积分

    CountEx = 0    #(BYTE CountEx)// 额外奖励数

    AwardItemExList = list()    #(vector<tagMCCrossActGubaoAwardEx> AwardItemExList)// 额外奖励列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCCrossActGubaoItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.CountEx):

            temAwardItemExList = tagMCCrossActGubaoAwardEx()

            _pos = temAwardItemExList.ReadData(_lpData, _pos)

            self.AwardItemExList.append(temAwardItemExList)

        return _pos



    def Clear(self):

        self.Rank = 0

        self.Count = 0

        self.AwardItemList = list()

        self.NeedScore = 0

        self.CountEx = 0

        self.AwardItemExList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()

        length += 4

        length += 1

        for i in range(self.CountEx):

            length += self.AwardItemExList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.Rank)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.CountEx)

        for i in range(self.CountEx):

            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Rank:%d,

                                Count:%d,

                                AwardItemList:%s,

                                NeedScore:%d,

                                CountEx:%d,

                                AwardItemExList:%s

                                '''\

                                %(

                                self.Rank,

                                self.Count,

                                "...",

                                self.NeedScore,

                                self.CountEx,

                                "..."

                                )

        return DumpString





class  tagMCCrossActGubaoInfo(Structure):

    Head = tagHead()

    ServerInfoLen = 0    #(BYTE ServerInfoLen)

    ServerIDRangeInfo = ""    #(String ServerIDRangeInfo)//开放该活动的服务器ID范围列表，json格式 [[IDA, IDB], ...]， [] 为全服

    GroupValue1 = 0    #(BYTE GroupValue1)// 活动榜单分组值1，用于查询对应榜单

    StartDate = ""    #(char StartDate[10])// 开始日期 y-m-d

    EndtDate = ""    #(char EndtDate[10])// 结束日期 y-m-d

    JoinStartTime = ""    #(char JoinStartTime[5])// 参与开始时间点 mm:ss

    JoinEndTime = ""    #(char JoinEndTime[5])// 参与结束时间点 mm:ss

    PersonalBillCount = 0    #(BYTE PersonalBillCount)

    PersonalBillboardInfoList = list()    #(vector<tagMCCrossActGubaoBillard> PersonalBillboardInfoList)// 个人榜单奖励信息列表，如果没有代表本次活动没有该榜奖励

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x83

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.ServerInfoLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.ServerIDRangeInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.ServerInfoLen)

        self.GroupValue1,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.PersonalBillCount):

            temPersonalBillboardInfoList = tagMCCrossActGubaoBillard()

            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)

            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x83

        self.ServerInfoLen = 0

        self.ServerIDRangeInfo = ""

        self.GroupValue1 = 0

        self.StartDate = ""

        self.EndtDate = ""

        self.JoinStartTime = ""

        self.JoinEndTime = ""

        self.PersonalBillCount = 0

        self.PersonalBillboardInfoList = list()

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 1

        length += len(self.ServerIDRangeInfo)

        length += 1

        length += 10

        length += 10

        length += 5

        length += 5

        length += 1

        for i in range(self.PersonalBillCount):

            length += self.PersonalBillboardInfoList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteBYTE(data, self.ServerInfoLen)

        data = CommFunc.WriteString(data, self.ServerInfoLen, self.ServerIDRangeInfo)

        data = CommFunc.WriteBYTE(data, self.GroupValue1)

        data = CommFunc.WriteString(data, 10, self.StartDate)

        data = CommFunc.WriteString(data, 10, self.EndtDate)

        data = CommFunc.WriteString(data, 5, self.JoinStartTime)

        data = CommFunc.WriteString(data, 5, self.JoinEndTime)

        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)

        for i in range(self.PersonalBillCount):

            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                ServerInfoLen:%d,

                                ServerIDRangeInfo:%s,

                                GroupValue1:%d,

                                StartDate:%s,

                                EndtDate:%s,

                                JoinStartTime:%s,

                                JoinEndTime:%s,

                                PersonalBillCount:%d,

                                PersonalBillboardInfoList:%s

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.ServerInfoLen,

                                self.ServerIDRangeInfo,

                                self.GroupValue1,

                                self.StartDate,

                                self.EndtDate,

                                self.JoinStartTime,

                                self.JoinEndTime,

                                self.PersonalBillCount,

                                "..."

                                )

        return DumpString





m_NAtagMCCrossActGubaoInfo=tagMCCrossActGubaoInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCrossActGubaoInfo.Head.Cmd,m_NAtagMCCrossActGubaoInfo.Head.SubCmd))] = m_NAtagMCCrossActGubaoInfo





#------------------------------------------------------

# AA 86 骑宠养成跨服活动信息 #tagMCCrossActHorsePetTrainInfo



class  tagMCCrossActHorsePetTrainItem(Structure):

    _pack_ = 1

    _fields_ = [

                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.ItemID = 0

        self.ItemCount = 0

        self.IsBind = 0

        return



    def GetLength(self):

        return sizeof(tagMCCrossActHorsePetTrainItem)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 86 骑宠养成跨服活动信息 //tagMCCrossActHorsePetTrainInfo:

                                ItemID:%d,

                                ItemCount:%d,

                                IsBind:%d

                                '''\

                                %(

                                self.ItemID,

                                self.ItemCount,

                                self.IsBind

                                )

        return DumpString





class  tagMCCrossActHorsePetTrainAwardEx(Structure):

    NeedScore = 0    #(DWORD NeedScore)// 额外奖励所需积分

    Count = 0    #(BYTE Count)// 额外奖励物品数

    AwardItemList = list()    #(vector<tagMCCrossActHorsePetTrainItem> AwardItemList)// 额外奖励物品列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCCrossActHorsePetTrainItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        return _pos



    def Clear(self):

        self.NeedScore = 0

        self.Count = 0

        self.AwardItemList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                NeedScore:%d,

                                Count:%d,

                                AwardItemList:%s

                                '''\

                                %(

                                self.NeedScore,

                                self.Count,

                                "..."

                                )

        return DumpString





class  tagMCCrossActHorsePetTrainBillard(Structure):

    Rank = 0    #(DWORD Rank)// 名次，1-代表第一名；支持夸段，如1，3 代表第1名，第2~3名

    Count = 0    #(BYTE Count)// 奖励物品数

    AwardItemList = list()    #(vector<tagMCCrossActHorsePetTrainItem> AwardItemList)// 奖励物品列表

    NeedScore = 0    #(DWORD NeedScore)// 上榜所需积分

    CountEx = 0    #(BYTE CountEx)// 额外奖励数

    AwardItemExList = list()    #(vector<tagMCCrossActHorsePetTrainAwardEx> AwardItemExList)// 额外奖励列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCCrossActHorsePetTrainItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.CountEx):

            temAwardItemExList = tagMCCrossActHorsePetTrainAwardEx()

            _pos = temAwardItemExList.ReadData(_lpData, _pos)

            self.AwardItemExList.append(temAwardItemExList)

        return _pos



    def Clear(self):

        self.Rank = 0

        self.Count = 0

        self.AwardItemList = list()

        self.NeedScore = 0

        self.CountEx = 0

        self.AwardItemExList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()

        length += 4

        length += 1

        for i in range(self.CountEx):

            length += self.AwardItemExList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.Rank)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.CountEx)

        for i in range(self.CountEx):

            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Rank:%d,

                                Count:%d,

                                AwardItemList:%s,

                                NeedScore:%d,

                                CountEx:%d,

                                AwardItemExList:%s

                                '''\

                                %(

                                self.Rank,

                                self.Count,

                                "...",

                                self.NeedScore,

                                self.CountEx,

                                "..."

                                )

        return DumpString





class  tagMCCrossActHorsePetTrainInfo(Structure):

    Head = tagHead()

    ServerInfoLen = 0    #(BYTE ServerInfoLen)

    ServerIDRangeInfo = ""    #(String ServerIDRangeInfo)//开放该活动的服务器ID范围列表，json格式 [[IDA, IDB], ...]， [] 为全服

    GroupValue1 = 0    #(BYTE GroupValue1)// 活动榜单分组值1，用于查询对应榜单

    StartDate = ""    #(char StartDate[10])// 开始日期 y-m-d

    EndtDate = ""    #(char EndtDate[10])// 结束日期 y-m-d

    JoinStartTime = ""    #(char JoinStartTime[5])// 参与开始时间点 mm:ss

    JoinEndTime = ""    #(char JoinEndTime[5])// 参与结束时间点 mm:ss

    PersonalBillCount = 0    #(BYTE PersonalBillCount)

    PersonalBillboardInfoList = list()    #(vector<tagMCCrossActHorsePetTrainBillard> PersonalBillboardInfoList)// 个人榜单奖励信息列表，如果没有代表本次活动没有该榜奖励

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x86

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.ServerInfoLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.ServerIDRangeInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.ServerInfoLen)

        self.GroupValue1,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.PersonalBillCount):

            temPersonalBillboardInfoList = tagMCCrossActHorsePetTrainBillard()

            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)

            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x86

        self.ServerInfoLen = 0

        self.ServerIDRangeInfo = ""

        self.GroupValue1 = 0

        self.StartDate = ""

        self.EndtDate = ""

        self.JoinStartTime = ""

        self.JoinEndTime = ""

        self.PersonalBillCount = 0

        self.PersonalBillboardInfoList = list()

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 1

        length += len(self.ServerIDRangeInfo)

        length += 1

        length += 10

        length += 10

        length += 5

        length += 5

        length += 1

        for i in range(self.PersonalBillCount):

            length += self.PersonalBillboardInfoList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteBYTE(data, self.ServerInfoLen)

        data = CommFunc.WriteString(data, self.ServerInfoLen, self.ServerIDRangeInfo)

        data = CommFunc.WriteBYTE(data, self.GroupValue1)

        data = CommFunc.WriteString(data, 10, self.StartDate)

        data = CommFunc.WriteString(data, 10, self.EndtDate)

        data = CommFunc.WriteString(data, 5, self.JoinStartTime)

        data = CommFunc.WriteString(data, 5, self.JoinEndTime)

        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)

        for i in range(self.PersonalBillCount):

            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                ServerInfoLen:%d,

                                ServerIDRangeInfo:%s,

                                GroupValue1:%d,

                                StartDate:%s,

                                EndtDate:%s,

                                JoinStartTime:%s,

                                JoinEndTime:%s,

                                PersonalBillCount:%d,

                                PersonalBillboardInfoList:%s

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.ServerInfoLen,

                                self.ServerIDRangeInfo,

                                self.GroupValue1,

                                self.StartDate,

                                self.EndtDate,

                                self.JoinStartTime,

                                self.JoinEndTime,

                                self.PersonalBillCount,

                                "..."

                                )

        return DumpString





m_NAtagMCCrossActHorsePetTrainInfo=tagMCCrossActHorsePetTrainInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCrossActHorsePetTrainInfo.Head.Cmd,m_NAtagMCCrossActHorsePetTrainInfo.Head.SubCmd))] = m_NAtagMCCrossActHorsePetTrainInfo





#------------------------------------------------------

# AA 90 炼器跨服活动信息 #tagMCCrossActLianqiInfo



class  tagMCCrossActLianqiItem(Structure):

@@ -32628,314 +29444,6 @@


m_NAtagMCActLianqiPlayerInfo=tagMCActLianqiPlayerInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCActLianqiPlayerInfo.Head.Cmd,m_NAtagMCActLianqiPlayerInfo.Head.SubCmd))] = m_NAtagMCActLianqiPlayerInfo





#------------------------------------------------------

# AA 80 仙匣秘境跨服活动信息 #tagMCCrossActXianXiaMJInfo



class  tagMCCrossActXianXiaMJItem(Structure):

    _pack_ = 1

    _fields_ = [

                  ("ItemID", c_int),    
                  ("ItemCount", c_ushort),    
                  ("IsBind", c_ubyte),    
                  ]



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, stringData, _pos=0, _len=0):

        self.Clear()

        memmove(addressof(self), stringData[_pos:], self.GetLength())

        return _pos + self.GetLength()



    def Clear(self):

        self.ItemID = 0

        self.ItemCount = 0

        self.IsBind = 0

        return



    def GetLength(self):

        return sizeof(tagMCCrossActXianXiaMJItem)



    def GetBuffer(self):

        return string_at(addressof(self), self.GetLength())



    def OutputString(self):

        DumpString = '''// AA 80 仙匣秘境跨服活动信息 //tagMCCrossActXianXiaMJInfo:

                                ItemID:%d,

                                ItemCount:%d,

                                IsBind:%d

                                '''\

                                %(

                                self.ItemID,

                                self.ItemCount,

                                self.IsBind

                                )

        return DumpString





class  tagMCCrossActXianXiaMJAwardEx(Structure):

    NeedScore = 0    #(DWORD NeedScore)// 额外奖励所需积分

    Count = 0    #(BYTE Count)// 额外奖励物品数

    AwardItemList = list()    #(vector<tagMCCrossActXianXiaMJItem> AwardItemList)// 额外奖励物品列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCCrossActXianXiaMJItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        return _pos



    def Clear(self):

        self.NeedScore = 0

        self.Count = 0

        self.AwardItemList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                NeedScore:%d,

                                Count:%d,

                                AwardItemList:%s

                                '''\

                                %(

                                self.NeedScore,

                                self.Count,

                                "..."

                                )

        return DumpString





class  tagMCCrossActXianXiaMJBillard(Structure):

    Rank = 0    #(DWORD Rank)// 名次，1-代表第一名；支持夸段，如1，3 代表第1名，第2~3名

    Count = 0    #(BYTE Count)// 奖励物品数

    AwardItemList = list()    #(vector<tagMCCrossActXianXiaMJItem> AwardItemList)// 奖励物品列表

    NeedScore = 0    #(DWORD NeedScore)// 上榜所需积分

    CountEx = 0    #(BYTE CountEx)// 额外奖励数

    AwardItemExList = list()    #(vector<tagMCCrossActXianXiaMJAwardEx> AwardItemExList)// 额外奖励列表

    data = None



    def __init__(self):

        self.Clear()

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        self.Rank,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.Count,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.Count):

            temAwardItemList = tagMCCrossActXianXiaMJItem()

            _pos = temAwardItemList.ReadData(_lpData, _pos)

            self.AwardItemList.append(temAwardItemList)

        self.NeedScore,_pos = CommFunc.ReadDWORD(_lpData, _pos)

        self.CountEx,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.CountEx):

            temAwardItemExList = tagMCCrossActXianXiaMJAwardEx()

            _pos = temAwardItemExList.ReadData(_lpData, _pos)

            self.AwardItemExList.append(temAwardItemExList)

        return _pos



    def Clear(self):

        self.Rank = 0

        self.Count = 0

        self.AwardItemList = list()

        self.NeedScore = 0

        self.CountEx = 0

        self.AwardItemExList = list()

        return



    def GetLength(self):

        length = 0

        length += 4

        length += 1

        for i in range(self.Count):

            length += self.AwardItemList[i].GetLength()

        length += 4

        length += 1

        for i in range(self.CountEx):

            length += self.AwardItemExList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteDWORD(data, self.Rank)

        data = CommFunc.WriteBYTE(data, self.Count)

        for i in range(self.Count):

            data = CommFunc.WriteString(data, self.AwardItemList[i].GetLength(), self.AwardItemList[i].GetBuffer())

        data = CommFunc.WriteDWORD(data, self.NeedScore)

        data = CommFunc.WriteBYTE(data, self.CountEx)

        for i in range(self.CountEx):

            data = CommFunc.WriteString(data, self.AwardItemExList[i].GetLength(), self.AwardItemExList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Rank:%d,

                                Count:%d,

                                AwardItemList:%s,

                                NeedScore:%d,

                                CountEx:%d,

                                AwardItemExList:%s

                                '''\

                                %(

                                self.Rank,

                                self.Count,

                                "...",

                                self.NeedScore,

                                self.CountEx,

                                "..."

                                )

        return DumpString





class  tagMCCrossActXianXiaMJInfo(Structure):

    Head = tagHead()

    ServerInfoLen = 0    #(BYTE ServerInfoLen)

    ServerIDRangeInfo = ""    #(String ServerIDRangeInfo)//开放该活动的服务器ID范围列表，json格式 [[IDA, IDB], ...]， [] 为全服

    GroupValue1 = 0    #(BYTE GroupValue1)// 活动榜单分组值1，用于查询对应榜单

    StartDate = ""    #(char StartDate[10])// 开始日期 y-m-d

    EndtDate = ""    #(char EndtDate[10])// 结束日期 y-m-d

    JoinStartTime = ""    #(char JoinStartTime[5])// 参与开始时间点 mm:ss

    JoinEndTime = ""    #(char JoinEndTime[5])// 参与结束时间点 mm:ss

    IsDayReset = 0    #(BYTE IsDayReset)// 是否每天重置

    PersonalBillCount = 0    #(BYTE PersonalBillCount)

    PersonalBillboardInfoList = list()    #(vector<tagMCCrossActXianXiaMJBillard> PersonalBillboardInfoList)// 个人榜单奖励信息列表，如果没有代表本次活动没有该榜奖励

    data = None



    def __init__(self):

        self.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x80

        return



    def ReadData(self, _lpData, _pos=0, _Len=0):

        self.Clear()

        _pos = self.Head.ReadData(_lpData, _pos)

        self.ServerInfoLen,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.ServerIDRangeInfo,_pos = CommFunc.ReadString(_lpData, _pos,self.ServerInfoLen)

        self.GroupValue1,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.StartDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.EndtDate,_pos = CommFunc.ReadString(_lpData, _pos,10)

        self.JoinStartTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.JoinEndTime,_pos = CommFunc.ReadString(_lpData, _pos,5)

        self.IsDayReset,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        self.PersonalBillCount,_pos = CommFunc.ReadBYTE(_lpData, _pos)

        for i in range(self.PersonalBillCount):

            temPersonalBillboardInfoList = tagMCCrossActXianXiaMJBillard()

            _pos = temPersonalBillboardInfoList.ReadData(_lpData, _pos)

            self.PersonalBillboardInfoList.append(temPersonalBillboardInfoList)

        return _pos



    def Clear(self):

        self.Head = tagHead()

        self.Head.Clear()

        self.Head.Cmd = 0xAA

        self.Head.SubCmd = 0x80

        self.ServerInfoLen = 0

        self.ServerIDRangeInfo = ""

        self.GroupValue1 = 0

        self.StartDate = ""

        self.EndtDate = ""

        self.JoinStartTime = ""

        self.JoinEndTime = ""

        self.IsDayReset = 0

        self.PersonalBillCount = 0

        self.PersonalBillboardInfoList = list()

        return



    def GetLength(self):

        length = 0

        length += self.Head.GetLength()

        length += 1

        length += len(self.ServerIDRangeInfo)

        length += 1

        length += 10

        length += 10

        length += 5

        length += 5

        length += 1

        length += 1

        for i in range(self.PersonalBillCount):

            length += self.PersonalBillboardInfoList[i].GetLength()



        return length



    def GetBuffer(self):

        data = ''

        data = CommFunc.WriteString(data, self.Head.GetLength(), self.Head.GetBuffer())

        data = CommFunc.WriteBYTE(data, self.ServerInfoLen)

        data = CommFunc.WriteString(data, self.ServerInfoLen, self.ServerIDRangeInfo)

        data = CommFunc.WriteBYTE(data, self.GroupValue1)

        data = CommFunc.WriteString(data, 10, self.StartDate)

        data = CommFunc.WriteString(data, 10, self.EndtDate)

        data = CommFunc.WriteString(data, 5, self.JoinStartTime)

        data = CommFunc.WriteString(data, 5, self.JoinEndTime)

        data = CommFunc.WriteBYTE(data, self.IsDayReset)

        data = CommFunc.WriteBYTE(data, self.PersonalBillCount)

        for i in range(self.PersonalBillCount):

            data = CommFunc.WriteString(data, self.PersonalBillboardInfoList[i].GetLength(), self.PersonalBillboardInfoList[i].GetBuffer())

        return data



    def OutputString(self):

        DumpString = '''

                                Head:%s,

                                ServerInfoLen:%d,

                                ServerIDRangeInfo:%s,

                                GroupValue1:%d,

                                StartDate:%s,

                                EndtDate:%s,

                                JoinStartTime:%s,

                                JoinEndTime:%s,

                                IsDayReset:%d,

                                PersonalBillCount:%d,

                                PersonalBillboardInfoList:%s

                                '''\

                                %(

                                self.Head.OutputString(),

                                self.ServerInfoLen,

                                self.ServerIDRangeInfo,

                                self.GroupValue1,

                                self.StartDate,

                                self.EndtDate,

                                self.JoinStartTime,

                                self.JoinEndTime,

                                self.IsDayReset,

                                self.PersonalBillCount,

                                "..."

                                )

        return DumpString





m_NAtagMCCrossActXianXiaMJInfo=tagMCCrossActXianXiaMJInfo()

ChNetPackDict[eval("0x%02x%02x"%(m_NAtagMCCrossActXianXiaMJInfo.Head.Cmd,m_NAtagMCCrossActXianXiaMJInfo.Head.SubCmd))] = m_NAtagMCCrossActXianXiaMJInfo





#------------------------------------------------------

@@ -40240,7 +36748,7 @@
                  ("CampID", c_ubyte),    # 营地ID，从1开始

                  ("GoldID", c_ubyte),    # 淘金ID，为0时代表该营地为空

                  ("RefreshCnt", c_ushort),    # 已刷新次数

                  ("EndTime", c_int),    # 预计完成时的时间戳，为0时代表还未开始淘金，通过该时间进行倒计时，完成时需发送操作完成淘金

                  ("EndTime", c_int),    # 预计完成时的时间戳，为0时代表还未开始淘金，通过该时间进行倒计时

                  ("WorkerCnt", c_ubyte),    # 使用监工数

                  ]




 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Event/EventSrc/Operate_EquipPlus.py

@@ -36,7 +36,6 @@
import ChPyNetSendPack

import NetPackCommon

import PlayerWeekParty

import PlayerActGarbageSorting

import PlayerTongTianLing

#-------------------------------------------------------------------------------------------



@@ -206,7 +205,6 @@
    PlayerSuccess.UpdateSuccessProgressByConditions(curPlayer, ShareDefine.SuccType_EquipPlus, plusLVCountDict)

    PlayerSuccess.UptateSuccessProgress(curPlayer, ShareDefine.SuccType_EquipPlusTotal, totalPlusLV)

    PlayerSuccess.UptateSuccessProgress(curPlayer, ShareDefine.SuccType_EquipPlusClass, classPlusLV, [classLV])

    PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_EquipPlus)

    return



def DoLogic_OnEquipPartStarLVChange(curPlayer, packType, classLV):


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Event/EventSrc/Operate_EquipWash.py

@@ -23,7 +23,6 @@
import PlayerSuccess

import IPY_GameWorld

import PlayerTongTianLing

import PlayerActGarbageSorting

import DataRecordPack

import PlayerActLogin

import PlayerActTask

@@ -298,7 +297,6 @@
    if isRefreshAttr:

        RefreshEquipWashAttr(curPlayer, classLV)

    PlayerActLogin.AddLoginAwardActionCnt(curPlayer, ChConfig.Def_LoginAct_EquipWash, 1)

    PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_EquipWash)

    PlayerTongTianLing.AddTongTianTaskValue(curPlayer, ChConfig.TTLTaskType_Wash, 1)

    PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_EquipWash)

    return


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/GM/Commands/ActNum.py

File was deleted

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/IpyGameDataPY.py

@@ -1707,88 +1707,6 @@
                        ("BYTE", "NeedNotify", 0),

                        ),



                "ActGarbageSorting":(

                        ("DWORD", "CfgID", 1),

                        ("char", "StartDate", 0),

                        ("char", "EndDate", 0),

                        ("BYTE", "ResetType", 0),

                        ("WORD", "LVLimit", 0),

                        ("BYTE", "CTGTypeEffValue", 0),

                        ),



                "ActGarbageTask":(

                        ("DWORD", "GarbageTasklD", 1),

                        ("DWORD", "FinishNeedValue", 0),

                        ("DWORD", "FinishTimeMax", 0),

                        ("BYTE", "AutoProduce", 0),

                        ("list", "ProduceGarbageRateList", 0),

                        ),



                "ActBossTrial":(

                        ("DWORD", "CfgID", 1),

                        ("char", "StartDate", 0),

                        ("char", "EndDate", 0),

                        ("char", "JoinStartTime", 0),

                        ("char", "JoinEndTime", 0),

                        ("WORD", "LVLimit", 0),

                        ("BYTE", "IsDayReset", 0),

                        ("BYTE", "ResetType", 0),

                        ("dict", "SubmitItemAwardInfo", 0),

                        ("BYTE", "SubmitAwardResetType", 0),

                        ("WORD", "ActShopType", 0),

                        ("list", "TemplateIDList", 0),

                        ("list", "FamilyTemplateIDList", 0),

                        ),



                "ActBossTrialTemplate":(

                        ("DWORD", "TemplateID", 1),

                        ("BYTE", "Rank", 0),

                        ("list", "AwardItemList", 0),

                        ("list", "MemAwardItemList", 0),

                        ("DWORD", "NeedScore", 0),

                        ("dict", "ScoreAwardEx", 0),

                        ),



                "ActHorsePetTrain":(

                        ("DWORD", "CfgID", 1),

                        ("char", "StartDate", 0),

                        ("char", "EndDate", 0),

                        ("char", "JoinStartTime", 0),

                        ("char", "JoinEndTime", 0),

                        ("WORD", "LVLimit", 0),

                        ("WORD", "ActShopType", 0),

                        ("WORD", "PersonalTemplateID", 0),

                        ("BYTE", "IsRelationCrossAct", 0),

                        ),



                "ActHorsePetTrainBillTemp":(

                        ("DWORD", "TemplateID", 1),

                        ("BYTE", "Rank", 0),

                        ("list", "AwardItemList", 0),

                        ("DWORD", "NeedScore", 0),

                        ("dict", "ScoreAwardEx", 0),

                        ),



                "ActGubao":(

                        ("DWORD", "CfgID", 1),

                        ("char", "StartDate", 0),

                        ("char", "EndDate", 0),

                        ("char", "JoinStartTime", 0),

                        ("char", "JoinEndTime", 0),

                        ("WORD", "LVLimit", 0),

                        ("WORD", "ActShopType", 0),

                        ("WORD", "PersonalTemplateID", 0),

                        ("BYTE", "IsRelationCrossAct", 0),

                        ),



                "ActGubaoBillTemp":(

                        ("DWORD", "TemplateID", 1),

                        ("BYTE", "Rank", 0),

                        ("list", "AwardItemList", 0),

                        ("DWORD", "NeedScore", 0),

                        ("dict", "ScoreAwardEx", 0),

                        ),



                "ActLianqiBillTemp":(

                        ("DWORD", "TemplateID", 1),

                        ("BYTE", "Rank", 0),

@@ -1805,42 +1723,6 @@
                        ("list", "GridWeightItemList", 0),

                        ("list", "LayerAwardItemList", 0),

                        ("list", "LayerWeightItemList", 0),

                        ),



                "ActXianXiaMJ":(

                        ("DWORD", "CfgID", 1),

                        ("char", "StartDate", 0),

                        ("char", "EndDate", 0),

                        ("char", "JoinStartTime", 0),

                        ("char", "JoinEndTime", 0),

                        ("BYTE", "IsDayReset", 0),

                        ("WORD", "LVLimit", 0),

                        ("DWORD", "UseItemID", 0),

                        ("list", "UseMoneyInfo", 0),

                        ("BYTE", "TemplateID", 0),

                        ("WORD", "PersonalTemplateID", 0),

                        ("WORD", "LotteryAddScore", 0),

                        ("WORD", "LayerAddScore", 0),

                        ("BYTE", "IsRelationCrossAct", 0),

                        ),



                "ActXianXiaMJBillTemp":(

                        ("DWORD", "TemplateID", 1),

                        ("BYTE", "Rank", 0),

                        ("list", "AwardItemList", 0),

                        ("DWORD", "NeedScore", 0),

                        ("dict", "ScoreAwardEx", 0),

                        ),



                "ActXianXiaMJAward":(

                        ("DWORD", "TemplateID", 1),

                        ("BYTE", "AwardLibType", 0),

                        ("list", "AwardItemCountList", 0),

                        ("list", "UnlockAwardLimitTimesList", 0),

                        ("list", "AwardLibWeightList", 0),

                        ("dict", "LibItemInfo", 0),

                        ("dict", "ItemLayerLimitInfo", 0),

                        ("dict", "ItemAwardTimesTotalInfo", 0),

                        ),



                "ActGodGift":(

@@ -1865,15 +1747,6 @@
                        ("BYTE", "ChooseItemCount", 0),

                        ("dict", "LibItemInfo", 0),

                        ("list", "NotifyItemNumList", 0),

                        ),



                "ActHorsePetFeast":(

                        ("DWORD", "CfgID", 1),

                        ("char", "StartDate", 0),

                        ("char", "EndDate", 0),

                        ("list", "StartTimeList", 0),

                        ("list", "EndTimeList", 0),

                        ("WORD", "LVLimit", 0),

                        ),



                "ActBossReborn":(

@@ -5145,128 +5018,6 @@
    def GetNeedItemList(self): return self.attrTuple[4] # 所需物品信息列表 [[物品ID,个数,是否绑定], ...] list

    def GetNeedNotify(self): return self.attrTuple[5] # 是否需要广播 BYTE

# 垃圾分类活动时间表
class IPY_ActGarbageSorting():
    
    def __init__(self):
        self.attrTuple = None
        return
        
    def GetCfgID(self): return self.attrTuple[0] # 配置ID DWORD

    def GetStartDate(self): return self.attrTuple[1] # 开启日期 char

    def GetEndDate(self): return self.attrTuple[2] # 结束日期 char

    def GetResetType(self): return self.attrTuple[3] # 重置类型，0-0点重置；1-5点重置 BYTE

    def GetLVLimit(self): return self.attrTuple[4] # 限制等级 WORD

    def GetCTGTypeEffValue(self): return self.attrTuple[5] # 充值有效类型值 BYTE

# 垃圾分类任务产出表
class IPY_ActGarbageTask():
    
    def __init__(self):
        self.attrTuple = None
        return
        
    def GetGarbageTasklD(self): return self.attrTuple[0] # 垃圾任务ID DWORD

    def GetFinishNeedValue(self): return self.attrTuple[1] # 完成所需进度值 DWORD

    def GetFinishTimeMax(self): return self.attrTuple[2] # 总可完成次数，0不限 DWORD

    def GetAutoProduce(self): return self.attrTuple[3] # 自动产生垃圾 BYTE

    def GetProduceGarbageRateList(self): return self.attrTuple[4] # 随机产生垃圾概率饼图 list

# Boss历练活动表
class IPY_ActBossTrial():
    
    def __init__(self):
        self.attrTuple = None
        return
        
    def GetCfgID(self): return self.attrTuple[0] # 配置ID DWORD

    def GetStartDate(self): return self.attrTuple[1] # 开启日期 char

    def GetEndDate(self): return self.attrTuple[2] # 结束日期 char

    def GetJoinStartTime(self): return self.attrTuple[3] # 参与开始时间点 char

    def GetJoinEndTime(self): return self.attrTuple[4] # 参与结束时间点 char

    def GetLVLimit(self): return self.attrTuple[5] # 限制等级 WORD

    def GetIsDayReset(self): return self.attrTuple[6] # 是否每天重置 BYTE

    def GetResetType(self): return self.attrTuple[7] # 重置类型，0-0点重置；1-5点重置 BYTE

    def GetSubmitItemAwardInfo(self): return self.attrTuple[8] # 提交凭证个数对应奖励 dict

    def GetSubmitAwardResetType(self): return self.attrTuple[9] # 提交凭证每日重置类型，0-跟随活动； 1-0点重置；2-5点重置 BYTE

    def GetActShopType(self): return self.attrTuple[10] # 开放商店类型，为0时不开放 WORD

    def GetTemplateIDList(self): return self.attrTuple[11] # 榜单模板编号列表 list

    def GetFamilyTemplateIDList(self): return self.attrTuple[12] # 仙盟榜单模板编号列表 list

# Boss历练榜单模版表
class IPY_ActBossTrialTemplate():
    
    def __init__(self):
        self.attrTuple = None
        return
        
    def GetTemplateID(self): return self.attrTuple[0] # 模板编号 DWORD

    def GetRank(self): return self.attrTuple[1] # 名次 BYTE

    def GetAwardItemList(self): return self.attrTuple[2] # 奖励物品列表[[物品ID,个数,是否拍品], ...] 仙盟榜时为盟主奖励，如果没有配置，则统一取成员奖励 list

    def GetMemAwardItemList(self): return self.attrTuple[3] # 仙盟榜成员奖励物品信息列表[[物品ID,个数,是否拍品], ...] list

    def GetNeedScore(self): return self.attrTuple[4] # 上榜所需积分 DWORD

    def GetScoreAwardEx(self): return self.attrTuple[5] # 达标积分额外奖励 {积分:[[物品ID,个数,是否拍品], ...], ...} dict

# 骑宠养成活动时间表
class IPY_ActHorsePetTrain():
    
    def __init__(self):
        self.attrTuple = None
        return
        
    def GetCfgID(self): return self.attrTuple[0] # 配置ID DWORD

    def GetStartDate(self): return self.attrTuple[1] # 开启日期 char

    def GetEndDate(self): return self.attrTuple[2] # 结束日期 char

    def GetJoinStartTime(self): return self.attrTuple[3] # 参与开始时间点 char

    def GetJoinEndTime(self): return self.attrTuple[4] # 参与结束时间点 char

    def GetLVLimit(self): return self.attrTuple[5] # 限制等级 WORD

    def GetActShopType(self): return self.attrTuple[6] # 开放商店类型，为0时不开放 WORD

    def GetPersonalTemplateID(self): return self.attrTuple[7] # 个人排行模板编号 WORD

    def GetIsRelationCrossAct(self): return self.attrTuple[8] # 是否关联跨服活动 BYTE

# 骑宠养成榜单模版表
class IPY_ActHorsePetTrainBillTemp():
    
    def __init__(self):
        self.attrTuple = None
        return
        
    def GetTemplateID(self): return self.attrTuple[0] # 模板编号 DWORD

    def GetRank(self): return self.attrTuple[1] # 名次 BYTE

    def GetAwardItemList(self): return self.attrTuple[2] # 奖励物品列表[[物品ID,个数,是否拍品], ...] list

    def GetNeedScore(self): return self.attrTuple[3] # 上榜所需积分 DWORD

    def GetScoreAwardEx(self): return self.attrTuple[4] # 达标积分额外奖励 {积分:[[物品ID,个数,是否拍品], ...], ...} dict

# 古宝养成活动时间表
class IPY_ActGubao():
    
    def __init__(self):
        self.attrTuple = None
        return
        
    def GetCfgID(self): return self.attrTuple[0] # 配置ID DWORD

    def GetStartDate(self): return self.attrTuple[1] # 开启日期 char

    def GetEndDate(self): return self.attrTuple[2] # 结束日期 char

    def GetJoinStartTime(self): return self.attrTuple[3] # 参与开始时间点 char

    def GetJoinEndTime(self): return self.attrTuple[4] # 参与结束时间点 char

    def GetLVLimit(self): return self.attrTuple[5] # 限制等级 WORD

    def GetActShopType(self): return self.attrTuple[6] # 开放商店类型，为0时不开放 WORD

    def GetPersonalTemplateID(self): return self.attrTuple[7] # 个人排行模板编号 WORD

    def GetIsRelationCrossAct(self): return self.attrTuple[8] # 是否关联跨服活动 BYTE

# 古宝养成榜单模版表
class IPY_ActGubaoBillTemp():
    
    def __init__(self):
        self.attrTuple = None
        return
        
    def GetTemplateID(self): return self.attrTuple[0] # 模板编号 DWORD

    def GetRank(self): return self.attrTuple[1] # 名次 BYTE

    def GetAwardItemList(self): return self.attrTuple[2] # 奖励物品列表[[物品ID,个数,是否拍品], ...] list

    def GetNeedScore(self): return self.attrTuple[3] # 上榜所需积分 DWORD

    def GetScoreAwardEx(self): return self.attrTuple[4] # 达标积分额外奖励 {积分:[[物品ID,个数,是否拍品], ...], ...} dict

# 炼器榜单模版表
class IPY_ActLianqiBillTemp():
    
@@ -5294,57 +5045,6 @@
    def GetGridWeightItemList(self): return self.attrTuple[4] # 格子物品权重随机库 [[权重,物品ID,个数], ...] list

    def GetLayerAwardItemList(self): return self.attrTuple[5] # 通关该层固定奖励 [[物品ID,个数,是否拍品], ...] list

    def GetLayerWeightItemList(self): return self.attrTuple[6] # 通关该层额外随机奖励 [[权重,物品ID,个数], ...] list

# 仙匣秘境活动时间表
class IPY_ActXianXiaMJ():
    
    def __init__(self):
        self.attrTuple = None
        return
        
    def GetCfgID(self): return self.attrTuple[0] # 配置ID DWORD

    def GetStartDate(self): return self.attrTuple[1] # 开启日期 char

    def GetEndDate(self): return self.attrTuple[2] # 结束日期 char

    def GetJoinStartTime(self): return self.attrTuple[3] # 参与开始时间点 char

    def GetJoinEndTime(self): return self.attrTuple[4] # 参与结束时间点 char

    def GetIsDayReset(self): return self.attrTuple[5] # 是否每天重置 BYTE

    def GetLVLimit(self): return self.attrTuple[6] # 限制等级 WORD

    def GetUseItemID(self): return self.attrTuple[7] # 消耗物品ID DWORD

    def GetUseMoneyInfo(self): return self.attrTuple[8] # 消耗货币信息 list

    def GetTemplateID(self): return self.attrTuple[9] # 模板ID BYTE

    def GetPersonalTemplateID(self): return self.attrTuple[10] # 个人排行模板编号 WORD

    def GetLotteryAddScore(self): return self.attrTuple[11] # 每次抽奖加积分 WORD

    def GetLayerAddScore(self): return self.attrTuple[12] # 每次跨层加积分 WORD

    def GetIsRelationCrossAct(self): return self.attrTuple[13] # 是否关联跨服活动 BYTE

# 仙匣秘境榜单模版表
class IPY_ActXianXiaMJBillTemp():
    
    def __init__(self):
        self.attrTuple = None
        return
        
    def GetTemplateID(self): return self.attrTuple[0] # 模板编号 DWORD

    def GetRank(self): return self.attrTuple[1] # 名次 BYTE

    def GetAwardItemList(self): return self.attrTuple[2] # 奖励物品列表[[物品ID,个数,是否拍品], ...] list

    def GetNeedScore(self): return self.attrTuple[3] # 上榜所需积分 DWORD

    def GetScoreAwardEx(self): return self.attrTuple[4] # 达标积分额外奖励 {积分:[[物品ID,个数,是否拍品], ...], ...} dict

# 仙匣秘境奖池表
class IPY_ActXianXiaMJAward():
    
    def __init__(self):
        self.attrTuple = None
        return
        
    def GetTemplateID(self): return self.attrTuple[0] # 奖池模板编号 DWORD

    def GetAwardLibType(self): return self.attrTuple[1] # 奖励库类型 BYTE

    def GetAwardItemCountList(self): return self.attrTuple[2] # 层选择个数列表  层1物品数|层2|… list

    def GetUnlockAwardLimitTimesList(self): return self.attrTuple[3] # 层抽X次后可产出（本层） 层1限制|层2|… list

    def GetAwardLibWeightList(self): return self.attrTuple[4] # 产出该库外权重 list

    def GetLibItemInfo(self): return self.attrTuple[5] # 本库物品随机库内权重（先随机库外权重，若产出再随机库内权重） dict

    def GetItemLayerLimitInfo(self): return self.attrTuple[6] # 物品产出奖池层限制 {物品ID:大于等于X层可产出, ...} dict

    def GetItemAwardTimesTotalInfo(self): return self.attrTuple[7] # 物品产出次数限制（所有层）{物品ID:总产出次数, ...} dict

# 天帝礼包活动时间表
class IPY_ActGodGift():
@@ -5379,20 +5079,6 @@
    def GetChooseItemCount(self): return self.attrTuple[3] # 选择个数 BYTE

    def GetLibItemInfo(self): return self.attrTuple[4] # 物品编号对应物品信息 {物品编号:[物品ID,个数,是否拍品,可选次数], ...}  0不限次数 dict

    def GetNotifyItemNumList(self): return self.attrTuple[5] # 需要广播的编号列表 list

# 骑宠盛宴活动
class IPY_ActHorsePetFeast():
    
    def __init__(self):
        self.attrTuple = None
        return
        
    def GetCfgID(self): return self.attrTuple[0] # 配置ID DWORD

    def GetStartDate(self): return self.attrTuple[1] # 开启日期 char

    def GetEndDate(self): return self.attrTuple[2] # 结束日期 char

    def GetStartTimeList(self): return self.attrTuple[3] # 开启时间列表, 支持多个时段 list

    def GetEndTimeList(self): return self.attrTuple[4] # 结束时间列表, 支持多个时段 list

    def GetLVLimit(self): return self.attrTuple[5] # 限制等级 WORD

# BOSS复活活动时间表
class IPY_ActBossReborn():
@@ -6910,22 +6596,10 @@
        self.__LoadFileData("ActFamilyCTGAssistTemp", onlyCheck)

        self.__LoadFileData("ActCollectWords", onlyCheck)

        self.__LoadFileData("CollectWordsExchange", onlyCheck)

        self.__LoadFileData("ActGarbageSorting", onlyCheck)

        self.__LoadFileData("ActGarbageTask", onlyCheck)

        self.__LoadFileData("ActBossTrial", onlyCheck)

        self.__LoadFileData("ActBossTrialTemplate", onlyCheck)

        self.__LoadFileData("ActHorsePetTrain", onlyCheck)

        self.__LoadFileData("ActHorsePetTrainBillTemp", onlyCheck)

        self.__LoadFileData("ActGubao", onlyCheck)

        self.__LoadFileData("ActGubaoBillTemp", onlyCheck)

        self.__LoadFileData("ActLianqiBillTemp", onlyCheck)

        self.__LoadFileData("CrossActFamilyGCZSQ", onlyCheck)

        self.__LoadFileData("ActXianXiaMJ", onlyCheck)

        self.__LoadFileData("ActXianXiaMJBillTemp", onlyCheck)

        self.__LoadFileData("ActXianXiaMJAward", onlyCheck)

        self.__LoadFileData("ActGodGift", onlyCheck)

        self.__LoadFileData("ActGodGiftAward", onlyCheck)

        self.__LoadFileData("ActHorsePetFeast", onlyCheck)

        self.__LoadFileData("ActBossReborn", onlyCheck)

        self.__LoadFileData("BossReborn", onlyCheck)

        self.__LoadFileData("ActRealmPoint", onlyCheck)

@@ -8327,62 +8001,6 @@
        self.CheckLoadData("CollectWordsExchange")
        return self.ipyCollectWordsExchangeCache[index]


    def GetActGarbageSortingCount(self):
        self.CheckLoadData("ActGarbageSorting")
        return self.ipyActGarbageSortingLen

    def GetActGarbageSortingByIndex(self, index):
        self.CheckLoadData("ActGarbageSorting")
        return self.ipyActGarbageSortingCache[index]


    def GetActGarbageTaskCount(self):
        self.CheckLoadData("ActGarbageTask")
        return self.ipyActGarbageTaskLen

    def GetActGarbageTaskByIndex(self, index):
        self.CheckLoadData("ActGarbageTask")
        return self.ipyActGarbageTaskCache[index]


    def GetActBossTrialCount(self):
        self.CheckLoadData("ActBossTrial")
        return self.ipyActBossTrialLen

    def GetActBossTrialByIndex(self, index):
        self.CheckLoadData("ActBossTrial")
        return self.ipyActBossTrialCache[index]


    def GetActBossTrialTemplateCount(self):
        self.CheckLoadData("ActBossTrialTemplate")
        return self.ipyActBossTrialTemplateLen

    def GetActBossTrialTemplateByIndex(self, index):
        self.CheckLoadData("ActBossTrialTemplate")
        return self.ipyActBossTrialTemplateCache[index]


    def GetActHorsePetTrainCount(self):
        self.CheckLoadData("ActHorsePetTrain")
        return self.ipyActHorsePetTrainLen

    def GetActHorsePetTrainByIndex(self, index):
        self.CheckLoadData("ActHorsePetTrain")
        return self.ipyActHorsePetTrainCache[index]


    def GetActHorsePetTrainBillTempCount(self):
        self.CheckLoadData("ActHorsePetTrainBillTemp")
        return self.ipyActHorsePetTrainBillTempLen

    def GetActHorsePetTrainBillTempByIndex(self, index):
        self.CheckLoadData("ActHorsePetTrainBillTemp")
        return self.ipyActHorsePetTrainBillTempCache[index]


    def GetActGubaoCount(self):
        self.CheckLoadData("ActGubao")
        return self.ipyActGubaoLen

    def GetActGubaoByIndex(self, index):
        self.CheckLoadData("ActGubao")
        return self.ipyActGubaoCache[index]


    def GetActGubaoBillTempCount(self):
        self.CheckLoadData("ActGubaoBillTemp")
        return self.ipyActGubaoBillTempLen

    def GetActGubaoBillTempByIndex(self, index):
        self.CheckLoadData("ActGubaoBillTemp")
        return self.ipyActGubaoBillTempCache[index]


    def GetActLianqiBillTempCount(self):
        self.CheckLoadData("ActLianqiBillTemp")
        return self.ipyActLianqiBillTempLen

@@ -8397,27 +8015,6 @@
        self.CheckLoadData("CrossActFamilyGCZSQ")
        return self.ipyCrossActFamilyGCZSQCache[index]


    def GetActXianXiaMJCount(self):
        self.CheckLoadData("ActXianXiaMJ")
        return self.ipyActXianXiaMJLen

    def GetActXianXiaMJByIndex(self, index):
        self.CheckLoadData("ActXianXiaMJ")
        return self.ipyActXianXiaMJCache[index]


    def GetActXianXiaMJBillTempCount(self):
        self.CheckLoadData("ActXianXiaMJBillTemp")
        return self.ipyActXianXiaMJBillTempLen

    def GetActXianXiaMJBillTempByIndex(self, index):
        self.CheckLoadData("ActXianXiaMJBillTemp")
        return self.ipyActXianXiaMJBillTempCache[index]


    def GetActXianXiaMJAwardCount(self):
        self.CheckLoadData("ActXianXiaMJAward")
        return self.ipyActXianXiaMJAwardLen

    def GetActXianXiaMJAwardByIndex(self, index):
        self.CheckLoadData("ActXianXiaMJAward")
        return self.ipyActXianXiaMJAwardCache[index]


    def GetActGodGiftCount(self):
        self.CheckLoadData("ActGodGift")
        return self.ipyActGodGiftLen

@@ -8431,13 +8028,6 @@
    def GetActGodGiftAwardByIndex(self, index):
        self.CheckLoadData("ActGodGiftAward")
        return self.ipyActGodGiftAwardCache[index]


    def GetActHorsePetFeastCount(self):
        self.CheckLoadData("ActHorsePetFeast")
        return self.ipyActHorsePetFeastLen

    def GetActHorsePetFeastByIndex(self, index):
        self.CheckLoadData("ActHorsePetFeast")
        return self.ipyActHorsePetFeastCache[index]


    def GetActBossRebornCount(self):
        self.CheckLoadData("ActBossReborn")

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Item/ItemControler.py

@@ -31,7 +31,6 @@
import ChPyNetSendPack

import NetPackCommon

import Operate_EquipStone

import PlayerActBossTrial

import PlayerXiangong

import IpyGameDataPY

import DataRecordPack

@@ -999,11 +998,7 @@
                #GameWorld.DebugLog("增加副本次数默认使用! mapID=%s" % mapID)

                tagItem.Clear()

                return True

        #活动道具自动转化

        if PlayerActBossTrial.CheckActItemAutoTransform(curPlayer, tagItem, itemID, tagItemCount):

            tagItem.Clear()

            return True

        
            
        if itemID in ChConfig.Def_TransformItemIDList or tagItem.GetType() == ChConfig.Def_ItemType_AutoUseMoney:

            # 直接转化为对应货币的物品仅在放入背包时直接转化，否则还是以真实物品的形式存在，但堆叠上限需要做特殊处理

            if packIndex == IPY_GameWorld.rptItem:


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/NPC/NPCCommon.py

@@ -48,8 +48,6 @@
import PlayerBossReborn

import PlayerCrossYaomoBoss

import PlayerActCollectWords

import PlayerActGarbageSorting

import PlayerActBossTrial

import PlayerTongTianLing

import CrossPlayerData

import PlayerFeastWish

@@ -1080,11 +1078,7 @@
        PlayerGubao.AddGubaoItemEffValue(curPlayer, PlayerGubao.GubaoEffType_KillCrossDemonLandBoss, 1)

        PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_CrossDemonLandBoss, 1)

    if mapID in [ChConfig.Def_FBMapID_CrossPenglai, ChConfig.Def_FBMapID_CrossDemonLand]:

        PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_CrossBoss)

        PlayerTongTianLing.AddTongTianTaskValue(curPlayer, ChConfig.TTLTaskType_CrossBoss, 1)

        
    if npcData.GetIsBoss() == ChConfig.Def_NPCType_Boss_Dark:

        PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_KillBoss)

        

    # 个人首杀记录

    ipyData = IpyGameDataPY.GetIpyGameDataNotLog("BOSSFirstKill", npcID)

@@ -3321,7 +3315,6 @@
        else:

            if GetNPCLV(curNPC) >= curPlayer.GetLV() - IpyGameDataPY.GetFuncCfg('DailyQuestKillMonster'):

                PlayerActivity.AddDailyActionFinishCnt(curPlayer, ShareDefine.DailyActionID_KillNPC)

                PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_KillNPC)

                PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_KillNPC)

            PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_FeastRedPack_KillSpecificNPC, 1, [npcID])

        #PlayerPrestigeSys.AddRealmTaskValue(curPlayer, PlayerPrestigeSys.RealmTaskType_KillNPC, 1)


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/ChPlayer.py

@@ -82,18 +82,12 @@
import PlayerActCollectWords

import PlayerActTotalRecharge

import PlayerActRechargePrize

import PlayerActGarbageSorting

import PlayerActXianXiaMJ

import PlayerActGubao

import PlayerActHorsePetTrain

import PlayerActLianqi

import PlayerActGodGift

import PlayerActFamilyCTGAssist

import PlayerActRechargeRebateGold

import PlayerActManyDayRecharge

import PlayerActSingleRecharge

import PlayerActHorsePetFeast

import PlayerActBossTrial

import PlayerSpringSale

import GY_Query_BossFirstKill

import PlayerCrossYaomoBoss

@@ -664,10 +658,6 @@
    PlayerFreeGoods.OnLogin(curPlayer)

    # BOSS复活活动

    PlayerBossReborn.OnLogin(curPlayer)

    # boss历练

    PlayerActBossTrial.OnPlayerLogin(curPlayer)

    # 骑宠盛宴活动

    PlayerActHorsePetFeast.OnLogin(curPlayer)

    # 周狂欢活动

    PlayerWeekParty.OnLogin(curPlayer)

    # 购买次数礼包活动

@@ -690,14 +680,6 @@
    PlayerFeastTravel.OnPlayerLogin(curPlayer)

    # 登录奖励活动

    PlayerActLogin.OnLogin(curPlayer)

    # 垃圾分类活动

    PlayerActGarbageSorting.OnPlayerLogin(curPlayer)

    # 仙匣秘境活动

    PlayerActXianXiaMJ.OnPlayerLogin(curPlayer)

    # 古宝养成活动

    PlayerActGubao.OnPlayerLogin(curPlayer)

    # 骑宠养成活动

    PlayerActHorsePetTrain.OnPlayerLogin(curPlayer)

    # 炼器活动

    PlayerActLianqi.OnPlayerLogin(curPlayer)

    # 天帝礼包活动

@@ -919,14 +901,6 @@
    # 同步排行榜

    PlayerBillboard.UpdatePlayerBillboardOnLeaveServer(curPlayer, isAll=True)

    

    # bossƾ֤

    PlayerActBossTrial.OnMixFirstLogin(curPlayer)

    # 仙匣秘境

    PlayerActXianXiaMJ.OnMixFirstLogin(curPlayer)

    # 古宝养成

    PlayerActGubao.OnMixFirstLogin(curPlayer)

    # 骑宠养成

    PlayerActHorsePetTrain.OnMixFirstLogin(curPlayer)

    # 重置玩家改名次数

    #UpdatePlayerName.ResetChangeNameCnt(curPlayer)

    return


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerActBossTrial.py

File was deleted

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerActGarbageSorting.py

File was deleted

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerActGubao.py

File was deleted

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerActHorsePetFeast.py

File was deleted

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerActHorsePetTrain.py

File was deleted

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerActXianXiaMJ.py

File was deleted

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerActivity.py

@@ -33,7 +33,6 @@
import time

import FormulaControl

import PlayerBossReborn

import PlayerActGarbageSorting

import PlayerTongTianLing

import PlayerActTask

import PlayerSuccess

@@ -309,7 +308,6 @@
    curTotalPoint = __GetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_TotalPoint)

    __SetPDictValue(curPlayer, ChConfig.Def_PDict_Activity_TotalPoint, curTotalPoint + addValue)

    __AddCanCostActivityPoint(curPlayer, addValue, isLVUp)

    PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_Activity, addValue)

    PlayerTongTianLing.AddTongTianTaskValue(curPlayer, ChConfig.TTLTaskType_Activity, addValue)

    PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_Activity, addValue)

    #PlayerControl.NotifyCode(curPlayer, "GetActivity", [addValue])

@@ -948,7 +946,6 @@
    GameWorld.DebugLog("领取活跃放置奖励: totalCount=%s,rewardCount=%s,rewardItemCount=%s,rewardItemList=%s" % (totalCount, rewardCount, rewardItemCount, rewardItemList))

    ItemControler.GivePlayerItemOrMail(curPlayer, rewardItemList, event=["ActivityPlace", False, {}])

    

    PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_ActivityPlace, rewardCount)

    PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_ActivityPlace, rewardCount)

    PlayerGubao.AddGubaoItemEffValue(curPlayer, PlayerGubao.GubaoEffType_ActivityPlace, rewardCount)

    


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerBillboard.py

@@ -15,15 +15,11 @@
#"""Version = 2018-03-06 11:00"""

#-------------------------------------------------------------------------------



import ChConfig

import GameWorld

import ShareDefine

import PlayerControl

import OpenServerCampaign

import ChPyNetSendPack

import NetPackCommon

import IpyGameDataPY

import GameFuncComm

import DBDataMgr



import time

@@ -38,7 +34,7 @@
        

    billboardMgr = DBDataMgr.GetBillboardMgr()

    for billboardType in drBillboardTypeList:

        if billboardType in [ShareDefine.Def_CBT_BossTrialSubmitBak, ShareDefine.Def_CBT_BossTrialSubmitFamilyBak, ShareDefine.Def_CBT_CrossRealmPK]:

        if billboardType in []:

            continue

        groupList = billboardMgr.GetBillboardGroupList(billboardType)

        for billboardType, groupValue1, groupValue2 in groupList:

@@ -71,35 +67,30 @@
        # 跨服服务器不用更新本服榜

        return

    

    UpdatePlayerLVBillboard(curPlayer) # 等级榜

    UpdatePlayerFPTotalBillboard(curPlayer, True) # 战斗力榜

    UpdateHorseBillboard(curPlayer, True, False) # 坐骑榜

    UpdatePyPetBillboard(curPlayer, True, False) # 灵宠榜

    UpdateRealmBillboard(curPlayer) # 境界榜

    
    if isAll:

        UpdateRuneTowerBillboard(curPlayer)

        
    return



def UpdatePlayerFPTotalBillboard(curPlayer, isForceUpdate=False, isCheckRule=True):

    ##更新玩家总战斗力

    
    playerFightPower = PlayerControl.GetFightPower(curPlayer)

    if not __CheckFightPowerCanUpdate(curPlayer, ChConfig.Def_PDict_FightPower_Total, playerFightPower,

                                      isForceUpdate, isCheckRule, ChConfig.Def_PDict_FightPower_TotalEx):

        return

    
    fightPower = playerFightPower % ChConfig.Def_PerPointValue

    fightPowerEx = playerFightPower / ChConfig.Def_PerPointValue

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_FightPower_Total, fightPower,

                                       ChConfig.Def_PDictType_FightPower)

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_FightPower_TotalEx, fightPowerEx,

                                       ChConfig.Def_PDictType_FightPower)

    
    GameWorld.DebugLog("更新总战斗力：playerFightPower=%s" % (playerFightPower), curPlayer.GetPlayerID())

    
    UpdatePlayerBillboard(curPlayer, ShareDefine.Def_BT_FightPower, fightPowerEx, fightPower)

#    
#    playerFightPower = PlayerControl.GetFightPower(curPlayer)

#    if not __CheckFightPowerCanUpdate(curPlayer, ChConfig.Def_PDict_FightPower_Total, playerFightPower,

#                                      isForceUpdate, isCheckRule, ChConfig.Def_PDict_FightPower_TotalEx):

#        return

#    
#    fightPower = playerFightPower % ChConfig.Def_PerPointValue

#    fightPowerEx = playerFightPower / ChConfig.Def_PerPointValue

#    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_FightPower_Total, fightPower,

#                                       ChConfig.Def_PDictType_FightPower)

#    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_FightPower_TotalEx, fightPowerEx,

#                                       ChConfig.Def_PDictType_FightPower)

#    
#    GameWorld.DebugLog("更新总战斗力：playerFightPower=%s" % (playerFightPower), curPlayer.GetPlayerID())

#    
#    UpdatePlayerBillboard(curPlayer, ShareDefine.Def_BT_FightPower, fightPowerEx, fightPower)

    

#    if bType == ShareDefine.Def_BT_FightPower:

#        playerID = bID

@@ -121,79 +112,47 @@
#            UpdatePlayerBillboard(bID, bName, bName2, jobBType, bType2, value1, value2, cmpValue, autoSort, cmpValue2, **kwargs)

    return



def __CheckFightPowerCanUpdate(curPlayer, key, fightPower, isForceUpdate=False, isCheckRule=True, key2=None):

    ''' 检查玩家可否更新战斗力

    @param curPlayer 玩家实例

    @param key 战斗力类型对应key

    @param fightPower 当前战斗力

    @param isForceUpdate 是否强制更新（若设置强制更新，在某些潜规则下也不一定能强制更新，如GM等）

    @param isCheckRule 是否检查战力范围更新差值

    @return True-可更新 
    '''

    if fightPower <= 0:

        return False

    
    historyFightPower = curPlayer.NomalDictGetProperty(key, 0, ChConfig.Def_PDictType_FightPower)

    if key2 != None:

        historyFightPower += curPlayer.NomalDictGetProperty(key2, 0, ChConfig.Def_PDictType_FightPower) * ChConfig.Def_PerPointValue

        
    if not __CanPlayerBillboardComm(curPlayer):

        return False

    
    if isForceUpdate:

        GameWorld.DebugLog("战斗力更新检查：强制更新 key=%s,fightPower=%s,history=%s" 
                           % (key, fightPower, historyFightPower), curPlayer.GetPlayerID())

        return True

    
    if fightPower == historyFightPower:

        GameWorld.DebugLog("战斗力更新检查：与上次相同，默认不更新 key=%s,fightPower=%s,history=%s" 
                           % (key, fightPower, historyFightPower), curPlayer.GetPlayerID())

        return False

    
    return True

#def __CheckFightPowerCanUpdate(curPlayer, key, fightPower, isForceUpdate=False, isCheckRule=True, key2=None):

#    ''' 检查玩家可否更新战斗力

#    @param curPlayer 玩家实例

#    @param key 战斗力类型对应key

#    @param fightPower 当前战斗力

#    @param isForceUpdate 是否强制更新（若设置强制更新，在某些潜规则下也不一定能强制更新，如GM等）

#    @param isCheckRule 是否检查战力范围更新差值

#    @return True-可更新 
#    '''

#    if fightPower <= 0:

#        return False

#    
#    historyFightPower = curPlayer.NomalDictGetProperty(key, 0, ChConfig.Def_PDictType_FightPower)

#    if key2 != None:

#        historyFightPower += curPlayer.NomalDictGetProperty(key2, 0, ChConfig.Def_PDictType_FightPower) * ChConfig.Def_PerPointValue

#        
#    if not __CanPlayerBillboardComm(curPlayer):

#        return False

#    
#    if isForceUpdate:

#        GameWorld.DebugLog("战斗力更新检查：强制更新 key=%s,fightPower=%s,history=%s" 
#                           % (key, fightPower, historyFightPower), curPlayer.GetPlayerID())

#        return True

#    
#    if fightPower == historyFightPower:

#        GameWorld.DebugLog("战斗力更新检查：与上次相同，默认不更新 key=%s,fightPower=%s,history=%s" 
#                           % (key, fightPower, historyFightPower), curPlayer.GetPlayerID())

#        return False

#    
#    return True



def UpdateHorseBillboard(curPlayer, isForceUpdate=False, isUpdateTotal=True):

    ##更新玩家坐骑排行榜

    
    HorseFightPower = PlayerControl.GetMFPFightPower(curPlayer, ShareDefine.Def_MFPType_Horse)

    if not HorseFightPower:

        return

    
    fightPower = HorseFightPower % ChConfig.Def_PerPointValue

    fightPowerEx = HorseFightPower / ChConfig.Def_PerPointValue

    
    UpdatePlayerBillboard(curPlayer, ShareDefine.Def_BT_FightPower_Horse, fightPowerEx, fightPower)

    
    if isUpdateTotal:

        UpdatePlayerFPTotalBillboard(curPlayer, isForceUpdate)

    return



def UpdatePyPetBillboard(curPlayer, isForceUpdate=False, isUpdateTotal=True):

    ## 更新宠物排行榜

    return

#    petMaxAtk = PlayerControl.GetPetMaxAtk(curPlayer)

#    if not petMaxAtk:

#        return

#    UpdatePlayerBillboard(curPlayer, ShareDefine.Def_BT_FightPower_Pet, petMaxAtk) 
#       
#    if isUpdateTotal:

#        UpdatePlayerFPTotalBillboard(curPlayer, isForceUpdate)

#    return



def UpdatePlayerLVBillboard(curPlayer, isForceUpdate=True):

    ##更新玩家等级排行榜

    UpdatePlayerBillboard(curPlayer, ShareDefine.Def_BT_LV, curPlayer.GetLV())

    return



def UpdateRuneTowerBillboard(curPlayer):

    ##更新玩家符印塔排行榜

    return



def UpdateRealmBillboard(curPlayer):

    ##境界榜

    if not curPlayer.GetOfficialRank():

        return

    UpdatePlayerBillboard(curPlayer, ShareDefine.Def_BT_Realm, curPlayer.GetOfficialRank())

    return



def __CanPlayerBillboardComm(curPlayer):


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerCoin.py

@@ -45,7 +45,6 @@
import PlayerDailyGiftbag

import PlayerGoldGift

import PlayerActTotalRecharge

import PlayerActGarbageSorting

import PlayerActRechargeRebateGold

import PlayerActFamilyCTGAssist

import PlayerActManyDayRecharge

@@ -782,7 +781,6 @@
    PlayerGoldGift.OnPlayerChargeGold(curPlayer)

    #累积充值X元

    PlayerActTotalRecharge.AddTotalRechargeGold(curPlayer, orderCoin, coinType)

    PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_CTG, addVIPExp, coinType) # 垃圾分类

    PlayerActSingleRecharge.UpdSingleRechargeValue(curPlayer, orderCoin, coinType) # 单笔累充

    PlayerActTurntable.OnPlayerRecharge(curPlayer, orderCoin, coinType) # 转盘

    #开服活动


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerControl.py

@@ -50,7 +50,6 @@
import PlayerActTurntable

import PlayerCostRebate

import PlayerActLunhuidian

import PlayerActGarbageSorting

import GY_Query_CrossRealmReg

import PlayerTongTianLing

import FunctionNPCCommon

@@ -2888,7 +2887,6 @@
    if costType not in ChConfig.CostRebate_DisableType:

        PlayerCostRebate.AddCostRebateGold(curPlayer, costType, price, infoDict)

        PlayerFeastTravel.AddFeastTravelTaskValue(curPlayer, ChConfig.Def_FeastTravel_UseGold, price)

        PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_UseGold, price)

    else:

        GameWorld.DebugLog("不计入消费活动的消费类型!costType=%s" % costType, curPlayer.GetPlayerID())

        


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerCrossRealmPK.py

@@ -24,7 +24,6 @@
import CrossRealmPlayer

import PlayerTongTianLing

import FunctionNPCCommon

import PlayerActGarbageSorting

import DataRecordPack

import PlayerWeekParty

import IPY_GameWorld

@@ -364,7 +363,6 @@
        PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_FeastRedPack_CrossPK, 1)

        PlayerSuccess.DoAddSuccessProgress(curPlayer, ShareDefine.SuccType_CrossPK, 1)

        PlayerGubao.AddGubaoItemEffValue(curPlayer, PlayerGubao.GubaoEffType_CrossRealmPK, 1)

        PlayerActGarbageSorting.AddActGarbageTaskProgress(curPlayer, ChConfig.Def_GarbageTask_CrossPK)

        PlayerTongTianLing.AddTongTianTaskValue(curPlayer, ChConfig.TTLTaskType_CrossPK, 1)

    else:

        GameWorld.Log("    不同天的PK结算不增加今日PK次数! ", playerID)


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerEventCounter.py

@@ -50,10 +50,6 @@
import CrossActAllRecharge

import PlayerActCollectWords

import PlayerActTotalRecharge

import PlayerActGarbageSorting

import PlayerActXianXiaMJ

import PlayerActGubao

import PlayerActHorsePetTrain

import PlayerActLianqi

import PlayerActGodGift

import PlayerActFamilyGCZ

@@ -64,7 +60,6 @@
import PlayerActRechargePrize

import PlayerActGrowupBuy

import PlayerActTurntable

import PlayerActBossTrial

import PlayerActBuyOne

import PlayerSpringSale

import PlayerBossReborn

@@ -82,7 +77,6 @@
import PlayerFlashGiftbag

import PlayerDailyGiftbag

import PlayerOfflineSupport

import PlayerActHorsePetFeast

import PlayerFeastRedPacket

import PlayerCrossYaomoBoss

import PlayerLuckyCloudBuy

@@ -349,8 +343,6 @@
    PlayerWishingWell.OnDay(curPlayer)

    #通天令

    PlayerTongTianLing.OnDay(curPlayer, onEventType)

    #bossƾ֤

    PlayerActBossTrial.PlayerOnDay(curPlayer, onEventType)

    #任务活动

    PlayerActTask.OnDay(curPlayer)

    #登录活动

@@ -943,18 +935,6 @@
            elif actionName == ShareDefine.OperationActionName_TotalRecharge:

                PlayerActTotalRecharge.RefreshTotalRechargeActionInfo(actNum)

                

            elif actionName == ShareDefine.OperationActionName_GarbageSorting:

                PlayerActGarbageSorting.RefreshGarbageSortingActionInfo(actNum)

                
            elif actionName == ShareDefine.OperationActionName_XianXiaMJ:

                PlayerActXianXiaMJ.RefreshXianXiaMJActionInfo(actNum)

                
            elif actionName == ShareDefine.OperationActionName_Gubao:

                PlayerActGubao.RefreshGubaoActionInfo(actNum)

                
            elif actionName == ShareDefine.OperationActionName_HorsePetTrain:

                PlayerActHorsePetTrain.RefreshHorsePetTrainActionInfo(actNum)

                
            elif actionName == ShareDefine.OperationActionName_GodGift:

                PlayerActGodGift.RefreshGodGiftActionInfo(actNum)

                

@@ -972,12 +952,6 @@


            elif actionName == ShareDefine.OperationActionName_BossReborn:

                PlayerBossReborn.RefreshOperationAction_BossReborn()

                
            elif actionName == ShareDefine.OperationActionName_BossTrial:

                PlayerActBossTrial.RefreshBossTrialActionInfo(actNum)

                
            elif actionName == ShareDefine.OperationActionName_HorsePetFeast:

                PlayerActHorsePetFeast.RefreshOperationAction_HorsePetFeast(actNum)

                

            elif actionName == ShareDefine.OperationActionName_FlashGiftbag:

                PlayerFlashGiftbag.RefreshFlashGiftbagActionInfo(actNum)

@@ -1067,18 +1041,6 @@
                

            elif actionName == ShareDefine.CrossActName_AllRecharge:

                CrossActAllRecharge.RefreshCrossActAllRechargeInfo()

                
            elif actionName == ShareDefine.CrossActName_BossTrial:

                PlayerActBossTrial.RefreshCrossActBossTrialInfo()

                
            elif actionName == ShareDefine.CrossActName_XianXiaMJ:

                PlayerActXianXiaMJ.RefreshCrossActXianXiaMJInfo()

                
            elif actionName == ShareDefine.CrossActName_Gubao:

                PlayerActGubao.RefreshCrossActGubaoInfo()

                
            elif actionName == ShareDefine.CrossActName_HorsePetTrain:

                PlayerActHorsePetTrain.RefreshCrossActHorsePetTrainInfo()

                

            elif actionName == ShareDefine.CrossActName_Lianqi:

                PlayerActLianqi.RefreshCrossActLianqiInfo()


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerGubao.py

@@ -29,7 +29,6 @@
import ChConfig

import ItemControler

import PlayerDienstgrad

import PlayerActGubao

import PlayerActTask

import PlayerCoat



@@ -168,7 +167,6 @@
    RefreshGubaoAttr(curPlayer)

    Sync_GubaoInfo(curPlayer, [gubaoID])

    

    PlayerActGubao.OnGubaoCost(curPlayer, needPieceInfo, realNeedItemList)

    return



#// B2 17 古宝升星 #tagCMGubaoStarUp

@@ -265,7 +263,6 @@
    RefreshGubaoAttr(curPlayer)

    Sync_GubaoInfo(curPlayer, [gubaoID])

    

    PlayerActGubao.OnGubaoCost(curPlayer, needPieceInfo, realNeedItemList)

    PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_GubaoStarUp)

    return



@@ -397,7 +394,6 @@
    RefreshGubaoAttr(curPlayer)

    Sync_GubaoInfo(curPlayer, [gubaoID])

    

    PlayerActGubao.OnGubaoCost(curPlayer, needPieceInfo, realNeedItemList)

    PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_GubaoLVUp)

    return




 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerHorse.py

@@ -33,7 +33,6 @@
import CrossPlayerData

import PlayerSuccess

import PlayerActLunhuidian

import PlayerActHorsePetTrain

import PlayerActTask

import PlayerPet



@@ -649,7 +648,6 @@
    # 刷属性，更新排行榜

    RefreshHorseAttr(curPlayer)

    

    PlayerActHorsePetTrain.OnHorsePetTrainCost(curPlayer, {costItemID:costItemCount})

    PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_HorseUpItem, costItemCount)

    PlayerActLunhuidian.AddLunhuidianValue(curPlayer, PlayerActLunhuidian.AwardType_UseItem, costItemID, costItemCount)

    return

@@ -732,7 +730,6 @@
    # 刷属性，更新排行榜

    RefreshHorseAttr(curPlayer)

    

    PlayerActHorsePetTrain.OnHorsePetTrainCost(curPlayer, {costItemID:costItemCount})

    if trainType == 2:

        PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_HorseTrainItem2, costItemCount)

    elif trainType == 3:


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerPet.py

@@ -43,7 +43,6 @@
import ChPyNetSendPack

import NetPackCommon

import PlayerActLunhuidian

import PlayerActHorsePetTrain

import PlayerActTask

import PlayerHorse

import GameObj

@@ -767,7 +766,6 @@
        

    #EventReport.WriteEvent_pet_class(curPlayer, petNpcData.GetName(), classLV, petClassExp, updClassLV, newClassExp)

    

    PlayerActHorsePetTrain.OnHorsePetTrainCost(curPlayer, {autoBuyItemID:costItemCount})

    PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_PetUpItem, costItemCount)

    PlayerActLunhuidian.AddLunhuidianValue(curPlayer, PlayerActLunhuidian.AwardType_UseItem, autoBuyItemID, costItemCount)

    return

@@ -1119,7 +1117,6 @@
    # 刷属性，更新排行榜

    RefreshPetItemAddAttr(curPlayer, True)

    

    PlayerActHorsePetTrain.OnHorsePetTrainCost(curPlayer, {costItemID:costItemCount})

    if trainType == 2:

        PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_PetTrainItem2, costItemCount)

    elif trainType == 3:


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerZhanling.py

@@ -21,8 +21,6 @@
import IpyGameDataPY

import PlayerControl

import ChPyNetSendPack

import PlayerActHorsePetTrain

import PlayerActGubao

import ItemControler

import IPY_GameWorld

import PlayerGubao

@@ -38,8 +36,8 @@
ZhanlingType_GubaoStar, # 古宝总星数 4

ZhanlingType_Login, # 登录 5

ZhanlingType_GatherTheSoulLV, # 聚魂 6

ZhanlingType_HorsePetTrain, # 骑宠养成 7

ZhanlingType_GubaoTrain, # 古宝养成 8

ZhanlingType_7, # 骑宠养成 7

ZhanlingType_8, # 古宝养成 8

ZhanlingType_Xianyuan, # 仙缘 9

ZhanlingType_Huanjingge, # 幻境阁 10

ZhanlingType_Lianqi, # 炼器 11

@@ -241,10 +239,6 @@
        if not firstLoginTime:

            return

        curValue = GameWorld.GetDiff_Day(int(time.time()), firstLoginTime) + 1      

    elif zhanlingType == ZhanlingType_HorsePetTrain:

        curValue = PlayerActHorsePetTrain.GetActHorsePetTrainScore(curPlayer)

    elif zhanlingType == ZhanlingType_GubaoTrain:

        curValue = PlayerActGubao.GetActGubaoTrainScore(curPlayer)

    elif zhanlingType == ZhanlingType_Xianyuan:

        curValue = PlayerControl.GetMoney(curPlayer, ShareDefine.TYPE_Price_XianyuanScore)

    elif zhanlingType in ZhanlingValue1TypeList:


 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/ShareDefine.py

@@ -313,18 +313,12 @@
OperationActionName_ManyDayRecharge = "ActManyDayRecharge" # 多日连充活动

OperationActionName_SingleRecharge = "ActSingleRecharge" # 单笔累充活动

OperationActionName_Turntable = "ActTurntable" # 转盘活动

OperationActionName_HorsePetFeast = "ActHorsePetFeast" # 骑宠盛宴活动

OperationActionName_GarbageSorting = "ActGarbageSorting" # 垃圾分类活动

OperationActionName_XianXiaMJ = "ActXianXiaMJ" # 仙匣秘境活动

OperationActionName_GodGift = "ActGodGift" # 天帝礼包活动

OperationActionName_BuyOne = "ActBuyOne" # 买一送多活动

OperationActionName_BossTrial = "ActBossTrial" # Boss历练

OperationActionName_ActLoginNew = "ActLoginNew" # 登录活动-新

OperationActionName_ActTask = "ActTask" # 活动任务

OperationActionName_BuyCountGift = "ActBuyCountGift" # 购买次数礼包活动

OperationActionName_FamilyCTGAssist = "ActFamilyCTGAssist" # 仙盟充值协助

OperationActionName_Gubao = "ActGubao" # 古宝养成活动

OperationActionName_HorsePetTrain = "ActHorsePetTrain" # 骑宠养成活动

OperationActionName_Yunshi = "ActYunshi" # 运势活动

OperationActionName_Lunhuidian = "ActLunhuidian" # 轮回殿活动

#节日活动类型列表 - 该类型无视开服天，日期到了就开启

@@ -344,12 +338,12 @@
                           OperationActionName_NewFairyCeremony, OperationActionName_LuckyTreasure,

                           OperationActionName_DailyGiftbag, OperationActionName_SingleRecharge,

                           OperationActionName_CollectWords, OperationActionName_ManyDayRecharge,

                           OperationActionName_Turntable, OperationActionName_HorsePetFeast, OperationActionName_GarbageSorting,

                           OperationActionName_XianXiaMJ, OperationActionName_GodGift,

                           OperationActionName_BuyOne, OperationActionName_BossTrial,

                           OperationActionName_Turntable,

                           OperationActionName_GodGift,

                           OperationActionName_BuyOne,

                           OperationActionName_ActLoginNew, OperationActionName_ActTask,

                           OperationActionName_BuyCountGift, OperationActionName_FamilyCTGAssist,

                           OperationActionName_Gubao, OperationActionName_HorsePetTrain, OperationActionName_Yunshi,

                           OperationActionName_Yunshi,

                           OperationActionName_Lunhuidian,

                           ] + FeastOperationActionNameList

#需要记录开启活动时的世界等级的运营活动

@@ -360,8 +354,8 @@
                                   OperationActionName_SpringSale, OperationActionName_LuckyTreasure,

                                   OperationActionName_DailyGiftbag, OperationActionName_GrowupBuy,

                                   OperationActionName_WeekParty, OperationActionName_Turntable,

                                   OperationActionName_CollectWords, OperationActionName_GarbageSorting,

                                   OperationActionName_FeastLogin, OperationActionName_XianXiaMJ,

                                   OperationActionName_CollectWords,

                                   OperationActionName_FeastLogin,

                                   OperationActionName_FeastWish, OperationActionName_FeastTravel,

                                   OperationActionName_ManyDayRecharge, OperationActionName_SingleRecharge,

                                   OperationActionName_GodGift,

@@ -372,12 +366,12 @@
                                   OperationActionName_FlashGiftbag, OperationActionName_CostRebate,

                                   OperationActionName_SpringSale, OperationActionName_FlashSale,

                                   OperationActionName_ManyDayRecharge, OperationActionName_SingleRecharge,

                                   OperationActionName_Turntable, OperationActionName_HorsePetFeast, OperationActionName_GarbageSorting,

                                   OperationActionName_XianXiaMJ, OperationActionName_GodGift,

                                   OperationActionName_BuyOne, OperationActionName_BossTrial,

                                   OperationActionName_Turntable,

                                   OperationActionName_GodGift,

                                   OperationActionName_BuyOne,

                                   OperationActionName_ActLoginNew, OperationActionName_ActTask,

                                   OperationActionName_BuyCountGift, OperationActionName_FamilyCTGAssist,

                                   OperationActionName_Gubao, OperationActionName_HorsePetTrain, OperationActionName_Yunshi,

                                   OperationActionName_Yunshi,

                                   OperationActionName_Lunhuidian,

                                   ]



@@ -385,16 +379,12 @@
CrossActName_CTGBillboard = "CrossActCTGBillboard" # 充值排行榜

CrossActName_AllRecharge = "CrossActAllRecharge" # 全民充值

CrossActName_LuckyCloudBuy = "CrossActLuckyCloudBuy" # 幸运云购

CrossActName_BossTrial = "CrossActBossTrial" # Boss历练 - 跨服

CrossActName_XianXiaMJ = "CrossActXianXiaMJ" # 仙匣秘境 - 跨服

CrossActName_Gubao = "CrossActGubao" # 古宝养成 - 跨服

CrossActName_HorsePetTrain = "CrossActHorsePetTrain" # 骑宠养成 - 跨服

CrossActName_Lianqi = "CrossActLianqi" # 炼器 - 跨服

CrossActName_FamilyGCZ = "CrossActFamilyGCZ" # 仙盟攻城战



#跨服运营活动列表

CrossActNameList = [CrossActName_CTGBillboard, CrossActName_AllRecharge, CrossActName_LuckyCloudBuy, CrossActName_BossTrial, 
                    CrossActName_XianXiaMJ, CrossActName_Gubao, CrossActName_HorsePetTrain, CrossActName_Lianqi, CrossActName_FamilyGCZ]

CrossActNameList = [CrossActName_CTGBillboard, CrossActName_AllRecharge, CrossActName_LuckyCloudBuy, 
                    CrossActName_Lianqi, CrossActName_FamilyGCZ]

#需要锁定活动分区分配直到活动结束的跨服运营活动，即使热更分区配置，也不会改变正在活动中的分区设定，直到活动结束

CrossActLockServerGroupIDList = [CrossActName_CTGBillboard, CrossActName_AllRecharge]



@@ -475,54 +465,8 @@
#排行榜类型BillboardType

#此地方改动需要通知修改ChConfig.Def_BT_Cnt, ChConfig.Def_BT_SaveType

BillboardTypeList = (

    Def_BT_FightPower,                        #个人战斗力 0

    Def_BT_FightPower_Warrior,                #剑修战斗力

    Def_BT_FightPower_Wizard,                 #道师战斗力

    Def_BT_FightPower_Assassin,               #枪豪战斗力

    Def_BT_LV,                                #个人等级榜

    Def_BT_FightPower_Horse,                  #坐骑战斗力 5

    Def_BT_FightPower_Pet,                    #宠物战斗力

    Def_BT_TrialTower,                        #天神之塔榜

    Def_BT_OffLineEfficient,                  #脱机效率榜

    Def_BT_Realm,                             #境界榜

    Def_BT_TotalRecharge,                     #充值排行榜 10

    
    Def_BT_Campaign_Plus,                     #强化战力(开服活动榜)

    Def_BT_Campaign_Horse,                    #坐骑战力(开服活动榜)

    Def_BT_Campaign_StoneLV,                  #宝石等级(开服活动榜)

    Def_BT_Campaign_LV,                       #冲级排行(开服活动榜)

    Def_BT_Campaign_RealmLV,                  #境界等级(开服活动榜) 15

    Def_BT_Campaign_FightPower,               #战力排行(开服活动榜)

    
    Def_BT_FCCostGold,                        #消费排行榜(仙界盛典)

    Def_BT_Campaign_RuneLV,                   #符印等级(开服活动榜)

    Def_BT_19,

    Def_BT_Campaign_GodWeaponLV,              #神兵等级(开服活动榜) 20

    Def_BT_Campaign_Recharge,                 #累计充值(开服活动榜)

    Def_BT_Campaign_PetLV,                    #灵宠等级(开服活动榜)

    
    Def_BT_NewFCCostGold,                     #消费排行榜(新仙界盛典)

    Def_BT_Campaign_LingGen,                  #灵根总点(开服活动榜)

    Def_BT_Campaign_StarLV,                   #升星等级(开服活动榜) 25

    Def_BT_Campaign_Wash,                     #洗练战力(开服活动榜)

    
    Def_BT_SkyTower,                          #天星塔榜

    Def_BT_Arena,                             #竞技场榜

    Def_BT_Environment,                       #环保榜 (垃圾分类活动)

    Def_BT_CharmTotal, #魅力总榜 30

    Def_BT_CharmWeek, #魅力周榜

    Def_BT_CharmDay, #魅力日榜

    Def_BT_BossTrialSubmit,                   #提交boss凭证榜 (boss历练活动)

    Def_BT_AlineInvade,                       #异兽入侵

    Def_BT_BossTrialSubmitBak,                #提交boss凭证榜 (boss历练活动 - 上一期) 35

    Def_BT_BossTrialSubmitFamily,             #提交boss凭证仙盟榜 (boss历练活动)

    Def_BT_BossTrialSubmitFamilyBak,          #提交boss凭证仙盟榜 (boss历练活动 - 上一期)

    Def_BT_XianXiaMJScore,                    #仙匣秘境积分榜 (仙匣秘境活动)

    Def_BT_GubaoScore,                        #古宝养成积分榜 (古宝养成活动)

    Def_BT_HorsePetTrainScore,                #骑宠养成积分榜 (骑宠养成活动) 40

    
    Def_BT_Max, #排行榜最大类型

) = range(0, 40 + 2) 
Def_BT_MainLevel,    # 主线关卡过关榜 0

) = range(0, 1) 


''' 跨服排行榜类型, 从 150 开始，最大条数在功能配置表 CrossBillboardSet 配置，没配默认100

与本服榜单存储的是不一样的数据库表格，理论上类型可以和本服榜单类型重复，为了做下区分防误导，跨服榜单从 150 开始

@@ -531,44 +475,15 @@
'''

CrossBillboardTypeList = (

Def_CBT_ActCTG, # 跨服运营活动 - 充值榜 150

Def_CBT_BattlefieldWJoin, # 跨服战场每周参与榜  151

Def_CBT_BattlefieldWCall, # 跨服战场每周召集榜  152

Def_CBT_BattlefieldWScore, # 跨服战场每周积分榜  153

Def_CBT_BattlefieldWScoreLastWeek, # 跨服战场上周积分榜  154

Def_CBT_YaomoBossHurt, # 跨服妖魔boss最新一次伤血排名  155

Def_CBT_FamilyFlagwar, # 逐鹿万界 - 单场榜  156

Def_CBT_FamilyFlagwarWeek, # 逐鹿万界 - 周总榜  157

Def_CBT_BossTrialSubmit, # boss凭证 - 个人榜  158

Def_CBT_BossTrialSubmitBak, # boss凭证 - 个人榜 上一期  159

Def_CBT_BossTrialSubmitFamily, # boss凭证 - 仙盟榜  160

Def_CBT_BossTrialSubmitFamilyBak, # boss凭证 - 仙盟榜 上一期  161

Def_CBT_XianXiaMJScore, # 仙匣秘境积分 - 个人榜  162

Def_CBT_GubaoScore, # 古宝养成积分 - 个人榜  163

Def_CBT_HorsePetTrainScore, # 骑宠养成积分 - 个人榜  164

Def_CBT_CrossRealmPK, # 跨服PK竞技场  165

Def_CBT_LianqiScore, # 炼器积分 - 个人榜  166

Def_CBT_FamilyGCZScore, # 仙盟攻城战 - 仙盟积分总榜  167 (zoneID, 0)

Def_CBT_FamilyGCZPlayerHurt, # 仙盟攻城战 - 玩家伤害总榜  168 (zoneID, 0)

Def_CBT_FamilyGCZRoundHurt, # 仙盟攻城战 - 本轮分组仙盟伤害榜  169 (zoneID, batType*100+groupNum)

) = range(150, 169 + 1)

) = range(150, 150 + 1)



BillboardTypeAllList = BillboardTypeList + CrossBillboardTypeList



#仙盟榜单类型

FamilyBillboardList = [Def_BT_BossTrialSubmitFamily, Def_BT_BossTrialSubmitFamilyBak, Def_CBT_FamilyGCZScore, Def_CBT_FamilyGCZRoundHurt]



#职业对应战力排行榜类型

JobFightPowerBillboardDict = {

                              PlayerJob_Warrior:Def_BT_FightPower_Warrior,

                              PlayerJob_Wizard:Def_BT_FightPower_Wizard,

                              PlayerJob_Assassin:Def_BT_FightPower_Assassin,

                              }

FamilyBillboardList = []



#排行榜Value1存储境界信息的榜单列表

BTValue1_OfficialRankList = [Def_BT_FightPower, Def_BT_FightPower_Warrior, Def_BT_FightPower_Wizard, Def_BT_FightPower_Assassin, 
                             Def_BT_LV, Def_BT_FightPower_Horse, Def_BT_FightPower_Pet, Def_BT_TrialTower, Def_BT_OffLineEfficient,

                             Def_BT_SkyTower, Def_BT_CharmTotal, Def_BT_CharmWeek, Def_BT_CharmDay

                             ]

BTValue1_OfficialRankList = [Def_BT_MainLevel]



##---比率---

#百分率

@@ -788,11 +703,11 @@
CDBPlayerRefresh_SuperDamPer, # 强化暴伤 259

CDBPlayerRefresh_SuperDamPerDef, # 弱化暴伤 260

CDBPlayerRefresh_Lingyu, # 灵玉 261

CDBPlayerRefresh_BossTrial, # 凭证积分 262

CDBPlayerRefresh_262, # 凭证积分 262

CDBPlayerRefresh_GatherSoul, # 聚魂精华 263

CDBPlayerRefresh_BossFinalHurtPer,  # Boss最终输出伤害百分比 264

CDBPlayerRefresh_HorsePetTrainScore, # 骑宠养成积分 265

CDBPlayerRefresh_GubaoTrainScore, # 古宝养成积分 266

CDBPlayerRefresh_265, # 骑宠养成积分 265

CDBPlayerRefresh_266, # 古宝养成积分 266

CDBPlayerRefresh_TiandaoFruit, # 天道果 267

CDBPlayerRefresh_Tuijinbi, # 推金币 268

CDBPlayerRefresh_PayCoinDay, # 代币时效 269

@@ -843,10 +758,10 @@
TYPE_Price_FamilyFlagWarPoint = 40    # 万界积分

TYPE_Price_Xiantao = 41    # 仙桃/战锤

TYPE_Price_Lingyu = 42    # 灵玉/将星玉髓

TYPE_Price_BossTrial = 43    # boss历练凭证积分

TYPE_Price_43 = 43    # boss历练凭证积分

TYPE_Price_GatherSoul = 44    # 聚魂精华

TYPE_Price_HorsePetTrainScore = 45    # 骑宠养成积分

TYPE_Price_GubaoTrainScore = 46    # 古宝养成积分

TYPE_Price_45 = 45    # 骑宠养成积分

TYPE_Price_46 = 46    # 古宝养成积分

TYPE_Price_TiandaoFruit = 47    # 天道果

TYPE_Price_Tuijinbi = 48    # 推金币

TYPE_Price_XianyuanScore = 49    # 仙缘积分

@@ -858,13 +773,17 @@


#key可用于遍历所有货币，value仅GM相关会用到

MoneyNameDict = {

                 1:"仙玉", 2:"绑玉", 3:"铜钱", 6:"战盟贡献度", 10:"战盟仓库积分", 13:"境界修行点", 14:"符印融合石", 15:"仙盟活跃令", 
                 16:"助战积分", 18:"荣誉", 19:"Boss积分", 23:"符印精华", 24:"符印碎片", 25:"寻宝积分", 26:"集市额度", 27:"丹精", 28:"魂尘", 
                 29:"聚魂碎片", 30:"核心环", 31:"功能特权令", 32:"环保值", 33:"GM令", 34:"古神币", 35:"功德点", 
                 39:"成就积分", 40:"万界积分", 41:"战锤", 42:"将星玉髓", 43:"凭证积分", 44:"聚魂精华", 45:"骑宠养成积分", 46:"古宝养成积分", 47:"天道果", 
                 49:"仙缘积分", 50:"幻境阁积分", 51:"招募积分", 52:"淘金令",

                 1:"金币", 41:"战锤", 42:"将星玉髓", 51:"招募积分", 52:"淘金令",

                 98:"代币时效", 99:"代币"

                 }

#MoneyNameDict = {

#                 1:"仙玉", 2:"绑玉", 3:"铜钱", 6:"战盟贡献度", 10:"战盟仓库积分", 13:"境界修行点", 14:"符印融合石", 15:"仙盟活跃令", 
#                 16:"助战积分", 18:"荣誉", 19:"Boss积分", 23:"符印精华", 24:"符印碎片", 25:"寻宝积分", 26:"集市额度", 27:"丹精", 28:"魂尘", 
#                 29:"聚魂碎片", 30:"核心环", 31:"功能特权令", 32:"环保值", 33:"GM令", 34:"古神币", 35:"功德点", 
#                 39:"成就积分", 40:"万界积分", 41:"战锤", 42:"将星玉髓", 43:"凭证积分", 44:"聚魂精华", 46:"古宝养成积分", 47:"天道果", 
#                 49:"仙缘积分", 50:"幻境阁积分", 51:"招募积分", 52:"淘金令",

#                 98:"代币时效", 99:"代币"

#                 }



#需要记录累计消耗的货币类型

UseTotalPriceTypeList = [TYPE_Price_TiandaoFruit]

@@ -900,10 +819,7 @@
                           TYPE_Price_Xiantao:CDBPlayerRefresh_Xiantao,

                           TYPE_Price_Lingyu:CDBPlayerRefresh_Lingyu,

                           TYPE_Price_FamilyFlagWarPoint:CDBPlayerRefresh_FamilyFlagWarPoint,

                           TYPE_Price_BossTrial:CDBPlayerRefresh_BossTrial,

                           TYPE_Price_GatherSoul:CDBPlayerRefresh_GatherSoul,

                           TYPE_Price_HorsePetTrainScore:CDBPlayerRefresh_HorsePetTrainScore,

                           TYPE_Price_GubaoTrainScore:CDBPlayerRefresh_GubaoTrainScore,

                           TYPE_Price_TiandaoFruit:CDBPlayerRefresh_TiandaoFruit,

                           TYPE_Price_XianyuanScore:CDBPlayerRefresh_XianyuanScore,

                           TYPE_Price_HuanjinggeScore:CDBPlayerRefresh_HuanjinggeScore,

@@ -1010,16 +926,15 @@
Def_WorshipTypeList = (

                       Def_WorshipType_ServerNaming, # 服务器冠名 1

                       Def_WorshipType_CrossChampionship, # 跨服排位冠军 2

                       Def_WorshipType_CrossBossTrial, # 跨服boss凭证 3

                       Def_WorshipType_CrossXianXiaMJ, # 跨服秘境寻宝 4

                       Def_WorshipType_CrossHorsePetTrain, # 跨服骑宠养成 5

                       Def_WorshipType_CrossGubaoTrain, # 跨服古宝养成 6

                       Def_WorshipType_3, # 跨服boss凭证 3

                       Def_WorshipType_4, # 跨服秘境寻宝 4

                       Def_WorshipType_5, # 跨服骑宠养成 5

                       Def_WorshipType_6, # 跨服古宝养成 6

                       Def_WorshipType_FamilyGCZ, # 仙盟攻城战 7

                       ) = range(1, 1 + 7)



#跨服膜拜类型

Def_WorshipTypeCross = [Def_WorshipType_CrossChampionship, Def_WorshipType_CrossBossTrial, Def_WorshipType_CrossXianXiaMJ, 
                        Def_WorshipType_CrossHorsePetTrain, Def_WorshipType_CrossGubaoTrain, Def_WorshipType_FamilyGCZ,

Def_WorshipTypeCross = [Def_WorshipType_CrossChampionship, Def_WorshipType_FamilyGCZ,

                        ]



#玩家记录类型

@@ -1147,7 +1062,7 @@
                      Def_ActionType_XXX10,    #10

                      Def_ActionType_OfficerModelEquip,    #记录家族有职位的成员模型装备信息11

                      Def_ActionType_FamilyEvent,    #记录家族事件12

                      Def_ActionType_BossTrialSubmit,    #boss凭证提交 13

                      Def_ActionType_13,    #boss凭证提交 13

                      Def_ActionType_FamilyCTGAssist,    #仙盟充值协助活动 14

                      Def_ActionType_FamilyEmblem,    #仙盟时效徽章信息 15

                      Def_ActionType_Zhenbaoge,    #珍宝阁 16

@@ -1220,19 +1135,6 @@


# 活动类型对应的奖励排行榜{活动类型:排行榜, ...}

Def_Campaign_Billboard_Dict = {

                               Def_Campaign_Type_Plus:Def_BT_Campaign_Plus,

                               Def_Campaign_Type_Horse:Def_BT_Campaign_Horse,

                               Def_Campaign_Type_StoneLV:Def_BT_Campaign_StoneLV,

                               Def_Campaign_Type_LV:Def_BT_Campaign_LV,

                               Def_Campaign_Type_RealmLV:Def_BT_Campaign_RealmLV,

                               Def_Campaign_Type_FightPower:Def_BT_Campaign_FightPower,

                               Def_Campaign_Type_RuneLV:Def_BT_Campaign_RuneLV,

                               Def_Campaign_Type_GodWeaponLV:Def_BT_Campaign_GodWeaponLV,

                               Def_Campaign_Type_Recharge:Def_BT_Campaign_Recharge,

                               Def_Campaign_Type_PetLV:Def_BT_Campaign_PetLV,

                               Def_Campaign_Type_LingGen:Def_BT_Campaign_LingGen,

                               Def_Campaign_Type_StarLV:Def_BT_Campaign_StarLV,

                               Def_Campaign_Type_Wash:Def_BT_Campaign_Wash,

                               }



#队伍最大人数

@@ -1300,7 +1202,6 @@
CrossServerMsg_CrossDailyActionState = "CrossDailyActionState" # 跨服日常任务状态信息

CrossServerMsg_CrossYaomoBossHurtInfo = "CrossYaomoBossHurtInfo" # 跨服妖魔boss玩家伤害信息

CrossServerMsg_FamilyFlagwarOver = "FamilyFlagwarOver"  # 逐鹿万界结算信息

CrossServerMsg_CrossBossTrialFamilyAward = "CrossBossTrialFamilyAward"  # 跨服boss历练仙盟奖励结算

CrossServerMsg_Worship = "Worship"  # 膜拜信息

CrossServerMsg_Xiangong = "Xiangong"  # 仙宫信息

CrossServerMsg_FuncTeamInfo = "FuncTeamInfo"  # 功能队伍信息同步

@@ -1347,14 +1248,10 @@
ClientServerMsg_ChampionshipWorship = "ChampionshipWorship" # 跨服排位膜拜

ClientServerMsg_ActAllRechargeValue = "ActAllRechargeValue" # 跨服全民充值额度

ClientServerMsg_CrossYaomoBossHurtAward = "CrossYaomoBossHurtAward" # 跨服妖魔boss玩家伤害领奖

ClientServerMsg_BossTrialSubmit = "BossTrialSubmit" # boss凭证提交

ClientServerMsg_XianXiaMJScore = "XianXiaMJScore" # 仙匣秘境积分

ClientServerMsg_CreateFuncTeam = "CreateFuncTeam"   # 创建功能队伍

ClientServerMsg_ChangeFuncTeam = "ChangeFuncTeam"   # 修改功能队伍

ClientServerMsg_FuncTeamMemOP = "FuncTeamMemOP"   # 功能队伍成员操作

ClientServerMsg_QueryFuncTeam = "QueryFuncTeam"   # 查询功能队伍

ClientServerMsg_GubaoScore = "GubaoScore" # 古宝养成积分

ClientServerMsg_HorsePetTrainScore = "HorsePetTrainScore" # 骑宠养成积分

ClientServerMsg_QueryXiangong = "QueryXiangong" # 查看仙宫仙名录

ClientServerMsg_LianqiScore = "LianqiScore" # 炼器积分

ClientServerMsg_SyncFamilyInfo = "SyncFamilyInfo" # 仙盟信息同步