16 卡牌服务端（删除旧版xml任务、镖车等不需要内容）

hxp

2025-05-29 167357e8425d0dc12f41ed5fdfd4d95f2c2a5aaf

 ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Event/EventShell.py

@@ -47,7 +47,6 @@
# @change: "2014-06-23 14:30" Alee 关闭输出

# @change: "2014-07-24 21:30" hxp 增加设置跑环任务星级，一键完成所有跑环任务

# @change: "2014-07-31 21:30" hxp 取消红名不能与NPC对话限制

# @change: "2014-08-26 11:00" hxp NotifyOneMission增加参数选择是否同步该任务全部字典信息

# @change: "2014-12-25 16:10" ljd 同步上一次背包开格时间

# @change: "2015-01-10 23:00" hxp 仓库购买特殊处理

# @change: "2015-01-14 00:30" hxp 增加事件汇报

@@ -72,61 +71,24 @@
import GameWorld

import EventSrc

import ChConfig

import QuestManager

import QuestRunner

import PlayerControl

import FunctionNPCCommon

import FBLogic

import ItemControler

import ItemCommon

import QuestCommon

import copy

import GameLogInfo

import time

import GameServerRefresh

import PlayerMissionCollect

import ReadChConfig

import PlayerFamily

import ShareDefine

import Operate_PlayerBuyZhenQi

import Func_6

import DataRecordPack

import PlayerCoin

import PlayerTrade

import PlayerExpandPackCfgMgr

import EventReport

import PlayerCoat

import PlayerGatherSoul

#import PlayerArrestTask

import PlayerRune

import IpyGameDataPY

import FormulaControl

import GameFuncComm

import ChPyNetSendPack

import NetPackCommon

import NPCCommon

import PlayerVip

import PlayerGoldInvest

import PlayerPrestigeSys

import GameObj



import math

import random

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



#每日任务最小触发等级

Day_Event_Trig_Min_LV = 21



#任务触发模式

Def_RunQuestType_Normal = 1     #普通

#Def_RunQuestType_NoAnswer = 2   #不需要回应(LVUp)

Def_RunQuestType_RunAll = 3     #运行所有(OnDay), 每日判定(不能只在onLVUP的时候判定, 因为玩家可能叛国, 叛国后, 如果只在onLVUP的时候写, 那么叛国后接不到每日任务)

Def_RunQuest_ChangeMap_Tick = 1000



Def_Warehouse_FuncName = "Func_6"  # 仓库相关功能py名

############################################################

#def QuestRunner_GetFunc(name):

#    return    GameWorld.GetExecFunc(EventSrc, "QuestRunner.%s"%name)



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

#导入所有的NPCAI

GameWorld.ImportAll("Script\\Event\\" , "EventSrc")

@@ -142,2199 +104,7 @@
    

    scriptPath = ChConfig.GetAppPath() + "Script\\Event"

    GameWorld.ReloadScript(scriptPath, "")

    
    #重新读取事件

    QuestManager.ReloadQuests(tick)

    DoReloadRefresh()

    return

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

#===============================================================================

# //08 01 事件触发#tagCNPCTalk

# tagCNPCTalk       *   GettagCNPCTalk();

# 
# class   IPY_CNPCTalk

# {

# public:

# 
#    int      GetNPCID();

# 
#    int      GetPosX();

# 
#    int      GetPosY();

# };

#===============================================================================

##客户端//08 01封包响应 事件触发#tagCNPCTalk

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端//08 01封包响应 事件触发#tagCNPCTalk

def BeginEvent(index, tick):

    GameWorld.GetPsycoFunc(__Func_BeginEvent)(index, tick)

    return



##客户端//08 01封包响应 事件触发#tagCNPCTalk

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端//08 01封包响应 事件触发#tagCNPCTalk

def __Func_BeginEvent(index, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)



    if curPlayer.GetPlayerAction() != IPY_GameWorld.paNull:

        #玩家状态不是空闲状态

        return

    
    #防沉迷

    if curPlayer.NomalDictGetProperty(ChConfig.Def_Player_Dict_Wallow_LV) > ChConfig.Def_GameWallow_LV_First:

        PlayerControl.NotifyCode(curPlayer, "AvoidSink09")

        return

    
#===============================================================================

#    #移动中不执行此操作

#    if curPlayer.IsMoving():

#        PlayerControl.NotifyCode(curPlayer, "GeRen_lhs_0")

#        return

#===============================================================================

    
    if tick - curPlayer.GetResetWorldPosAskTick() < Def_RunQuest_ChangeMap_Tick:

        #[bug]2009.4.25

        #1. 玩家进入焚天溶洞(任务状态设置为2)

        #2. 在等待切换地图回应之前, 普通聊天(任务状态设置为1)

        #3. 进入地图了

        #这样就可以刷焚天溶洞

        GameWorld.GodLog(curPlayer, "BeginEvent, ResetWorldPosAskTick")

        return

     
    #玩家触发事件 
    sendPack = IPY_GameWorld.IPY_CNPCTalk()

    
    sendPack_EventNPCID = sendPack.GetNPCID()

    sendPack_NPCPosX = sendPack.GetPosX()

    sendPack_NPCPosY = sendPack.GetPosY()

    
    if sendPack_EventNPCID == 0:

        #目前不处理地点触发类事件

        return

    
    #2010/5/6 移动中接受客户端封包(因客户端移除Stopmove), 校验误差, 累加

    #===========================================================================

    # if not PlayerControl.PlayerRefreshPos(curPlayer, curPlayer, sendPack_NPCPosX, sendPack_NPCPosY):

    #    #玩家当前位置刷新失败

    #    #GameWorld.Log(' CheckUseSkill RefreshPosErr packPos = ( %s, %s ), playerPos = ( %s, %s )'%( posX, posY, curPlayer.GetPosX(), curPlayer.GetPosY() ), curPlayerID )

    #    return

    #===========================================================================

    
    #执行对话逻辑

    EventLogic(curPlayer, sendPack_EventNPCID, tick)

    return



#// C1 06 跨服NPC对话 #tagCMCrossNPCTalk

#

#struct    tagCMCrossNPCTalk

#{

#    tagHead        Head;

#    WORD        ObjID;

#    DWORD        NPCID;

#    WORD        PosX;

#    WORD        PosY;

#};

def OnCrossNPCTalk(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    
    objID = clientData.ObjID

    npcID = clientData.NPCID

    #posX = clientData.PosX

    #posY = clientData.PosY

    if GameWorld.IsCrossServer():

        return

    
    lastTick = curPlayer.GetDictByKey("CrossNPCTalkTick")

    if tick - lastTick < 2000:

        return

    curPlayer.SetDict("CrossNPCTalkTick", tick)

    
    npcData = GameWorld.GetGameData().FindNPCDataByID(npcID)

    if not npcData:

        GameWorld.ErrLog("跨服NPCID不存在! npcID=%s" % npcID)

        return

        
    # 目前暂支持跨服采集

    if npcData.GetType() not in [IPY_GameWorld.ntCollection, IPY_GameWorld.ntMissionCollect]:

        return

    
    collectNPCIpyData = IpyGameDataPY.GetIpyGameData("CollectNPC", npcID)

    if collectNPCIpyData:

        if not NPCCommon.CheckCanCollectByNPCID(curPlayer, npcID, collectNPCIpyData):

            return

        
        msgDict = {"PlayerID":curPlayer.GetPlayerID(), "ObjID":objID, "NPCID":npcID}

        GameWorld.SendMsgToCrossServer(ShareDefine.ClientServerMsg_CollectNPC, msgDict)

        
    return



def ClientServerMsg_CollectNPC(curPlayer, msgData, serverGroupID, tick):

    ## 收到子服同步的采集NPC

    objID = msgData["ObjID"]

    npcID = msgData["NPCID"]

    curNPC = GameWorld.FindNPCByID(objID)

    if not curNPC:

        return

    if npcID !=  curNPC.GetNPCID():

        GameWorld.ErrLog("采集跨服NPC错误!npcID=%s != curNPCID=%s" % (npcID, curNPC.GetNPCID()))

        return

    EventLogic(curPlayer, objID, tick)

    return



##客户端//08 01封包响应 自定义函数: 事件处理

#@param curPlayer 当前玩家

#@param eventNPCID 事件NPCID

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端//08 01封包响应 自定义函数: 事件处理

def EventLogic(curPlayer, eventNPCID, tick):

    #检查玩家和NPC的距离在不在对话范围内

    curNPC = GameWorld.GetNPCManager().FindNPCByID(eventNPCID)

    
    #没有这个NPC

    if curNPC == None :

        return



    #可进入事件类型NPC

    eventNPCType = [IPY_GameWorld.ntFunctionNPC, IPY_GameWorld.ntCollection, IPY_GameWorld.ntMissionCollect]

    
    if curNPC.GetType() not in eventNPCType:

        GameWorld.Log("不是对话NPC, 不能对话 %d"%(curNPC.GetType()) , curPlayer.GetPlayerID())

        return 
    
    dist = GameWorld.GetDist(curPlayer.GetPosX(), curPlayer.GetPosY(), curNPC.GetPosX(), curNPC.GetPosY())

    
    if dist > ChConfig.Def_EventDist:

        #玩家距离过远, 不能触发

        curPlayer.ResetPos(curPlayer.GetPosX(), curPlayer.GetPosY())

        return

    
    if curNPC.GetType() == IPY_GameWorld.ntCollection:

        #家族战的塔和棋, 对话会开始读进度条

        __BeginCollect(curPlayer, curNPC, tick)

        return

    
    #任务采集NPC

    if curNPC.GetType() == IPY_GameWorld.ntMissionCollect:

        PlayerMissionCollect.QueryMissionCollect(curPlayer, curNPC, tick)

        return

    
    #清空玩家传送地图带走的NPC

    #因为副本任务中, 如果副本人满不能进, 会传送一次多一只NPC...

    curPlayer.ClearChangeMapTakeCreateNPC()

    
    #在XML表中找到这个NPC的脚本

    EventRespons_OnVisit(curPlayer, curNPC)

    return



##客户端//08 01封包响应 自定义函数: 开始家族战中的塔和期拉进度条

#@param curPlayer 当前玩家

#@param curNPC 事件NPC实例

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端//08 01封包响应 自定义函数: 开始家族战中的塔和期拉进度条

def __BeginCollect(curPlayer, curNPC, tick):

    result = FBLogic.OnCanCollect(curPlayer, curNPC, tick)

    if not result:

        #不可采集

        return

    
    curPlayer.SetActionObj(curNPC)

    PlayerControl.ChangePlayerAction(curPlayer, IPY_GameWorld.paNull)

    
    if NPCCommon.OnCollectNPCBegin(curPlayer, curNPC, tick):

        return

    
    prepareTime = FBLogic.GetFBPrepareTime(curPlayer, curNPC)

    
    collTimeReduceRate = PlayerVip.GetPrivilegeValue(curPlayer, ChConfig.VIPPrivilege_CollTimeReduceRate)

    if collTimeReduceRate:

        prepareTime = max(1000, int(prepareTime * (ShareDefine.Def_MaxRateValue - collTimeReduceRate) / float(ShareDefine.Def_MaxRateValue)))

        
    PlayerControl.Sync_PrepareBegin(curPlayer, prepareTime, IPY_GameWorld.pstCollecting, prepareID = curNPC.GetID())

    
    ##添加这个NPC的伤血列表，用于多个人一起抢棋，一人成功后，其他人打断

    curNPC_HurtList = curNPC.GetPlayerHurtList()

    import AttackCommon

    AttackCommon.AddHurtValue(curNPC, curPlayer.GetPlayerID(), ChConfig.Def_NPCHurtTypePlayer, 1)

    return

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



#===============================================================================

# //08 02 事件回应#tagCNPCAnswer

# tagCNPCAnswer       *   GettagCNPCAnswer();

# 
# class   IPY_CNPCAnswer

# {

# public:

# 
#    int      GetAnswerLen();

#    //size = AnswerLen

#    char *      GetAnswer();

# };

#===============================================================================

##客户端//08 02封包响应 事件回应#tagCNPCAnswer

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端//08 02封包响应 事件回应#tagCNPCAnswer

def EventAnswer(index, tick):

    GameWorld.GetPsycoFunc(__Func_EventAnswer)(index, tick)

    return



##客户端//08 02封包响应 事件回应#tagCNPCAnswer

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端//08 02封包响应 事件回应#tagCNPCAnswer

def __Func_EventAnswer(index, tick):

    timeClock = time.clock()

    
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    
#    if curPlayer.GetPlayerAction() != IPY_GameWorld.paEvent:

#        #玩家不在事件中,返回

#        GameWorld.Log("EventAnswer, 玩家不在事件中", curPlayer.GetID())

#        return

    
    if tick - curPlayer.GetResetWorldPosAskTick() < Def_RunQuest_ChangeMap_Tick:

        #[bug]2009.4.25

        #1. 玩家进入焚天溶洞(任务状态设置为2)

        #2. 在等待切换地图回应之前, 普通聊天(任务状态设置为1)

        #3. 进入地图了

        #这样就可以刷焚天溶洞

        GameWorld.GodLog(curPlayer, "EventAnswer, ResetWorldPosAskTick")

        return

    
    sendPack = IPY_GameWorld.IPY_CNPCAnswer()

    answer = sendPack.GetAnswer()

    if answer == "":

        #玩家回答为空

        GameWorld.Log("玩家回答为空" , curPlayer.GetPlayerID())

        return

    
    answerBase = copy.deepcopy(answer)

    answer = answer.lower()

    if answer == "cancel":

        #GameWorld.Log("玩家强制结束事件" , curPlayer.GetPlayerID())

        DoExitEvent(curPlayer)

        return

    
    funcHead = "fc_"

    xmlFuncHead = "evt_"

    
    curNPC = QuestRunner.GetPlayerTalkNPC(curPlayer)

    #红名玩家无法接,交任务

#    if curPlayer.GetPlayerNameColor() == IPY_GameWorld.pncRed and __Check_FunctionNPC_Talk_RedName(curNPC):

#        PlayerControl.NotifyCode(curPlayer, "PK_lhs_161795")

#        #结束事件

#        DoExitEvent(curPlayer)

#        return

    
    if curNPC != None and not GameWorld.IsSameCountry(curPlayer, curNPC) :

        #PK_lhs_372238   <n color="255,0,0">我不会给敌人提供任何帮助的!</n>

        #不同国籍, 不能和NPC对话

        #PlayerControl.NotifyCode(curPlayer, "PK_lhs_372238")

        DoExitEvent(curPlayer)

        return

    
    GameWorld.DebugLog("%s(%d) 访问NPC回应: %s"%(curPlayer.GetName(), curPlayer.GetID(), answerBase) , curPlayer.GetPlayerID())

    
    if answer.find(funcHead) == 0:

        #是事件响应

        if curNPC == None:

            #没有这个NPC

            GameWorld.Log("funcHead没有这个NPC" , curPlayer.GetPlayerID())

            return

        
        #得到玩家的对象

        funcAnswer = answerBase.replace(funcHead, "")

        responseType="Func_%d"%curNPC.GetFunctionType()

        callFunc = GameWorld.GetExecFunc(EventSrc, "%s.%s"%(responseType, funcAnswer))

        
        if callFunc == None:

            #函数调用不可使用

            GameWorld.Log("回应事件响应 %s %s不可使用"%(responseType, funcAnswer) , curPlayer.GetPlayerID())

            return

        
        callFunc(curPlayer, tick)

        return

    
    elif answer.find(xmlFuncHead) == 0:

        #运行Func目录下的XML文件

        #事件对话(开通仓库, 购买骠车马匹使用时间等

        funcAnswer = answer.replace(xmlFuncHead, "")

        QuestsEvent = QuestManager.GetAllQuestsEvents()

        curNPC = QuestRunner.GetPlayerTalkNPC(curPlayer)

        
        if curNPC == None:

            #没有这个NPC

            GameWorld.Log("GetPlayerTalkNPC没有这个NPC" , curPlayer.GetPlayerID())

            return

        
        #得到NPC的TypeID

        funcType = curNPC.GetFunctionType()

        key = ("function_npc", "%d_%s.xml"%(funcType, funcAnswer))

        
        if QuestsEvent.has_key(key):

            for event in QuestsEvent[key]:

                nodeList = event[1].GetXMLEventLoader().GetNodeList()

                #运行function_npc目录下的[funcType].xml文件

                if QuestRunner.RunFunctionQuest(curPlayer, nodeList) != True:

                    GameWorld.Log("任务事件对话执行失败" , curPlayer.GetPlayerID())

                    DoExitEvent(curPlayer)

        else:

            GameWorld.Log("哈细特锁吗利(精灵族语) %s"%(str(key)) , curPlayer.GetPlayerID())

            DoExitEvent(curPlayer)

            
        return

    
    else:



        #普通对话

        QuestRunner.RunPlayerAnswer(curPlayer, answer)

    
    #记录任务相关信息

    GameLogInfo.LogInfo_MissionTime(timeClock)

    GameLogInfo.LogInfo_MissionCount(1)

    return

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



##任务触发器装备普通强化使用次数

#@param curPlayer 玩家实例

#@param curNPC NPC实例

#@return 返回值无意义

#@remarks 任务触发器_OnKillById 击杀指定ID的怪物

def EventRespons_OnEquipNormalPlus(curPlayer, itemID):

    RunQuestEvent(curPlayer, "on_equip_normal_plus", itemID, Def_RunQuestType_Normal)

    return





## 任务触发器_OnVisit 和NPC对话

#@param curPlayer 玩家实例

#@param curNPC NPC实例

#@return 返回值无意义

#@remarks 任务触发器_OnVisit 和NPC对话

def EventRespons_OnVisit(curPlayer, curNPC):

    #GameWorld.Log("访问NPC锁住" , curPlayer.GetPlayerID())

    curPlayer.BeginEvent()

    curPlayer.SetActionObj(curNPC)

        
    #得到NPC的TypeID

    npcTypeID = curNPC.GetNPCID()

    #GameWorld.Log("%s(%d) 访问NPC %d"%(curPlayer.GetName(), curPlayer.GetID(),npcTypeID) , curPlayer.GetPlayerID())

    if QuestRunner.RunQuestOnVisit(curPlayer, npcTypeID) != True:

        GameWorld.Log("%s任务对话执行失败"%(npcTypeID) , curPlayer.GetPlayerID())

        DoExitEvent(curPlayer)

    
    return

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

##任务_每日任务 //0.xml, 函数调用 QuestRunner.RunQuest 执行逻辑

#@param curPlayer 玩家实例

#@param eventName 事件字典名

#@param trigID 事件字典值

#@param eventDictName 随机事件字典名，储存ID

#@return 返回值无意义

#@remarks 任务_每日任务 //0.xml, 函数调用 QuestRunner.RunQuest 执行逻辑

def RunDayEvent(curPlayer, eventName, trigID, eventDictName):

    QuestsEvent = QuestManager.GetAllQuestsEvents()

    key = (eventName, "0.xml")

    #因为每日任务杀怪随机, 所以只有用0.xml来读取

    if not QuestsEvent.has_key(key) :

        return

    
    curQuestList = QuestsEvent[key]

    if len(curQuestList) == 0:

        GameWorld.Log("%s 没有触发!"%str(key) , curPlayer.GetPlayerID())

        return

    
    for event in curQuestList:

        questID = event[0]

        curMission = curPlayer.FindMission(questID)

        if curMission == None:

            continue

        
        killRangeName = "killrangenpclv"

        #指定NPC等级范围

        killRangeLV = curMission.GetProperty(killRangeName)

        #从一个范围随机出一个指定值

        eventID = curMission.GetProperty(eventDictName)

        #杀任意怪

        anyKill = curMission.GetProperty(QuestCommon.Def_Day_Event_Any_Kill)

        
        #符合一样即可执行

        if anyKill == 0 and eventID != trigID and killRangeLV == 0:

            continue

        
        if killRangeLV > 0:

            curMission.SetProperty(killRangeName, trigID, False)

        
        QuestRunner.RunQuest(curPlayer, questID, event[1].GetXMLEventLoader().GetNodeList())

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

##任务_任务事件

#@param curPlayer 玩家实例

#@param eventName 事件字典名

#@param fileID 事件XML文件名

#@param runType 执行方式 Def_RunQuestType_

#@return 返回值无意义

#@remarks 任务_任务事件

def RunQuestEvent(curPlayer, eventName, fileID, runType):

    eventName = eventName.lower()

    QuestsEvent = QuestManager.GetAllQuestsEvents()

    key = (eventName, "%s.xml"%str(fileID))

    
    if not QuestsEvent.has_key(key) :

        #GameWorld.DebugLog("RunQuestEvent 没有key = %s  !" % str(key), curPlayer.GetPlayerID())

        return False

    
    curQuestList = QuestsEvent[key]

    if len(curQuestList) == 0:

        GameWorld.Log("%s 没有触发!"%str(key) , curPlayer.GetPlayerID())

        return

    
    for event in curQuestList:

        questID = event[0]



        #未激活的任务也需要触发, 原因: 任务未激活, 但是还是会保存在玩家身上

        #原因: 玩家一天只能领取一次活动, 不管活动开启多少次

        #所以要让非激活状态触发onday

        
        #2009.2.15      更新, 未激活的活动不会触发, 不考虑活动删除

        curQuestData = QuestManager.FindQuest(questID)

        curMission = curPlayer.FindMission(questID)

        
        if curQuestData != None and curQuestData.Type == QuestCommon.Def_GM_Active_Mission_Type:

            #检查有没有激活

            #没有激活, 跳过    
            if not GameWorld.GetGameWorld().IsEventActive(questID):

                if curMission == None:

                    continue

                #是完成的任务

                if curMission.GetState() == ChConfig.Def_Mission_State_Over:

                    continue

            
        #GameWorld.Log("玩家触发任务: %s  - %d"%(str(key), questID) , curPlayer.GetPlayerID())    
        if runType == Def_RunQuestType_RunAll:

            #运行所有节点

            QuestRunner.RunAllQuest(curPlayer, questID, event[1].GetXMLEventLoader().GetNodeList())

            continue

#        elif runType == Def_RunQuestType_NoAnswer:

#            QuestRunner.RunQuestNoAnswer(curPlayer, questID, event[1].GetXMLEventLoader().GetNodeList())

#            continue

        
#        curMission = curPlayer.FindMission(questID)

        if curMission == None:

            continue

        
        if runType != Def_RunQuestType_RunAll and curMission.GetState() == ChConfig.Def_Mission_State_Over:

            #任务已经完成

            continue



        if runType == Def_RunQuestType_Normal:

            QuestRunner.RunQuest(curPlayer, questID, event[1].GetXMLEventLoader().GetNodeList())



    return True

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

def Event_OnKillByID(curPlayer, npcID):

    #运行on_kill_by_id目录下的[NPCTypeID].xml文件

    RunQuestEvent(curPlayer, "on_kill_by_id", npcID, Def_RunQuestType_Normal)

    #触发每日任务杀怪

    RunDayEvent(curPlayer, "on_kill_by_id", npcID, QuestCommon.Def_Kill_Npc_ID)

    return



##任务触发器_OnKillById 击杀指定ID的怪物

#@param curPlayer 玩家实例

#@param curNPC NPC实例

#@return 返回值无意义

#@remarks 任务触发器_OnKillById 击杀指定ID的怪物

def EventRespons_OnKillById(curPlayer, curNPC):

    #得到NPC的TypeID

    npcTypeID = curNPC.GetNPCID()

    QuestRunner.SetKillNPC(curNPC)

    
    Event_OnKillByID(curPlayer, npcTypeID)

    
    #触发按等级杀怪

    EventRespons_OnKillByLv(curPlayer, curNPC)

    return

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

##任务触发器_OnKillByLv 击杀指定等级的怪物

#@param curPlayer 玩家实例

#@param curNPC NPC实例

#@return 返回值无意义

#@remarks 任务触发器_OnKillByLv 击杀指定等级的怪物

def EventRespons_OnKillByLv(curPlayer, curNPC):

    if GameWorld.GetMap().GetMapFBType() != IPY_GameWorld.fbtNull:

        return

    
    #得到NPC的TypeID

    npcLV = NPCCommon.GetNPCLV(curNPC)    
    
    #运行on_kill_by_lv目录下的[NPCTypeID].xml文件

    #QuestRunner.SetKillNPC(curNPC)

    
    RunQuestEvent(curPlayer, "on_kill_by_lv", npcLV, Def_RunQuestType_Normal)

    
    #触发每日任务杀怪

    RunDayEvent(curPlayer, "on_kill_by_lv", npcLV, QuestCommon.Def_Kill_Npc_LV)

    return



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

##任务触发器_完成某手机任务

# @param curPlayer：玩家实例

# @param curTaskType：('1_MissionId'：游历江湖；'2_MissionId'：笑恩录；)

# @return None

def EventRespons_OnPhoneAchieveTask(curPlayer, curTaskType):

    
    RunQuestEvent(curPlayer, "on_phone_achieve_task", curTaskType, Def_RunQuestType_Normal)

    return









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

##任务触发器_OnGet 玩家拾取物品

#@param curPlayer 玩家实例

#@param itemTypeID 物品ID

#@return 返回值无意义

#@remarks 任务触发器_OnGet 玩家拾取物品

def EventRespons_OnGet(curPlayer, itemTypeID):

    RunQuestEvent(curPlayer, "on_get", itemTypeID, Def_RunQuestType_Normal)

    #触发每日任务得到物品

    RunDayEvent(curPlayer, "on_get", itemTypeID, QuestCommon.Def_Item_ID)

    return



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

##任务触发器_OnTruckDisappear 镖车丢失触发任务

#@param curPlayer 玩家实例

#@param taskID 镖车事件ID

#@return 返回值无意义

#@remarks 任务触发器_OnTruckDisappear 镖车丢失触发任务

def EventRespons_OnTruckDisappear(curPlayer, taskID):

    GameWorld.Log("骠车丢失, 触发骠车丢失任务 %d"%(taskID), curPlayer.GetPlayerID())

    RunQuestEvent(curPlayer, "on_truck_disappear", taskID, Def_RunQuestType_Normal)

    return



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

##任务触发器_OnTruckDestroy 镖车打烂触发任务

#@param curPlayer 玩家实例

#@param taskID 镖车事件ID

#@return 返回值无意义

#@remarks 任务触发器_OnTruckDestroy 镖车打烂触发任务

def EventRespons_OnTruckDestroy(curPlayer, taskID):

    GameWorld.Log("骠车打烂, 触发骠车打烂任务 %d"%(taskID), curPlayer.GetPlayerID())

    RunQuestEvent(curPlayer, "on_truck_destroy", taskID, Def_RunQuestType_Normal)

    return

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

##自定义函数:OnEnter 玩家上线触发GM开关的活动

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 自定义函数:OnEnter 玩家上线触发GM开关的活动

def PlayerGMEventTrig(curPlayer):

    gameWorld = GameWorld.GetGameWorld()

    #检查玩家触发GM事件(触发on_active和on_deactive)

    #QuestManager.FindQuest

    
    delQuestList = []

    for i in range(0, curPlayer.GetMissionCount()):

        curMission = curPlayer.GetMissionByIndex(i)

        missionID = curMission.GetMissionID()

        missionData = QuestManager.FindQuest(missionID)

        if missionData == None:

            continue

        
        if missionData.Type != QuestCommon.Def_GM_Active_Mission_Type:

            continue

        
        #检查节庆任务

        if not gameWorld.IsEventActive(missionID):

            #玩家有节庆任务, 但是任务已经关闭了

            #注意: 这里是在for中删除!!!

            delQuestList.append(missionID)

            #EventResponse_OnDeActive(curPlayer, missionID)

            
    for missionID in delQuestList:

        EventResponse_OnDeActive(curPlayer, missionID)

    
    for i in range(gameWorld.GetActiveEventCount()):

        missionID = gameWorld.GetActiveEventByIndex(i)

        if curPlayer.FindMission(missionID):

            #玩家有这个任务

            continue

        
        #玩家没有这个节庆任务, 需要触发

        EventResponse_OnActive(curPlayer, missionID)

        
    return



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

##触发所有他人发布的任务

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 自定义函数:触发所有他人发布的任务

def PlayerMissionPubEventTrig(curPlayer):

    #检查玩家触发GM事件(触发on_active和on_deactive)

    #QuestManager.FindQuest

    missionPubManager = GameWorld.GetGameWorld().GetDBMissionPubManager()    
    for i in range(missionPubManager.GetCount()):

        curMissionPub = missionPubManager.GetAt(i)

        missionID = curMissionPub.GetMissionID()

        if curPlayer.FindMission(missionID):

            #玩家有这个任务

            continue

        
        #触发他人发布的任务

        CheckTrigMissionPub(curPlayer, curMissionPub)

        
    return

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

##任务触发器_OnEnter 任务潜规则,玩家第一次登陆游戏要添加任务1给玩家

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_OnEnter 任务潜规则,玩家第一次登陆游戏要添加任务1给玩家

def EventResponse_OnEnter(curPlayer):

    curPlayerID = curPlayer.GetID()

    #quests = QuestManager.GetQuests()

    addMission = QuestCommon.GetCommonMission(curPlayer)

    
    if addMission == None:

        #执行第一次登陆逻辑

        __FirstLoginOnEnter(curPlayer)

        
        addMission = QuestCommon.GetCommonMission(curPlayer)

        
        if addMission == None:

            GameWorld.ErrLog('EventResponse_OnEnter, 玩家 = %s无法获得公共任务'%(curPlayer.GetName()), curPlayer.GetID())

            return

    
    if addMission.GetState() != ChConfig.Def_Mission_State_NoAccept:

        return 
    
    #玩家第一个任务没有做,锁住

    GameWorld.Log("玩家第一个任务没有做, 锁住", curPlayerID)

    #curPlayer.BeginEvent()

    curPlayer.SetDict(ChConfig.Def_PlayerKey_Frist_Lock, 1)

    #调用执行新手任务

    RunQuestEvent(curPlayer, "on_enter", ChConfig.Def_XML_FirstLogin, Def_RunQuestType_Normal)

    return



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

##玩家第一次登陆游戏逻辑, 如任务加载逻辑, 自动学习技能

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 自定义函数:玩家第一次登陆游戏逻辑, 如任务加载逻辑, 自动学习技能

def __FirstLoginOnEnter(curPlayer):

    playerID = curPlayer.GetID()

    
    GameWorld.Log('玩家是第一次进入游戏', playerID)

    # 特殊说明： 如果地图没有完全初始化好，客户端断开或者异常等情况会触发RunGateGameServerMapServerKickOutPlayerNoSave

    # 那么在DoPlayerLogin 中设置的数据将不会被保存， 如会导致第一个任务重复触发问题，记录多次发送

    EventReport.WriteEvent_Entry(curPlayer, 4)

    #EventReport.EventReport(ShareDefine.Def_UserAction_FirstLogin, "", curPlayer)

    #---给玩家新手任务---

    addMission = QuestCommon.AddNewMission(curPlayer, ChConfig.Def_MissionID_FirstLogin)

    #广播新增任务

    NotifyOneMission(curPlayer, addMission)

    
    #---补满血满魔---

    GameObj.SetHP(curPlayer, GameObj.GetMaxHP(curPlayer))

    curPlayer.SetMP(curPlayer.GetMaxMP())

    
    #---给予玩家新手物品---

    
    #---初始化装备显隐 第1套*10+没有套装

    curPlayer.SetEquipShowSwitch(10)

    PlayerControl.SetFaceEquipIndex(curPlayer, 11012014)

    
    #默认触发一次功能开启

    if curPlayer.GetLV() == 1:

        GameFuncComm.DoFuncOpenLogic(curPlayer)

        
    #初始化组队状态

    autoJoinReqCheck = IpyGameDataPY.GetFuncCfg("TeamCheckSet", 1)

    autoInviteCheck = IpyGameDataPY.GetFuncCfg("TeamCheckSet", 2)

    PlayerControl.SetTeamCheckStateEx(curPlayer, int(not autoJoinReqCheck), int(not autoInviteCheck))

    
    #按平台给首个称号

    #PlayerDienstgrad.GiveFirstLoginDienstgrad(curPlayer)

    
    #玩家默认恶名值

    curPlayer.SetInfamyValue(ChConfig.Def_FirstLogin_InfamyValue)

    
    #标记已登陆过，用于非同一天二次登陆

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_OtherDayLogin, 1)

    
    #curPlayer.SetDict("ThunderLogin", 1)

    #记录第一次登陆

    DataRecordPack.DR_FirstLogin(curPlayer.GetAccID(), curPlayer.GetIP(), curPlayer)

    
    #内部号给予元宝

    #PlayerCoin.GiveGoldByCreate(curPlayer)

    
    #首登邮件

    mailList = IpyGameDataPY.GetFuncEvalCfg("MailLVAward", 2)

    for mailTypeKey, mailItemList in mailList:

        PlayerControl.SendMailByKey(mailTypeKey, [curPlayer.GetPlayerID()], mailItemList)

    return

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

##任务触发器_OnLogin 玩家登陆游戏触发

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_OnLogin 玩家登陆游戏触发

def EventResponse_OnLogin(curPlayer):

    #触发GM开关活动

#    PlayerGMEventTrig(curPlayer)

    #触发他人发布活动

#    PlayerMissionPubEventTrig(curPlayer)

    
    RunQuestEvent(curPlayer, "on_login", "on_login", Def_RunQuestType_RunAll)

    return



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

##任务触发器_On_GameServer_Login 此事件需要GameServer初始化玩家后，返回是家族长后触发

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_On_GameServer_Login 此事件需要GameServer初始化玩家后，返回是家族长后触发

def EventResponse_On_GameServer_Login(curPlayer):

    #设置为家族长（GameServer已验证，MapServer还没刷新）

    curPlayer.SetFamilyMemberLV(IPY_GameWorld.fmlLeader)

    RunQuestEvent(curPlayer, "on_gs_login", "on_gs_login", Def_RunQuestType_RunAll)

    return

#===============================================================================

# 
# #城门活动开始触发任务事件

# def EventResponse_On_Open_Gate_War(curPlayer):

#    if not curPlayer.GetGameServerInitOK():

#        GameServerRefresh.Set_Mission_No_ID_On_Open_Gate_War( curPlayer , 1 )

#        return

#    
#    RunQuestEvent(curPlayer, "on_open_gate_war", "on_open_gate_war", Def_RunQuestType_RunAll)

#    return

# 
# #城门活动结束触发任务事件

# def EventResponse_On_Close_Gate_War(curPlayer):

#    if not curPlayer.GetGameServerInitOK():

#        GameServerRefresh.Set_Mission_No_ID_On_Close_Gate_War( curPlayer , 1 )

#        return

#    
#    RunQuestEvent(curPlayer, "on_close_gate_war", "on_close_gate_war", Def_RunQuestType_RunAll)

#    return

# 
# #城门活动中登陆触发任务事件

# def EventResponse_On_Gate_War_Login(curPlayer):

#    RunQuestEvent(curPlayer, "on_gate_war_login", "on_gate_war_login", Def_RunQuestType_RunAll)

#    return

# 
# #城门活动后登陆触发任务事件

# def EventResponse_Not_Gate_War_Login(curPlayer):

#    RunQuestEvent(curPlayer, "not_gate_war_login", "not_gate_war_login", Def_RunQuestType_RunAll)

#    return

#===============================================================================

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

##任务触发器_OnGameEvent 跳舞钓鱼进度条结束后触发

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_OnGameEvent 跳舞钓鱼进度条结束后触发

def EventRespons_OnGameEvent(curPlayer):

    RunQuestEvent(curPlayer, "on_game_event", "on_game_event", Def_RunQuestType_Normal)

    return



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

##任务触发器_OnMap 玩家登陆地图

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_OnMap 玩家登陆地图

def EventResponse_OnMap(curPlayer):

    RunQuestEvent(curPlayer, "on_map", "on_map", Def_RunQuestType_Normal)

    return





##任务触发器_OnMapEx 玩家登陆地图

#@param curPlayer 玩家实例

#@return None

def EventResponse_OnMapEx(curPlayer):

    RunQuestEvent(curPlayer, "on_map_ex", "on_map_ex", Def_RunQuestType_RunAll)

    return



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

def EventResponse_Funcopen(curPlayer, funcID):

    ## 功能开启触发

    RunQuestEvent(curPlayer, "funcopen", funcID, Def_RunQuestType_RunAll)

    return



##任务触发器_LVUp 当玩家升级的时候触发

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_LVUp 当玩家升级的时候触发

def EventResponse_LVUp(curPlayer):

    #已接任务升级触发逻辑

    RunQuestEvent(curPlayer, "on_lv_up", "on_lv_up", Def_RunQuestType_Normal)

    
    #2010/5/18 LvUp触发由读取XML修改为读取配置表LvUpTrigMissionID

    #升级触发任务分2种: 1.添加任务并且触发任务XML逻辑，任务已存在则只触发XML逻辑

    #                2.不添加任务，如果任务存在才触发XML逻辑

    
    #{ 职业:{{等级:[ 触发任务ID列表] } }

    missionDist = ReadChConfig.GetEvalChConfig('LvUpTrigMissionID')

    #根据条件过滤字典

    missionJobDist = missionDist.get(curPlayer.GetJob())

    
    if not missionJobDist:

        #GameWorld.ErrLog('EventResponse_LVUp, job = %s'%(curPlayer.GetJob()), curPlayer.GetID())

        return

    
    missionIDList = missionJobDist.get(curPlayer.GetLV())

    
    if not missionIDList:

        #GameWorld.ErrLog('EventResponse_LVUp, lv = %s'%(curPlayer.GetLV()), curPlayer.GetID())

        
        # 升级只触发任务XML，不添加任务

        __LVUpNoAddMission(curPlayer)

        return

    
    #给予任务标志位

    isGiveMission = False

    
    for missionID in missionIDList:

        if curPlayer.FindMission(missionID):

            GameWorld.ErrLog('EventResponse_LVUp, hasSameMissionID = %s'%(missionID), curPlayer.GetID())

            continue

        
        isGiveMission = True

        
        #添加新任务给玩家

        addMission = QuestCommon.AddNewMission(curPlayer, missionID)

        NotifyOneMission(curPlayer, addMission)

    
    if isGiveMission:

        #LvUp_Get_Task <n color="0,255,0" BKCOLOR="0,0,0">等级提升,您有新的任务可接受!</n>

        PlayerControl.NotifyCode(curPlayer , "LvUp_Get_Task")

    
    RunQuestEvent(curPlayer, "on_lv_up", curPlayer.GetLV(), Def_RunQuestType_RunAll)

#===============================================================================

#    #能否触发城门活动

#    __IsGateWar(curPlayer)

#===============================================================================

    return True



## 升级只触发任务XML，不添加任务

#  @param curPlayer 玩家实例

#  @return None

def __LVUpNoAddMission(curPlayer):

    missionDist = ReadChConfig.GetEvalChConfig('LvUpTrigMissionNotAdd')

    #根据条件过滤字典

    lvTrigMissionList = missionDist.get(curPlayer.GetJob())

    
    if lvTrigMissionList == None:

        return

    
    if curPlayer.GetLV() not in lvTrigMissionList:

        return



    RunQuestEvent(curPlayer, "on_lv_up", curPlayer.GetLV(), Def_RunQuestType_RunAll)

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

##任务触发器_通用活动响应, 单个玩家

#@param curPlayer 玩家实例

#@param eventName 事件字典名

#@param fileID 事件XML文件名

#@return 返回值无意义

#@remarks 
def EventResponse_OnAction(curPlayer, eventName, fileID):

    RunQuestEvent(curPlayer, eventName, fileID, Def_RunQuestType_RunAll)

    return



##任务触发器_通用活动响应, 全服玩家

#@param eventName 事件字典名

#@param fileID 事件XML文件名

#@return 返回值无意义

#@remarks 
def EventResponse_OnActionAllMapPlayer(eventName, fileID):

    playerManager = GameWorld.GetPlayerManager()



    for i in range(0, playerManager.GetPlayerCount()):

        curPlayer = playerManager.GetPlayerByIndex(i)

        
        if not GameWorld.IsNormalPlayer(curPlayer):

            continue



        EventResponse_OnAction(curPlayer, eventName, fileID)



    return



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

##任务触发器_OnHalfHour 每半小时触发一次

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_OnHour 每小时触发一次

def EventResponse_OnHalfHour(curPlayer):

    RunQuestEvent(curPlayer, "on_halfhour", "on_halfhour", Def_RunQuestType_RunAll)

    return



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

##任务触发器_OnHour 每小时触发一次

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_OnHour 每小时触发一次

def EventResponse_OnHour(curPlayer):

    RunQuestEvent(curPlayer, "on_hour", "on_hour", Def_RunQuestType_RunAll)

    return



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

##任务触发器_OnDay 每天触发一次

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_OnDay 每天触发一次

def EventResponse_OnDay(curPlayer):

    RunQuestEvent(curPlayer, "on_day", "on_day", Def_RunQuestType_RunAll)

    RunQuestEvent(curPlayer, "on_day", "on_dayex", Def_RunQuestType_Normal)

    
    #清赏金任务奖励

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_RunTaskAwardState % QuestCommon.Def_Mission_Type_RunDaily, 0)

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_RunTaskAwardRecord % QuestCommon.Def_Mission_Type_RunDaily, 0)

    NotifyRunEndAward(curPlayer, QuestCommon.Def_Mission_Type_RunDaily)

    return



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

##任务触发器_OnWeek 每周触发一次

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_OnWeek 每周触发一次

def EventResponse_OnWeek(curPlayer):

    RunQuestEvent(curPlayer, "on_week", "on_week", Def_RunQuestType_RunAll)

    
    #清仙盟任务奖励

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_RunTaskAwardState % QuestCommon.Def_Mission_Type_RunFamily, 0)

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_RunTaskAwardRecord % QuestCommon.Def_Mission_Type_RunFamily, 0)

    NotifyRunEndAward(curPlayer, QuestCommon.Def_Mission_Type_RunFamily)

    return



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

##任务触发器_OnLeaveFamily 玩家离开家族触发( 自动/被动 )

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_OnLeaveFamily 玩家离开家族触发( 自动/被动 )

def EventResponse_OnLeaveFamily(curPlayer):

    if not curPlayer.GetGameServerInitOK():

        GameServerRefresh.Set_Mission_No_ID_OnLeaveFamily(curPlayer , 1)

        return

    
    RunQuestEvent(curPlayer, "on_leave_family", "on_leave_family", Def_RunQuestType_RunAll)

    return



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

##任务触发器_OnMemberChange 家族长变更

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_OnMemberChange 家族长变更

def EventResponse_OnMemberChange(curPlayer):

    if not curPlayer.GetGameServerInitOK():

        GameServerRefresh.Set_Mission_No_ID_OnMemberChange(curPlayer , 1)

        return

    
    GameWorld.Log('EventResponse_OnMemberChange' , curPlayer.GetID())

    RunQuestEvent(curPlayer, 'on_member_change', 'on_member_change', Def_RunQuestType_RunAll)

    return



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

##任务触发器_OnFamily 进入家族

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_OnFamily 进入家族

def EventResponse_OnFamily(curPlayer):

    RunQuestEvent(curPlayer, "on_family", "on_family", Def_RunQuestType_RunAll)

    return



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

##任务触发器_OnCreateFamily 创建家族

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_OnCreateFamily 创建家族

def EventResponse_OnCreateFamily(curPlayer):

    RunQuestEvent(curPlayer, "on_create_family", "on_create_family", Def_RunQuestType_RunAll)

    return



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

##任务触发器_OnFamilyAdd 加入家族

#@param curPlayer 玩家实例

#@return 返回值无意义

def EventResponse_OnFamilyAdd(curPlayer):

    RunQuestEvent(curPlayer, "on_add_family", "on_add_family", Def_RunQuestType_Normal)

    return



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

##任务触发器_OnFamilyLVUp 家族升级

#@param curPlayer 玩家实例

#@return 返回值无意义

def EventResponse_OnFamilyLVUp(curPlayer):

    RunQuestEvent(curPlayer, "on_lv_up_family", "on_lv_up_family", Def_RunQuestType_RunAll)

    return



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

##任务触发器_OnLeaveMap 离开地图

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_OnLeaveMap 离开地图

def EventResponse_OnLeaveMap(curPlayer):

    RunQuestEvent(curPlayer, "on_leave_map", "on_leave_map", Def_RunQuestType_Normal)

    return

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

##任务触发器_OnFBTimeOut 副本时间结束

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_OnFBTimeOut 副本时间结束

def EventResponse_OnFBTimeOut(curPlayer):

    RunQuestEvent(curPlayer, "on_fb_timeout", "on_fb_timeout", Def_RunQuestType_Normal)

    return



#===============================================================================

# #攻击城门事件触发

# def EventResponse_OnAttackGate(curPlayer):

#    RunQuestEvent(curPlayer, "on_attack_gate", "on_attack_gate", Def_RunQuestType_Normal)

#    return

#===============================================================================

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

##任务触发器_OnKillEnemy 击杀玩家事件触发

#@param attackPlayer 攻击者

#@param deadPlayer 死亡的玩家

#@return 返回值无意义

#@remarks 任务触发器_OnKillEnemy 击杀玩家事件触发

def EventResponse_OnKillEnemy(attackPlayer, deadPlayer):

    RunQuestEvent(attackPlayer, "on_kill_enemy", "on_kill_enemy", Def_RunQuestType_Normal)

    return



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

##任务触发器_OnEnemyKill 被玩家击杀事件触发

#@param deadPlayer 死亡的玩家

#@param attackPlayer 攻击者

#@return 返回值无意义

#@remarks 任务触发器_OnEnemyKill 被玩家击杀事件触发

def EventResponse_OnEnemyKill(deadPlayer, attackPlayer):

    RunQuestEvent(deadPlayer, "on_enemy_kill", "on_enemy_kill", Def_RunQuestType_Normal)

    return





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

##任务触发器vip等级改变

#@param curPlayer 玩家

#@return 返回值无意义

#@remarks 任务触发器vip等级改变触发

def EventResponse_OnVipLvUp(curPlayer, vipLV):

    RunQuestEvent(curPlayer, "on_viplv_up", vipLV, Def_RunQuestType_RunAll)

    return



##任务触发器购买vip礼包

#@param curPlayer 玩家

#@return 返回值无意义

#@remarks 任务触发器vip等级改变触发

def EventResponse_BuyVIPItem(curPlayer, vipLV):

    RunQuestEvent(curPlayer, "buyvipitem", "buyvipitem", Def_RunQuestType_Normal)

    return



def EventResponse_MineAreaPull(curPlayer, isRob):

    ## 福地采集物品

    RunQuestEvent(curPlayer, "minearea_pull", "rob" if isRob else "self", Def_RunQuestType_Normal)

    RunQuestEvent(curPlayer, "minearea_pull", 0, Def_RunQuestType_Normal)

    return



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

##任务触发器_Active 已经无使用了

#@param curPlayer 玩家实例

#@param typeName 类型

#@param missionID 任务ID

#@return 返回值无意义

#@remarks 任务触发器_Active 已经无使用了

def __EventResponse_Active(curPlayer, typeName, missionID):

    eventName = typeName

    fileID = typeName

    QuestsEvent = QuestManager.GetAllQuestsEvents()

    key = (eventName, "%s.xml"%str(fileID))

    if not QuestsEvent.has_key(key) :

        return False

    
    curQuestList = QuestsEvent[key]

    if len(curQuestList) == 0:

        GameWorld.Log("%s 没有触发!"%str(key) , curPlayer.GetPlayerID())

        return

    
    for event in curQuestList:

        questID = event[0]

        if questID != missionID:

            continue



        #GameWorld.Log("玩家触发任务: %s  - %d"%(str(key), questID) , curPlayer.GetPlayerID())    
        #运行所有节点

        QuestRunner.RunAllQuest(curPlayer, questID, event[1].GetXMLEventLoader().GetNodeList())

        break



    return



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

##触发单个他人发布的任务

#@param curPlayer 玩家实例

#@param curMissionPub 发布的任务数据

#@return 返回值无意义

#@remarks 自定义函数:触发单个他人发布的任务

def CheckTrigMissionPub(curPlayer, curMissionPub):

    missionID = curMissionPub.GetMissionID()

    if curPlayer.FindMission(missionID):

        #玩家有这个任务

        return

    
    missinoPubType = curMissionPub.GetMissinoPubType()

    
    #检查触发任务发布

    if missinoPubType == IPY_GameWorld.mptFamily:

        #家族发布

        if curPlayer.GetFamilyID() == 0:

            return

        
        if curPlayer.GetFamilyID() != curMissionPub.GetPubID():

            return 
        
        EventResponse_OnMissionPub(curPlayer, missionID)

        
    elif missinoPubType == IPY_GameWorld.mptCountry:

        #家族发布

        if curPlayer.GetCountry() != curMissionPub.GetPubID():

            return 
        
        EventResponse_OnMissionPub(curPlayer, missionID)

        
    return



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

##任务触发器_OnMissionPub 他人发布任务

#@param curPlayer 玩家实例

#@param missionID 任务ID

#@return 返回值无意义

#@remarks 任务触发器_OnMissionPub 他人发布任务

def EventResponse_OnMissionPub(curPlayer, missionID):

    if not curPlayer.GetGameServerInitOK():

        GameServerRefresh.Set_Mission_Have_ID_OnMissionPub(curPlayer , missionID)

        return

    
    RunQuestEvent(curPlayer, 'on_pub', missionID, Def_RunQuestType_RunAll)

    return



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

##任务触发器_OnActive 触发GM开关任务

#@param curPlayer 玩家实例

#@param missionID 任务ID

#@return 返回值无意义

#@remarks 任务触发器_OnActive 触发GM开关任务

def EventResponse_OnActive(curPlayer, missionID):

    if not curPlayer.GetGameServerInitOK():

        GameServerRefresh.Set_Mission_Have_ID_OnActive(curPlayer , missionID)

        return

    
    RunQuestEvent(curPlayer, 'on_active', missionID, Def_RunQuestType_RunAll)

    return



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

##任务触发器_OnDeActive 关闭GM开关任务

#@param curPlayer 玩家实例

#@param missionID 任务ID

#@return 返回值无意义

#@remarks 任务触发器_OnDeActive 关闭GM开关任务

def EventResponse_OnDeActive(curPlayer, missionID):

    if not curPlayer.GetGameServerInitOK():

        GameServerRefresh.Set_Mission_Have_ID_OnDeActive(curPlayer , missionID)

        return

    
    RunQuestEvent(curPlayer, 'on_deactive', missionID, Def_RunQuestType_RunAll)

    return





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

##任务触发器_OnDig 挖宝进度条结束后触发

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_OnDig 挖宝进度条结束后触发

def EventResponse_OnDig(curPlayer):    
    #玩家挖地触发

    QuestRunner.InitTreasureNotifyContentList()

    #GameWorld.Log("开始挖地")

    
    for i in range(0, curPlayer.GetMissionCount()):

        curMission = curPlayer.GetMissionByIndex(i)

        #这个任务已经做完了(-1)  或者   这个任务还没有接(0)

        if curMission.GetState() in [ChConfig.Def_Mission_State_NoAccept, ChConfig.Def_Mission_State_Over]:

            continue



        RunQuestEvent(curPlayer, "on_dig", curMission.GetMissionID(), Def_RunQuestType_Normal)

            
    treasureNotifyList = QuestRunner.GetTreasureNotifyContentList()

    #得到提示的最高等级

    minLV = 0

    minIndex = -1

    for i in range(0, len(treasureNotifyList)):

        if minLV == 0:

            minLV = treasureNotifyList[i].LV

            minIndex = i

            continue

        if treasureNotifyList[i].LV < minLV:

            minLV = treasureNotifyList[i].LV 
            minIndex = i

            
    if minIndex == -1:

        #没有挖宝任务

        curPlayer.Notify(0, "n")

        return

    
    missionID = treasureNotifyList[minIndex].MissionID

    #通知玩家

    curPlayer.Notify(missionID, treasureNotifyList[minIndex].Content)

    #curPlayer.NotifyMiddle(missionID, QuestRunner.TreasureNotifyContentList[minIndex].Content)            
    return



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

##任务触发器_LVFull 当前等级满级的时候触发

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 任务触发器_LVFull 当前等级满级的时候触发

def EventResponse_LVFull(curPlayer):

    #得到NPC的TypeID

    #运行on_visit目录下的[NPCTypeID].xml文件

    questID = curPlayer.GetLV() * 100

    
    return RunQuestEvent(curPlayer, "on_lv_full", questID, Def_RunQuestType_RunAll)



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

##任务触发器_MisCollectTime 询问是否可采集该NPC

#@param curPlayer 玩家实例

#@param curNPC NPC实例

#@return 返回值无意义

#@remarks 任务触发器_MisCollectTime 询问是否可采集该NPC

def EventRespons_MisCollectTime(curPlayer, curNPC):

    #得到NPC的TypeID

    npcTypeID = curNPC.GetNPCID()

    
    #GameWorld.Log("询问是否可采集该NPC, NPCID %d"%(npcTypeID))

    
    #运行on_coltime_by_id目录下的[NPCTypeID].xml文件

    RunQuestEvent(curPlayer, "on_coltime_by_id", npcTypeID, Def_RunQuestType_Normal)

    
    #跑环任务随机采集时，无NPCID 运行on_coltime_by_id目录下的0.xml文件

    RunQuestEvent(curPlayer, "on_coltime_by_id", 0, Def_RunQuestType_Normal)

    return



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

##任务触发器_MisCollectSuccess 采集进度条结束后触发

#@param curPlayer 玩家实例

#@param curNPC NPC实例

#@return 返回值无意义

#@remarks 任务触发器_MisCollectSuccess 采集进度条结束后触发

def EventRespons_MisCollectSuccess(curPlayer, curNPC):

    #得到NPC的TypeID

    npcTypeID = curNPC.GetNPCID()

    
    #GameWorld.Log("采集该NPC成功, NPCID %d"%(npcTypeID))

    
    #运行on_collect_by_id目录下的[NPCTypeID].xml文件

    RunQuestEvent(curPlayer, "on_collect_by_id", npcTypeID, Def_RunQuestType_Normal)

    
    #随机采集

    RunDayEvent(curPlayer, "on_collect_by_id", npcTypeID, QuestCommon.Def_Collect_Npc_ID)

    return



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

##任务触发器CatchPetOK, 抓宠成功.

# @param curPlayer 玩家实例

# @param curNPC NPC实例

# @return 返回值无意义

# @remarks 抓宠成功

def EventRespons_CatchPetOK(curPlayer, curNPC):

    #运行on_catch_pet_ok_by_id目录下的[NPCTypeID].xml文件

    #RunQuestEvent(curPlayer, "on_catch_pet_ok_by_id", curNPC.GetNPCID(), Def_RunQuestType_Normal)

    return



def EventRespons_LearnSkill(curPlayer, skillTypeID):

    # 学习技能

    RunQuestEvent(curPlayer, "on_learnskill", skillTypeID, Def_RunQuestType_Normal)

    return



##任务触发器 跑环任务触发下一个跑环任务触发相关事件

# @param curPlayer 玩家实例

# @param missionID 下一个跑环任务ID

# @return 返回值无意义

# @remarks 任务触发器 跑环任务触发下一个跑环任务触发相关事件

def EventRespons_SetRunAround(curPlayer, missionID):

    RunQuestEvent(curPlayer, "on_run_around", missionID, Def_RunQuestType_Normal)



##FB事件触发

# @param curPlayer 玩家实例

# @param eventName 事件名

# @return 返回值无意义

def EventRespons_FBEvent(curPlayer, eventName):

    RunQuestEvent(curPlayer, "fb_event", eventName, Def_RunQuestType_Normal)





##添加好友成功触发

# @param curPlayer 玩家实例

# @param eventName 事件名

# @return 返回值无意义

def EventRespons_AddFriendSucceed(curPlayer, eventName):

    RunQuestEvent(curPlayer, "add_friend_succeed", eventName, Def_RunQuestType_Normal)

    return





##buff消失触发

# @param curPlayer 玩家实例

# @param eventName 事件名

# @return 返回值无意义

def EventRespons_BuffDisappear(curPlayer, eventName):

    RunQuestEvent(curPlayer, "buff_disappear", eventName, Def_RunQuestType_Normal)

    return





##秒cd触发

# @param curPlayer 玩家实例

# @param eventName 事件名

# @return 返回值无意义

def EventRespons_ClearCDTime(curPlayer, eventName):

    RunQuestEvent(curPlayer, "clear_cd_time", eventName, Def_RunQuestType_Normal)

    return





##冲穴

# @param curPlayer 玩家实例

# @param eventName 事件名

# @return 返回值无意义

def EventRespons_OpenXueWei(curPlayer, eventName):

    RunQuestEvent(curPlayer, "open_xuewei", eventName, Def_RunQuestType_Normal)

    return





##玩家事件

# @param curPlayer 玩家实例

# @param eventName 事件名

# @return 返回值无意义

def EventRespons_PlayerEvent(curPlayer, eventName):

    RunQuestEvent(curPlayer, "player_event", eventName, Def_RunQuestType_Normal)

    return





##使用远程功能事件

# @param curPlayer 玩家实例

# @param eventName 事件名

# @return 返回值无意义

def EventRespons_DirectFuncEvent(curPlayer, eventName):

    RunQuestEvent(curPlayer, "direct_event", eventName, Def_RunQuestType_Normal)

    return





##官职(威望)相关触发

# @param curPlayer 玩家实例

# @param eventName 事件名

# @return 返回值无意义

def EventRespons_PlayerPrestige(curPlayer, eventName):

    RunQuestEvent(curPlayer, "player_prestige", eventName, Def_RunQuestType_Normal)

    return



## 商店购买物品触发

#  @param curPlayer 玩家实例

#  @param itemID 物品ID

#  @param itemCnt 物品数量

#  @return None

def EventRespons_BuyItem(curPlayer, itemID, itemCnt):

    curPlayer.SetDict(ChConfig.Def_PlayerKey_BuyItemCnt, itemCnt)

    RunQuestEvent(curPlayer, "buy_item", "buy_item_%s"%itemID, Def_RunQuestType_Normal)

    return



## NPC死亡摸怪逻辑

#  @param curPlayer 玩家实例

#  @param curNPC npc实例

#  @return None

def EventRespons_OnKillByFeel(curPlayer, curNPC):

    
    #得到NPC的TypeID

    npcTypeID = curNPC.GetNPCID()

    
    #运行on_kill_by_feel目录下的[NPCTypeID].xml文件

    QuestRunner.SetKillNPC(curNPC)

    
    RunQuestEvent(curPlayer, "on_kill_by_feel", npcTypeID, Def_RunQuestType_Normal)

    
    #触发每日任务杀怪

    RunDayEvent(curPlayer, "on_kill_by_feel", npcTypeID, QuestCommon.Def_Kill_Npc_ID)

    EventRespons_OnKillByLv(curPlayer, curNPC)

    return



## 完成任务

#  @param curPlayer 玩家实例

#  @param taskID 任务id

#  @param rewardPer 奖励倍值百分比, 如150为1.5倍奖励

#  @return None

def EventRespons_OnFinishTask(curPlayer, taskID, rewardPer=100):

    curMission = curPlayer.FindMission(taskID)

    if curMission == None:

        GameWorld.ErrLog("玩家无该任务: %s" % taskID, curPlayer.GetPlayerID())

        return

    
    missionState = curMission.GetState()

    
    if missionState != ChConfig.Def_Mission_State_CanComplete:

        GameWorld.DebugLog("任务状态(%s)不可提交，不能完成任务！taskID=%s" % (missionState, taskID))

        return

    
    curQuestData = QuestManager.FindQuest(taskID)

    
    rewardPer = 100 if rewardPer <= 0 else rewardPer

    moneyType, moneyCnt = 0, 0

    # 环任务支持多倍奖励领取

    if curQuestData != None and curQuestData.Type in QuestCommon.Def_RunTask_Type_List:

        if rewardPer != 100:

            rewardCostDict = ReadChConfig.GetEvalChConfig("RunAround_MulRewardCost")

            if rewardPer not in rewardCostDict:

                GameWorld.ErrLog("不支持该多倍奖励比例: taskID=%s,rewardPer=%s" % (taskID, rewardPer), curPlayer.GetPlayerID())

                return

            
            moneyType, moneyCnt = rewardCostDict[rewardPer]

            if not PlayerControl.HaveMoney(curPlayer, moneyType, moneyCnt):

                return

            
        curMission.SetProperty(QuestRunner.Def_Task_Reward_Per, rewardPer, False)

    
    isOK = RunQuestEvent(curPlayer, "on_finish", taskID, Def_RunQuestType_Normal)

    
    if not isOK:

        GameWorld.DebugLog("OnFinishTask 失败！")

        return

    
    if moneyCnt > 0:

        PlayerControl.PayMoney(curPlayer, moneyType, moneyCnt, ChConfig.Def_Cost_MissionDel, 
                               {"taskID":taskID, "rewardPer":rewardPer, ChConfig.Def_Cost_Reason_SonKey:taskID})

    return



## 快速完成任务

#  @param curPlayer 玩家实例

#  @param missionID 任务id

#  @return None

def EventRespons_OnQuickFinishTask(curPlayer, missionID):

    RunQuestEvent(curPlayer, "quick_finish_task", missionID, Def_RunQuestType_Normal)

    return



## 一键完成所有环任务

#  @param curPlayer 玩家实例

#  @param missionID 任务id

#  @return None

def EventRespons_OnQuickFinishAllAround(curPlayer, missionID):

    RunQuestEvent(curPlayer, "on_quick_finish_all_around", missionID, Def_RunQuestType_Normal)

    return



## 设置任务星级

#  @param curPlayer 玩家实例

#  @param missionID 任务id

#  @return None

def EventRespons_OnSetMissionStar(curPlayer, missionID):

    RunQuestEvent(curPlayer, "on_set_mission_star", missionID, Def_RunQuestType_Normal)

    return



## 收获果实

#  @param curPlayer 玩家实例

#  @param eventName 
#  @return None

def EventRespons_OnPlantHarvest(curPlayer, eventName):

    RunQuestEvent(curPlayer, "on_plant_harvest", eventName, Def_RunQuestType_Normal)

    return



## 副本采集NPC

#  @param curPlayer 玩家实例

#  @param eventName 
#  @return None

def EventRespons_OnFBCollect(curPlayer, eventName):

    RunQuestEvent(curPlayer, "on_fb_collect", eventName, Def_RunQuestType_Normal)

    return



## 购买日常任务次数上限

#  @param curPlayer 玩家实例

#  @param eventName 
#  @return None

def EventRespons_OnBuyDayMissionSum(curPlayer, buyNum):

    RunQuestEvent(curPlayer, "on_buy_mission_sum", buyNum, Def_RunQuestType_RunAll)

    return





## 穿装备触发判断所穿橙装数量

#  @param curPlayer 玩家实例

#  @param eventName 
#  @return None

def EventRespons_OrangeQualityCnt(curPlayer, equipcnt):

    RunQuestEvent(curPlayer, "quality_orange_cnt", equipcnt, Def_RunQuestType_Normal)

    return



## 部位强化星级

#  @param curPlayer 玩家实例

#  @param eventName 
#  @return None

def EventRespons_OnEquipPartStarUp(curPlayer, upstar):

    RunQuestEvent(curPlayer, "on_equippartstarup", "on_equippartstarup", Def_RunQuestType_Normal)

    return



## 爵位升阶

#  @param curPlayer 玩家实例

#  @param eventName

#  @return None

def EventRespons_OnOfficialUp(curPlayer, officialLV, starIndex):

    #星级*100+阶级

    RunQuestEvent(curPlayer, "on_officialup", starIndex*100+officialLV, Def_RunQuestType_Normal)

    return



## 通关试炼之塔第X层

#  @param curPlayer 玩家实例

#  @param eventName 
#  @return None

def EventRespons_TrialTowerCnt(curPlayer, cnt):

    RunQuestEvent(curPlayer, "on_trialtowercnt", cnt, Def_RunQuestType_Normal)

    return



## 通关天星塔第X层

#  @param curPlayer 玩家实例

#  @param eventName 
#  @return None

def EventRespons_SkyTowerCnt(curPlayer, cnt):

    RunQuestEvent(curPlayer, "skytowerpass", cnt, Def_RunQuestType_Normal)

    return



##护送X次美女 
# @param curPlayer 玩家实例

# @param eventName 事件名

# @return 返回值无意义

def EventRespons_TruckCnt(curPlayer):

    RunQuestEvent(curPlayer, "on_truckcnt", "on_truckcnt", Def_RunQuestType_Normal)

    
##分解任意X件橙装 
# @param curPlayer 玩家实例

# @param eventName 事件名

# @return 返回值无意义

def EventRespons_EquipDecompose(curPlayer):

    RunQuestEvent(curPlayer, "on_equipdecompose", "on_equipdecompose", Def_RunQuestType_Normal)

    return

    
def EventRespons_OnBuyNobleVIP(curPlayer, nobleType):

    # 购买贵族

    RunQuestEvent(curPlayer, "on_buy_noblevip", "on_buy_noblevip", Def_RunQuestType_Normal)

    RunQuestEvent(curPlayer, "on_buy_noblevip", nobleType, Def_RunQuestType_Normal)

    return

    
def EventRespons_OnGoldInvest(curPlayer, investType):

    # 绑钻投资

    RunQuestEvent(curPlayer, "on_goldinvest", "on_goldinvest", Def_RunQuestType_Normal)

    RunQuestEvent(curPlayer, "on_goldinvest", investType, Def_RunQuestType_Normal)

    return



def EventRespons_OnActivatePet(curPlayer, petID):

    # 激活宠物

    RunQuestEvent(curPlayer, "on_activatepet", "on_activatepet", Def_RunQuestType_Normal)

    RunQuestEvent(curPlayer, "on_activatepet", petID, Def_RunQuestType_Normal)

    return



def EventRespons_MagicWeaponLV(curPlayer, mwID, lv):

    # 法宝解锁进度

    RunQuestEvent(curPlayer, "magicweaponlv", '%s_%s'%(mwID, lv), Def_RunQuestType_RunAll)

    return



def EventRespons_MagicWeaponFBPassLV(curPlayer, mwID, lv):

    # 魔族法宝关卡进度

    RunQuestEvent(curPlayer, "mwfbpasslv", '%s_%s'%(mwID, lv), Def_RunQuestType_Normal)

    return



def EventRespons_SuccessFinish(curPlayer, succID):

    # 领取完成就

    RunQuestEvent(curPlayer, "successfinish", succID, Def_RunQuestType_RunAll)

    return



def EventRespons_KillWorldBoss(curPlayer):

    # 击杀世界BOSS

    RunQuestEvent(curPlayer, "killworldboss", 'killworldboss', Def_RunQuestType_Normal)

    return



def EventRespons_KillWorldBossByFeel(curPlayer):

    #摸世界BOSS

    RunQuestEvent(curPlayer, "killworldbossbyfeel", 'killworldbossbyfeel', Def_RunQuestType_Normal)

    return



def EventRespons_KillBoss(curPlayer, indexMark):

    # 击杀BOSS

    RunQuestEvent(curPlayer, "killboss", indexMark, Def_RunQuestType_Normal)

    return



def EventRespons_SealDemon(curPlayer):

    # 获得封魔坛110级以上BOSS伤害排名第一

    RunQuestEvent(curPlayer, "sealdemon", "sealdemon", Def_RunQuestType_Normal)

    return



def EventRespons_HorseMultiple(curPlayer, multiple):

    #坐骑喂养X倍暴击一次

    RunQuestEvent(curPlayer, "horsemultiple", multiple, Def_RunQuestType_Normal)

    return



def EventRespons_HorseLV(curPlayer, horselv):

    #任意坐骑到X级

    RunQuestEvent(curPlayer, "horselv", horselv, Def_RunQuestType_Normal)

    return



def EventRespons_FBEncourage(curPlayer, mapid):

    #副本鼓舞几次

    RunQuestEvent(curPlayer, "fbencourage", mapid, Def_RunQuestType_Normal)

    return



def EventRespons_AddFriend(curPlayer, cnt):

    #好友数量

    RunQuestEvent(curPlayer, "addfriend", cnt, Def_RunQuestType_Normal)

    return



def EventRespons_DujieFBHelp(curPlayer):

    #仙盟护法

    RunQuestEvent(curPlayer, "dujiehelp", "dujiehelp", Def_RunQuestType_Normal)

    return



def EventRespons_DujieFBHelpPass(curPlayer):

    #渡劫助战

    RunQuestEvent(curPlayer, "dujiehelppass", "dujiehelppass", Def_RunQuestType_Normal)

    return



def EventRespons_PassiveSet(curPlayer):

    #被动技能设置

    RunQuestEvent(curPlayer, "passiveset", "passiveset", Def_RunQuestType_Normal)

    return



def EventRespons_PlusGodWeapon(curPlayer, weaponType):

    #神兵锤炼

    RunQuestEvent(curPlayer, "plusgodweapon", "plusgodweapon", Def_RunQuestType_Normal)

    RunQuestEvent(curPlayer, "plusgodweapon", weaponType, Def_RunQuestType_Normal)

    return

def EventRespons_GodWeaponUp(curPlayer, weaponType, attrLV):

    # 神兵升级

    RunQuestEvent(curPlayer, "godweaponup", "%s_%s"%(weaponType, attrLV), Def_RunQuestType_Normal)

    return



def EventRespons_RefineItem(curPlayer, alchemyLV, alchemyItemID):

    #八卦炉炼丹

    #这两个接口策划暂时不用，先注释，使用新的连某个丹药接口

    #RunQuestEvent(curPlayer, "refineitem", alchemyLV, Def_RunQuestType_Normal)

    #RunQuestEvent(curPlayer, "refineitem", "refineitem", Def_RunQuestType_Normal)

    RunQuestEvent(curPlayer, "refineitem", alchemyItemID, Def_RunQuestType_Normal)

    return



def EventRespons_RefineStoveUp(curPlayer, alchemyLV):

    #八卦炉升至X级

    RunQuestEvent(curPlayer, "refinestoveup", alchemyLV, Def_RunQuestType_RunAll)

    return



def EventRespons_GetRealmPoint(curPlayer):

    #获得修行点

    RunQuestEvent(curPlayer, "getrealmpoint", "getrealmpoint", Def_RunQuestType_Normal)

    return



def EventRespons_MWSkillUp(curPlayer):

    #法宝技能升级

    RunQuestEvent(curPlayer, "mwskillup", "mwskillup", Def_RunQuestType_Normal)

    return



def EventRespons_ShopBuy(curPlayer, shopid):

    #指定商店买东西

    RunQuestEvent(curPlayer, "shopbuy", shopid, Def_RunQuestType_Normal)

    return



def EventRespons_GetLastRunTaskAward(curPlayer, taskType):

    #跑环最终奖励领取

    RunQuestEvent(curPlayer, "on_lastruntask_award", taskType, Def_RunQuestType_Normal)

    return



def EventRespons_RunTaskAllCnt(curPlayer, tastType, allcnt):

    #当天已完成跑环数

    RunQuestEvent(curPlayer, "runtaskallcnt", '%s_%s'%(tastType, allcnt), Def_RunQuestType_Normal)

    return



def EventRespons_RealmUp(curPlayer, realmlv):

    #境界升级

    RunQuestEvent(curPlayer, "realmup", realmlv, Def_RunQuestType_RunAll)

    return



def EventRespons_RealmXXZLAward(curPlayer, taskID):

    #境界修仙之路完成任务

    RunQuestEvent(curPlayer, "realmxxzlaward", taskID, Def_RunQuestType_RunAll)

    return



def EventRespons_PassQueenRelecs(curPlayer, lineID, grade):

    #X级通关X层娲皇遗迹

    RunQuestEvent(curPlayer, "passqueenrelecs", '%s_%s'%(lineID, grade), Def_RunQuestType_Normal)

    return



def EventRespons_HorseUp(curPlayer):

    #坐骑升级

    RunQuestEvent(curPlayer, "horseup", "horseup", Def_RunQuestType_Normal)

    return



def EventRespons_SuitPlus(curPlayer, cnt):

    #2阶强化防具套装X件

    RunQuestEvent(curPlayer, "suitplus", cnt, Def_RunQuestType_Normal)

    return



def EventRespons_TrialExchange(curPlayer, costItemID):

    #宗门试炼兑换装备

    RunQuestEvent(curPlayer, "trialexange", costItemID, Def_RunQuestType_Normal)

    return



def EventRespons_EquipByPlace(curPlayer, itemClassLV, equipplace):

    #穿戴某部位装备(非时效)

    RunQuestEvent(curPlayer, "equipbyplace", '%s_%s'%(itemClassLV, equipplace), Def_RunQuestType_Normal)

    return



def EventRespons_CompoundEquip(curPlayer, itemColor, itemQuality):

    #装备合成某品质某星级

    RunQuestEvent(curPlayer, "compoundequip", '%s_%s'%(itemColor, itemQuality), Def_RunQuestType_Normal)

    return



def EventRespons_EquipWash(curPlayer, washType, washLV):

    #装备洗练至X级

    RunQuestEvent(curPlayer, "equipwash", '%s_%s'%(washType, washLV), Def_RunQuestType_Normal)

    return



def EventRespons_AddBourseItem(curPlayer):

    #上架集市物品

    RunQuestEvent(curPlayer, "addbourseitem", "addbourseitem", Def_RunQuestType_Normal)

    return



def EventRespons_StoreDonate(curPlayer):

    #捐献仙盟装备

    RunQuestEvent(curPlayer, "storedonate", "storedonate", Def_RunQuestType_Normal)

    return



def EventRespons_EquipPlus(curPlayer, classLV, partPlusLV):

    #强化等级变化

    RunQuestEvent(curPlayer, "equipplus", "equipplus", Def_RunQuestType_Normal)

    RunQuestEvent(curPlayer, "equipplus", '%s_%s'%(classLV, partPlusLV), Def_RunQuestType_Normal)

    return



def EventRespons_EquipPlusEvolve(curPlayer, nextEvolveLV):

    #强化进化

    RunQuestEvent(curPlayer, "equipplusevolve", "equipplusevolve", Def_RunQuestType_Normal)

    return



def EventRespons_Talk(curPlayer, eventName):

    #频道发言

    RunQuestEvent(curPlayer, "talk", eventName, Def_RunQuestType_Normal)

    return



def EventRespons_FairyDomain(curPlayer, eventType):

    #完成缥缈仙域事件

    RunQuestEvent(curPlayer, "fairydomain", 'fairydomain', Def_RunQuestType_Normal)

    RunQuestEvent(curPlayer, "fairydomain", eventType, Def_RunQuestType_Normal)

    return



def EventRespons_AroundMission(curPlayer, missionType):

    #完成跑环任务

    RunQuestEvent(curPlayer, "aroundfinish", missionType, Def_RunQuestType_Normal)

    return



def EventRespons_Pray(curPlayer, prayType):

    #完成祈愿

    RunQuestEvent(curPlayer, "pray", prayType, Def_RunQuestType_Normal)

    return



def EventRespons_ThinkMagicWeapon(curPlayer):

    #感应法宝

    RunQuestEvent(curPlayer, "thinkfabao", 'thinkfabao', Def_RunQuestType_Normal)

    return



def EventRespons_ElementSkill(curPlayer, mainSkillID, skillElementType, updSelectSkillLV):

    #激活五行专精 主技能ID_专精类型_激活等级.xml

    RunQuestEvent(curPlayer, "elementskill", '%s_%s_%s'%(mainSkillID, skillElementType, updSelectSkillLV), Def_RunQuestType_Normal)

    return



def EventRespons_EquipStarUp(curPlayer):

    #装备升星

    RunQuestEvent(curPlayer, "equipstarup", 'equipstarup', Def_RunQuestType_Normal)

    return



def EventRespons_InlayStone(curPlayer):

    #宝石镶嵌

    RunQuestEvent(curPlayer, "inlaystone", 'inlaystone', Def_RunQuestType_Normal)

    return



def EventRespons_StoneChange(curPlayer):

    # 宝石变更

    RunQuestEvent(curPlayer, "stonechange", 'stonechange', Def_RunQuestType_Normal)

    return



def EventRespons_EquipItem(curPlayer):

    #穿脱装备

    RunQuestEvent(curPlayer, "equipitem", 'equipitem', Def_RunQuestType_Normal)

    return



def EventRespons_SkillUp(curPlayer, FuncType, skillLV):

    #升级技能

    RunQuestEvent(curPlayer, "skillup", FuncType, Def_RunQuestType_Normal)

    RunQuestEvent(curPlayer, "skillup", '%s_%s' % (FuncType, skillLV), Def_RunQuestType_Normal)

    return



def EventRespons_LingGenQualityUP(curPlayer, attrID, qualityLV):

    #灵根升品

    RunQuestEvent(curPlayer, "linggenqualityup", '%s_%s' % (attrID, qualityLV), Def_RunQuestType_Normal)

    return



def EventRespons_AddPoint(curPlayer):

    #灵根加点

    RunQuestEvent(curPlayer, "addpoint", '0', Def_RunQuestType_Normal)

    return



def EventRespons_ActivityAward(curPlayer, awardIndex):

    #活跃领奖

    RunQuestEvent(curPlayer, "activityaward", awardIndex, Def_RunQuestType_Normal)

    return



def EventRespons_AddActivityValue(curPlayer):

    # 增加活跃度

    RunQuestEvent(curPlayer, "addactivity", "addactivity", Def_RunQuestType_Normal)

    return



def EventRespons_HorsePetBoss(curPlayer):

    #参加骑宠BOSS

    RunQuestEvent(curPlayer, "horsepetboss", 'horsepetboss', Def_RunQuestType_Normal)

    return



def EventRespons_LingGenReset(curPlayer):

    #灵根重置

    RunQuestEvent(curPlayer, "linggenreset", 'linggenreset', Def_RunQuestType_Normal)

    return



def EventRespons_UseMissionItem(curPlayer, missionID):

    # 使用物品触发任务

    RunQuestEvent(curPlayer, "usemissionitem", missionID, Def_RunQuestType_RunAll)

    return



def EventRespons_XBXZ(curPlayer, MWID):

    # 仙宝寻主领奖

    RunQuestEvent(curPlayer, "xbxz", MWID, Def_RunQuestType_Normal)

    return



def EventRespons_AddAuctionEquip(curPlayer, color):

    # 上架装备拍品

    RunQuestEvent(curPlayer, "addauctionequip", color, Def_RunQuestType_Normal)

    return



def EventRespons_BuyAuctionEquip(curPlayer, color):

    # 购买装备拍品

    RunQuestEvent(curPlayer, "buyauctionequip", color, Def_RunQuestType_Normal)

    return



def EventRespons_AddAuction(curPlayer):

    # 上架拍品

    RunQuestEvent(curPlayer, "addauction", 0, Def_RunQuestType_Normal)

    return



def EventRespons_BuyAuction(curPlayer):

    # 购买拍品

    RunQuestEvent(curPlayer, "buyauction", 0, Def_RunQuestType_Normal)

    return





def EventRespons_OnMoneyChange(curPlayer, moneyType):

    # 货币变更时

    
    # 暂开放灵石

    if moneyType not in [IPY_GameWorld.TYPE_Price_Gold_Paper]:

        return

    RunQuestEvent(curPlayer, "onmoneychange", moneyType, Def_RunQuestType_Normal)

    return



def EventRespons_ActivityPlace(curPlayer, event, runall=False):

    ''' 活跃放置事件

    @param event: 可启动 canstart、启动 start、可领奖 cangetreward、领奖 getreward

    '''

    RunQuestEvent(curPlayer, "activityplace", event, Def_RunQuestType_RunAll if runall else Def_RunQuestType_Normal)

    return



def EventRespons_ArenaBattleOver(curPlayer):

    # 挑战竞技场 - 结算才算

    RunQuestEvent(curPlayer, "arenabattleover", "arenabattleover", Def_RunQuestType_Normal)

    return



def EventRespons_ArenaHighestScore(curPlayer):

    # 刷新竞技场历史最高分

    RunQuestEvent(curPlayer, "arenahighestscore", "arenahighestscore", Def_RunQuestType_Normal)

    return



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



#================================================================================

#===============================================================================

# //08 07 玩家切换地图#tagCChangeMap

# tagCChangeMap       *   GettagCChangeMap();

# 
# class   IPY_CChangeMap

# {

# public:

#    //传送点ID

#    int      GetTransportID();

# };

#===============================================================================

##客户端封包响应//08 07 玩家切换地图#tagCChangeMap

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 07 玩家切换地图#tagCChangeMap

def ChangeMap(index, tick):

    GameWorld.GetPsycoFunc(__Func_ChangeMap)(index, tick)

    return



##客户端封包响应//08 07 玩家切换地图#tagCChangeMap

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 07 玩家切换地图#tagCChangeMap

def __Func_ChangeMap(index, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    changeMapPack = IPY_GameWorld.IPY_CChangeMap()

    
    if PlayerChangeMap(curPlayer, changeMapPack.GetTransportID(), tick):

        return

    
    #传送失败, 设置玩家可以移动

    curPlayer.SetCanMove(True)

    return

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

##玩家通过传送点, 传送地图

#@param curPlayer 玩家实例

#@param transportID 传送点ID

#@param tick 时间戳

#@return 布尔值

#@remarks 玩家通过传送点, 传送地图

def PlayerChangeMap(curPlayer, transportID, tick):

    transport = GameWorld.GetGameData().FindTransportByID(transportID)

    if transport == None:

        #GameWorld.Log("没有此切换点 = %s"%(transportID) , curPlayer.GetPlayerID())

        return False



    #切换地图坐标距离

    dist = GameWorld.GetDist(curPlayer.GetPosX(), curPlayer.GetPosY(), transport.GetPosX(), transport.GetPosY())

    #不在切换点范围内

    if dist > transport.GetRange() + 16:

#    if curPlayer.GetPosX() < transport.GetPosX()-dist or curPlayer.GetPosX() > transport.GetPosX()+dist or curPlayer.GetPosY() < transport.GetPosY()-dist or curPlayer.GetPosY() > transport.GetPosY()+dist:

        #GameWorld.Log("玩家不在切换点内" , curPlayer.GetPlayerID())

        curPlayer.ResetPos(curPlayer.GetPosX(), curPlayer.GetPosY())

        GameWorld.GodLog(curPlayer, '传送点距离过远 = %s, Range = %s'%(dist, transport.GetRange()))

        return False



    #在切换点范围内，切换地图

    mapID = transport.GetTargetMapID()

    targetPosX = transport.GetTargetPosX()

    targetPosY = transport.GetTargetPosY()

    
    if not PlayerControl.CanEnterMap(curPlayer, mapID):

        #玩家不可进入该场景

        return False



#    #添加有限无敌BUFF

#    SkillCommon.AddBuffBySkillType(curPlayer, ChConfig.Def_SkillID_LimitSuperBuff, tick)

    #2. 玩家切换地图（地图ID，X，Y）

    curTruck = curPlayer.GetTruck()

    if curTruck:

        isTakeTruck = curTruck.GetMode() != IPY_GameWorld.trmStop

    else:

        isTakeTruck = False

        
    PlayerControl.PlayerResetWorldPos(curPlayer, mapID, targetPosX, targetPosY, isTakeTruck, canLock = False)

    return True

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

#===============================================================================

# //08 0A 结束事件#tagCCancelEvent

# tagCCancelEvent       *   GettagCCancelEvent();

# 
# class   IPY_CCancelEvent

# {

# public:

# 
#    int      GetType();

# };

#===============================================================================

##客户端封包响应//08 0A 结束事件#tagCCancelEvent

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 0A 结束事件#tagCCancelEvent

def ExitEvent(index, tick):

    GameWorld.GetPsycoFunc(__Func_ExitEvent)(index, tick)

    return



##客户端封包响应//08 0A 结束事件#tagCCancelEvent

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 0A 结束事件#tagCCancelEvent

def __Func_ExitEvent(index, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    
    DoExitEvent(curPlayer)

    #副本离开事件

    FBLogic.OnExitEvent(curPlayer, tick)

    return

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

#把当前任务通知给客户端

#/**任务状态定义*/

#enum        TMissionState

#{

#    msNoMission = 0,    ///<未接

#    msProcessing,       ///<进行中

#    msCanComplete,      ///<可提交

#    msComplete,         ///<已完成

#    msFail,             ///<失败

#    msNoExist,          ///<骠车不存在

#};

#特殊任务状态定义: 
#0 : 未接

#-1: 已完成

#-2: 骠车丢失

#-3: 骠车被打烂

#-4: 任务未达到可接状态

#-5: 任务可提交

        
##刷新单独的任务

#@param curPlayer 玩家实例

#@param curMission 任务实例

#@param isFirstLogin 是否第一次登陆

#@return 返回值无意义

#@remarks 刷新单独的任务

def NotifyOneMission(curPlayer, curMission, isFirstLogin = False, isNotifyAll = True):

    #state = curMission.GetState()

    
    #通知任务字典

    if isNotifyAll:

        curMission.Notify_AllProperty()

    
    #新方式: 刷新这个

    QuestRunner.RefreshMission(curPlayer, curMission)

        
#    GameWorld.Log("state = %d"%state)

#    missionState = curMission.GetMissionState()

#    lastMissionState = missionState

#    taskID = curMission.GetMissionID()

#    
#    if QuestManager.FindQuest(taskID) == None:

#        GameWorld.Log("任务ID = %d 没有任务描述!"%taskID)

#        return

#

#    questData = QuestManager.FindQuest(taskID)

#    taskName = questData.Name

#    
#    if taskName == "":

#        #GameWorld.Log("任务名称 = 空")

#        return

#    
#    parentID = 0

#    if state == -1:

#        missionState = IPY_GameWorld.msComplete

#    if state == -4:

#        missionState = IPY_GameWorld.msNoExist

#        
#    if missionState == IPY_GameWorld.msNoMission and state != 0:

#        missionState = IPY_GameWorld.msProcessing

#        
#    curMission.SetMissionState(missionState)

#    
#    if questData.Type == 8 and state == 0:

#        #任务类型:8 为勇者任务(卷轴任务), 不通知给客户端

#        return

#    
#    
#    
#    if state == 0:

#        #状态等于0, 只显示灯

##        GameWorld.Log("状态等于0, 只显示灯")

#        QuestRunner.ShowMissionLight(curPlayer, curMission)

#        
#        #在任务查询中添加这个任务

#        QuestRunner.NotifyNewQuestInfo(curPlayer, curMission)

#        return

#    
#    if not isFirstLogin and lastMissionState == missionState:

#        #GameWorld.Log("lastMissionState = %d  curMissionState = %s"%(lastMissionState, missionState))

#        GameWorld.Log("玩家当前任务更新, 描述不变")

#        return

#    GameWorld.Log("玩家当前任务: %s, state = %d"%(taskName, state))

#    
#    
#    #if questData.Invisible == 0 or missionState !=:

#    #    #如果任务为隐藏任务, 则不显示给客户端看到

#    taskType = QuestManager.FindQuest(taskID).Type

#    curPlayer.NotifyTaskInfo(taskType, questData.NameCode, taskID, parentID, missionState)

#    
#        
#    if state == -1 or state == -4:

#        #任务ID为-1或者-4, 表示任务已经完成, 不需要进一步显示任务详细情况

#        curPlayer.Sync_ClearMapMissionLight(taskID)

#        return

#        
#

#    
#    #发送所有任务追踪信息

#    QuestRunner.ShowMissionInfo(curPlayer, curMission, -1)

#

#    #发送所有灯的信息

#    QuestRunner.ShowMissionLight(curPlayer, curMission)



#---------------------------------------------------------------------    
##把玩家当前的所有任务发送给客户端, 如果玩家是第一次登录, 把所有任务发给客户端   
#@param curPlayer 玩家实例

#@param isFirstLogin 是否第一次登陆

#@return 返回值无意义

#@remarks 把玩家当前的所有任务发送给客户端, 如果玩家是第一次登录, 把所有任务发给客户端   
def NotifyAllQuestDetail(curPlayer, isFirstLogin = False):

    notifyMissionList = []

    for i in range(0, curPlayer.GetMissionCount()):

        curMission = curPlayer.GetMissionByIndex(i)

        notifyMissionList.append(curMission)

    
    for curMission in notifyMissionList:

        #在通知任务的时候, 会删除任务, 所以要重建一次列表

        NotifyOneMission(curPlayer, curMission, isFirstLogin)

        
    return



#任务描述

#def GetTaskDetail(index, tick):

#    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

#    sendPack = IPY_GameWorld.IPY_CGetTaskDetail()

#    sendTaskID = sendPack.GetTaskID()

#    curTask = curPlayer.FindMission(sendTaskID)

#    if curTask == None:

#        GameWorld.Log("没有这个任务%d"%sendTaskID)

#        return 
#

#    descriptionIndex = 0

#    state = curTask.GetState()

#    questDescriptionList = QuestManager.FindQuest(sendTaskID).QuestDescriptionList

#    
#    rewardNode = None

#    if state == -1 or state ==0:

#        #任务已经完成/没有接， 没有奖励节点

#        descriptionIndex = len(questDescriptionList) - 1

#        questDescs = QuestManager.GetQuestDescriptions()

#        if questDescs.has_key(sendTaskID):

#            detail = questDescs[sendTaskID]

#    else:

#        descriptionIndex = curTask.GetDescriptionIndex()

#        #得到任务奖励, 拼接

#        rewardNode = QuestRunner.GetRewardNode(curPlayer, curTask)

#        #任务描述替换

#        detail = questDescriptionList[descriptionIndex].Msg 
#        if detail == "":

#            return

#        
#        
#        if rewardNode != None:

#            #任务描述与任务奖励替换

#            #detail = detail + QuestRunner.ReplaceNPCTalkText(curPlayer, curTask, rewardNode.FindChildNode("msg").GetXML())

#            detail = "%s %s"%(detail, rewardNode.FindChildNode("msg").GetAttribute("code"))

#    curPlayer.NotifyTaskDetail(sendPack.GetType(), curTask, detail)

#    return



#############################################################

##回绝装备加工封包

@@ -2421,55 +191,7 @@
        return

    

    return GameWorld.GetPsycoFunc(callFunc)(curPlayer, tick)

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

#    //08 11 特殊任务结果#tagEndSpecialEvent

#

#    struct  tagEndSpecialEvent

#    {

#        tagHead     Head;

#        BYTE        Type;       //1. 开始打造 2. 开始鉴定 3. ...

#    };

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

#===============================================================================

# //08 0B 打造物品#tagCMakeItem

# tagCMakeItem       *   GettagCMakeItem();

# 
# class   IPY_CMakeItem

# {

# public:

#    //打造的物品ID

#    int      GetMakeItemID();

# };

#===============================================================================

##客户端封包响应//08 0B 打造物品#tagCMakeItem

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 0B 打造物品#tagCMakeItem

def MakeItem(index, tick):

    return



#===============================================================================

# //08 19 打造装备#tagCBuildEquip

# int GetBuildID(); //打造ID

# int GetItem1Count(); //使用物品1个数

# int GetItem2Count(); //使用物品2个数

# int GetItem3Count(); //使用物品3个数

# int GetItem4Count(); //使用物品4个数

# int GetItem5Count(); //使用物品5个数

# int GetItem6Count(); //使用物品6个数

# int GetBuildMode(); //打造模式，目前有：默认，绑定，非绑定打造模式

#===============================================================================

##客户端封包响应//08 19 打造装备#tagCBuildEquip

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 19 打造装备#tagCBuildEquip

def BuildEquip(index, tick):

#    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

#    FuncDirectCall(curPlayer, "Func_102", "BuildEquip", tick)

    return

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

#===============================================================================

# //08 03 玩家购买物品#tagCBuyItemList

# tagCBuyItemList       *   GettagCBuyItemList();

@@ -2515,224 +237,9 @@
def BuyItemBack(index, clientPack, tick):

    #得到玩家的对象

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)



    FunctionNPCCommon.BuyItemBack(curPlayer, clientPack, tick)



    return





#===============================================================================

# //0E 04 玩家鉴定物品#tagCShopIdentifyItem

# tagCShopIdentifyItem       *   GettagCShopIdentifyItem();

# 
# class   IPY_CShopIdentifyItem

# {

# public:

# 
#    int      GetTYPE();

# };

#===============================================================================

##客户端封包响应//0E 04 玩家鉴定物品#tagCShopIdentifyItem

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0E 04 玩家鉴定物品#tagCShopIdentifyItem

def IdentifyItem(index, tick):

    return



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

#===============================================================================

# //12 01 打开信件#tagCOpenLetter

# tagCOpenLetter       *   GettagCOpenLetter();

# 
# class   IPY_COpenLetter

# {

# public:

#    //信件ID

#    char *      GetMailID();

# };

#===============================================================================

##客户端封包响应//12 01 打开信件#tagCOpenLetter

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//12 01 打开信件#tagCOpenLetter

def OpenLetter(index, tick):

    #curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    #FuncCall(curPlayer, "OpenLetter", tick)

    return



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

#===============================================================================

# //12 02 发送信件#tagCSendMail

# tagCSendMail       *   GettagCSendMail();

# 
# class   IPY_CSendMail

# {

# public:

#    //目标名称

#    char *      GetTagName();

#    //主题

#    char *      GetTitle();

# 
#    int      GetContentLen();

#    //size = ContentLen

#    char *      GetContent();

#    //银子

#    int      GetMoney();

#    //类型: TLetterType, 自己付费, 对方付费

#    int      GetLetterType();

#    //发送物品数量

#    int      GetItemCount();

#    //size = ItemCount

#    int      GetItem(int index);

# };

#===============================================================================

##客户端封包响应//12 02 发送信件#tagCSendMail

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//12 02 发送信件#tagCSendMail

def SendLetter(index, tick):

    #curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    #FuncCall(curPlayer, "SendLetter", tick)

    return



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

#===============================================================================

# //12 05 退信#tagCReturnMail

# tagCReturnMail       *   GettagCReturnMail();

# 
# class   IPY_CReturnMail

# {

# public:

# 
#    char *      GetMailID();

# };

#===============================================================================

##客户端封包响应//12 05 退信#tagCReturnMail

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//12 05 退信#tagCReturnMail

def ReturnLetter(index, tick):

    #curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    #FuncCall(curPlayer, "ReturnLetter", tick)

    return



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

#===============================================================================

# //12 06 删除信件#tagCDeleteMail

# tagCDeleteMail       *   GettagCDeleteMail();

# 
# class   IPY_CDeleteMail

# {

# public:

# 
#    char *      GetMailID();

# };

#===============================================================================

##客户端封包响应//12 06 删除信件#tagCDeleteMail

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//12 06 删除信件#tagCDeleteMail

def DeleteLetter(index, tick):

    #curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    #FuncCall(curPlayer, "DeleteLetter", tick)

    return



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

#===============================================================================

# //12 07 置为保存#tagCSaveMail

# tagCSaveMail       *   GettagCSaveMail();

# 
# class   IPY_CSaveMail

# {

# public:

# 
#    char *      GetMailID();

# };

#===============================================================================

##客户端封包响应//12 07 置为保存#tagCSaveMail

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//12 07 置为保存#tagCSaveMail

def SaveLetter(index, tick):

    #curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    #FuncCall(curPlayer, "SaveLetter", tick)

    return



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

#===============================================================================

# //12 03 提取信件的钱#tagCGetMailMoney

# tagCGetMailMoney       *   GettagCGetMailMoney();

# 
# class   IPY_CGetMailMoney

# {

# public:

# 
#    char *      GetMailID();

# };

#===============================================================================

##客户端封包响应//12 03 提取信件的钱#tagCGetMailMoney

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//12 03 提取信件的钱#tagCGetMailMoney

def GetLetterMoney(index, tick):

    #curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    #FuncCall(curPlayer, "GetLetterMoney", tick)

    return



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

#===============================================================================

# //12 04 提取信件物品#tagCGetMailItem

# tagCGetMailItem       *   GettagCGetMailItem();

# 
# class   IPY_CGetMailItem

# {

# public:

# 
#    char *      GetMailID();

# };

#===============================================================================

##客户端封包响应//12 04 提取信件物品#tagCGetMailItem

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//12 04 提取信件物品#tagCGetMailItem

def GetLetterItem(index, tick):

    #curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    #FuncCall(curPlayer, "GetLetterItem", tick)

    return



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

#===============================================================================

# //08 05 玩家修理物品#tagCShopRepairItem

# tagCShopRepairItem       *   GettagCShopRepairItem();

# 
# class   IPY_CShopRepairItem

# {

# public:

# 
#    int      GetPackType();

# 
#    int      GetItemIndex();

# };

#===============================================================================

##客户端封包响应//08 05 玩家修理物品#tagCShopRepairItem

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 05 玩家修理物品#tagCShopRepairItem

def RepairItem(index, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    FuncDirectCall(curPlayer, "FunctionNPCCommon", "RepairItem", tick)

    return



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

#===============================================================================

# //08 06 卖物品#tagCPlayerSellItem

# tagCPlayerSellItem       *   GettagCPlayerSellItem();

@@ -2753,805 +260,9 @@
#@remarks 客户端封包响应//08 06 卖物品#tagCPlayerSellItem

def SellItem(index, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)



    result = FuncDirectCall(curPlayer, "FunctionNPCCommon", "SellItem", tick)

    
    sendData = IPY_GameWorld.IPY_CPlayerSellItem()

    packType = sendData.GetPackType()

    FuncDirectCall(curPlayer, "FunctionNPCCommon", "SellItem", tick)

    return



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

#===============================================================================

# //08 0C 合成#tagCMerge

# tagCMerge       *   GettagCMerge();

# 
# class   IPY_CMerge

# {

#    int GetCompoundTimes();//合成次数

#    int GetIsAutoBuy();//是否自动购买附加材料

# };

#===============================================================================

##客户端封包响应//08 0C 合成#tagCMerge

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 0C 合成#tagCMerge

def MergeItem(index, tick):

    return



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

#===============================================================================

# //08 0E 物品绑定#tagCBindItem

# tagCBindItem       *   GettagCBindItem();

# 
# class   IPY_CBindItem

# {

# public:

#    //绑定印记的index

#    int      GetBindStoneIndex();

# };

#===============================================================================

##客户端封包响应//08 0E 物品绑定#tagCBindItem

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 0E 物品绑定#tagCBindItem

def BindItem(index, tick):

    return



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

#===============================================================================

# //08 0F 装备打孔#tagCMakeHoleItem

# tagCMakeHoleItem       *   GettagCMakeHoleItem();

# 
# class   IPY_CMakeHoleItem

# {

# public:

#    //是否自动购买, 如果自动购买, 则下面字段无效

#    int      GetAutoBuyItem();

#    //服务器端自己找打孔位置

#    int      GetMakeHoleType();

#    //是否使用绑定材料, 为1是全部用, 0为只用不绑定的

#    int      GetIsUseBindItem();

# };

#===============================================================================

# ----->>>秦始皇版封包, 暂时不用<<<-----

##客户端封包响应//08 0F 装备打孔#tagCMakeHoleItem

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 0F 装备打孔#tagCMakeHoleItem

def MakeHoleItem(index, tick):

    return



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

#===============================================================================

# //08 10 装备升星#tagCItemLVUpStar

# tagCItemLVUpStar       *   GettagCItemLVUpStar();

# 
# class   IPY_CItemLVUpStar

# {

# public:

#    //是否自动购买, 如果自动购买, 则下面字段无效

#    int      GetAutoBuyItem();

#    //背包星石位置

#    int      GetStarStoneIndex();

#    //是否使用防爆符

#    int      GetUseFangBaoFu();

#    //防爆附Index

#    int      GetFangBaoFuIndex();

#    //是否自动购买防爆符

#    int      GetAutoBuyFangBaoFu();

# };

#===============================================================================

##客户端封包响应08 10 装备升星#tagCItemLVUpStar

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应08 10 装备升星#tagCItemLVUpStar

def ItemLVUpStar(index, tick):

    return



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

#===============================================================================

# //08 11 镶嵌宝石#tagCInsertStone

# tagCInsertStone       *   GettagCInsertStone();

# 
# class   IPY_CInsertStone

# {

# public:

#    //宝石位置

#    int      GetStoneIndex();

# };

#===============================================================================

##客户端封包响应//08 11 镶嵌宝石#tagCInsertStone

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 11 镶嵌宝石#tagCInsertStone

def InsertStone(index, tick):

    return



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

#===============================================================================

# //08 12 拆解物品#tagCDepartItem

# tagCDepartItem       *   GettagCDepartItem();

# 
# class   IPY_CDepartItem

# {

# public:

# 
#    int      GetType();

# };

#===============================================================================

##客户端封包响应//08 12 拆解物品#tagCDepartItem

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 12 拆解物品#tagCDepartItem

def DepartItem(index, tick):

    return



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

#===============================================================================

# //0D 01 合成物品放入背包#tagCPutItemInComposePack

# tagCPutItemInComposePack       *   GettagCPutItemInComposePack();

# 
# class   IPY_CPutItemInComposePack

# {

# public:

#    //背包位置

#    int      GetItemIndex();

#    //放入位置

#    int      GetMakePackIndex();

#    //放入数量

#    int      GetCount();

# };

#===============================================================================

##客户端封包响应//0D 01 合成物品放入背包#tagCPutItemInComposePack

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0D 01 合成物品放入背包#tagCPutItemInComposePack

def PutItemInCompose(index, tick):

    return



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

#===============================================================================

# //0D 02 取出合成背包物品#tagCGetItemInComposePack

# tagCGetItemInComposePack       *   GettagCGetItemInComposePack();

# 
# class   IPY_CGetItemInComposePack

# {

# public:

#    //合成位置

#    int      GetComposePackIndex();

#    //物品位置

#    int      GetItemIndex();

#    //取出数量

#    int      GetCount();

# };

#===============================================================================

##客户端封包响应//0D 02 取出合成背包物品#tagCGetItemInComposePack

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0D 02 取出合成背包物品#tagCGetItemInComposePack

def GetItemInCompose(index, tick):

    return



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

#===============================================================================

# //0D 03 合成背包中拖动物品#tagCMoveItemInComposePack

# tagCMoveItemInComposePack       *   GettagCMoveItemInComposePack();

# 
# class   IPY_CMoveItemInComposePack

# {

# public:

#    //起始位置

#    int      GetSrcIndex();

#    //目标位置

#    int      GetDestIndex();

# 
#    int      GetCount();

# };

#===============================================================================

##客户端封包响应//0D 03 合成背包中拖动物品#tagCMoveItemInComposePack

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0D 03 合成背包中拖动物品#tagCMoveItemInComposePack

def MoveItemInCompose(index, tick):

    return



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

#===============================================================================

# //0D 04 物品放入准备拆解背包#tagCPutItemInBreakPreparePack

# tagCPutItemInBreakPreparePack       *   GettagCPutItemInBreakPreparePack();

# 
# class   IPY_CPutItemInBreakPreparePack

# {

# public:

#    //背包位置

#    int      GetItemIndex();

# };

#===============================================================================

##客户端封包响应//0D 04 物品放入准备拆解背包#tagCPutItemInBreakPreparePack

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0D 04 物品放入准备拆解背包#tagCPutItemInBreakPreparePack

def PutItemInBreakPreparePack(index, tick):

    return



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

#===============================================================================

# //0D 05 从拆解准备背包中取出#tagCGetBackItemInBreakPrepare

# tagCGetBackItemInBreakPrepare       *   GettagCGetBackItemInBreakPrepare();

# 
# class   IPY_CGetBackItemInBreakPrepare

# {

# public:

#    //拆解背包的位置

#    int      GetBreakPrepareIndex();

#    //拖到目的地的位置

#    int      GetItemIndex();

# };

#===============================================================================

##客户端封包响应 //0D 05 从拆解准备背包中取出#tagCGetBackItemInBreakPrepare

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应 //0D 05 从拆解准备背包中取出#tagCGetBackItemInBreakPrepare

def GetBackItemInBreakPrepare(index, tick):

    return



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

#===============================================================================

# //0D 06 从拆解结果背包中取出#tagCGetBackItemInBreakItem

# tagCGetBackItemInBreakItem       *   GettagCGetBackItemInBreakItem();

# 
# class   IPY_CGetBackItemInBreakItem

# {

# public:

#    //拆解结果背包位置

#    int      GetBreakItemIndex();

#    //取出数目

#    int      GetCount();

#    //背包位置

#    int      GetItemIndex();

# };

#===============================================================================

##客户端封包响应//0D 06 从拆解结果背包中取出#tagCGetBackItemInBreakItem

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0D 06 从拆解结果背包中取出#tagCGetBackItemInBreakItem

def GetBackItemInBreakItem(index, tick):

    return



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

#===============================================================================

# //0D 07 取出合成结果背包#tagCGetItemFromResultPack

# tagCGetItemFromResultPack       *   GettagCGetItemFromResultPack();

# 
# class   IPY_CGetItemFromResultPack

# {

# public:

# 
#    int      GetItemIndex();

# };

#===============================================================================

##客户端封包响应//0D 07 取出合成结果背包#tagCGetItemFromResultPack

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0D 07 取出合成结果背包#tagCGetItemFromResultPack

def GetItemFromResultPack(index, tick):

    return



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

#===============================================================================

# //0D 08 放入合成结果背包#tagCPutInResultPack

# tagCPutInResultPack       *   GettagCPutInResultPack();

# 
# class   IPY_CPutInResultPack

# {

# public:

# 
#    int      GetItemIndex();

# };

#===============================================================================

##客户端封包响应//0D 08 放入合成结果背包#tagCPutInResultPack

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0D 08 放入合成结果背包#tagCPutInResultPack

def PutItemInResultPack(index, tick):

    return



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

#===============================================================================

# //0E 01 鉴定物品放入背包#tagCPutItemInIdentify

# tagCPutItemInIdentify       *   GettagCPutItemInIdentify();

# 
# class   IPY_CPutItemInIdentify

# {

# public:

#    //背包位置

#    int      GetItemIndex();

# };

#===============================================================================

##客户端封包响应//0E 01 鉴定物品放入背包#tagCPutItemInIdentify

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0E 01 鉴定物品放入背包#tagCPutItemInIdentify

def PutItemInIdentify(index, tick):

    return



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

#===============================================================================

# //0E 02 取出鉴定背包内的物品#tagCGetBackItemInIdentify

# tagCGetBackItemInIdentify       *   GettagCGetBackItemInIdentify();

# 
# class   IPY_CGetBackItemInIdentify

# {

# public:

#    //物品位置

#    int      GetItemIndex();

#    //取出数量

#    int      GetCount();

# };

#===============================================================================

##客户端封包响应//0E 02 取出鉴定背包内的物品#tagCGetBackItemInIdentify

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0E 02 取出鉴定背包内的物品#tagCGetBackItemInIdentify

def GetItemInIdentify(index, tick):

    return



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

#===============================================================================

# //0E 03 鉴定结束#tagCIdentifyOK

# tagCIdentifyOK       *   GettagCIdentifyOK();

# 
# class   IPY_CIdentifyOK

# {

# public:

#    //无意义

#    int      GetType();

# };

#===============================================================================

##客户端封包响应//0E 03 鉴定结束#tagCIdentifyOK

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0E 03 鉴定结束#tagCIdentifyOK

def IdentifyOK(index, tick):

    return



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

#===============================================================================

# //08 15 拆解物品宝石#tagCBreakItemStone

# tagCBreakItemStone       *   GettagCBreakItemStone();

# 
# class   IPY_CBreakItemStone

# {

# public:

#    //物品的第几个宝石

#    int      GetStoneIndex();

# };

#===============================================================================

##客户端封包响应//08 15 拆解物品宝石#tagCBreakItemStone

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 15 拆解物品宝石#tagCBreakItemStone

def DigItemStone(index, tick):

    return



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

#===============================================================================

# //08 16 使用威尔刚#tagCUseWeiErGangIncreaseEndure

# tagCUseWeiErGangIncreaseEndure       *   GettagCUseWeiErGangIncreaseEndure();

# 
# class   IPY_CUseWeiErGangIncreaseEndure

# {

# public:

#    //威尔刚位置

#    int      GetGangStoneIndex();

# };

#===============================================================================

##客户端封包响应//08 16 使用威尔刚#tagCUseWeiErGangIncreaseEndure

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 16 使用威尔刚#tagCUseWeiErGangIncreaseEndure

def UseWegAddEndure(index, tick):

    return



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

#===============================================================================

# //07 27 传说物品合成#tagCLegendMerge

# tagCLegendMerge       *   GettagCLegendMerge();

# 
# class   IPY_CLegendMerge

# {

# public:

#    //Index

#    int      GetItemIndex();

# };

#===============================================================================

##客户端封包响应//07 27 传说物品合成#tagCLegendMerge

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//07 27 传说物品合成#tagCLegendMerge

def LegendItemMerge(index, tick):

    return



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

#===============================================================================

# //08 17 解除绑定#tagCCancelBind

# tagCCancelBind       *   GettagCCancelBind();

# 
# class   IPY_CCancelBind

# {

# public:

#    //绑定印记的index

#    int      GetUnBindStoneIndex();

# };

#===============================================================================

##客户端封包响应//08 17 解除绑定#tagCCancelBind

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 17 解除绑定#tagCCancelBind

def UnBindItem(index, tick):

    return



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

#===============================================================================

# //08 18 战魂套装合成#tagCSoulOfWarMerge

# tagCSoulOfWarMerge       *   GettagCSoulOfWarMerge();

# 
# class   IPY_CSoulOfWarMerge

# {

# public:

#    //是否使用绑定材料

#    int      GetUseBindItem();

# };

#===============================================================================

##客户端封包响应//08 18 战魂套装合成#tagCSoulOfWarMerge

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 18 战魂套装合成#tagCSoulOfWarMerge

def SoulOfWarEquip(index, tick):

    return



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

#===============================================================================

# //07 23 修理法宝#tagCRepairFabao

# tagCRepairFabao       *   GettagCRepairFabao();

# 
# class   IPY_CRepairFabao

# {

# public:

#    //法宝的位置

#    int      GetFabaoIndex();

# };

#===============================================================================

##客户端封包响应//07 23 修理法宝#tagCRepairFabao

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//07 23 修理法宝#tagCRepairFabao

def RepairFaBao(index , tick):

    return



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

#===============================================================================

# //07 22 提炼法宝#tagCForgeFaBao

# tagCForgeFaBao       *   GettagCForgeFaBao();

# 
# class   IPY_CForgeFaBao

# {

# public:

#    //提炼多少分钟

#    int      GetTime();

# };

#===============================================================================

##客户端封包响应//07 22 提炼法宝#tagCForgeFaBao

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//07 22 提炼法宝#tagCForgeFaBao

def ForgeFaBao(index, tick):

    return



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

#===============================================================================

# //07 25 法宝合成#tagCFaBaoMix

# tagCFaBaoMix       *   GettagCFaBaoMix();

# 
# class   IPY_CFaBaoMix

# {

# public:

#    //3个合成一个

#    int      GetItemIndex1();

# 
#    int      GetItemIndex2();

# 
#    int      GetItemIndex3();

# };

#===============================================================================

##客户端封包响应//07 25 法宝合成#tagCFaBaoMix

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//07 25 法宝合成#tagCFaBaoMix

def MixFaBao(index , tick):

    return



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

#===============================================================================

# //07 34 法宝飞升#tagCFaBaoFly

# tagCFaBaoFly       *   GettagCFaBaoFly();

# 
# class   IPY_CFaBaoFly

# {

# public:

#    //Index

#    int      GetItemIndex();

# };

#===============================================================================

##客户端封包响应//07 34 法宝飞升#tagCFaBaoFly

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//07 34 法宝飞升#tagCFaBaoFly

def FaBaoFly(index , tick):

    return



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

#===============================================================================

# //07 35 抹去法宝技能#tagCFaBaoForget

# tagCFaBaoForget       *   GettagCFaBaoForget();

# 
# class   IPY_CFaBaoForget

# {

# public:

#    //Index

#    int      GetItemIndex();

# };

#===============================================================================

##客户端封包响应//07 35 抹去法宝技能#tagCFaBaoForget

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//07 35 抹去法宝技能#tagCFaBaoForget

def FaBaoForget(index , tick):

    return



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

#===============================================================================

# //07 36 法宝融合#tagCFaBaoMerge

# tagCFaBaoMerge       *   GettagCFaBaoMerge();

# 
# class   IPY_CFaBaoMerge

# {

# public:

#    //左边那个法宝

#    int      GetFaBao1Index();

#    //右边那个法宝

#    int      GetFaBao2Index();

#    //第一个物品, 红红的豆子

#    int      GetItem1Cnt();

#    //第二个物品, 圆圆的球

#    int      GetItem2Cnt();

#    //第三个物品, 卷轴

#    int      GetItem3Cnt();

#    //是否使用绑定材料

#    int      GetUseBindItem();

# };

#===============================================================================

##客户端封包响应//07 36 法宝融合#tagCFaBaoMerge

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//07 36 法宝融合#tagCFaBaoMerge

def FaBaoMerge(index , tick):

    return



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

#===============================================================================

# //0F 0E 家族捐献银子#tagCContributeSilver

def ContributeFamilyMoney(index , tick):

    # 使用新 A6 05  家族捐献 #tagCMFamilyDonate

    return



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

#===============================================================================

# //07 28 5行转换#tagCItemChangeProperty

# tagCItemChangeProperty       *   GettagCItemChangeProperty();

# 
# class   IPY_CItemChangeProperty

# {

# public:

#    //是否材料不足自动购买

#    int      GetAutoBuyStuff();

#    //是否使用绑定材料

#    int      GetUseBindItem();

# };

#===============================================================================

##客户端封包响应//07 28 5行转换#tagCItemChangeProperty

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//07 28 5行转换#tagCItemChangeProperty

def ItemChangeProperty(index, tick):

    return



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

#===============================================================================

# //07 29 灵魂封印#tagCItemChangeGiveSoul

# tagCItemChangeGiveSoul       *   GettagCItemChangeGiveSoul();

# 
# class   IPY_CItemChangeGiveSoul

# {

# public:

#    //是否材料不足自动购买

#    int      GetAutoBuyStuff();

#    //是否使用绑定材料

#    int      GetUseBindItem();

# };

#===============================================================================

##客户端封包响应//07 29 灵魂封印#tagCItemChangeGiveSoul

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//07 29 灵魂封印#tagCItemChangeGiveSoul

def ItemChangeGiveSoul(index, tick):

    return



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

#===============================================================================

# //07 30 灵魂转换#tagCItemChangeSoul

# tagCItemChangeSoul       *   GettagCItemChangeSoul();

# 
# class   IPY_CItemChangeSoul

# {

# public:

#    //是否材料不足自动购买

#    int      GetAutoBuyStuff();

#    //是否使用绑定材料

#    int      GetUseBindItem();

#    //是否使用灵魂石

#    int      GetUseIceStone();

#    //是否自动购买

#    int      GetIceStoneAutoBuy();

# };

#===============================================================================

##客户端封包响应//07 30 灵魂转换#tagCItemChangeSoul

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//07 30 灵魂转换#tagCItemChangeSoul

def ItemChangeSoul(index, tick):

    return



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

#===============================================================================

# //07 31 签名改变珠#tagCItemChangeMark

# tagCItemChangeMark       *   GettagCItemChangeMark();

# 
# class   IPY_CItemChangeMark

# {

# public:

#    //是否使用绑定材料

#    int      GetUseBindItem();

# };

#===============================================================================

##客户端封包响应//07 31 签名改变珠#tagCItemChangeMark

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//07 31 签名改变珠#tagCItemChangeMark

def ItemChangeMark(index, tick):

    return



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

#===============================================================================

# //07 32 签名珠#tagCItemChangeGiveMark

# tagCItemChangeGiveMark       *   GettagCItemChangeGiveMark();

# 
# class   IPY_CItemChangeGiveMark

# {

# public:

#    //是否使用绑定材料

#    int      GetUseBindItem();

# };

#===============================================================================

##客户端封包响应//07 32 签名珠#tagCItemChangeGiveMark

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//07 32 签名珠#tagCItemChangeGiveMark

def ItemChangeGiveMark(index, tick):

    return



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

##重置背包等级

#@param curPlayer 玩家实例

#@param addPackCnt 开启等级

#@return 布尔值

#@remarks 自定义函数 设置背包等级

def ResetBackPack(curPlayer, addPackCnt = 1):

    packType = IPY_GameWorld.rptItem

    
    #初始化玩家背包

    if packType not in ChConfig.Def_Type_CanBuyPack_PlayerDict.keys():

        return

    
    keyName = ChConfig.Def_Type_CanBuyPack_PlayerDict.get(packType)[ChConfig.Def_PlayerPackDict_Index_Key]

    
    #已经开启的背包格子数

    packCount = ItemCommon.GetPackInitCount(packType) + curPlayer.NomalDictGetProperty(keyName)

    resetPackCnt = packCount + addPackCnt



    curPack = curPlayer.GetItemManager().GetPack(packType)

        
    if resetPackCnt > curPack.GetMaxCount():

        return False

    
    #设置玩家背包数量

    curPack.SetCount(resetPackCnt)

    
    PlayerControl.NomalDictSetProperty(curPlayer, keyName, curPlayer.NomalDictGetProperty(keyName) + addPackCnt)

    
    #初始化玩家背包

    PlayerControl.Init_ItemPack(curPlayer)



    PlayerControl.NotifyCode(curPlayer, "GeRen_hwj35_149184", [addPackCnt])

    return True

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

##设置仓库等级

#@param curPlayer 玩家实例

#@param addWarehouseCnt 仓库等级

#@param needNotify 是否需要系统提示

#@return 布尔值

#@remarks 自定义函数 设置仓库等级

def ResetWarehouse(curPlayer, addWarehouseCnt = 1, needNotify = True):

    packType = IPY_GameWorld.rptWarehouse

    #初始化玩家背包

    if packType not in ChConfig.Def_Type_CanBuyPack_PlayerDict.keys():

        return

    
    keyName = ChConfig.Def_Type_CanBuyPack_PlayerDict.get(packType)[ChConfig.Def_PlayerPackDict_Index_Key]

    count = ItemCommon.GetPackInitCount(packType) + curPlayer.NomalDictGetProperty(keyName) + addWarehouseCnt



    curPack = curPlayer.GetItemManager().GetPack(packType)

        
    if count > curPack.GetMaxCount():

        return False

    
    #设置仓库格子数

    curPack.SetCount(count)

    
    PlayerControl.NomalDictSetProperty(curPlayer, keyName, curPlayer.NomalDictGetProperty(keyName) + addWarehouseCnt)

    
    #初始化仓库

    PlayerControl.Init_Warehouse(curPlayer)

    
    if not needNotify:

        return True 
    
    PlayerControl.NotifyCode(curPlayer, "GeRen_hwj35_874335", [addWarehouseCnt])

    return True

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

#===============================================================================

# //0C 01 背包物品放入仓库#tagCPutItemInWarehouse

# tagCPutItemInWarehouse       *   GettagCPutItemInWarehouse();

@@ -3605,169 +316,6 @@


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

#===============================================================================

# //0C 03 仓库取出金钱#tagCGetMoneyInWarehouse

# tagCGetMoneyInWarehouse       *   GettagCGetMoneyInWarehouse();

# 
# class   IPY_CGetMoneyInWarehouse

# {

# public:

#    //金钱类型

#    int      GetMoneyType();

#    //Ǯ

#    int      GetMoney();

# };

#===============================================================================

##客户端封包响应//0C 03 仓库取出金钱#tagCGetMoneyInWarehouse

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0C 03 仓库取出金钱#tagCGetMoneyInWarehouse

def GetMoneyInWarehouse(index, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    FuncDirectCall(curPlayer, Def_Warehouse_FuncName, "GetMoneyInWarehouse", tick)

    return



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

#===============================================================================

# //0C 04 仓库放入金钱#tagCPutMoneyInWarehouse

# tagCPutMoneyInWarehouse       *   GettagCPutMoneyInWarehouse();

# 
# class   IPY_CPutMoneyInWarehouse

# {

# public:

#    //金钱类型

#    int      GetMoneyType();

#    //金钱

#    int      GetMoney();

# };

#===============================================================================

##客户端封包响应//0C 04 仓库放入金钱#tagCPutMoneyInWarehouse

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0C 04 仓库放入金钱#tagCPutMoneyInWarehouse

def PutMoneyInWarehouse(index, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    FuncDirectCall(curPlayer, Def_Warehouse_FuncName, "PutMoneyInWarehouse", tick)

    return



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

#===============================================================================

# //0C 05 设置仓库密码#tagCSetWarehousePsw

# tagCSetWarehousePsw       *   GettagCSetWarehousePsw();

# 
# class   IPY_CSetWarehousePsw

# {

# public:

#    //当前密码(空表示没有密码)

#    char *      GetPsw();

#    //旧密码

#    char *      GetOldPsw();

# };

#===============================================================================

##客户端封包响应//0C 05 设置仓库密码#tagCSetWarehousePsw

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0C 05 设置仓库密码#tagCSetWarehousePsw

def SetWarehousePsw(index, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    FuncDirectCall(curPlayer, Def_Warehouse_FuncName, "SetWarehousePsw", tick)

    return



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

#===============================================================================

# //0C 06 锁定仓库#tagCSetWarehouseLock

# tagCSetWarehouseLock       *   GettagCSetWarehouseLock();

# 
# class   IPY_CSetWarehouseLock

# {

# public:

#    //0: 解锁 1:锁定

#    int      GetIsLock();

# };

#===============================================================================

##客户端封包响应//0C 06 锁定仓库#tagCSetWarehouseLock

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0C 06 锁定仓库#tagCSetWarehouseLock

def SetWarehouseLock(index, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    FuncDirectCall(curPlayer, Def_Warehouse_FuncName, "SetWarehouseLock", tick)

    return



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

#===============================================================================

# //0C 07 客户端发送仓库密码#tagSendWarehousePsw

# tagSendWarehousePsw       *   GettagSendWarehousePsw();

# 
# class   IPY_SendWarehousePsw

# {

# public:

# 
#    char *      GetPsw();

# };

#===============================================================================

##客户端封包响应//0C 07 客户端发送仓库密码#tagSendWarehousePsw

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0C 07 客户端发送仓库密码#tagSendWarehousePsw

def SendWarehousePsw(index, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    FuncDirectCall(curPlayer, Def_Warehouse_FuncName, "SendWarehousePsw", tick)

    return



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

#===============================================================================

# //0C 08 第一次打开仓库#tagCInitWarehousePsw

# tagCInitWarehousePsw       *   GettagCInitWarehousePsw();

# 
# class   IPY_CInitWarehousePsw

# {

# public:

#    //密码

#    char *      GetPsw();

# };

#===============================================================================

##客户端封包响应//0C 08 第一次打开仓库#tagCInitWarehousePsw

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0C 08 第一次打开仓库#tagCInitWarehousePsw

def InitWarehousePsw(index, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    FuncDirectCall(curPlayer, Def_Warehouse_FuncName, "InitWarehousePsw", tick)

    DoExitEvent(curPlayer)

    return



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

#===============================================================================

# //07 10 仓库重整#tagCWarehouseReset

# tagCWarehouseReset       *   GettagCWarehouseReset();

# 
# class   IPY_CWarehouseReset

# {

# public:

# 
#    int      GetType();

# };

#===============================================================================

##客户端封包响应//07 10 仓库重整#tagCWarehouseReset

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//07 10 仓库重整#tagCWarehouseReset

def ResetWarehouseItem(index, tick):

#===============================================================================

#    背包重整合并 07 0F

#    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

#    FuncCall(curPlayer, "ResetWarehouseItem", tick)

#===============================================================================

    return

#---------------------------------------------------------------------    
#===============================================================================

# //07 0F 背包重整#tagCItemPackReset

# //对性能有比较大的影响

#

@@ -3818,545 +366,7 @@
    #背包整理逻辑

    ItemControler.ResetItem(curPlayer, sendPack_PackIndex, sendPack_ItemBeginIndex, sendPack_ItemEndIndex, tick)

    return

#---------------------------------------------------------------------   
#===============================================================================

# //08 14 称号合成#tagCTitleMix

# tagCTitleMix       *   GettagCTitleMix();

# 
# class   IPY_CTitleMix

# {

# public:

#    //最终要合成的称号

#    int      GetTitleID();

# };

#===============================================================================

##客户端封包响应//08 14 称号合成#tagCTitleMix

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 14 称号合成#tagCTitleMix

def MixTitle(index, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    FuncCall(curPlayer, "MixTitle", tick)

    return



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

#===============================================================================

# //0C 09 仓库拖动物品#tagMoveItemInWarehouse

# tagMoveItemInWarehouse       *   GettagMoveItemInWarehouse();

# 
# class   IPY_MoveItemInWarehouse

# {

# public:

#    //起始位置

#    int      GetSrcIndex();

#    //目标位置

#    int      GetDestIndex();

# 
#    int      GetCount();

# };

#===============================================================================

##客户端封包响应//0C 09 仓库拖动物品#tagMoveItemInWarehouse

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//0C 09 仓库拖动物品#tagMoveItemInWarehouse

def MoveItemInWarehouse(index, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    FuncDirectCall(curPlayer, Def_Warehouse_FuncName, "MoveItemInWarehouse", tick)

    return

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

##重读任务刷新

#@param 无

#@return 返回值无意义

#@remarks 重读任务刷新

def DoReloadRefresh():

    #赋值

    QuestRunner.SetFindQuestFunc(QuestManager.FindQuest)

    QuestRunner.SetFunctionNPCTalk(QuestManager.GetFunctionNPCTalk())

    QuestRunner.SetFindDefaultTalkFunc(QuestManager.FindDefaultTalk)

    QuestRunner.SetQuestTrig(QuestManager.GetQuestTrig())

    QuestRunner.SetQuestDescriptions(QuestManager.GetQuestDescriptions())

    QuestRunner.SetAllQuestsEvents(QuestManager.GetAllQuestsEvents())

    
#--------------------------------------自定义方法

##结束事件响应

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 自定义函数:结束事件响应

def DoExitEvent(curPlayer):    
    #允许整理背包

    #ExitEvent() 会把状态清空,Onday会触发，需要还原

    playerAction = curPlayer.GetPlayerAction()

    
    curPlayer.SetForbiddenResetItem(0)

    ExitCompose(curPlayer)

    ExitWarehouse(curPlayer)

    #ExitRepair(curPlayer)

    ExitCreateFamily(curPlayer)

    ExitBillboard(curPlayer)

    #ExitEventLock(curPlayer)

    #npc商店退出

    ExitNPCShop(curPlayer)

    
    #PlayerTrade.LeaveTrade(curPlayer, 0)

    # 清除py自定义状态

    #ClearPyPlayerAction(curPlayer)

    
    #调用底层结束事件

    #避免策划变更，导致其他退出锁定事件使任务1未接取就退出锁定

    if curPlayer.GetDictByKey(ChConfig.Def_PlayerKey_Frist_Lock) != 1:

        curPlayer.ExitEvent()

    
    if playerAction == IPY_GameWorld.paSit:

        #还原打坐

        PlayerControl.SetIsNeedProcess(curPlayer, True)

        #玩家坐下

        curPlayer.Sit()

    
    #GameWorld.Log("玩家退出所有事件成功" , curPlayer.GetPlayerID())

    return True



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

## npc商店退出

#  @param curPlayer 玩家实例

#  @return 返回值无意义

def ExitNPCShop(curPlayer):

    # 设置当前商店的npcid为0

    curPlayer.SetDict(ChConfig.Def_PlayerKey_TradeTagNPC, 0)        
    return





## 清除py自定义状态

#  @param curPlayer 玩家实例

#  @return 返回值无意义

def ClearPyPlayerAction(curPlayer):

    #清除py自定义状态

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_PyPlayerAction, 0)      
    return



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

##结束查看排行榜

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 自定义函数:结束查看排行榜

def ExitBillboard(curPlayer):

    if curPlayer.GetWatchBillboardState() == 0:

        return

    curPlayer.GameServer_SetWatchBillboardState(0)

    return

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

##结束仓库事件

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 自定义函数:结束仓库事件

def ExitWarehouse(curPlayer):

    curPlayer.SetWarehouseState(IPY_GameWorld.wsNull)

    return

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

##结束打造事件

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 自定义函数:结束打造事件

def ExitCompose(curPlayer):

    curPlayer.SetComposeItemState(IPY_GameWorld.cisNull)

    return

#--------------------------------------------------------------------- 
##结束修理事件

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 自定义函数:结束修理事件

def ExitRepair(curPlayer):

    if curPlayer.GetEventHaveFixItem() == True:

        #刷新属性

        playerControl = PlayerControl.PlayerControl(curPlayer)

        playerControl.RefreshAllState()

        #重置状态

        curPlayer.SetEventHaveFixItem(False)

        
#---------------------------------------------------------------------   
##结束创建家族事件

#@param curPlayer 玩家实例

#@return 返回值无意义

#@remarks 自定义函数:结束创建家族事件

def ExitCreateFamily(curPlayer):

    #PlayerFamily.SendPack_GameServer_ClearViewFamilyState(curPlayer)

    return



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

#===============================================================================

# //08 09 取消任务#tagCCancelTask

# tagCCancelTask       *   GettagCCancelTask();

# 
# class   IPY_CCancelTask

# {

# public:

# 
#    int      GetTaskID();

# };

#===============================================================================

##客户端封包响应//08 09 取消任务#tagCCancelTask

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//08 09 取消任务#tagCCancelTask

def DeleteMission(index, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    pack = IPY_GameWorld.IPY_CCancelTask()

    missionID = pack.GetTaskID() 
    curMission = curPlayer.FindMission(missionID)

    
    if not curMission:

        return

    
    missionState = curMission.GetState()

    
    #未接任务或已完成任务不可放弃

    if missionState in [ ChConfig.Def_Mission_State_NoAccept, ChConfig.Def_Mission_State_Over ]:

        return

    
    #移动中不执行此操作

    if curPlayer.IsMoving():

        #PlayerControl.NotifyCode(curPlayer, "GeRen_lhs_0")

        return

    
    if curPlayer.GetPlayerAction()!= IPY_GameWorld.paNull:

        #您只有在空闲状态下才可放弃任务

        PlayerControl.NotifyCode(curPlayer, "Task_cannot_Delete02")

        return

    
    #if GameWorld.GetMap().GetMapFBType() != IPY_GameWorld.fbtNull:

    #    PlayerControl.NotifyCode(curPlayer, "GeRen_hgg_880525")

    #    return

    
    curQuestData = QuestManager.FindQuest(missionID)

    if not curQuestData:

        return

    
    #放弃悬赏任务

    #if missionID == ChConfig.Def_ArrestMissionID:

    #    PlayerArrestTask.OnDeleteArrestTask(curPlayer)

    
    #先在任务表中找数据, 如果找到了, 就不遍历XML了

    if __DoLogic_DeleteMission(curPlayer, curMission):

        GameWorld.Log("在任务表中找数据, 删除任务 = %s, 状态 = %s"%(missionID, missionState), curPlayer.GetID())

        return

    
    #GameWorld.Log("在XML中查找数据, 删除任务 = %s, 状态 = %s"%(missionID, missionState), curPlayer.GetID())

    #删除表中无, 就读XML( 这里的任务应该都是全图任务, 如每日任务 )

    RunQuestEvent(curPlayer, "on_delete", missionID, Def_RunQuestType_Normal)

    return



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

##读数据库任务删除表, 删除任务

# @param curPlayer 玩家实例

# @param curMission 任务实例

# @return 返回值真, 删除成功

# @remarks 自定义函数, 读数据库任务删除表, 删除任务

def __DoLogic_DeleteMission(curPlayer, curMission):

    missionID = curMission.GetMissionID()

    GameWorld.Log("__DoLogic_DeleteMission---%s"%missionID, curPlayer.GetID())

    delMissionData = GameWorld.GetGameData().GetMissionDeleteByID(missionID)

    #任务删除表中无此任务

    if not delMissionData:

        return

    
    #是否清除镖车

    if delMissionData.GetDeleteTruck():

        #玩家拥有镖车, 且镖车ID和任务ID一致

        if curPlayer.GetTruckID() != 0 and curPlayer.GetTruckEventID() == missionID:

            curPlayer.GameServer_DelTruck()

    
    #是否需要删除物品

    for index in range(0, delMissionData.GetDeleteItemCount()):

        delItemData = delMissionData.GetDeleteItemAt(index)

        delItemID = delItemData.GetID()

        #0表示全部删除

        delItemCount = delItemData.GetCount()

        ItemCommon.DelMissionItem(curPlayer, IPY_GameWorld.rptItem, delItemID, delItemCount, missionID)

    
    #删除这个任务

    QuestCommon.DeleteMission(curPlayer, missionID)

    
    #是否有触发新任务

    nextMissionID = delMissionData.GetNextMissionID()

    
    if nextMissionID > 0:

        curAddMission = QuestCommon.AddNewMission(curPlayer, nextMissionID)

        NotifyOneMission(curPlayer, curAddMission)

    
    return True

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

#===============================================================================

# //04 03 任务传送#tagCMissionTransport

# tagCMissionTransport       *   GettagCMissionTransport();

# 
# class   IPY_CMissionTransport

# {

# public:

# 
#    int      GetMapID();

# 
#    int      GetPosX();

# 
#    int      GetPosY();

# };

#===============================================================================

##客户端封包响应//04 03 任务传送#tagCMissionTransport

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应//04 03 任务传送#tagCMissionTransport

def MissionMove(index, tick):

    return





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

#===============================================================================

# //07 37 圣器强化#tagCShengQiQiangHua

# tagCShengQiQiangHua       *   GettagCShengQiQiangHua();

# 
# class   IPY_CShengQiQiangHua

# {

# public:

#    //圣器位置

#    int      GetDestIndex();

#    //自动买材料

#    int      GetAutoBuyMaterial();

#    // 不使用绑定材料强化

#    int      GetNotUserBindMaterial();

# };

#===============================================================================

##客户端封包响应 //07 37 圣器强化#tagCShengQiQiangHua

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应 //07 37 圣器强化#tagCShengQiQiangHua

def ShengQiQiangHua(index, tick):

    return



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

#===============================================================================

# //07 38 清除圣器附加属性#tagCClearShengQiAttrs

# tagCClearShengQiAttrs       *   GettagCClearShengQiAttrs();

# 
# class   IPY_CClearShengQiAttrs

# {

# public:

# 
#    int      GetDestIndex();

# };

#===============================================================================

##客户端封包响应 //07 38 清除圣器附加属性#tagCClearShengQiAttrs

#@param index 玩家索引

#@param tick 时间戳

#@return 返回值无意义

#@remarks 客户端封包响应 //07 38 清除圣器附加属性#tagCClearShengQiAttrs

def ClearShengQiAttrs(index, tick):

    return



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



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

#===============================================================================

# //0D 0E 宝石合成#tagCStoneCompound

# tagCStoneCompound       *   GettagCStoneCompound();

# 
# class   IPY_CStoneCompound

# {

# public:

#    // 合成次数

#    int      GetCompoundCount();

#    // 合成模式

#    int      GetCompoundTimes();

#    // 自动购买

#    int      GetIsAutoBuy();

# };

#===============================================================================

##客户端封包响应 //0D 0E 宝石合成#tagCStoneCompound

# @param index 玩家索引

# @param tick 时间戳

# @return 返回值无意义

# @remarks 客户端封包响应 //0D 0E 宝石合成#tagCStoneCompound

def StoneCompound(index, tick):

#    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

#    FuncDirectCall(curPlayer, "Func_103", "BeginStoneCompound", tick)

    return





#===============================================================================

# //A1 06 装备套装化#tagCEquipSuite

# 
# struct tagCEquipSuite

# {

#    tagHead    Head;

#    BYTE    EquipPackType;    //装备所在背包类型

#    DWORD    ItemIndex;    //装备背包索引

# };

#===============================================================================

##客户端封包响应 //08 1A 装备套装化#tagCEquipSuite

# @param index 玩家索引

# @param tick 时间戳

# @return 返回值无意义

# @remarks 客户端封包响应 //08 1A 装备套装化#tagCEquipSuite

def EquipMakeSuit(index, clientData, tick):

    #curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    #FuncDirectCall(curPlayer, "Func_104", "EquipMakeSuit", tick, clientData)

    return



#===============================================================================

#//A1 05 装备附魔 #tagCEquipAddSkill

#

#struct    tagCEquipAddSkill

#{

#    tagHead        Head;

#    BYTE        EquipPackType;        //装备所在背包类型

#    BYTE        Type;            // 0-清空;1-附加

#    WORD        EquipIndex;        // 装备在背包中的索引

#};

#===============================================================================

##客户端封包响应

# @param index 玩家索引

# @param tick 时间戳

# @return 返回值无意义

# @remarks 客户端封包响应 //0D 09 装备附魔#tagCEquipAddSkill

def MagicAttached(index, clientData, tick):

#    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

#    FuncDirectCall(curPlayer, "Func_104", "MagicAttached", tick, clientData)

    return





#===================================================================================================

# //0D 11 威望装备合成封包#tagCPrestigeEquipMerge

# tagCPrestigeEquipMerge    * GettagCPrestigeEquipMerge();

# 
# class IPY_CPrestigeEquipMerge

# {

# public:

# 
#    //合成类型

#    int GetType();

#    //装备索引

#    int GetEquipIndex();

#    //材料索引

#    int GetMaterialIndex();

# };

#===================================================================================================

##0D 11 威望装备合成封包#tagCPrestigeEquipMerge

# @param curPlayer 玩家实例

# @param tick 时间戳

# @return 返回值无意义

# @remarks 客户端封包响应 //0D 11 威望装备合成封包#tagCPrestigeEquipMerge

def PrestigeEquipMerge(index, tick):

#    
#    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

#    FuncDirectCall(curPlayer, "Func_106", "PrestigeEquipMerge", tick)

    return





#===============================================================================

# //0D 0C 材料加工#tagCMaterialCompound

# 
# struct    tagCMaterialCompound

# {

#    tagHead        Head;

#    WORD        ItemIndex;    // 材料在背包中的索引

# };

#===============================================================================

##材料加工封包，点一次只合一次，（碎片合成）

# @param index 玩家索引

# @param tick 时间戳

# @return 返回值无意义

# @remarks 客户端封包响应 //0D 0C 材料加工#tagCMaterialCompound

def StuffMachining(index, tick):

    return

    
    
##进入副本场景验证.

# @param curPlayer 玩家实例

# @param mapID 地图ID

# @param tick 时间戳

# @return 是否验证成功

# @remarks 客户端封包响应

def DoLogic_EnterFbGameEvent(curPlayer, mapID, tick):

    #暂屏蔽NPC验证判断

    return

#    #没有NPC对话弹界面

#    if mapID in ChConfig.Def_EnterFB_NoNPCForm or mapID in ReadChConfig.GetEvalChConfig("MapID_NoNPCForm"):

#        return True

#    
#    callName = ChConfig.Def_EnterFb_CallNPCFunc.get(mapID)

#    
#    if callName == None:

#        return False

#    
#    result = FuncCall(curPlayer, callName, tick)

#    
#    if not result:

#        return False

#

#    return True



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

## 购买仓库封包 //0C 10 购买仓库空间

#  @param index 玩家索引

#  @param tick 时间戳

#  @return 无返回值

#  @remarks 购买仓库封包 
def BuyWarehouse(index, tick):

#    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

#

#    #转换玩家的货币

#    buyWarehouseType = PlayerControl.ChangeMoneyType(curPlayer, ChConfig.Def_BuyWarehouse_Type)

#    
#    if not PlayerControl.HaveMoney(curPlayer, buyWarehouseType, ChConfig.Def_BuyWarehouse_Cost):

#        #金钱不足

#        return

#    
#    if not ResetWarehouse(curPlayer):

#        #仓库空间已满

#        return

#    
#    #---扣玩家钱---

#    if not PlayerControl.PayMoney(curPlayer, buyWarehouseType, ChConfig.Def_BuyWarehouse_Cost):

#        GameWorld.ErrLog('BuyWarehouse PayMoneyErr')

#        return

#    
#    #手续费流向记录

#    PlayerControl.DataServerMoneyLog(curPlayer, buyWarehouseType, 656, par = ChConfig.Def_BuyWarehouse_Cost)

   
    return

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

##//07 3A 购买物品背包空间#tagCBuyBackpack

#  @param index 玩家索引

#  @param tick 时间戳

#  @return 无返回值

#  @remarks 购买物品背包空间

def BuyItemPack(index, tick):

    # 关闭此封包功能，请使用通用购买封包07 41

    return

#

#    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

#    #转换玩家的货币

#    useMoneyType = PlayerControl.ChangeMoneyType(curPlayer, ChConfig.Def_BuyItemPack_Type)

#    
#    #验证玩家货币

#    if not PlayerControl.HaveMoney(curPlayer, useMoneyType, ChConfig.Def_BuyItemPack_Cost):

#        return

#    
#    if not ResetBackPack(curPlayer):

#        #背包空间已满

#        return

#    
#    #---扣玩家钱---

#    if not PlayerControl.PayMoney(curPlayer, useMoneyType, ChConfig.Def_BuyItemPack_Cost):

#        GameWorld.ErrLog('BuyItemPack PayMoneyErr')

#        return

#

#    #手续费流向记录

#    PlayerControl.DataServerMoneyLog(curPlayer, useMoneyType, 655, par = ChConfig.Def_BuyItemPack_Cost)

#    return

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

#===============================================================================

# #//07 3C通用背包操作#tagCBackpackOperate

# #//对性能影响很小

@@ -4428,93 +438,6 @@
                                          pack_SrcIndex, pack_DestIndex, tick)

    return



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

#===============================================================================

# //08 1B 使用修理道具修理装备#tagCRepairEquip

# struct tagCRepairEquip

# {

#         tagHead Head

#         WORD        ItemIndex; // 道具索引

#         BYTE PackType; //背包类型

#         WORD        EquipIndex; //装备在相应背包中的索引 
# };

#===============================================================================

##使用修理道具修理装备#tagCRepairEquip

# @param index 玩家索引

# @param tick 时间戳

# @return 返回值无意义

# @remarks 客户端封包响应 //08 1B 使用修理道具修理装备#tagCRepairEquip

def ChangeEquipEndure(index, tick):

    return

    
    
#//07 3F 使用道具增加最大灵纹次数#tagCUseIncreaseMaxAddSkill 
#struct tagCUseIncreaseMaxAddSkill 
#{ 
#tagHead Head; 
#WORD ItemIndex; // 道具索引 
#BYTE PackType; //背包类型 
#WORD EquipIndex; //装备在相应背包中的索引 
#}; 
##使用道具增加最大灵纹次数

# @param index 玩家索引

# @param tick 时间戳

# @return 返回值无意义

def UseIncreaseMaxAddSkill(index, tick):

    return

#    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

#    sendPack = IPY_GameWorld.IPY_CUseIncreaseMaxAddSkill()

#    
#    Operate_MagicAttached.UseIncreaseMaxAddSkill(curPlayer, sendPack.GetItemIndex(),

#                                                     sendPack.GetPackType(), sendPack.GetEquipIndex())

    


#===============================================================================

# //07 42 物品能量转移#tagCItemTransfer

# struct       tagCItemTransfer

# {

#         tagHead            Head;

#         BYTE                  PackType;         //背包类型:rptItem, rptEquip, rptWarehouse 
#         BYTE                  ItemPlace;

#         BYTE                  TransferType;  //转移类型

# };

#===============================================================================

##物品能量转移

# @param index 玩家索引

# @param tick 时间戳

# @return 返回值无意义

def ItemEnergyTransfer(index, tick):

#    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

#    
#    #避免反复操作

#    if tick - curPlayer.GetTickByType(ChConfig.TYPE_Player_Tick_ChangeEnergy) \

#    < ChConfig.TYPE_Player_Tick_Time[ChConfig.TYPE_Player_Tick_ChangeEnergy]:

#        return

#    
#    curPlayer.SetTickByType(ChConfig.TYPE_Player_Tick_ChangeEnergy, tick)

#    
#    pack = IPY_GameWorld.IPY_CItemTransfer()

#    Operate_MagicAttached.ItemEnergyTransfer(curPlayer, pack.GetPackType(),

#                                             pack.GetItemPlace(), pack.GetTransferType())

    return



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

#===============================================================================

# //16 0B宠物炼化#tagCPetRefinery

# struct tagCPetRefinery

# {

# tagHead Head;

# DWORD PetID;//宠物ID

# };

#===============================================================================

##宠物炼化.

# @param index 玩家索引

# @param tick 时间戳

# @return 返回值无意义

# @remarks 客户端封包响应 //16 0B宠物炼化#tagCPetRefinery

def CPetRefinery(index, tick):

    return



#===============================================================================

#//07 41 通用购买Pack空间#tagCOpenPackCount

# struct       tagCOpenPackCount

@@ -4546,12 +469,6 @@
    

    curPack = curPlayer.GetItemManager().GetPack(packType)

    curPackMaxCnt = curPack.GetMaxCount()

    
    if packType in [IPY_GameWorld.rptPetCabinetPet, IPY_GameWorld.rptCabinetWeaponCoat, 
                    IPY_GameWorld.rptCabinetDressCoat, IPY_GameWorld.rptCabinetHorse]:

        vipLv = curPlayer.GetVIPLv()

        #curPackMaxCnt = ChConfig.Def_PackCnt_Fashion + PlayerVip.GetVipCabinetAddGridCnt(vipLv)

        
    openAnonCnt =  initCnt + curGridCnt + buyCount

    

    if curPackMaxCnt < openAnonCnt:

@@ -4570,8 +487,6 @@
    if packType == IPY_GameWorld.rptItem:

        #背包刷新

        PlayerControl.Init_ItemPack(curPlayer)

        #开格子，加经验

        #OpenPackAddExp(curPlayer, packType, fromIndex, toIndex)

        PlayerControl.NotifyCode(curPlayer, "GeRen_liubo_671654")

        #PlayerControl.SyncOnLineTimeTotal(curPlayer)

        #PlayerControl.SyncOnLineTimeLastOpenPack(curPlayer, packType)

@@ -4580,8 +495,6 @@
    elif packType == IPY_GameWorld.rptWarehouse:

        #仓库刷新

        PlayerControl.Init_Warehouse(curPlayer)

        #开格子，加经验

        #OpenPackAddExp(curPlayer, packType, fromIndex, toIndex)

            

    else:

        #收纳柜刷新

@@ -4641,184 +554,6 @@
        

    return True, costMoneyList

        

##开启物品背包格子或仓库格子可增加的经验值

# @param curPlayer 玩家对象

# @param packType 背包类型

# @param packType 背包类型

# @param packType 背包类型

# @param needRefresh 是否需要刷新玩家属性

# @return None

def OpenPackAddExp(curPlayer, packType, fromIndex, toIndex, needRefresh = True):

    cfgObj = PlayerExpandPackCfgMgr.GetExpandPackCfg(curPlayer, packType)

    #找不找这种背包的配置信息对象

    if not cfgObj:

#        GameWorld.Log("not cfgObj")

        return

    
    attrInfo = cfgObj.GetTotalCanAddAttrInfo(curPlayer, fromIndex, toIndex)

    #没找到属性信息

    if not attrInfo:

#        GameWorld.Log("not attrInfo")

        return

#    GameWorld.Log("attrInfo=%s"%attrInfo)

    playerControl = PlayerControl.PlayerControl(curPlayer)

    #增加经验

    #通知获得经验

    addExp = attrInfo.get("Exp", 0)

    if 0 != addExp:

        playerControl.AddExp(addExp)

    if needRefresh:

        #重刷主角属性

        playerControl.RefreshAllState()

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

#===============================================================================

# //16 0D 宠物装备合成#tagPetEquipMerge 
# struct tagPetEquipMerge 
# { 
# tagHead Head; 
# DWORD StuffIndex1; //装备索引 
# DWORD StuffIndex2; //装备索引 
# DWORD StuffIndex3; //装备索引 
# BYTE AutoBuy; //是否自动购买结魂灯 
# };

#===============================================================================

##宠物装备合成#tagPetEquipMerge 
# @param index 玩家索引

# @param tick 时间戳

# @return None

# @remarks 
def CPetEquipMerge(index, tick):

    return



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

#===============================================================================

# //08 26 装备直接升星#tagCEquipUpStarImmediately

# struct         tagCEquipUpStarImmediately

# {

#         tagHead             Head;

#         WORD                 ItemIndex;          // 道具索引

#         BYTE          PackType; //背包类型

#         WORD                 EquipIndex;        //装备在相应背包中的索引 
# };

#===============================================================================

##装备直接升星#tagCEquipUpStarImmediately

# @param index 玩家索引

# @param tick 时间戳

# @return None

# @remarks 
def CEquipUpStarImmediately(index, tick):

    return



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

#===============================================================================

# //0D 12 神兵唤醒#tagCEquipWakeUp

# struct         tagCEquipWakeUp

# {

#         tagHead             Head;

#         WORD                 ItemIndex;                   //材料在物品背包中的位置索引

#         BYTE          PackType;           //背包类型 
#         WORD                 EquipIndex;                 //装备在相应背包中的索引

# };

#===============================================================================

##神兵唤醒#tagCEquipWakeUp

# @param index 玩家索引

# @param tick 时间戳

# @return None

# @remarks 
def CEquipWakeUp(index, tick):

    return



#===============================================================================

# #07 43 tagCEsotericaStudy

# #struct tagCEsotericaStudy

# #{

# #    tagHead    Head;

# #    WORD    ItemIndex;

# #};

#===============================================================================

##学习武林秘笈

# @param index 玩家索引

# @param tick 时间戳

# @return None

def LearnWuLinSkill(index, tick):

    return



#===============================================================================

# //A0 10 购买真气#tagPyCMBuyZhenqi

# struct tagPyCMBuyZhenqi

# {

#    tagHead Head;    
# };

#===============================================================================

## A0 10 购买真气#tagPyCMBuyZhenqi

#  @param index 索引

#  @param clientData 封包结构体

#  @param tick 时间戳

#  @return None

#  @remarks

def PlayerBuyZhenqi(index, clientData, tick):

    #Operate_PlayerBuyZhenQi.PlayerBuyZhenQi(index, clientData, tick)

    return





#===============================================================================

#===============================================================================

# //B0 15 玩家领取收藏夹奖励#tagAskCollectPrize

# struct tagAskCollectPrize

# {

#    tagHead Head;    
# };

#===============================================================================

## B0 15 玩家领取收藏夹奖励#tagAskCollectPrize

#  @param index 索引

#  @param clientData 封包结构体

#  @param tick 时间戳

#  @return None

#  @remarks

def PlayerGetFavoriteAward(index, clientData, tick):

    return





#===============================================================================

# //B0 01 打开远程商店

# 
# struct tagPyOpenLongShop

# {

#    tagHead Head;

# };

#===============================================================================

## B0 01 打开远程商店

#  @param index 索引

#  @param clientData 封包结构体

#  @param tick 时间戳

#  @return None

#  @remarks

def PlayerOpenLongShop(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    
    #红名玩家无法使用远程商店

    if curPlayer.GetPlayerNameColor() == IPY_GameWorld.pncRed or curPlayer.GetPKValue() > 0:

        PlayerControl.NotifyCode(curPlayer, "PK_lhs_161795")

        return

        
    #当前vip等级不能使用远程商店

    #if not PlayerVip.GetVipCanLongShop(curPlayer):

    #    moneyCnt, moneyType = ReadChConfig.GetEvalChConfig("DirectShopCost")

    #    if not PlayerControl.PayMoney(curPlayer, moneyType, moneyCnt):

    #        #金钱不足

    #        return

    #    
            
    FunctionNPCCommon.StartTrade(curPlayer, tick)

    
    #触发任务

    EventRespons_DirectFuncEvent(curPlayer, "open_shop")

    return

    
    
#===============================================================================

#//A2 04 请求打开远程仓库 #tagCMOpenLongWarehouse

#

@@ -4837,349 +572,6 @@
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    # 暂不加CD防范

    curPlayer.Sync_WarehouseItem()

    
    return



#===============================================================================

# //B0 06 查看家族战申请信息 #tagViewAllFamilyInfo

# 
# struct    tagViewAllFamilyInfo

# {

#    tagHead        Head;

# };

#===============================================================================

## B0 06 查看家族战申请信息

#  @param index 索引

#  @param clientData 封包结构体

#  @param tick 时间戳

#  @return None

#  @remarks

def ViewAllFamilyInfo(index, clientData, tick):

    #curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    #PlayerFamily.SendPack_GameServer_ViewAllFamily(curPlayer)

    return





#===============================================================================

# //B0 07 查看家族争霸战信息 #tagViewAllFamilyBattlenfo

# 
# struct    tagViewAllFamilyBattlenfo

# {

#    tagHead        Head;

# };

#===============================================================================

## B0 07 查看家族争霸战信息

#  @param index 索引

#  @param clientData 封包结构体

#  @param tick 时间戳

#  @return None

#  @remarks

def ViewAllFamilyBattlenfo(index, clientData, tick):

    return





#===============================================================================

#//B0 31 客户端登入方式 #tagPlayerLoginType

#

#struct tagPlayerLoginType

#

#{

#    tagHead    Head;

#    BYTE        LoginType;        //类型

#};

#====================================

## B0 31 客户端登入方式

#  @param index 索引

#  @param clientData 封包结构体

#  @param tick 时间戳

#  @return None

def OnPlayerLoginType(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_Player_Dict_LoginType, clientData.LoginType)

    EventRespons_OnRevLoginType(curPlayer)

    return





#===============================================================================

#//B0 32 登入器登入领取奖励 #tagFastLoginPrize

#

#struct tagFastLoginPrize

#{

#    tagHead    Head;

#};

#====================================

## B0 32 登入器登入领取奖励

#  @param index 索引

#  @param clientData 封包结构体

#  @param tick 时间戳

#  @return None

def OnRewardByLoginType(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    RunQuestEvent(curPlayer, "on_logintype", "on_reward_bylogintype", Def_RunQuestType_Normal)

    return



#=======================================================================================================================

# //A0 17  领取每天物品 #tagGiveItemByDay

# 
# struct    tagGiveItemByDay

# 
# {

#    tagHead        Head;

# };

#=======================================================================================================================

## A0 17 领取每日物品

#  @param index 索引

#  @param clientData 封包结构体

#  @param tick 时间戳

#  @return None

def GiveItemByDay(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    EventRespons_PlayerEvent(curPlayer, "player_give_item")

    return





##任务触发器在记录登陆模式的时候触发

#@param curPlayer 玩家实例

#@return 返回值无意义

def EventRespons_OnRevLoginType(curPlayer):

    RunQuestEvent(curPlayer, "on_revlogintype_event", "on_revlogintype_event", Def_RunQuestType_Normal)

    return



#// A2 07 接受任务 #tagCMTakeTask

#

#struct    tagCMTakeTask

#{

#    tagHead        Head;

#    DWORD        TaskID;

#};

def OnTakeTask(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    
    missionID = clientData.TaskID

    curMission = curPlayer.FindMission(missionID)

    if not curMission:

        return

    
    missionState = curMission.GetState()

    if missionState != ChConfig.Def_Mission_State_NoAccept:

        return

    
    curQuestData = QuestManager.FindQuest(missionID)

    if not curQuestData:

        return

    
    QuestCommon.SetPlayerMissionState(curPlayer, curMission, 1)

    return



#// A2 18 完成任务 #tagCMFinishTask

#

#struct tagCMFinishTask

#{

#    tagHead         Head;

#    DWORD        TaskID;

#    WORD        RewardPer;    // 奖励百分比, 默认100;  150则代表1.5倍

#};

def OnPlayerFinishTask(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    taskID = clientData.TaskID

    rewardPer = clientData.RewardPer

    
    if taskID <= 0:

        return

    
    EventRespons_OnFinishTask(curPlayer, taskID, rewardPer)

    return



#// A2 06 快速完成任务#tagCMQuickFinishMission

#

#struct tagCMQuickFinishMission

#{

#    tagHead         Head;

#    DWORD        MissionID;

#    BYTE        DoType; // 0-只完成本次；1-完成所有环任务

#};

def PlayerQuickFinishTask(index, clientData, tick):

    missionID = clientData.MissionID

    if missionID <= 0:

        return

    
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    doType = clientData.DoType

    if doType == 1:

        EventRespons_OnQuickFinishAllAround(curPlayer, missionID)

        return

    
    curQuestData = QuestManager.FindQuest(missionID)

    curMission = curPlayer.FindMission(missionID)

    if not curQuestData or not curMission:

        return

    isFree = PlayerGoldInvest.CanQuickFinishMissionFree(curPlayer)

    costMoneyInfo = IpyGameDataPY.GetFuncEvalCfg("QuickFinishMission", 1)

    if costMoneyInfo and not isFree and curQuestData.Type in QuestCommon.Def_RunTask_Type_List:

        moneyType, moneyValue = costMoneyInfo

        if not PlayerControl.PayMoney(curPlayer, moneyType, moneyValue, ChConfig.Def_Cost_MissionDel, {"MissionID":missionID}):

            return

        
    EventRespons_OnQuickFinishTask(curPlayer, missionID)

    return





## A2 09 设置环任务星级#tagCMSetRunMissionStar

#  @param index 索引

#  @param clientData 封包结构体

#  @param tick 时间戳

#  @return None

def PlayerSetRunMissionStar(index, clientData, tick):

    missionID = clientData.MissionID

    if missionID <= 0:

        return



    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    EventRespons_OnSetMissionStar(curPlayer, missionID)

    return





## A2 15 购买日常任务次数上限#tagCMBuyDayMissionSum

#  @param index 索引

#  @param clientData 封包结构体

#  @param tick 时间戳

#  @return None

def PlayerBuyDayMissionSum(index, clientData, tick):

    buyNum = clientData.BuyNum

    if buyNum <= 0:

        return



    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    EventRespons_OnBuyDayMissionSum(curPlayer, buyNum)

    return



#// A2 21 领取跑环每轮结束奖励 #tagCMGetRunTaskEndAward

#  @param index 索引

#  @param clientData 封包结构体

#  @param tick 时间戳

#  @return None

def OnGetRunTaskAward(index, clientData, tick):

    taskType = clientData.Type

    if taskType not in [QuestCommon.Def_Mission_Type_RunDaily, QuestCommon.Def_Mission_Type_RunFamily]:

        GameWorld.DebugLog('领取环任务每轮奖励 类型错误 %s'%taskType)

        return

    
    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)



    hasGotAward = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_RunTaskAwardState % taskType)

    if hasGotAward:

        GameWorld.DebugLog('领取环任务每轮奖励  已奖励 类型 %s'%taskType)

        return

    #物品奖励

    itemList = []

    itemAwardDict = IpyGameDataPY.GetFuncEvalCfg('RunTaskAward', 3, {})

    if str(taskType) in itemAwardDict:

        itemList = itemAwardDict[str(taskType)]

        # 检查背包

        needSpace = len(itemList)

        packSpace = ItemCommon.GetItemPackSpace(curPlayer, IPY_GameWorld.rptItem, needSpace)

        if needSpace > packSpace:

            PlayerControl.NotifyCode(curPlayer, "GeRen_chenxin_998371")

            return

        for itemID, itemCount, isBind in itemList:

            ItemControler.GivePlayerItem(curPlayer, itemID, itemCount, 0, [IPY_GameWorld.rptItem])

    
    #给经验

    giveExp = 0

    expAwardDict = IpyGameDataPY.GetFuncEvalCfg('RunTaskAward', 4, {})

    if str(taskType) in expAwardDict:

        reExp = PlayerControl.GetPlayerReExp(curPlayer)

        giveExp = eval(expAwardDict[str(taskType)])

        PlayerControl.PlayerControl(curPlayer).AddExp(giveExp)

    
    #给钱

    moneyType = 0

    moneyNum = 0

    runTaskMoneyAwardDict = IpyGameDataPY.GetFuncEvalCfg('RunTaskAward')

    if taskType in runTaskMoneyAwardDict:

        specialAwardDict = IpyGameDataPY.GetFuncEvalCfg('RunTaskAward', 2, {})

        if taskType in specialAwardDict:

            rate, moneyCnt = specialAwardDict[taskType]

            if GameWorld.CanHappen(rate):

                moneyNum = moneyCnt

                if taskType == QuestCommon.Def_Mission_Type_RunDaily:

                    PlayerControl.WorldNotify(0, 'CoinTaskReward', [curPlayer.GetName()])

        moneyType, minMoney, maxMoney = runTaskMoneyAwardDict[taskType]

        if not moneyNum:

            moneyNum = random.randint(minMoney, maxMoney)

        if moneyType == ShareDefine.TYPE_Price_Family_Contribution:

            PlayerFamily.AddPlayerFamilyActiveValue(curPlayer, moneyNum, True, ShareDefine.Def_AddFAVReason_DoFamilyMisson)

        else:

            addDataDict = {ChConfig.Def_Give_Reason_SonKey:"Run"}

            PlayerControl.GiveMoney(curPlayer, moneyType, moneyNum, ChConfig.Def_GiveMoney_Mission, addDataDict, False)

        
        PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_RunTaskAwardRecord % taskType, moneyNum)

        
    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_RunTaskAwardState % taskType, 1)

    GameWorld.DebugLog('领取环任务每轮奖励成功  moneyType=%s, moneyNum=%s, itemList=%s, giveExp=%s'%(moneyType, moneyNum, itemList, giveExp))

    
    #通知客户端

    NotifyRunEndAward(curPlayer, taskType)

    ItemControler.NotifyGiveAwardInfo(curPlayer, itemList, "RunTaskEndAward", giveExp, {moneyType:moneyNum})

    
    #删除领取奖励的任务 (改由任务脚本触发下一环)

    EventRespons_GetLastRunTaskAward(curPlayer, taskType)

#    runTaskAwardTaskIDDict = IpyGameDataPY.GetFuncEvalCfg('RunTaskAwardTaskID')

#    runTaskAwardTaskID = runTaskAwardTaskIDDict.get(taskType, 0)

#    if runTaskAwardTaskID:

#        QuestCommon.DeleteMission(curPlayer, runTaskAwardTaskID)

    
    #更新下轮任务

#    mission_1 = QuestCommon.GetCommonMission(curPlayer)

#    if not mission_1:

#        return

#    nextMissionID = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_RunTaskNextMissionID % taskType)

#    if not nextMissionID:

#        #没有下轮任务

#        return

#    PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_RunTaskNextMissionID % taskType, 0)

#    if not curPlayer.FindMission(nextMissionID):

#        QuestCommon.AddNewMission(curPlayer, nextMissionID)

#    nextMission = curPlayer.FindMission(nextMissionID)

#    QuestCommon.SetPlayerMissionState(curPlayer, nextMission, 1)

#    nextMission.SetMissionState(1)

#    nextMission.SetDescriptionIndex(0)

#

#    #先清空字典再设置新的字典

#    curPlayer.Sync_ClearMissionDict(nextMissionID)

#    nextMission.ClearProperty()

#    Def_Around_AllCount = QuestRunner.GetRunKey(taskType, QuestRunner.Key_Around_AllCount)

#    Def_Around_Count = QuestRunner.GetRunKey(taskType, QuestRunner.Key_Around_Count)

#    mission_1.SetProperty(Def_Around_Count,0)

#    #总环数

#    allCount = mission_1.GetProperty(Def_Around_AllCount)

#    #单轮已做环数

#    #aroundCount = mission_1.GetProperty(Def_Around_Count)

#    nextMission.SetProperty(Def_Around_AllCount, allCount)

#    nextMission.SetProperty(Def_Around_Count, 0)

#    
#    #设置随机任务事件

#    EventRespons_SetRunAround(curPlayer, nextMissionID)

#    
#    
# 
#    NotifyOneMission(curPlayer, nextMission, isNotifyAll = False)

    return



def NotifyRunEndAward(curPlayer, taskType=-1):

    ## 通知跑环轮奖励

    taskTypeList = [QuestCommon.Def_Mission_Type_RunDaily, QuestCommon.Def_Mission_Type_RunFamily] if taskType == -1 else [taskType]

    infoPack = ChPyNetSendPack.tagMCRunTaskAwardInfo()

    infoPack.Clear()

    infoPack.InfoList = []

    for ttype in taskTypeList:

        recordPack = ChPyNetSendPack.tagMCRunTaskAwardRecord()

        recordPack.Type = ttype

        recordPack.Num = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_RunTaskAwardRecord % ttype)

        recordPack.AwardState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_RunTaskAwardState % ttype)

        infoPack.InfoList.append(recordPack)

    infoPack.Cnt = len(infoPack.InfoList)

    NetPackCommon.SendFakePack(curPlayer, infoPack)

    return



#// A2 24 触碰NPC #tagCMTouchNPC

@@ -5218,22 +610,3 @@
    npcControl.SetKilled()

    return





## 客户端任务计数

#===============================================================================

# //A2 25 客户端任务计数 # tagCMClientTaskCount

# 
# struct     tagCMClientTaskCount

# {

#    tagHead        Head;

#    DWORD        CountID;        // 计数ID，客户端与策划约定，可以是NPCID或其他

#    BYTE        Type;    // 1-杀怪

# };

#===============================================================================

def ClientTaskCount(index, clientData, tick):

    curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)

    countType = clientData.Type 
    RunQuestEvent(curPlayer, "on_client_by_id", clientData.CountID, Def_RunQuestType_Normal)

    #if countType == 1:

    #    PlayerPrestigeSys.AddRealmTaskValue(curPlayer, PlayerPrestigeSys.RealmTaskType_KillNPC, 1)

    return