#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
##@package Player.PlayerHorse
|
#
|
# @todo:×øÆï
|
# @author hxp
|
# @date 2019-12-17
|
# @version 1.0
|
#
|
# ÏêϸÃèÊö: ×øÆï
|
#
|
#-------------------------------------------------------------------------------
|
#"""Version = 2019-12-17 18:30"""
|
#-------------------------------------------------------------------------------
|
|
import ChPyNetSendPack
|
import IPY_GameWorld
|
import GameWorld
|
import PlayerControl
|
import ChConfig
|
import OperControlManager
|
import OpenServerCampaign
|
import ItemCommon
|
import ChEquip
|
import ShareDefine
|
import DataRecordPack
|
import ItemControler
|
import NetPackCommon
|
import PlayerBillboard
|
import PlayerAttrFruit
|
import PlayerGameEvent
|
import GameFuncComm
|
import EventShell
|
import IpyGameDataPY
|
import CrossPlayerData
|
import PlayerSuccess
|
import PlayerActLunhuidian
|
import PlayerActHorsePetTrain
|
import PlayerActTask
|
import PlayerPet
|
|
import time
|
|
|
Def_HorseEquipIndex = 5
|
|
|
#//03 09 Íæ¼ÒÆïÂí#tagCRideHorse
|
#
|
#struct tagCRideHorse
|
#{
|
# tagHead Head;
|
# BYTE Ride; //1: ÆïÂí 0: ÏÂÂí
|
#};
|
def OnRideHorse(index, tick):
|
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_Horse):
|
return False
|
|
cdTime = ChConfig.TYPE_Player_Tick_Time[ChConfig.TYPE_Player_Tick_HorseChangState]
|
# ÅжÏʱ¼äÊÇ·ñ³¬¹ý¼ä¸ô
|
if tick - curPlayer.GetTickByType(ChConfig.TYPE_Player_Tick_HorseChangState) <= cdTime:
|
#ûÓе½Ë¢Ð¼ä¸ô
|
return
|
curPlayer.SetTickByType(ChConfig.TYPE_Player_Tick_HorseChangState, tick)
|
|
pack = IPY_GameWorld.IPY_CRideHorse()
|
#//1: ÆïÂí 0: ÏÂÂí
|
curPlayerRideType = pack.GetRide()
|
if PlayerControl.GetCrossMapID(curPlayer):
|
# ÔÝÖ»´¦ÀíÉÏÂí
|
if curPlayerRideType:
|
dataList = [curPlayerRideType]
|
CrossPlayerData.SendDataToCrossServer(curPlayer, CrossPlayerData.CrossData_RideHorse, dataList)
|
return
|
#ÆïÂíÐÐΪ״̬, ¿Í»§¶ËÏÞÖÆ
|
if not OperControlManager.IsObjCanDoAction(curPlayer,
|
ChConfig.Def_Obj_ActState_ClientAct,
|
IPY_GameWorld.oalRide):
|
return
|
|
#ÏÂÂí
|
if curPlayerRideType == 0 :
|
PlayerRideHorseDown(curPlayer, True)
|
|
#ÆïÂí
|
elif curPlayerRideType == 1:
|
PlayerRideHorseUp(curPlayer, True)
|
|
return
|
|
def CrossServer_RideHorse(curPlayer, dataList):
|
curPlayerRideType = dataList[0]
|
|
#ÆïÂí
|
if curPlayerRideType == 1:
|
PlayerRideHorseUp(curPlayer, True)
|
|
return
|
|
def PlayerRideHorseDown(curPlayer, refreshState=True) :
|
## Íæ¼ÒÏÂÂí
|
if curPlayer.GetPlayerVehicle() != IPY_GameWorld.pvHorse:
|
return
|
|
curPlayer.SetPlayerVehicle(IPY_GameWorld.pvNull)
|
curPlayer.Sync_GetoffHorse()
|
|
playerControl = PlayerControl.PlayerControl(curPlayer)
|
playerControl.RefreshPlayerAttrByBuff()
|
return
|
|
def PlayerRideHorseUp(curPlayer, refreshState=True, isNotify=True) :
|
## Íæ¼ÒÉÏÂí
|
|
# δ¼ÓÔسɹ¦Æï³Ë»áµ¼ÖÂÄ£ÐͼÓÔØʧ°Ü±¨´í
|
if not curPlayer.GetInitOK():
|
return
|
|
customMapID = PlayerControl.GetCustomMapID(curPlayer)
|
if customMapID:
|
ipyMapData = IpyGameDataPY.GetIpyGameData("ChinMap", customMapID)
|
if not ipyMapData or not ipyMapData.GetCanRide():
|
PlayerControl.NotifyCode(curPlayer, "RideLimit_lhs_0")
|
return
|
else:
|
#µØͼ²»ÔÊÐíÆïÂí RideLimit_lhs_0
|
if not GameWorld.GetMap().GetMapCanRide():
|
PlayerControl.NotifyCode(curPlayer, "RideLimit_lhs_0")
|
return
|
|
#¼ì²éÍæ¼Ò״̬,Ö»ÓÐÔÚ¿ÕÏÐ״̬²ÅÄÜÉÏÂí
|
if curPlayer.GetPlayerVehicle() != IPY_GameWorld.pvNull :
|
#GameWorld.Log("ÒѾÓн»Í¨¹¤¾ß,ÎÞ·¨ÉÏÂí")
|
return
|
|
#¼ì²éÊÇ·ñ×°±¸Ö¸¶¨IDÎïÆ·
|
playerEquip = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
|
itemRideHorse = playerEquip.GetAt(Def_HorseEquipIndex)
|
#ÎÞÖ¸¶¨µÀ¾ß
|
if itemRideHorse.IsEmpty():
|
return
|
|
if curPlayer.GetPlayerAction() == IPY_GameWorld.paGameEvent:
|
tick = GameWorld.GetGameWorld().GetTick()
|
PlayerGameEvent.StopGameEvent(curPlayer, tick)
|
|
#ÉèÖÃÍæ¼ÒΪÆïÂí״̬
|
curPlayer.SetPlayerVehicle(IPY_GameWorld.pvHorse)
|
#ÉèÖÃÂíƥΪÆÕͨÒƶ¯×´Ì¬
|
curPlayer.SetPlayerRidehorseState(IPY_GameWorld.prsNormal)
|
|
if isNotify:
|
curPlayer.Sync_RideHorse()
|
|
if refreshState:
|
playerControl = PlayerControl.PlayerControl(curPlayer)
|
playerControl.RefreshPlayerAttrByBuff()
|
return True
|
|
#=====================================================================
|
|
#//A5 01 ×øÆＤ»î #tagPlayerActivateHorse
|
#
|
#struct tagPlayerActivateHorse
|
#{
|
# tagHead Head;
|
# DWORD HorseID; //×øÆï»Ã»¯ID
|
#};
|
def ActivateHorseSkinItem(index, curPackData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
playerID = curPlayer.GetPlayerID()
|
activateID = curPackData.HorseID
|
|
if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_Horse):
|
return
|
|
ipyData = IpyGameDataPY.GetIpyGameData("HorseSkinPlus", activateID)
|
if not ipyData:
|
return
|
|
updSkinEndTime = 0
|
validTime = ipyData.GetSkinValidTime()
|
if validTime:
|
curTime = int(time.time())
|
skinEndTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserSkinEndTime % activateID)
|
if curTime >= skinEndTime:
|
updSkinEndTime = curTime + validTime
|
else:
|
updSkinEndTime = skinEndTime + validTime
|
else:
|
if GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_HorserSkinPlusState, activateID):
|
GameWorld.DebugLog("¸Ã×øÆïÒѻû¯! activateID=%s" % activateID)
|
return
|
|
needItemID = ipyData.GetUnlockItemID()
|
needItemCnt = ipyData.GetUnlockItemCnt()
|
itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
|
hasEnough, itemList = ItemCommon.GetItem_FromPack_ByID(needItemID, itemPack, needItemCnt)
|
if not hasEnough:
|
GameWorld.DebugLog("×øÆï»Ã»¯µÀ¾ß²»×ã! needItemID=%s,needItemCnt=%s" % (needItemID, needItemCnt))
|
return
|
ItemCommon.ReduceItem(curPlayer, itemPack, itemList, needItemCnt, False, ChConfig.ItemDel_Horse)
|
|
if validTime:
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorserSkinEndTime % activateID, updSkinEndTime)
|
GameWorld.DebugLog("×øÆï»Ã»¯Ê±Ð§ activateID=%s,updSkinEndTime=%s(%s)" % (activateID, updSkinEndTime, GameWorld.ChangeTimeNumToStr(updSkinEndTime)), playerID)
|
|
#ʱЧ¼°·ÇʱЧ¸Ã״̬¾ùÉèÖü¤»î
|
activateState, updActivateState = GameWorld.SetDictValueByBit(curPlayer, ChConfig.Def_PDict_HorserSkinPlusState, activateID, 1)
|
|
playerEquip = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
|
itemRideHorse = playerEquip.GetAt(Def_HorseEquipIndex)
|
#ÎÞÖ¸¶¨µÀ¾ß
|
if itemRideHorse.IsEmpty():
|
DoChangeHorse(curPlayer, 2, activateID, tick)
|
|
Sync_HorseClassData(curPlayer)
|
if validTime:
|
SyncHorseSkinTimeInfo(curPlayer, activateID)
|
GameWorld.Log("×øÆＤ»î³É¹¦£¡activateID=%s,activateState=%s,updActivateState=%s,updSkinEndTime=%s"
|
% (activateID, activateState, updActivateState, updSkinEndTime), playerID)
|
|
# Ë¢ÊôÐÔ£¬¸üÐÂÅÅÐаñ
|
RefreshHorseAttr(curPlayer)
|
PlayerControl.WorldNotify(0, "GetMount", [curPlayer.GetName(), ipyData.GetHorseSkinPlusID()])
|
return
|
|
|
#//A5 02 ×øÆïÑ¡Ôñ #tagPlayerChooseHorse
|
#
|
#struct tagPlayerChooseHorse
|
#{
|
# tagHead Head;
|
# BYTE ChooseType; // 1-°´µÈ½×£¬2-°´»Ã»¯
|
# BYTE LVID; // ½×µÈ¼¶»ò»Ã»¯ID
|
#};
|
def OnPlayerChangeHorse(index, packData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
|
if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_Horse):
|
return
|
|
#¼ì²é»»×°¼ä¸ô
|
if tick - curPlayer.GetLastChangeEquipTick() <= ChConfig.Def_MinChangeEquipTime:
|
return
|
curPlayer.SetLastChangeEquipTick(tick)
|
|
chooseType = packData.ChooseType
|
lvID = packData.LVID
|
|
if not DoChangeHorse(curPlayer, chooseType, lvID, tick):
|
return
|
|
if not GameWorld.IsCrossServer():
|
dataList = [chooseType, lvID]
|
CrossPlayerData.SendDataToCrossServer(curPlayer, CrossPlayerData.CrossData_HorseChange, dataList)
|
|
return
|
|
def CrossServer_ChangeHorse(curPlayer, dataList):
|
## ¿ç·þ´¦Àí ×øÆï±ä¸ü
|
chooseType, lvID = dataList
|
tick = GameWorld.GetGameWorld().GetTick()
|
DoChangeHorse(curPlayer, chooseType, lvID, tick)
|
return
|
|
def DoChangeHorse(curPlayer, chooseType, lvID, tick):
|
''' ×øÆïÑ¡Ôñ
|
@param chooseType: 1-°´½×£¬2-°´»Ã»¯
|
@param lvID: ½×µÈ¼¶»ò»Ã»¯ID
|
'''
|
|
# °´½×
|
if chooseType == 1:
|
horseLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserLV)
|
if horseLV < lvID:
|
GameWorld.DebugLog("×øÆïµÈ¼¶²»×㣬ÎÞ·¨Ê¹ÓøÃ×øÆïƤ·ô! horseLV=%s,lvID=%s" % (horseLV, lvID))
|
return
|
|
horseIpyData = IpyGameDataPY.GetIpyGameData("HorseLVUp", lvID)
|
if not horseIpyData:
|
return
|
horseItemID = horseIpyData.GetHorseSkinID()
|
|
# °´»Ã»¯
|
elif chooseType == 2:
|
skinPlusIpyData = IpyGameDataPY.GetIpyGameData("HorseSkinPlus", lvID)
|
if not skinPlusIpyData:
|
return
|
if not CheckHorseSkinState(curPlayer, skinPlusIpyData):
|
return
|
horseItemID = skinPlusIpyData.GetHorseSkinPlusID()
|
|
else:
|
return
|
|
if not horseItemID:
|
GameWorld.DebugLog("ÕÒ²»µ½Ñ¡ÔñµÄ×øÆïID! chooseType=%s,lvID=%s" % (chooseType, lvID))
|
return
|
|
if ItemCommon.FindItemInPackByItemID(curPlayer, horseItemID, IPY_GameWorld.rptEquip):
|
GameWorld.DebugLog("ÒѾѡÔñÁ˸Ã×øÆÎÞÐèÖØÐÂÑ¡Ôñ! horseItemID=%s" % horseItemID)
|
return
|
|
isOK = ItemControler.PutItemInTempSwap(curPlayer, horseItemID)
|
if not isOK:
|
return
|
|
curHorse = ItemCommon.FindItemInPackByItemID(curPlayer, horseItemID, ShareDefine.rptTempSwap)
|
if not curHorse:
|
return
|
isRideHorse = curPlayer.GetPlayerVehicle() == IPY_GameWorld.pvHorse
|
|
# Èç¹ûÆï³Ë״̬£¬ÏÈÏÂÂí£¬»»×°£¬ÔÙÉÏÂí
|
if isRideHorse:
|
PlayerRideHorseDown(curPlayer, False)
|
|
#---Ö´ÐÐÍæ¼Ò»»×°Âß¼---
|
if ChEquip.DoPlayerEquipItem(curPlayer, curHorse, ItemCommon.GetEquipPackIndex(curHorse), tick):
|
if isRideHorse:
|
PlayerRideHorseUp(curPlayer, False)
|
|
return True
|
|
def CheckHorseSkinState(curPlayer, skinPlusIpyData):
|
skinID = skinPlusIpyData.GetID()
|
if skinPlusIpyData.GetSkinValidTime():
|
skinEndTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserSkinEndTime % skinID)
|
if not skinEndTime:
|
return False
|
curTime = int(time.time())
|
if curTime >= skinEndTime:
|
playerID = curPlayer.GetPlayerID()
|
GameWorld.Log("×øÆï»Ã»¯ÒѹýÆÚ! skinID=%s,skinEndTime=%s(%s)" % (skinID, skinEndTime, GameWorld.ChangeTimeNumToStr(skinEndTime)), playerID)
|
# ·¢Ë͹ýÆÚ֪ͨÓʼþ£¬ÖØÖÃΪ0
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorserSkinEndTime % skinID, 0)
|
|
skinItemID = skinPlusIpyData.GetUnlockItemID()
|
addItemList = []
|
paramList = [skinItemID]
|
PlayerControl.SendMailByKey("HorseSkinInvalidNotify", [playerID], addItemList, paramList)
|
|
activateState, updActivateState = GameWorld.SetDictValueByBit(curPlayer, ChConfig.Def_PDict_HorserSkinPlusState, skinID, 0)
|
GameWorld.Log("×øÆï»Ã»¯¹ýÆÚ¸üÐÂ״̬! skinID=%s,activateState=%s,updActivateState=%s" % (skinID, activateState, updActivateState), playerID)
|
Sync_HorseClassData(curPlayer)
|
return False
|
else:
|
if not GameWorld.GetDictValueByBit(curPlayer, ChConfig.Def_PDict_HorserSkinPlusState, skinID):
|
#GameWorld.DebugLog("×øÆï»Ã»¯Î´¼¤»î! skinID=%s,activateState=%s" % (skinID, activateState), curPlayer.GetPlayerID())
|
return False
|
return True
|
|
def DoHorseOpen(curPlayer):
|
## ÂíÆ¥¹¦ÄÜ¿ªÆô
|
horseLV = 1
|
ipyData = IpyGameDataPY.GetIpyGameData("HorseLVUp", horseLV)
|
if not ipyData:
|
return
|
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorserLV, horseLV)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorserEatItemCount, 0)
|
for trainType in xrange(1, GetHorseTrainTypes() + 1):
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorserTrainLV % trainType, 1)
|
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for index in xrange(ipyDataMgr.GetHorseSkinPlusCount()):
|
skinPlusIpyData = ipyDataMgr.GetHorseSkinPlusByIndex(index)
|
skinID = skinPlusIpyData.GetID()
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorserSkinEndTime % skinID, 0)
|
GameWorld.SetDictValueByBit(curPlayer, ChConfig.Def_PDict_HorserSkinPlusState, skinID, 0)
|
|
horseID = ipyData.GetHorseSkinID()
|
if not ItemCommon.FindItemInPackByItemID(curPlayer, horseID, IPY_GameWorld.rptEquip):
|
isOK = ItemControler.PutItemInTempSwap(curPlayer, horseID)
|
if not isOK:
|
return
|
|
curHorse = ItemCommon.FindItemInPackByItemID(curPlayer, horseID, ShareDefine.rptTempSwap)
|
if not curHorse:
|
return
|
#---Ö´ÐÐÍæ¼Ò»»×°Âß¼---
|
tick = GameWorld.GetGameWorld().GetTick()
|
ChEquip.DoPlayerEquipItem(curPlayer, curHorse, Def_HorseEquipIndex, tick)
|
|
GameWorld.DebugLog("×øÆ﹦ÄÜ¿ªÆô! horseLV=%s,horseID=%s" % (horseLV, horseID))
|
Sync_HorseClassData(curPlayer)
|
RefreshHorseAttr(curPlayer)
|
return True
|
|
def RefreshHorseAttr(curPlayer, isUpdateBill=True):
|
# ×øÆ﹦ÄÜÊôÐÔ±ä¸üË¢ÐÂ
|
CalcHorseAttrEx(curPlayer)
|
# ÐèÒª¸üÐÂ×øÆï°ñ¡¢Ç¿ÖÆË¢ÐÂÊôÐÔ
|
PlayerControl.PlayerControl(curPlayer).RefreshPlayerAttrState(billboardFunc=PlayerBillboard.UpdateHorseBillboard if isUpdateBill else None)
|
return
|
|
def CalcHorseAttrEx(curPlayer):
|
## ¼ÆËãÂíÆ¥ÊôÐÔ
|
if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_Horse):
|
return
|
|
allAttrList = [{} for _ in range(4)]
|
allAttrListHorseSoul = [{} for _ in range(4)]
|
allAttrListSkin = [{} for _ in range(4)]
|
allAttrListTrain = [{} for _ in range(4)]
|
allAttrListStar = [{} for _ in range(4)]
|
|
customAttrDictHorse = {}
|
customAttrDictSkin = {}
|
|
horseSpeed = 0 # ×øÆ﹦ÄÜÔö¼ÓµÄËÙ¶ÈÖµ£¬Æï³Ëʱ²ÅÓÐЧ¹û
|
horseLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserLV)
|
# µÈ½×ÅàÑøÊôÐÔ
|
#totalItemCount = 0
|
horseBaseAttrInfo = {}
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for index in xrange(ipyDataMgr.GetHorseLVUpCount()):
|
horseIpyData = ipyDataMgr.GetHorseLVUpByIndex(index)
|
dataHorseLV = horseIpyData.GetHorseLV()
|
if dataHorseLV > horseLV:
|
break
|
elif dataHorseLV == horseLV:
|
upItemCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserEatItemCount)
|
else:
|
upItemCount = horseIpyData.GetNeedEatCount()
|
|
# µÈ½×¶îÍâÊôÐÔ
|
lvAttrTypeList = horseIpyData.GetLVAttrType()
|
lvAttrValueList = horseIpyData.GetLVAttrValue()
|
for i, attrID in enumerate(lvAttrTypeList):
|
attrValue = lvAttrValueList[i]
|
if attrID == ShareDefine.Def_Effect_Speed:
|
horseSpeed += attrValue
|
continue
|
PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrList)
|
horseBaseAttrInfo[attrID] = horseBaseAttrInfo.get(attrID, 0) + attrValue
|
|
# ÅàÑøµ¤Ôö¼ÓÊôÐÔ
|
upItemPerCount = horseIpyData.GetUpEatItemPerCount()
|
if upItemCount and upItemPerCount:
|
upItemAttrTypeList = horseIpyData.GetUpItemAttrType()
|
upItemAttrValueList = horseIpyData.GetUpItemAttrValue()
|
attrMultiple = upItemCount / upItemPerCount
|
for i, attrID in enumerate(upItemAttrTypeList):
|
attrValue = upItemAttrValueList[i]
|
PlayerControl.CalcAttrDict_Type(attrID, attrValue * attrMultiple, allAttrList)
|
horseBaseAttrInfo[attrID] = horseBaseAttrInfo.get(attrID, 0) + attrValue * attrMultiple
|
|
customAttrDictHorse["horseBaseAttrInfo"] = horseBaseAttrInfo
|
|
# # µÈ½×ÅàÑøµ¤ÀÛ¼Ó¸öÊýÊôÐÔ
|
# eatItemAttrInfo = IpyGameDataPY.GetFuncCfg("HorseUpItem", 3)
|
# for attrID, attrValue in eatItemAttrInfo:
|
# PlayerControl.CalcAttrDict_Type(attrID, attrValue * totalItemCount, allAttrList)
|
|
# »Ã»¯ÊôÐÔ
|
initFPAdd = 0 #³õʼսÁ¦
|
horseSkinQualityAttrInfo = {}
|
for index in xrange(ipyDataMgr.GetHorseSkinPlusCount()):
|
skinPlusIpyData = ipyDataMgr.GetHorseSkinPlusByIndex(index)
|
if not CheckHorseSkinState(curPlayer, skinPlusIpyData):
|
continue
|
initFPAdd += skinPlusIpyData.GetInitFightPower()
|
attrTypeList = skinPlusIpyData.GetAttrType()
|
attrValueList = skinPlusIpyData.GetAttrValue()
|
for i, attrID in enumerate(attrTypeList):
|
attrValue = attrValueList[i]
|
if attrID == ShareDefine.Def_Effect_Speed:
|
horseSpeed += attrValue
|
continue
|
PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrListSkin)
|
|
#¾õÐÑÕ½Á¦
|
skintype = 1
|
horseID = skinPlusIpyData.GetHorseID()
|
skinData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorsePetSkinData % (skintype, horseID))
|
skinIpyData = IpyGameDataPY.GetIpyGameDataNotLog('HorsePetSkin', skintype, horseID, skinData / 100)
|
if skinIpyData:
|
for attrID, attrValue in skinIpyData.GetAttrInfo().items():
|
PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrListSkin)
|
|
hIpyData = IpyGameDataPY.GetIpyGameData("Horse", horseID)
|
if hIpyData:
|
quality = hIpyData.GetQuality()
|
if quality not in horseSkinQualityAttrInfo:
|
horseSkinQualityAttrInfo[quality] = {}
|
qualityAttrDict = horseSkinQualityAttrInfo[quality]
|
for i, attrID in enumerate(attrTypeList):
|
attrValue = attrValueList[i]
|
qualityAttrDict[attrID] = qualityAttrDict.get(attrID, 0) + attrValue
|
|
#ÐǼ¶
|
horseStar = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserStar % horseID)
|
starIpyData = IpyGameDataPY.GetIpyGameDataNotLog("HorseStarUp", horseID, horseStar)
|
if starIpyData:
|
starAttrType = starIpyData.GetStarAttrType()
|
starAttrValue = starIpyData.GetStarAttrValue()
|
for i, attrID in enumerate(starAttrType):
|
attrValue = starAttrValue[i]
|
if attrID == ShareDefine.Def_Effect_Speed:
|
horseSpeed += attrValue
|
continue
|
PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrListStar)
|
|
customAttrDictSkin["horseSkinQualityAttrInfo"] = horseSkinQualityAttrInfo
|
|
# ÐÂÅàÑøÊôÐÔ
|
for index in xrange(ipyDataMgr.GetHorseTrainCount()):
|
trainIpyData = ipyDataMgr.GetHorseTrainByIndex(index)
|
trainType = trainIpyData.GetTrainType()
|
dataTrainLV = trainIpyData.GetTrainLV()
|
trainLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserTrainLV % trainType)
|
|
if dataTrainLV > trainLV:
|
continue
|
elif dataTrainLV == trainLV:
|
trainItemCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserTrainItemCount % trainType)
|
else:
|
trainItemCount = trainIpyData.GetEatCntTotal()
|
|
# µÈ½×¶îÍâÊôÐÔ
|
lvAttrTypeList = trainIpyData.GetLVAttrTypeList()
|
lvAttrValueList = trainIpyData.GetLVAttrValueList()
|
for i, attrID in enumerate(lvAttrTypeList):
|
attrValue = lvAttrValueList[i]
|
if attrID == ShareDefine.Def_Effect_Speed:
|
horseSpeed += attrValue
|
continue
|
PlayerControl.CalcAttrDict_Type(attrID, attrValue, allAttrListTrain)
|
|
# ÅàÑøµ¤Ôö¼ÓÊôÐÔ
|
eatCntEverytime = trainIpyData.GetEatCntEverytime()
|
if trainItemCount and eatCntEverytime:
|
eatItemAttrTypeList = trainIpyData.GetEatItemAttrTypeList()
|
eatItemAttrValueList = trainIpyData.GetEatItemAttrValueList()
|
attrMultiple = trainItemCount / eatCntEverytime
|
for i, attrID in enumerate(eatItemAttrTypeList):
|
attrValue = eatItemAttrValueList[i]
|
PlayerControl.CalcAttrDict_Type(attrID, attrValue * attrMultiple, allAttrListTrain)
|
|
PlayerControl.SetMFPExFightPower(curPlayer, ShareDefine.Def_MFPType_Horse, initFPAdd)
|
|
#GameWorld.DebugLog("×øÆ﹦ÄÜÊôÐÔ: horseLV=%s,horseSpeed=%s,totalItemCount=%s,initFPAdd=%s" % (horseLV, horseSpeed, totalItemCount, initFPAdd))
|
|
# ÏÈ»º´æÖµ£¬Æï³Ë״̬ʱ½øÐи½¼Ó
|
curPlayer.SetDict(ChConfig.Def_PlayerKey_SpeedHorse, horseSpeed)
|
|
# ¹ûʵ¶Ô×øÆïµÄ¼Ó³É, »êʯ¹ûʵË㸽¼ÓÊôÐԲ㣬µ¥¶À¼ÆËã
|
fightPowerEx = PlayerAttrFruit.CalcAttrFruitAddAtrr(curPlayer, allAttrListHorseSoul, ShareDefine.Def_AttrFruitFunc_Horse)
|
PlayerControl.SetMFPExFightPower(curPlayer, ShareDefine.Def_MFPType_HorseSoul, fightPowerEx)
|
|
# ±£´æ¼ÆËãÖµ
|
PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_Horse, allAttrList, customAttrDict=customAttrDictHorse)
|
PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_HorseSoul, allAttrListHorseSoul)
|
PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_HorseSkin, allAttrListSkin, customAttrDict=customAttrDictSkin)
|
PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_HorseTarin, allAttrListTrain)
|
PlayerControl.SetCalcAttrListValue(curPlayer, ChConfig.Def_CalcAttrFunc_HorseStar, allAttrListStar)
|
return
|
|
def GetHorseSkinActCount(curPlayer):
|
horseSkinActCount = 0
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for index in xrange(ipyDataMgr.GetHorseSkinPlusCount()):
|
skinPlusIpyData = ipyDataMgr.GetHorseSkinPlusByIndex(index)
|
if not CheckHorseSkinState(curPlayer, skinPlusIpyData):
|
continue
|
horseSkinActCount += 1
|
return horseSkinActCount
|
|
#// A5 27 ×øÆïÌáÉý #tagCMHorseUp
|
#
|
#struct tagCMHorseUp
|
#{
|
# tagHead Head;
|
# WORD UseItemCnt; //ÏûºÄ²ÄÁϸöÊý
|
# BYTE IsAutoBuy; //ÊÇ·ñ×Ô¶¯¹ºÂò
|
#};
|
def OnHorseClassLVUP(index, curPackData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
costItemCount = curPackData.UseItemCnt # ÏûºÄ²ÄÁϸöÊý
|
isAutoBuy = curPackData.IsAutoBuy # ÊÇ·ñ×Ô¶¯¹ºÂò
|
|
# ÅжÏÍæ¼ÒÊÇ·ñ¿ÉÒÔÉý¼¶ÂíÆ¥
|
if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_Horse):
|
GameWorld.DebugLog("×øÆï먦Æô!")
|
return
|
|
horseLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserLV)
|
curEatItemCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserEatItemCount)
|
if horseLV <= 0:
|
GameWorld.DebugLog("×øÆïÌáÉý ¸Ã×øÆïδ¼¤»î horseLV=%s" % horseLV)
|
return
|
|
horseIpyData = IpyGameDataPY.GetIpyGameData("HorseLVUp", horseLV)
|
if not horseIpyData:
|
return
|
|
needEatCount = horseIpyData.GetNeedEatCount()
|
if not needEatCount:
|
GameWorld.DebugLog("×øÆïÒÑÂú¼¶£¡horseLV=%s" % horseLV)
|
return
|
|
costItemID = IpyGameDataPY.GetFuncCfg("HorseUpItem", 1)
|
if not costItemID or not costItemCount:
|
return
|
|
costItemIndexList, bindCnt, unBindCnt = ItemCommon.GetPackItemBindStateIndexInfo(curPlayer, costItemID, costItemCount)
|
lackCnt = costItemCount - bindCnt - unBindCnt
|
if lackCnt > 0 and not isAutoBuy:
|
GameWorld.DebugLog("ÏûºÄµÀ¾ß²»×㣬ÎÞ·¨Éý¼¶×øÆï!costItemID=%s,costItemCount=%s,bindCnt=%s,unBindCnt=%s,lackCnt=%s"
|
% (costItemID, costItemCount, bindCnt, unBindCnt, lackCnt))
|
return
|
|
delCnt = costItemCount
|
if lackCnt > 0:
|
lackCost = ItemCommon.GetAutoBuyItemNeedGold({costItemID:lackCnt})
|
if lackCost <= 0:
|
return
|
infoDict = {ChConfig.Def_Cost_Reason_SonKey:costItemID}
|
if not PlayerControl.PayMoney(curPlayer, IPY_GameWorld.TYPE_Price_Gold_Money, lackCost, ChConfig.Def_Cost_BuyStoreItem, infoDict):
|
return
|
delCnt -= lackCnt
|
|
# ¿Û³ýÏûºÄ
|
if delCnt:
|
ItemCommon.DelCostItemByBind(curPlayer, costItemIndexList, bindCnt, unBindCnt, delCnt, ChConfig.ItemDel_Horse)
|
|
updClassLV = horseLV
|
updEatItemCount = curEatItemCount + costItemCount
|
GameWorld.DebugLog("×øÆïÅàÑø: horseLV=%s,curEatItemCount=%s,costItemCount=%s,updEatItemCount=%s,needEatCount=%s"
|
% (horseLV, curEatItemCount, costItemCount, updEatItemCount, needEatCount))
|
|
if updEatItemCount >= needEatCount:
|
updClassLV += 1
|
updEatItemCount -= needEatCount
|
GameWorld.DebugLog(" Éý½×: updClassLV=%s,updEatItemCount=%s" % (updClassLV, updEatItemCount))
|
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorserLV, updClassLV)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorserEatItemCount, updEatItemCount)
|
|
# Éý½×
|
upItemPerCount = horseIpyData.GetUpEatItemPerCount()
|
upCnt = costItemCount / upItemPerCount
|
for _ in range(upCnt):
|
EventShell.EventRespons_HorseUp(curPlayer) # ¸ÄΪʹÓþÍËã
|
if updClassLV > horseLV:
|
EventShell.EventRespons_HorseLV(curPlayer, updClassLV)
|
# Íæ¼ÒÂíÆ¥½ø½×
|
DataRecordPack.DR_NewHorseByClassUp(curPlayer, updClassLV, 0)
|
# ¼Ç¼¿ª·þ»î¶¯ÂíÆ¥½×¼¶
|
#OpenServerCampaign.UpdOpenServerCampaignRecordData(curPlayer, ShareDefine.Def_Campaign_Type_Horse, updClassLV)
|
PlayerSuccess.UptateSuccessProgress(curPlayer, ShareDefine.SuccType_HorseAllLV, updClassLV)
|
|
Sync_HorseClassData(curPlayer)
|
# Ë¢ÊôÐÔ£¬¸üÐÂÅÅÐаñ
|
RefreshHorseAttr(curPlayer)
|
|
PlayerActHorsePetTrain.OnHorsePetTrainCost(curPlayer, {costItemID:costItemCount})
|
PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_HorseUpItem, costItemCount)
|
PlayerActLunhuidian.AddLunhuidianValue(curPlayer, PlayerActLunhuidian.AwardType_UseItem, costItemID, costItemCount)
|
return
|
|
#// A5 31 ×øÆïÅàÑø #tagCMHorseTrain
|
#
|
#struct tagCMHorseTrain
|
#{
|
# tagHead Head;
|
# BYTE TrainType; //ÅàÑøÀàÐÍ£º 1-»ù´¡ÅàÑø£¬2-ÌØÊâÅàÑø£¬3-°Ù·Ö±ÈÅàÑø
|
# WORD UseItemCnt; //ÏûºÄ²ÄÁϸöÊý
|
#};
|
def OnHorseTrain(index, curPackData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
trainType = curPackData.TrainType # ÅàÑøÀàÐÍ
|
costItemCount = curPackData.UseItemCnt # ÏûºÄ²ÄÁϸöÊý
|
|
trainLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserTrainLV % trainType)
|
curEatItemCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserTrainItemCount % trainType)
|
GameWorld.DebugLog("×øÆïÅàÑø: trainType=%s,trainLV=%s,costItemCount=%s,curEatItemCount=%s"
|
% (trainType, trainLV, costItemCount, curEatItemCount))
|
|
if trainType <= 0 or trainType > GetHorseTrainTypes():
|
return
|
|
if trainLV <= 0:
|
GameWorld.DebugLog(" ×øÆïÅàÑøδ¼¤»î trainType=%s" % trainType)
|
return
|
|
trainIpyData = IpyGameDataPY.GetIpyGameData("HorseTrain", trainType, trainLV)
|
if not trainIpyData:
|
return
|
|
needRealmLV = trainIpyData.GetNeedRealmLV()
|
curRealmLV = PlayerControl.GetTrainRealmLVReal(curPlayer, 1)
|
if curRealmLV < needRealmLV:
|
GameWorld.DebugLog(" ¾³½ç²»×㣬ÎÞ·¨ÅàÑø£¡ curRealmLV(%s) < needRealmLV(%s)" % (curRealmLV, needRealmLV))
|
return
|
|
needEatCountTotal = trainIpyData.GetEatCntTotal()
|
if not needEatCountTotal:
|
GameWorld.DebugLog(" ¸ÃÅàÑøÒÑÂú¼¶£¡")
|
return
|
|
costItemIDList = IpyGameDataPY.GetFuncEvalCfg("HorseTrain", 1)
|
costItemID = costItemIDList[trainType - 1]
|
if not costItemID or not costItemCount:
|
return
|
|
costItemIndexList, bindCnt, unBindCnt = ItemCommon.GetPackItemBindStateIndexInfo(curPlayer, costItemID, costItemCount)
|
lackCnt = costItemCount - bindCnt - unBindCnt
|
if lackCnt > 0:
|
GameWorld.DebugLog(" ÏûºÄµÀ¾ß²»×㣬ÎÞ·¨ÅàÑø!costItemID=%s,costItemCount=%s,bindCnt=%s,unBindCnt=%s,lackCnt=%s"
|
% (costItemID, costItemCount, bindCnt, unBindCnt, lackCnt))
|
return
|
|
delCnt = costItemCount
|
|
# ¿Û³ýÏûºÄ
|
if delCnt:
|
ItemCommon.DelCostItemByBind(curPlayer, costItemIndexList, bindCnt, unBindCnt, delCnt, ChConfig.ItemDel_Horse)
|
|
updClassLV = trainLV
|
updEatItemCount = curEatItemCount + costItemCount
|
GameWorld.DebugLog(" updEatItemCount=%s,needEatCountTotal=%s" % (updEatItemCount, needEatCountTotal))
|
|
if updEatItemCount >= needEatCountTotal:
|
updClassLV += 1
|
updEatItemCount -= needEatCountTotal
|
GameWorld.DebugLog(" ½ø½×: updClassLV=%s,updEatItemCount=%s" % (updClassLV, updEatItemCount))
|
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorserTrainLV % trainType, updClassLV)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorserTrainItemCount % trainType, updEatItemCount)
|
|
# Éý½×
|
if updClassLV > trainLV:
|
pass
|
|
Sync_HorseClassData(curPlayer)
|
# Ë¢ÊôÐÔ£¬¸üÐÂÅÅÐаñ
|
RefreshHorseAttr(curPlayer)
|
|
PlayerActHorsePetTrain.OnHorsePetTrainCost(curPlayer, {costItemID:costItemCount})
|
if trainType == 2:
|
PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_HorseTrainItem2, costItemCount)
|
elif trainType == 3:
|
PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_HorseTrainItem3, costItemCount)
|
elif trainType == 1:
|
PlayerActTask.AddActTaskValue(curPlayer, ChConfig.ActTaskType_HorseTrainItem1, costItemCount)
|
return
|
|
#// A5 35 ×øÆïÉýÐÇ #tagCMHorseStarUp
|
#
|
#struct tagCMHorseStarUp
|
#{
|
# tagHead Head;
|
# DWORD HorseID; //×øÆïID£¬¶ÔÓ¦×øÆï±íID
|
#};
|
def OnHorseStarUp(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
playerID = curPlayer.GetPlayerID()
|
horseID = clientData.HorseID
|
|
horseStar = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserStar % horseID)
|
nextStar = horseStar + 1
|
nextIpyData = IpyGameDataPY.GetIpyGameData("HorseStarUp", horseID, nextStar)
|
if not nextIpyData:
|
GameWorld.DebugLog("×øÆï²»´æÔÚ¸ÃÐǼ¶£¬ÎÞ·¨ÉýÐÇ. horseID=%s,curStar=%s" % (horseID, horseStar), playerID)
|
return
|
needItemList = nextIpyData.GetStarUpNeedItemList()
|
if not needItemList:
|
return
|
itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
|
lackItemDict, delInfoDict = ItemCommon.GetCostItemIndexList(needItemList, itemPack)
|
if lackItemDict:
|
GameWorld.DebugLog("×øÆïÉýÐÇËùÐèÎïÆ·²»×㣡 horseID=%s,nextStar=%s,needItemList=%s,lackItemDict=%s"
|
% (horseID, nextStar, needItemList, lackItemDict), playerID)
|
return
|
|
ItemCommon.DelCostItem(curPlayer, itemPack, delInfoDict, "HorseStarUp")
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorserStar % horseID, nextStar)
|
|
GameWorld.DebugLog("×øÆïÉýÐÇ. horseID=%s,curStar=%s,nextStar=%s" % (horseID, horseStar, nextStar), playerID)
|
|
RefreshHorseAttr(curPlayer)
|
SyncHorseStarInfo(curPlayer, horseID)
|
return
|
|
def GetHorseTrainTypes():
|
return len(IpyGameDataPY.GetFuncEvalCfg("HorseTrain", 1))
|
|
def PlayerHorseLogin(curPlayer):
|
##×øÆïµÇ¼´¦Àí
|
if not GameFuncComm.GetFuncCanUse(curPlayer, ShareDefine.GameFuncID_Horse):
|
return
|
|
# ×øÆï»Ã»¯×´Ì¬¶àÖµÖ§³ÖÐ޸ģ¬ÏßÉÏ°æ±¾×ö¾ÉֵתÒÆ
|
oldVerSkinStateKey = "HorserSkinPlusState"
|
oldVerSkinStateValue = curPlayer.NomalDictGetProperty(oldVerSkinStateKey)
|
if oldVerSkinStateValue:
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorserSkinPlusState % 0, oldVerSkinStateValue)
|
PlayerControl.NomalDictSetProperty(curPlayer, oldVerSkinStateKey, 0)
|
GameWorld.Log("ÏßÉϰ汾תÒÆ×øÆï»Ã»¯×´Ì¬¼Ç¼×ÖµäÖµ! oldVerSkinStateValue=%s" % (oldVerSkinStateValue), curPlayer.GetPlayerID())
|
|
# ÅàÑøÊǺóÃæ¼ÓµÄ¹¦ÄÜ£¬Ã¿´ÎµÇ¼²¹¼ì²éһϹ¦ÄÜ¿ªÊ¼Ê±ÉèÖÃΪÅàÑø1¼¶
|
for trainType in xrange(1, GetHorseTrainTypes() + 1):
|
if curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserTrainLV % trainType) == 0:
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorserTrainLV % trainType, 1)
|
|
Sync_HorseClassData(curPlayer)
|
SyncHorsePetSkinData(curPlayer)
|
SyncHorseSkinTimeInfo(curPlayer)
|
SyncHorseStarInfo(curPlayer)
|
return
|
|
def Sync_HorseClassData(curPlayer):
|
horseData = ChPyNetSendPack.tagTrainHorseData()
|
horseData.Clear()
|
horseData.LV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserLV)
|
horseData.EatItemCount = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserEatItemCount)
|
horseData.SkinPlusState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserSkinPlusState)
|
horseData.TrainLVList = []
|
horseData.TrainItemCountList = []
|
for trainType in xrange(1, GetHorseTrainTypes() + 1):
|
horseData.TrainLVList.append(curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserTrainLV % trainType))
|
horseData.TrainItemCountList.append(curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserTrainItemCount % trainType))
|
horseData.TrainTypes = len(horseData.TrainLVList)
|
horseData.SkinPlusStateList = GetHorseSkinPlusStateList(curPlayer)
|
horseData.SkinPlusStateCount = len(horseData.SkinPlusStateList)
|
NetPackCommon.SendFakePack(curPlayer, horseData)
|
return
|
|
def GetHorseSkinPlusStateList(curPlayer):
|
maxSkinID = 0
|
skinPlusStateList = []
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
skinCnt = ipyDataMgr.GetHorseSkinPlusCount()
|
for index in xrange(skinCnt):
|
maxSkinID = max(maxSkinID, ipyDataMgr.GetHorseSkinPlusByIndex(index).GetID())
|
for index in xrange(maxSkinID / 31+1):
|
skinPlusStateList.append(curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserSkinPlusState % index))
|
return skinPlusStateList
|
|
def GetHorseSumLV(curPlayer):
|
## ×øÆï×ܵȼ¶
|
return curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserLV)
|
|
def IsHorseLVFull(curPlayer):
|
## ×øÆïÊÇ·ñÂú¼¶
|
horseLV = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserLV)
|
horseIpyData = IpyGameDataPY.GetIpyGameData("HorseLVUp", horseLV)
|
if not horseIpyData:
|
return False
|
needEatCount = horseIpyData.GetNeedEatCount()
|
if not needEatCount:
|
return True
|
return False
|
|
#============================Æï³è¾õÐÑ=============================
|
#// A5 29 Æï³è¾õÐÑ #tagCMHorsePetAwake
|
#
|
#struct tagCMHorsePetAwake
|
#{
|
# tagHead Head;
|
# WORD Type; // 1-×øÆï 2-Áé³è
|
# DWORD ID; // ¶ÔÓ¦×øÆï±íÁé³è±íID
|
# DWORD EatItemID; // ÍÌÊɵÄÎïÆ·ID
|
#};
|
def OnHorsePetAwake(index, curPackData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
skintype = curPackData.Type
|
horsePetID = curPackData.ID
|
eatItemID = curPackData.EatItemID
|
GameWorld.DebugLog("Æï³è¾õÐÑ: skintype=%s,horsePetID=%s,eatItemID=%s" % (skintype, horsePetID, eatItemID))
|
if not IpyGameDataPY.GetIpyGameDataByCondition('HorsePetSkin', {'Type':skintype, 'ID':horsePetID}):
|
return
|
# if skintype == 1:
|
# #×øÆïÍæ·¨Ð޸ģ¬ÔݹرÕ×øÆï¾õÐÑ
|
# return
|
# if not IsHorseMaxLV(curPlayer, horsePetID):
|
# GameWorld.DebugLog('Æï³è¾õÐÑ ¶ÔÓ¦Æï³èδÂú¼¶ horsePetID=%s' % horsePetID)
|
# return
|
# else:
|
# if not PlayerPet.IsPetMaxLV(curPlayer, horsePetID):
|
# GameWorld.DebugLog('Æï³è¾õÐÑ ¶ÔÓ¦Æï³èδÂú¼¶ horsePetID=%s' % horsePetID)
|
# return
|
|
skinData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorsePetSkinData % (skintype, horsePetID), 0)
|
curSkinLV, curSkinIndex = skinData / 100, skinData % 100
|
ipyData = IpyGameDataPY.GetIpyGameData('HorsePetSkin', skintype, horsePetID, curSkinLV)
|
if not ipyData:
|
return
|
upNeedExp = ipyData.GetNeedExp()
|
if not upNeedExp:
|
GameWorld.DebugLog('Æï³è¾õÐÑ ÒÑÂú¼¶')
|
return
|
curExp = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorsePetSkinExp % (skintype, horsePetID), 0)
|
curItem = GameWorld.GetGameData().GetItemByTypeID(eatItemID)
|
if not curItem:
|
return
|
curEff = curItem.GetEffectByIndex(4)
|
curEffID = curEff.GetEffectID()
|
addExp = curEff.GetEffectValue(0)
|
if curEffID != ChConfig.Def_Effect_HorsePetSkinExp or not addExp:
|
GameWorld.ErrLog('ÎïƷЧ¹û5ûÓÐÅäÖÃÆï³è¾õÐѾÑéЧ¹û! eatItemID=%s,curEffID=%s,addExp=%s,needEffID=%s'
|
% (eatItemID, curEffID, addExp, ChConfig.Def_Effect_HorsePetSkinExp))
|
return
|
itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
|
hasEnough, itemList = ItemCommon.GetItem_FromPack_ByID(eatItemID, itemPack, 1)
|
if not hasEnough:
|
GameWorld.DebugLog("OnHorsePetAwake() item(%s[%s]) isn't enough" % (eatItemID, 1))
|
return
|
ItemCommon.ReduceItem(curPlayer, itemPack, itemList, 1, False, ChConfig.ItemDel_HorsePetAwake)
|
|
updExp = curExp + addExp
|
updSkinLV = curSkinLV
|
updSkinIndex = curSkinIndex
|
if updExp >= upNeedExp:
|
for _ in xrange(10):
|
ipyData = IpyGameDataPY.GetIpyGameDataNotLog('HorsePetSkin', skintype, horsePetID, updSkinLV + 1)
|
if not ipyData:
|
break
|
if updExp < upNeedExp:
|
break
|
updExp -= upNeedExp
|
updSkinLV += 1
|
updSkinIndex = ipyData.GetSkinIndex()
|
upNeedExp = ipyData.GetNeedExp()
|
|
updSkinData = updSkinLV * 100 + updSkinIndex
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorsePetSkinData % (skintype, horsePetID), updSkinData)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorsePetSkinExp % (skintype, horsePetID), updExp)
|
GameWorld.DebugLog("skinData=%s,curExp=%s,updSkinData=%s,updExp=%s" % (skinData, curExp, updSkinData, updExp))
|
if curSkinIndex != updSkinIndex:
|
__DoHorsePetSkinChange(curPlayer, skintype, horsePetID, updSkinIndex)
|
if updSkinLV != curSkinLV:
|
if skintype == 1:
|
RefreshHorseAttr(curPlayer)
|
else:
|
PlayerPet.RefreshPetItemAddAttr(curPlayer, True)
|
|
SyncHorsePetSkinData(curPlayer, [[skintype, horsePetID]])
|
return
|
|
#// A5 30 Æï³èÍâ¹ÛÑ¡Ôñ #tagCMHorsePetSkinSelect
|
#struct tagCMHorsePetSkinSelect
|
#{
|
# tagHead Head;
|
# WORD Type; // 1-×øÆï 2-Áé³è
|
# DWORD ID; // ¶ÔÓ¦×øÆï±íÁé³è±íID
|
# BYTE SkinIndex; // Íâ¹ÛË÷Òý
|
#};
|
def OnHorsePetSkinSelect(index, curPackData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
skintype = curPackData.Type
|
horsePetID = curPackData.ID
|
skinIndex = curPackData.SkinIndex
|
ipyData = IpyGameDataPY.GetIpyGameDataByCondition('HorsePetSkin', {'Type':skintype, 'ID':horsePetID, 'SkinIndex':skinIndex})
|
if not ipyData:
|
return
|
skinData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorsePetSkinData % (skintype, horsePetID), 0)
|
curSkinLV, curSkinIndex = skinData / 100, skinData % 100
|
if skinIndex == curSkinIndex:
|
return
|
if curSkinLV < ipyData.GetSkinLV():
|
return
|
|
updSkinData = curSkinLV * 100 + skinIndex
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HorsePetSkinData % (skintype, horsePetID), updSkinData)
|
|
__DoHorsePetSkinChange(curPlayer, skintype, horsePetID, skinIndex)
|
|
SyncHorsePetSkinData(curPlayer, [[skintype, horsePetID]])
|
return
|
|
def __DoHorsePetSkinChange(curPlayer, skinType, horsePetID, skinIndex):
|
##Æï³è¾õÐÑÍâ¹Û¸ü»»
|
ChEquip.ChangeEquipfacadeByHorsePetSkin(curPlayer, skinType, skinIndex)
|
if skinType == 1:#×øÆï
|
# ×øÆ﹦ÄÜÐ޸ģ¬ÔݹرվõÐÑ
|
return
|
playerEquip = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptEquip)
|
itemRideHorse = playerEquip.GetAt(Def_HorseEquipIndex)
|
#ÎÞÖ¸¶¨µÀ¾ß
|
if itemRideHorse.IsEmpty():
|
return
|
ipyData = IpyGameDataPY.GetIpyGameData("Horse", horsePetID)
|
if not ipyData:
|
return
|
horseItemID = ipyData.GetItemID()
|
if itemRideHorse.GetItemTypeID() != horseItemID:
|
return
|
itemRideHorse.SetUserAttr(ShareDefine.Def_IudetHorsePetSkinIndex, skinIndex)
|
elif skinType == 2:#Áé³è
|
pass
|
return
|
|
def GetHorsePetSkinIndex(curPlayer, skintype, horsePetID):
|
# »ñÈ¡Æï³è¾õÐÑÍâ¹ÛË÷Òý
|
skinData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorsePetSkinData % (skintype, horsePetID), 0)
|
return skinData % 100
|
|
def SyncHorsePetSkinData(curPlayer, skinList=None):
|
if not skinList:
|
skinList = []
|
ipyMgr = IpyGameDataPY.IPY_Data()
|
for i in xrange(ipyMgr.GetHorsePetSkinCount()):
|
ipyData = ipyMgr.GetHorsePetSkinByIndex(i)
|
if [ipyData.GetType(), ipyData.GetID()] not in skinList:
|
skinList.append([ipyData.GetType(), ipyData.GetID()])
|
|
packData = ChPyNetSendPack.tagMCHorsePetSkinData()
|
packData.Clear()
|
packData.InfoList = []
|
for skintype, horsePetID in skinList:
|
skinInfo = ChPyNetSendPack.tagMCHorsePetSkinInfo()
|
skinInfo.Type = skintype
|
skinInfo.ID = horsePetID
|
curExp = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorsePetSkinExp % (skintype, horsePetID), 0)
|
skinData = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorsePetSkinData % (skintype, horsePetID), 0)
|
if not curExp and not skinData:
|
continue
|
curSkinLV, curSkinIndex = skinData / 100, skinData % 100
|
skinInfo.Exp = curExp
|
skinInfo.SkinLV = curSkinLV
|
skinInfo.SkinIndex = curSkinIndex
|
packData.InfoList.append(skinInfo)
|
packData.Num = len(packData.InfoList)
|
NetPackCommon.SendFakePack(curPlayer, packData)
|
return
|
|
def SyncHorseSkinTimeInfo(curPlayer, skinID=None):
|
skinList = []
|
if skinID > 0:
|
timeInfo = ChPyNetSendPack.tagMCHorseSkinTimeInfo()
|
timeInfo.ID = skinID
|
timeInfo.InvalidTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserSkinEndTime % skinID)
|
skinList.append(timeInfo)
|
else:
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for index in xrange(ipyDataMgr.GetHorseSkinPlusCount()):
|
skinPlusIpyData = ipyDataMgr.GetHorseSkinPlusByIndex(index)
|
skinID = skinPlusIpyData.GetID()
|
if not skinPlusIpyData.GetSkinValidTime():
|
continue
|
timeInfo = ChPyNetSendPack.tagMCHorseSkinTimeInfo()
|
timeInfo.ID = skinID
|
timeInfo.InvalidTime = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserSkinEndTime % skinID)
|
skinList.append(timeInfo)
|
|
packData = ChPyNetSendPack.tagMCHorseSkinTimeInfoList()
|
packData.Clear()
|
packData.TimeInfoList = skinList
|
packData.TimeCnt = len(packData.TimeInfoList)
|
NetPackCommon.SendFakePack(curPlayer, packData)
|
return
|
|
def SyncHorseStarInfo(curPlayer, horseID=None):
|
if horseID > 0:
|
syncIDList = [horseID]
|
else:
|
syncIDList = []
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for index in range(ipyDataMgr.GetHorseCount()):
|
ipyData = ipyDataMgr.GetHorseByIndex(index)
|
syncIDList.append(ipyData.GetHorseID())
|
|
if not syncIDList:
|
return
|
|
horseStarList = []
|
for horseID in syncIDList:
|
horseStar = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HorserStar % horseID)
|
if not horseStar:
|
continue
|
starInfo = ChPyNetSendPack.tagMCHorseStar()
|
starInfo.Clear()
|
starInfo.HorseID = horseID
|
starInfo.Star = horseStar
|
horseStarList.append(starInfo)
|
|
if not horseStarList:
|
return
|
|
clientPack = ChPyNetSendPack.tagMCHorseStarInfo()
|
clientPack.Clear()
|
clientPack.HorseStarList = horseStarList
|
clientPack.Count = len(clientPack.HorseStarList)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
