#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
##@package Player.PlayerHero
|
#
|
# @todo:Î佫ӢÐÛ
|
# @author hxp
|
# @date 2025-06-11
|
# @version 1.0
|
#
|
# ÏêϸÃèÊö: Î佫ӢÐÛ
|
#
|
#-------------------------------------------------------------------------------
|
#"""Version = 2025-06-11 11:00"""
|
#-------------------------------------------------------------------------------
|
|
import ItemCommon
|
import ShareDefine
|
import IpyGameDataPY
|
import IPY_GameWorld
|
import ItemControler
|
import ChPyNetSendPack
|
import NetPackCommon
|
import PlayerControl
|
import GameWorld
|
import ChConfig
|
|
import random
|
|
def OnPlayerLogin(curPlayer):
|
Sync_HeroInfo(curPlayer)
|
return
|
|
def InitHeroItem(singleItem):
|
## Î佫¿¨ÅƳõʼ»¯£º³õʼµÈ¼¶1£» ÐǼ¶¡¢Í»ÆƵȼ¶¡¢¾õÐѵȼ¶¾ùΪ0
|
singleItem.SetUserAttr(ShareDefine.Def_IudetHeroLV, 1)
|
if singleItem.GetUserAttr(ShareDefine.Def_IudetHeroStar):
|
singleItem.SetUserAttr(ShareDefine.Def_IudetHeroStar, 0)
|
if singleItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV):
|
singleItem.SetUserAttr(ShareDefine.Def_IudetHeroBreakLV, 0)
|
if singleItem.GetUserAttr(ShareDefine.Def_IudetHeroAwakeLV):
|
singleItem.SetUserAttr(ShareDefine.Def_IudetHeroAwakeLV, 0)
|
if singleItem.GetUserAttr(ShareDefine.Def_IudetHeroSkin):
|
singleItem.SetUserAttr(ShareDefine.Def_IudetHeroSkin, 0)
|
if singleItem.GetUserAttr(ShareDefine.Def_IudetHeroPosNum):
|
singleItem.SetUserAttr(ShareDefine.Def_IudetHeroPosNum, 0)
|
|
if singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentID):
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentID)
|
if singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDLV):
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentIDLV)
|
if singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentWashLock):
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentWashLock)
|
if singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentWashID):
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentWashID)
|
if singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDAwakeRand):
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentIDAwakeRand)
|
|
InitHeroTalent(singleItem)
|
return
|
|
def InitHeroTalent(singleItem):
|
'''³õʼ»¯²ÛλÌ츳£¬²»Í¬²ÛλÌ츳ID²»ÄÜÒ»Ñù
|
'''
|
heroID = singleItem.GetItemTypeID()
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
|
if not heroIpyData:
|
return
|
quality = heroIpyData.GetQuality()
|
qualityIpyData = IpyGameDataPY.GetIpyGameData("HeroQuality", quality)
|
if not qualityIpyData:
|
return
|
|
initTalentCnt = 1
|
initTalentWeight = qualityIpyData.GetInitTalentWeight() # ³õʼÌ츳ÊýȨÖØ
|
if initTalentWeight:
|
initTalentCnt = GameWorld.GetResultByWeightList(initTalentWeight, 1)
|
|
talentIDDict = {}
|
talentWeightList = []
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for index in range(ipyDataMgr.GetHeroTalentCount()):
|
talentIpyData = ipyDataMgr.GetHeroTalentByIndex(index)
|
talentID = talentIpyData.GetTalentID()
|
initWeight = talentIpyData.GetInitWeight()
|
talentWeightList.append([initWeight, talentID])
|
talentIDDict[talentID] = initWeight
|
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentID)
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentIDLV)
|
for _ in range(initTalentCnt):
|
randTalentID = GameWorld.GetResultByWeightList(talentWeightList)
|
if not randTalentID:
|
continue
|
|
# ÒƳýÈ·±£²»Öظ´
|
randWeightID = [talentIDDict.get(randTalentID, 0), randTalentID]
|
if randWeightID in talentWeightList:
|
talentWeightList.remove(randWeightID)
|
|
singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentID, randTalentID)
|
singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentIDLV, 1)
|
|
return
|
|
def OnGiveHeroItem(curPlayer, heroItem):
|
## »ñµÃij¸öÎ佫
|
heroID = heroItem.GetItemTypeID()
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
|
if not heroIpyData:
|
return
|
|
if not GetHeroActivite(curPlayer, heroID):
|
SetHeroActivite(curPlayer, heroID, 1)
|
GameWorld.DebugLog("Ê״줻îÎ佫: heroID=%s" % (heroID), curPlayer.GetPlayerID())
|
#Ê״λñµÃͼ¼ø¶îÍâÂß¼ ...
|
Sync_HeroInfo(curPlayer, [heroID])
|
|
return
|
|
def GetHeroActivite(curPlayer, heroID):
|
## Î佫״̬
|
# @return: 0-δ¼¤»î£»1-Î佫ÒÑ»ñµÃ,¿É¼¤»î£»2-ͼ¼øÒѼ¤»î
|
actState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID) % 10
|
return actState
|
|
def SetHeroActivite(curPlayer, heroID, isAct=1):
|
## ÉèÖÃÎ佫ÒÑ»ñµÃ£¬¿É¼¤»î״̬
|
bookState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID)
|
actState = bookState % 10
|
if isAct:
|
if actState:
|
return
|
actState = 1
|
else:
|
actState = 0
|
updBookState = GameWorld.SetValue(bookState, 1, 1, actState)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HeroBook % heroID, updBookState)
|
GameWorld.DebugLog("ÉèÖÃÎ佫¼¤»î״̬:%s,bookState=%s,updBookState=%s" % (isAct, bookState, updBookState), curPlayer.GetPlayerID())
|
return
|
|
def GetHeroBookInitState(curPlayer, heroID):
|
## Î佫ͼ¼ø¼¤»î״̬
|
initState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID) % 10
|
return initState > 1
|
def SetHeroBookInitState(curPlayer, heroID, isAct=1):
|
## ÉèÖÃÎ佫ͼ¼ø¼¤»î״̬
|
bookState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID)
|
actState = bookState % 10
|
if isAct:
|
actState = 2
|
else:
|
actState = 1 if actState else 0
|
updBookState = GameWorld.SetValue(bookState, 1, 1, actState)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HeroBook % heroID, updBookState)
|
GameWorld.DebugLog("ÉèÖÃÎ佫ͼ¼ø¼¤»î״̬:%s,bookState=%s,updBookState=%s" % (isAct, bookState, updBookState), curPlayer.GetPlayerID())
|
return
|
|
def GetHeroBookStarLV(curPlayer, heroID):
|
## Î佫ͼ¼øÐǼ¶µÈ¼¶
|
bookState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID)
|
return GameWorld.GetValue(bookState, 4, 3)
|
def SetHeroBookStarLV(curPlayer, heroID, starLV):
|
## ÉèÖÃÎ佫ͼ¼øÐǼ¶µÈ¼¶£¬Ö§³ÖÈýλÊý 0~999 ¼¶
|
bookState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID)
|
updBookState = GameWorld.SetValue(bookState, 4, 3, starLV)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HeroBook % heroID, updBookState)
|
GameWorld.DebugLog("ÉèÖÃÎ佫ͼ¼øÐǼ¶µÈ¼¶:%s,bookState=%s,updBookState=%s" % (starLV, bookState, updBookState), curPlayer.GetPlayerID())
|
return
|
|
def GetHeroBookBreakLV(curPlayer, heroID):
|
## Î佫ͼ¼øÍ»ÆƵȼ¶
|
bookState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID)
|
return GameWorld.GetValue(bookState, 7, 3)
|
def SetHeroBookBreakLV(curPlayer, heroID, breakLV):
|
## ÉèÖÃÎ佫ͼ¼øÍ»ÆƵȼ¶£¬Ö§³ÖÈýλÊý 0~999 ¼¶
|
bookState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID)
|
updBookState = GameWorld.SetValue(bookState, 7, 3, breakLV)
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HeroBook % heroID, updBookState)
|
GameWorld.DebugLog("ÉèÖÃÎ佫ͼ¼øÍ»ÆƵȼ¶:%s,bookState=%s,updBookState=%s" % (breakLV, bookState, updBookState), curPlayer.GetPlayerID())
|
return
|
|
def GetHeroItem(curPlayer, itemIndex):
|
curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
|
if itemIndex < 0 or itemIndex >= curPack.GetCount():
|
return
|
heroItem = curPack.GetAt(itemIndex)
|
if not heroItem or heroItem.IsEmpty():
|
return
|
if heroItem.GetType() != ChConfig.Def_ItemType_Hero:
|
return
|
return heroItem
|
|
#// B2 30 Î佫Éý¼¶ #tagCSHeroLVUP
|
#
|
#struct tagCSHeroLVUP
|
#{
|
# tagHead Head;
|
# WORD ItemIndex; //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
|
#};
|
def OnHeroLVUP(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
playerID = curPlayer.GetPlayerID()
|
itemIndex = clientData.ItemIndex
|
heroItem = GetHeroItem(curPlayer, itemIndex)
|
if not heroItem:
|
return
|
heroID = heroItem.GetItemTypeID()
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
|
if not heroIpyData:
|
return
|
quality = heroIpyData.GetQuality()
|
breakLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV)
|
heroLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroLV)
|
LVMax = GetHeroLVMax(heroItem)
|
GameWorld.DebugLog("ÇëÇóÎ佫Éý¼¶: itemIndex=%s,heroID=%s,heroLV=%s,quality=%s,breakLV=%s,LVMax=%s"
|
% (itemIndex, heroID, heroLV, quality, breakLV, LVMax), playerID)
|
if heroLV >= LVMax:
|
GameWorld.DebugLog("¸ÃÎ佫ÒÑÂú¼¶£¡LVMax=%s" % (LVMax), playerID)
|
return
|
qualityIpyData = IpyGameDataPY.GetIpyGameData("HeroQuality", quality)
|
if not qualityIpyData:
|
return
|
costItemInfo = qualityIpyData.GetUPCostItem()
|
if not costItemInfo:
|
return
|
costItemID, costItemCount = costItemInfo
|
if not costItemID or not costItemCount:
|
return
|
itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
|
hasEnough, itemIndexList = ItemCommon.GetItem_FromPack_ByID(costItemID, itemPack, costItemCount)
|
if not hasEnough:
|
GameWorld.DebugLog("²ÄÁϲ»×㣬Î佫ÎÞ·¨Éý¼¶! costItemID=%s, costItemCount=%s" % (costItemID, costItemCount))
|
return
|
ItemCommon.ReduceItem(curPlayer, itemPack, itemIndexList, costItemCount, True, "HeroLVUP")
|
|
updHeroLV = heroLV + 1
|
GameWorld.DebugLog("Î佫Éý¼¶: itemIndex=%s,heroID=%s,updHeroLV=%s" % (itemIndex, heroID, updHeroLV), playerID)
|
heroItem.SetUserAttr(ShareDefine.Def_IudetHeroLV, updHeroLV)
|
|
# Ë¢ÊôÐÔ£¬Ö®ºóÀ©Õ¹
|
|
return
|
|
def GetHeroLVMax(heroItem):
|
## »ñÈ¡Î佫µ±Ç°×î´óµÈ¼¶
|
heroID = heroItem.GetItemTypeID()
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
|
if not heroIpyData:
|
return 0
|
quality = heroIpyData.GetQuality()
|
breakLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV)
|
qualityBreakIpyData = IpyGameDataPY.GetIpyGameData("HeroQualityBreak", quality, breakLV)
|
if not qualityBreakIpyData:
|
return 0
|
LVMax = qualityBreakIpyData.GetLVMax()
|
return LVMax
|
|
#// B2 31 Î佫ÉýÐÇ #tagCSHeroStarUP
|
#
|
#struct tagCSHeroStarUP
|
#{
|
# tagHead Head;
|
# WORD ItemIndex; //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
|
# WORD UseItemIndex; //ʹÓÃÎ佫²ÄÁÏÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
|
#};
|
def OnHeroStarUP(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
playerID = curPlayer.GetPlayerID()
|
itemIndex = clientData.ItemIndex
|
useItemIndex = clientData.UseItemIndex
|
heroItem = GetHeroItem(curPlayer, itemIndex)
|
useItem = GetHeroItem(curPlayer, useItemIndex)
|
if not heroItem or not useItem or itemIndex == useItemIndex:
|
return
|
heroID = heroItem.GetItemTypeID()
|
useHeroID = useItem.GetItemTypeID()
|
GameWorld.DebugLog("ÇëÇóÎ佫ÉýÐÇ: itemIndex=%s,heroID=%s,useItemIndex=%s,useHeroID=%s"
|
% (itemIndex, heroID, useItemIndex, useHeroID), playerID)
|
if heroID != useHeroID:
|
GameWorld.DebugLog("Î佫²ÄÁϷDZ¾Ì壬ÎÞ·¨ÉýÐÇ!", playerID)
|
return
|
washIDCnt = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentWashID)
|
if washIDCnt:
|
GameWorld.ErrLog("Î佫ϴÁ¶½á¹ûδ´¦Àí£¬ÎÞ·¨ÉýÐÇ! itemIndex=%s,heroID=%s" % (itemIndex, heroID), playerID)
|
return
|
awakeRandCnt = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDAwakeRand)
|
if awakeRandCnt:
|
GameWorld.ErrLog("Î佫¾õÐѽâËøÌ츳δѡÔñ£¬ÎÞ·¨ÉýÐÇ! itemIndex=%s,heroID=%s" % (itemIndex, heroID), playerID)
|
return
|
useBreakLV = useItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV)
|
useAwakeLV = useItem.GetUserAttr(ShareDefine.Def_IudetHeroAwakeLV)
|
if useBreakLV or useAwakeLV:
|
GameWorld.DebugLog("²ÄÁÏ¿¨Í»ÆÆ»ò¾õÐѵȼ¶²»Îª0ÔÝʱÎÞ·¨ÉýÐÇ£¡useBreakLV=%s,useAwakeLV=%s" % (useBreakLV, useAwakeLV), playerID)
|
return
|
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
|
if not heroIpyData:
|
return
|
quality = heroIpyData.GetQuality()
|
star = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)
|
awakeLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroAwakeLV)
|
starMax = GetHeroStarMax(heroItem)
|
GameWorld.DebugLog("heroID=%s,star=%s,quality=%s,awakeLV=%s,starMax=%s" % (heroID, star, quality, awakeLV, starMax), playerID)
|
if star >= starMax:
|
GameWorld.DebugLog("¸ÃÎ佫ÒÑÂúÐÇ£¡starMax=%s" % (starMax), playerID)
|
return
|
useStar = useItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)
|
addStar = useStar + 1
|
updStar = star + addStar
|
GameWorld.DebugLog("Î佫ÉýÐÇ: itemIndex=%s,heroID=%s,star=%s,useStar=%s,addStar=%s,updStar=%s"
|
% (itemIndex, heroID, star, useStar, addStar, updStar), playerID)
|
ItemCommon.DelItem(curPlayer, useItem, useItem.GetCount(), False, "HeroStarUP")
|
DoHeroUpdStar(curPlayer, heroItem, updStar)
|
return
|
|
def GetHeroStarMax(heroItem):
|
## »ñÈ¡Î佫µ±Ç°×î´óÐǼ¶
|
heroID = heroItem.GetItemTypeID()
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
|
if not heroIpyData:
|
return 0
|
quality = heroIpyData.GetQuality()
|
qualityIpyData = IpyGameDataPY.GetIpyGameData("HeroQuality", quality)
|
if not qualityIpyData:
|
return 0
|
InitStarUpper = qualityIpyData.GetInitStarUpper()
|
|
addStarUpper = 0
|
heroAwakeIpyDataList = IpyGameDataPY.GetIpyGameDataList("HeroAwake", heroID)
|
if heroAwakeIpyDataList:
|
awakeLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroAwakeLV)
|
for ipyData in heroAwakeIpyDataList:
|
if ipyData.GetAwakeLV() > awakeLV:
|
break
|
#ipyData.GetUnlockTalentSlot()
|
addStarUpper += ipyData.GetAddStarUpper()
|
|
starMax = InitStarUpper + addStarUpper
|
return starMax
|
|
def DoHeroUpdStar(curPlayer, heroItem, updStar):
|
## Ö´ÐÐÎ佫ÐǼ¶¸üÐÂ
|
curStar = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)
|
addStar = updStar - curStar
|
item = heroItem.GetItem()
|
item.SetUserAttr(ShareDefine.Def_IudetHeroStar, updStar)
|
if addStar > 0:
|
__DoHeroStarTalentUp(item, addStar)
|
heroItem.Sync_Item()
|
|
# Ë¢ÊôÐÔ£¬Ö®ºóÀ©Õ¹
|
|
return
|
|
def __DoHeroStarTalentUp(singleItem, addLV):
|
## Ö´ÐÐÎ佫ÐǼ¶Ì츳µÈ¼¶ÌáÉý
|
|
commTalentSlot = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 1) # ³£¹æÌ츳²Û¸öÊý
|
talentMaxLV = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 2) # ÿ¸öÌ츳×î´óµÈ¼¶
|
idCount = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentID)
|
lvCount = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDLV)
|
idList, lvList = [], [] # ¼Ç¼ÔÚÎïÆ·ÉϵÄÖµ£¬ÓÐ˳Ðò
|
unfullLVIDList = [] # δÂú¼¶µÄÌ츳ID
|
haveUp = False
|
for index in range(min(idCount, lvCount)):
|
talentID = singleItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentID, index)
|
talentLV = singleItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentIDLV, index)
|
idList.append(talentID)
|
lvList.append(talentLV)
|
if talentLV < talentMaxLV:
|
unfullLVIDList.append(talentID)
|
|
if len(idList) < commTalentSlot:
|
idList += [0] * (commTalentSlot - len(idList))
|
lvList += [0] * (commTalentSlot - len(lvList))
|
|
GameWorld.DebugLog("Ö´ÐÐÎ佫ÐǼ¶Ì츳µÈ¼¶ÌáÉý: addLV=%s" % addLV)
|
GameWorld.DebugLog("µ±Ç°ÐǼ¶Ì츳: idList=%s,lvList=%s" % (idList, lvList))
|
GameWorld.DebugLog("δÂú¼¶ÐǼ¶Ì츳ID: %s" % unfullLVIDList)
|
|
# ÓпÕÓà²Û룬ÓÅÏȸø¿ÕÓà²ÛλÌ츳£¬¶îÍâ½âËøµÄ²ÛλÊÇÐèÒªÏÈÑ¡ÔñµÄ£¬ËùÒÔÒ»¶¨²»Îª¿Õ£¬¹ÊÕâÀïÖ»Åжϳ£¹æ²Ûλ¼´¿É
|
if 0 in idList:
|
idWeightDict = {}
|
talentWeightList = []
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for index in range(ipyDataMgr.GetHeroTalentCount()):
|
talentIpyData = ipyDataMgr.GetHeroTalentByIndex(index)
|
talentID = talentIpyData.GetTalentID()
|
if talentID in idList:
|
# Ì츳ID²»¿ÉÖظ´
|
continue
|
weight = talentIpyData.GetWashWeight()
|
talentWeightList.append([weight, talentID])
|
idWeightDict[talentID] = weight
|
|
GameWorld.DebugLog("³£¹æ¿Õ²ÛλÔö¼ÓÌ츳Êý£º%s" % addLV)
|
for _ in range(addLV):
|
if 0 not in idList:
|
break
|
randTalentID = GameWorld.GetResultByWeightList(talentWeightList)
|
if not randTalentID:
|
continue
|
# ÒƳýÈ·±£²»Öظ´
|
randWeightID = [idWeightDict.get(randTalentID, 0), randTalentID]
|
if randWeightID in talentWeightList:
|
talentWeightList.remove(randWeightID)
|
zeroIndex = idList.index(0)
|
idList[zeroIndex] = randTalentID
|
lvList[zeroIndex] = 1
|
unfullLVIDList.append(randTalentID)
|
GameWorld.DebugLog("ÐÂÔöÐǼ¶Ì츳ID: %s" % (randTalentID))
|
addLV -= 1
|
haveUp = True
|
|
# ʣϵĵȼ¶´ÎÊý¶ÔÒÑÓÐÌ츳½øÐÐÉý¼¶
|
if addLV > 0:
|
for _ in range(addLV):
|
if not unfullLVIDList:
|
break
|
randID = random.choice(unfullLVIDList)
|
if randID not in idList:
|
unfullLVIDList.remove(randID)
|
continue
|
randIndex = idList.index(randID)
|
idLV = lvList[randIndex]
|
|
if idLV < talentMaxLV:
|
idLV += 1
|
lvList[randIndex] = idLV
|
GameWorld.DebugLog("Éý¼¶ÐǼ¶Ì츳ID: %s,idLV=%s,index=%s" % (randID, idLV, randIndex))
|
|
if idLV >= talentMaxLV:
|
unfullLVIDList.remove(randID)
|
GameWorld.DebugLog(" ÒƳýδÂú¼¶ID: %s,unfullLVIDList=%s" % (randID, unfullLVIDList))
|
|
haveUp = True
|
|
if not haveUp:
|
return
|
GameWorld.DebugLog("¸üÐÂÐǼ¶Ì츳: idList=%s,lvList=%s" % (idList, lvList))
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentID)
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentIDLV)
|
for index, talentID in enumerate(idList):
|
if not talentID:
|
break
|
singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentID, talentID)
|
singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentIDLV, lvList[index])
|
return
|
|
#// B2 32 Î佫ͻÆÆ #tagCSHeroBreak
|
#
|
#struct tagCSHeroBreak
|
#{
|
# tagHead Head;
|
# WORD ItemIndex; //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
|
#};
|
def OnHeroBreak(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
playerID = curPlayer.GetPlayerID()
|
itemIndex = clientData.ItemIndex
|
heroItem = GetHeroItem(curPlayer, itemIndex)
|
if not heroItem:
|
return
|
heroID = heroItem.GetItemTypeID()
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
|
if not heroIpyData:
|
return
|
quality = heroIpyData.GetQuality()
|
breakLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV)
|
GameWorld.DebugLog("ÇëÇóÎ佫ͻÆÆ: itemIndex=%s,heroID=%s,quality=%s,breakLV=%s"
|
% (itemIndex, heroID, quality, breakLV), playerID)
|
ipyData = IpyGameDataPY.GetIpyGameData("HeroQualityBreak", quality, breakLV)
|
if not ipyData:
|
return
|
nextBreakLV = breakLV + 1
|
if not IpyGameDataPY.GetIpyGameData("HeroQualityBreak", quality, nextBreakLV):
|
GameWorld.DebugLog("Í»ÆƵȼ¶ÒÑÂú¼¶: quality=%s,breakLV=%s" % (quality, breakLV), playerID)
|
return
|
costItemInfo = ipyData.GetUPCostItem()
|
if not costItemInfo:
|
return
|
costItemID, costItemCount = costItemInfo
|
if not costItemID or not costItemCount:
|
return
|
itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
|
hasEnough, itemIndexList = ItemCommon.GetItem_FromPack_ByID(costItemID, itemPack, costItemCount)
|
if not hasEnough:
|
GameWorld.DebugLog("²ÄÁϲ»×㣬Î佫ÎÞ·¨Í»ÆÆ! costItemID=%s, costItemCount=%s" % (costItemID, costItemCount))
|
return
|
ItemCommon.ReduceItem(curPlayer, itemPack, itemIndexList, costItemCount, True, "HeroBreak")
|
GameWorld.DebugLog("Î佫ͻÆÆ: itemIndex=%s,heroID=%s,nextBreakLV=%s" % (itemIndex, heroID, nextBreakLV), playerID)
|
SetHeroBreakLV(heroItem, nextBreakLV)
|
|
# Ë¢ÊôÐÔ£¬Ö®ºóÀ©Õ¹
|
|
return
|
|
def SetHeroBreakLV(heroItem, breakLV):
|
## ÉèÖÃÎ佫ͻÆƵȼ¶
|
heroItem.SetUserAttr(ShareDefine.Def_IudetHeroBreakLV, breakLV)
|
return
|
|
#// B2 33 Î佫¾õÐÑ #tagCSHeroAwake
|
#
|
#struct tagCSHeroAwake
|
#{
|
# tagHead Head;
|
# WORD ItemIndex; //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
|
#};
|
def OnHeroAwake(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
playerID = curPlayer.GetPlayerID()
|
itemIndex = clientData.ItemIndex
|
heroItem = GetHeroItem(curPlayer, itemIndex)
|
if not heroItem:
|
return
|
heroID = heroItem.GetItemTypeID()
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
|
if not heroIpyData:
|
return
|
quality = heroIpyData.GetQuality()
|
starLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)
|
awakeLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroAwakeLV)
|
GameWorld.DebugLog("ÇëÇóÎ佫¾õÐÑ: itemIndex=%s,heroID=%s,quality=%s,awakeLV=%s,starLV=%s"
|
% (itemIndex, heroID, quality, awakeLV, starLV), playerID)
|
awakeLimitStar = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 4)
|
commTalentSlot = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 1) # ³£¹æÌ츳²Û¸öÊý
|
if starLV < awakeLimitStar or starLV < commTalentSlot:
|
GameWorld.DebugLog("µ±Ç°ÐǼ¶²»¿É¾õÐÑ: starLV=%s < %s, %s" % (starLV, awakeLimitStar, commTalentSlot), playerID)
|
return
|
ipyData = IpyGameDataPY.GetIpyGameData("HeroQualityAwake", quality, awakeLV)
|
if not ipyData:
|
return
|
nextAwakeLV = awakeLV + 1
|
if not IpyGameDataPY.GetIpyGameData("HeroQualityAwake", quality, nextAwakeLV):
|
GameWorld.DebugLog("¾õÐѵȼ¶ÒÑÂú¼¶: quality=%s,awakeLV=%s" % (quality, awakeLV), playerID)
|
return
|
costItemInfo = ipyData.GetUPCostItem()
|
if not costItemInfo:
|
return
|
costItemID, costItemCount = costItemInfo
|
if not costItemID or not costItemCount:
|
return
|
itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
|
hasEnough, itemIndexList = ItemCommon.GetItem_FromPack_ByID(costItemID, itemPack, costItemCount)
|
if not hasEnough:
|
GameWorld.DebugLog("²ÄÁϲ»×㣬Î佫ÎÞ·¨¾õÐÑ! costItemID=%s, costItemCount=%s" % (costItemID, costItemCount))
|
return
|
ItemCommon.ReduceItem(curPlayer, itemPack, itemIndexList, costItemCount, True, "HeroAwake")
|
GameWorld.DebugLog("Î佫¾õÐÑ: itemIndex=%s,heroID=%s,nextBreakLV=%s" % (itemIndex, heroID, nextAwakeLV), playerID)
|
SetHeroAwakeLV(heroItem, nextAwakeLV)
|
|
# Ë¢ÊôÐÔ£¬Ö®ºóÀ©Õ¹
|
|
return
|
|
def SetHeroAwakeLV(heroItem, awakeLV):
|
## ÉèÖÃÎ佫¾õÐѵȼ¶
|
item = heroItem.GetItem()
|
item.SetUserAttr(ShareDefine.Def_IudetHeroAwakeLV, awakeLV)
|
unlockTalentSlotByAwake(item)
|
heroItem.Sync_Item()
|
return
|
|
def unlockTalentSlotByAwake(singleItem):
|
## ¾õÐѽâËøÌ츳²Û
|
heroID = singleItem.GetItemTypeID()
|
awakeLV = singleItem.GetUserAttr(ShareDefine.Def_IudetHeroAwakeLV)
|
awakeIpyDataList = IpyGameDataPY.GetIpyGameDataList("HeroAwake", heroID)
|
if not awakeIpyDataList:
|
return
|
maxUnlockSlot = 0
|
for ipyData in awakeIpyDataList[:awakeLV][::-1]: # µ¹Ðò±éÀú£¬µÚÒ»¸öÃüÖеľÍÊÇ×î´óµÄ
|
unlockTalentSlot = ipyData.GetUnlockTalentSlot()
|
if unlockTalentSlot:
|
maxUnlockSlot = unlockTalentSlot
|
break
|
if not maxUnlockSlot:
|
return
|
idCount = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentID)
|
if idCount >= maxUnlockSlot:
|
return
|
commTalentSlot = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 1) # ³£¹æÌ츳²Û¸öÊý
|
if maxUnlockSlot <= commTalentSlot:
|
return
|
awakeRandCnt = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDAwakeRand)
|
if awakeRandCnt:
|
# ÒѾ´æÔÚ¾õÐÑÌ츳Ëæ»úÑ¡ÏÐèÒªÏÈÑ¡Ôñºó²ÅÄܼÌÐø
|
return
|
|
# Ëæ»ú¾õÐÑÌ츳ѡÏî
|
idList = []
|
for index in range(idCount):
|
talentID = singleItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentID, index)
|
idList.append(talentID)
|
|
GameWorld.DebugLog("¾õÐѽâËøÌ츳²Û: awakeLV=%s,maxUnlockSlot=%s,idList=%s" % (awakeLV, maxUnlockSlot, idList))
|
|
idWeightDict = {}
|
talentWeightList = []
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for index in range(ipyDataMgr.GetHeroTalentCount()):
|
talentIpyData = ipyDataMgr.GetHeroTalentByIndex(index)
|
talentID = talentIpyData.GetTalentID()
|
if talentID in idList:
|
# Ì츳ID²»¿ÉÖظ´
|
continue
|
weight = talentIpyData.GetAweakWeight()
|
talentWeightList.append([weight, talentID])
|
idWeightDict[talentID] = weight
|
|
randTalentCnt = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 3)
|
for _ in range(randTalentCnt):
|
randTalentID = GameWorld.GetResultByWeightList(talentWeightList)
|
if not randTalentID:
|
continue
|
# ÒƳýÈ·±£²»Öظ´
|
randWeightID = [idWeightDict.get(randTalentID, 0), randTalentID]
|
if randWeightID in talentWeightList:
|
talentWeightList.remove(randWeightID)
|
singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentIDAwakeRand, randTalentID)
|
GameWorld.DebugLog("Ëæ»ú¾õÐÑÌ츳ѡÏî: randTalentID=%s" % (randTalentID))
|
|
return
|
|
#// B2 34 Î佫¾õÐÑÑ¡ÔñÌ츳 #tagCSHeroAwakeSelectTalent
|
#
|
#struct tagCSHeroAwakeSelectTalent
|
#{
|
# tagHead Head;
|
# WORD ItemIndex; //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
|
# BYTE SelectIndex; //Ñ¡ÔñнâËø²ÛλµÄÌ츳Ë÷Òý
|
#};
|
def OnHeroAwakeSelectTalent(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
playerID = curPlayer.GetPlayerID()
|
itemIndex = clientData.ItemIndex
|
selectIndex = clientData.SelectIndex
|
heroItem = GetHeroItem(curPlayer, itemIndex)
|
if not heroItem:
|
return
|
heroID = heroItem.GetItemTypeID()
|
awakeRandCnt = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDAwakeRand)
|
if not awakeRandCnt or selectIndex >= awakeRandCnt:
|
GameWorld.DebugLog("²»´æÔڸþõÐÑÌ츳Ëæ»úÑ¡Ïî! heroID=%s,selectIndex=%s,awakeRandCnt=%s" % (heroID, selectIndex, awakeRandCnt), playerID)
|
return
|
selectTalentID = heroItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentIDAwakeRand, selectIndex)
|
if not selectTalentID:
|
return
|
|
singleItem = heroItem.GetItem()
|
idCount = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentID)
|
lvCount = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDLV)
|
idList, lvList = [], [] # ¼Ç¼ÔÚÎïÆ·ÉϵÄÖµ£¬ÓÐ˳Ðò
|
for index in range(min(idCount, lvCount)):
|
talentID = singleItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentID, index)
|
talentLV = singleItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentIDLV, index)
|
idList.append(talentID)
|
lvList.append(talentLV)
|
|
commTalentSlot = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 1) # ³£¹æÌ츳²Û¸öÊý
|
if idCount < commTalentSlot:
|
idList += [0] * (commTalentSlot - idCount)
|
lvList += [0] * (commTalentSlot - idCount)
|
|
if selectTalentID in idList:
|
GameWorld.ErrLog("Ñ¡ÔñÌ츳ID²»ÄÜÖظ´! heroID=%s,selectIndex=%s,selectTalentID=%s in %s"
|
% (heroID, selectIndex, selectTalentID, idList), playerID)
|
return
|
|
idList.append(selectTalentID)
|
lvList.append(1)
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentIDAwakeRand)
|
|
GameWorld.DebugLog("¸üÐÂÑ¡ÔñÌ츳: selectTalentID=%s,idList=%s,lvList=%s" % (selectTalentID, idList, lvList))
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentID)
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentIDLV)
|
for index, talentID in enumerate(idList):
|
singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentID, talentID)
|
singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentIDLV, lvList[index])
|
|
unlockTalentSlotByAwake(singleItem)
|
|
heroItem.Sync_Item()
|
|
# Ë¢ÊôÐÔ£¬Ö®ºóÀ©Õ¹
|
|
return
|
|
#// B2 35 Î佫ϴÁ¶ #tagCSHeroWash
|
#
|
#struct tagCSHeroWash
|
#{
|
# tagHead Head;
|
# WORD ItemIndex; //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
|
# BYTE LockCnt;
|
# BYTE LockTalentIndexs[LockCnt]; //Ëø¶¨Ì츳Ë÷ÒýÁбí
|
# BYTE OPType; // ²Ù×÷ÀàÐÍ£º0-Ö´ÐÐÏ´Á¶£»1-Ìæ»»ÔÌ츳£»2-±£ÁôÔÌ츳
|
#};
|
def OnHeroWash(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
itemIndex = clientData.ItemIndex
|
lockTalentIndexs = clientData.LockTalentIndexs
|
opType = clientData.OPType
|
|
heroItem = GetHeroItem(curPlayer, itemIndex)
|
if not heroItem:
|
return
|
|
if opType == 1:
|
HeroTalentWashReplace(curPlayer, itemIndex, heroItem)
|
elif opType == 2:
|
heroItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentWashID)
|
else:
|
HeroTalentWash(curPlayer, itemIndex, heroItem, lockTalentIndexs)
|
|
return
|
|
def HeroTalentWash(curPlayer, itemIndex, heroItem, lockTalentIndexs):
|
## Î佫ϴÁ¶
|
|
heroID = heroItem.GetItemTypeID()
|
GameWorld.DebugLog("Î佫ϴÁ¶: itemIndex=%s,heroID=%s,lockTalentIndexs=%s" % (itemIndex, heroID, lockTalentIndexs))
|
washIDCnt = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentWashID)
|
if washIDCnt:
|
GameWorld.ErrLog("Î佫ϴÁ¶½á¹ûδ´¦Àí£¬ÎÞ·¨Ï´Á¶! washIDCnt=%s" % washIDCnt)
|
return
|
|
washCostItemInfo = IpyGameDataPY.GetFuncEvalCfg("HeroWash", 1)
|
lockCostItemInfo = IpyGameDataPY.GetFuncEvalCfg("HeroWash", 2)
|
if not washCostItemInfo or not lockCostItemInfo:
|
return
|
washItemID, washCostItemCount = washCostItemInfo
|
lockItemID, lockCostItemCount = lockCostItemInfo
|
|
itemPack = curPlayer.GetItemManager().GetPack(IPY_GameWorld.rptItem)
|
hasEnough, washItemIndexList = ItemCommon.GetItem_FromPack_ByID(washItemID, itemPack, washCostItemCount)
|
if not hasEnough:
|
GameWorld.DebugLog("Ï´Á¶²ÄÁϲ»×㣬Î佫ÎÞ·¨Ï´Á¶! washItemID=%s,washCostItemCount=%s" % (washItemID, washCostItemCount))
|
return
|
lockItemIndexList = []
|
lockCostItemCountTotal = 0
|
if lockTalentIndexs:
|
lockCostItemCountTotal = len(lockTalentIndexs) * lockCostItemCount
|
hasEnough, lockItemIndexList = ItemCommon.GetItem_FromPack_ByID(lockItemID, itemPack, lockCostItemCountTotal)
|
if not hasEnough:
|
GameWorld.DebugLog("Ëø¶¨²ÄÁϲ»×㣬Î佫ÎÞ·¨Ï´Á¶! lockItemID=%s,lockCostItemCount=%s,lockCostItemCountTotal=%s"
|
% (lockItemID, lockCostItemCount, lockCostItemCountTotal))
|
return
|
|
ItemCommon.ReduceItem(curPlayer, itemPack, washItemIndexList, washCostItemCount, True, "HeroTalentWash")
|
ItemCommon.ReduceItem(curPlayer, itemPack, lockItemIndexList, lockCostItemCountTotal, True, "HeroTalentWash")
|
|
singleItem = heroItem.GetItem()
|
idCount = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentID)
|
washIDList = []
|
for index in range(idCount):
|
if index in lockTalentIndexs:
|
talentID = singleItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentID, index)
|
washIDList.append(talentID)
|
else:
|
washIDList.append(0)
|
|
GameWorld.DebugLog("Ï´Á¶Ç°: %s" % (washIDList))
|
|
idWeightDict = {}
|
talentWeightList = []
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for index in range(ipyDataMgr.GetHeroTalentCount()):
|
talentIpyData = ipyDataMgr.GetHeroTalentByIndex(index)
|
talentID = talentIpyData.GetTalentID()
|
if talentID in washIDList:
|
# Ì츳ID²»¿ÉÖظ´
|
continue
|
weight = talentIpyData.GetWashWeight()
|
talentWeightList.append([weight, talentID])
|
idWeightDict[talentID] = weight
|
|
for index, talentID in enumerate(washIDList):
|
if talentID:
|
continue
|
randTalentID = GameWorld.GetResultByWeightList(talentWeightList)
|
if not randTalentID:
|
continue
|
# ÒƳýÈ·±£²»Öظ´
|
randWeightID = [idWeightDict.get(randTalentID, 0), randTalentID]
|
if randWeightID in talentWeightList:
|
talentWeightList.remove(randWeightID)
|
washIDList[index] = randTalentID
|
GameWorld.DebugLog("Ï´Á¶ºó: %s" % (washIDList))
|
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentWashID)
|
for talentID in washIDList:
|
singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentWashID, talentID)
|
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentWashLock)
|
for index in lockTalentIndexs:
|
singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentWashLock, index)
|
|
heroItem.Sync_Item()
|
GameWorld.DebugLog("Î佫ϴÁ¶½á¹û! itemIndex=%s,heroID=%s,washIDList=%s,lockTalentIndexs=%s"
|
% (itemIndex, heroID, washIDList, lockTalentIndexs))
|
return
|
|
def HeroTalentWashReplace(curPlayer, itemIndex, heroItem):
|
## Î佫ϴÁ¶Ìæ»»
|
heroID = heroItem.GetItemTypeID()
|
singleItem = heroItem.GetItem()
|
|
washIDList = []
|
idCount = singleItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentWashID)
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentID)
|
for index in range(idCount):
|
talentID = singleItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentWashID, index)
|
washIDList.append(talentID)
|
singleItem.AddUserAttr(ShareDefine.Def_IudetHeroTalentID, talentID)
|
|
singleItem.ClearUserAttr(ShareDefine.Def_IudetHeroTalentWashID)
|
|
heroItem.Sync_Item()
|
GameWorld.DebugLog("Î佫ϴÁ¶Ìæ»»! itemIndex=%s,heroID=%s,washIDList=%s" % (itemIndex, heroID, washIDList))
|
|
# Ë¢ÊôÐÔ£¬Ö®ºóÀ©Õ¹
|
|
return
|
|
#// B2 36 Î佫»»·ô #tagCSHeroWearSkin
|
#
|
#struct tagCSHeroWearSkin
|
#{
|
# tagHead Head;
|
# WORD ItemIndex; //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
|
# BYTE SkinIndex; //Ƥ·ôË÷Òý
|
#};
|
def OnHeroWearSkin(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
itemIndex = clientData.ItemIndex
|
skinIndex = clientData.SkinIndex
|
heroItem = GetHeroItem(curPlayer, itemIndex)
|
if not heroItem:
|
return
|
heroID = heroItem.GetItemTypeID()
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
|
if not heroIpyData:
|
return
|
skinNPCIDList = heroIpyData.GetSkinNPCIDList()
|
if skinIndex > 0: # 0µÄΪĬÈÏƤ·ô£¬²»×öÏÞÖÆ
|
if skinIndex >= len(skinNPCIDList):
|
GameWorld.DebugLog("¸ÃÎ佫²»´æÔÚ¸ÃƤ·ô! heroID=%s,skinIndex=%s" % (heroID, skinIndex))
|
return
|
skinState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroSkin % heroID)
|
if not skinState & pow(2, skinIndex):
|
GameWorld.DebugLog("¸ÃÎ佫Ƥ·ôδ½âËø! heroID=%s,skinIndex=%s,skinState=%s" % (heroID, skinIndex, skinState))
|
return
|
heroItem.SetUserAttr(ShareDefine.Def_IudetHeroSkin, skinIndex)
|
|
# Ë¢ÊôÐÔ
|
|
return
|
|
def ActiveHeroSkin(curPlayer, heroID, skinIndex, isActive=True):
|
skinState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroSkin % heroID)
|
if isActive:
|
updState = skinState | pow(2, skinIndex)
|
GameWorld.DebugLog("¼¤»îÎ佫Ƥ·ô: heroID=%s,skinIndex=%s,skinState=%s,updState=%s"
|
% (heroID, skinIndex, skinState, updState), curPlayer.GetPlayerID())
|
else:
|
updState = GameWorld.SetBitValue(skinState, skinIndex, 0)
|
GameWorld.DebugLog("ʧЧÎ佫Ƥ·ô: heroID=%s,skinIndex=%s,skinState=%s,updState=%s"
|
% (heroID, skinIndex, skinState, updState), curPlayer.GetPlayerID())
|
PlayerControl.NomalDictSetProperty(curPlayer, ChConfig.Def_PDict_HeroSkin % heroID, updState)
|
Sync_HeroInfo(curPlayer, [heroID])
|
return
|
|
#// B2 37 Î佫ͼ¼ø¼¤»îÉý¼¶ #tagCSHeroBookUP
|
#
|
#struct tagCSHeroBookUP
|
#{
|
# tagHead Head;
|
# DWORD HeroID; //Î佫ID
|
# WORD ItemIndex; //¹ØÁªÎ佫ÎïÆ·ËùÔÚÎ佫±³°üË÷Òý£¬¼¤»îʱ¿É²»Ó÷¢
|
# BYTE BookType; //ͼ¼ø¼¤»îÀàÐÍ£º 0-³õʼ¼¤»î£»1-ÐǼ¶Éý¼¶£»2-Í»ÆƵȼ¶Éý¼¶
|
#};
|
def OnHeroBookUP(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
heroID = clientData.HeroID
|
itemIndex = clientData.ItemIndex
|
bookType = clientData.BookType
|
|
if bookType == 1:
|
__doHeroBookStarLVUP(curPlayer, heroID, itemIndex)
|
elif bookType == 2:
|
__doHeroBookBreakLVUP(curPlayer, heroID, itemIndex)
|
else:
|
__doHeroBookAct(curPlayer, heroID)
|
return
|
|
def __doHeroBookAct(curPlayer, heroID):
|
## ͼ¼ø¼¤»î
|
playerID = curPlayer.GetPlayerID()
|
if GetHeroBookInitState(curPlayer, heroID):
|
GameWorld.DebugLog("¸ÃÎ佫ͼ¼øÒѼ¤»î! heroID=%s" % heroID, playerID)
|
return
|
GameWorld.DebugLog("Î佫ͼ¼ø¼¤»î! heroID=%s" % heroID, playerID)
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
|
if not heroIpyData:
|
return
|
quality = heroIpyData.GetQuality()
|
qualityIpyData = IpyGameDataPY.GetIpyGameData("HeroQuality", quality)
|
if not qualityIpyData:
|
return
|
if GetHeroActivite(curPlayer, heroID) != 1:
|
GameWorld.DebugLog("Î佫δ»ñµÃ¹ý£¬²»¿É¼¤»îͼ¼ø! heroID=%s" % (heroID), playerID)
|
return
|
SetHeroBookInitState(curPlayer, heroID, 1)
|
|
awardMoneyInfo = qualityIpyData.GetBookActAwardMoney()
|
if awardMoneyInfo and len(awardMoneyInfo) == 2:
|
moneyType, moneyValue = awardMoneyInfo
|
if moneyType and moneyValue:
|
PlayerControl.GiveMoney(curPlayer, moneyType, moneyValue, "HeroBookAct")
|
|
Sync_HeroInfo(curPlayer, [heroID])
|
return
|
|
def __doHeroBookStarLVUP(curPlayer, heroID, itemIndex):
|
## ͼ¼øÐǼ¶Éý¼¶
|
playerID = curPlayer.GetPlayerID()
|
heroItem = GetHeroItem(curPlayer, itemIndex)
|
if not heroItem:
|
return
|
if heroItem.GetItemTypeID() != heroID:
|
GameWorld.DebugLog("·Ç¸ÃÎ佫ͼ¼ø¹ØÁªÎïÆ·! heroID=%s,itemID=%s" % (heroID, heroItem.GetItemTypeID()), playerID)
|
return
|
heroStar = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)
|
bookStar = GetHeroBookStarLV(curPlayer, heroID)
|
if bookStar >= heroStar:
|
GameWorld.DebugLog("¸ÃÎ佫ͼ¼øÐǼ¶ÒѴﵱǰӢÐÛÐǼ¶! heroID=%s,bookStar=%s,heroStar=%s" % (heroID, bookStar, heroStar), playerID)
|
return
|
GameWorld.DebugLog("Î佫ͼ¼øÐǼ¶Éý¼¶! heroID=%s,bookStar=%s,heroStar=%s" % (heroID, bookStar, heroStar), playerID)
|
SetHeroBookStarLV(curPlayer, heroID, bookStar + 1)
|
Sync_HeroInfo(curPlayer, [heroID])
|
|
# Ë¢ÊôÐÔ
|
|
return
|
|
def __doHeroBookBreakLVUP(curPlayer, heroID, itemIndex):
|
## ͼ¼øÍ»ÆÆÉý¼¶
|
playerID = curPlayer.GetPlayerID()
|
heroItem = GetHeroItem(curPlayer, itemIndex)
|
if not heroItem:
|
return
|
if heroItem.GetItemTypeID() != heroID:
|
GameWorld.DebugLog("·Ç¸ÃÎ佫ͼ¼ø¹ØÁªÎïÆ·! heroID=%s,itemID=%s" % (heroID, heroItem.GetItemTypeID()), playerID)
|
return
|
heroBreakLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV)
|
bookBreakLV = GetHeroBookBreakLV(curPlayer, heroID)
|
if bookBreakLV >= heroBreakLV:
|
GameWorld.DebugLog("¸ÃÎ佫ͼ¼øÍ»ÆƵȼ¶ÒѴﵱǰӢÐÛÍ»ÆƵȼ¶! heroID=%s,bookBreakLV=%s,heroBreakLV=%s" % (heroID, bookBreakLV, heroBreakLV), playerID)
|
return
|
GameWorld.DebugLog("Î佫ͼ¼øÍ»ÆÆÉý¼¶! heroID=%s,bookBreakLV=%s,heroBreakLV=%s" % (heroID, bookBreakLV, heroBreakLV), playerID)
|
SetHeroBookBreakLV(curPlayer, heroID, bookBreakLV + 1)
|
Sync_HeroInfo(curPlayer, [heroID])
|
|
# Ë¢ÊôÐÔ
|
|
return
|
|
#// B4 12 Õ½¶·ÕóÐͱ£´æ #tagCSHeroBattlePosSave
|
#
|
#struct tagCSHeroBattlePos
|
#{
|
# WORD ItemIndex; //Î佫ÎïÆ·ËùÔÚÎ佫±³°üλÖÃË÷Òý
|
# BYTE PosNum; //1~nÉÏÕóλÖñàºÅ
|
#};
|
#
|
#struct tagCSHeroBattlePosSave
|
#{
|
# tagHead Head;
|
# BYTE FuncType; //²¼Õó¹¦ÄÜÀàÐÍ£º0-ĬÈÏÖ÷ÕóÐÍ£»ÆäËû´ýÀ©Õ¹£¬Èçij¸ö»î¶¯µÄ·ÀÊØÕóÐÍ
|
# BYTE PosCnt;
|
# tagCSHeroBattlePos HeroPosList[PosCnt]; // ±£´æµÄÕóÐÍ£¬Ö»Òª·¢ËÍ×îÖÕµÄÕóÐÍÎ佫λÖü´¿É
|
#};
|
def OnHeroBattlePosSave(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
funcType = clientData.FuncType
|
heroPosList = clientData.HeroPosList
|
|
heroPosDict = {}
|
indexList = []
|
for posInfo in heroPosList:
|
posNum = posInfo.PosNum
|
itemIndex = posInfo.ItemIndex
|
if itemIndex in indexList:
|
# µ¥Î佫ֻÄÜÒ»¸öλÖã¬Ò»¸öλÖÃÖ»ÄܶÔӦΨһÎ佫µ¥Î»
|
continue
|
indexList.append(itemIndex)
|
heroPosDict[posNum] = itemIndex
|
|
# Ö÷ÕóÐÍ
|
if funcType == 0:
|
MainBattlePosSave(curPlayer, heroPosDict)
|
|
# ÆäËû´ýÀ©Õ¹
|
elif funcType == 1:
|
pass
|
|
return
|
|
def MainBattlePosSave(curPlayer, heroPosDict):
|
GameWorld.DebugLog("±£ÁôÖ÷Õ½¶·ÕóÐÍ: %s" % heroPosDict, curPlayer.GetPlayerID())
|
curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
|
# Ö±½ÓÖØÖþÉÕóÐÍ
|
for index in range(curPack.GetCount()):
|
heroItem = curPack.GetAt(index)
|
if not heroItem or heroItem.IsEmpty():
|
continue
|
if not heroItem.GetUserAttr(ShareDefine.Def_IudetHeroPosNum):
|
continue
|
item = heroItem.GetItem()
|
item.ClearUserAttr(ShareDefine.Def_IudetHeroPosNum)
|
|
# ¸üÐÂÐÂÕóÐÍ
|
for posNum, itemIndex in heroPosDict.items():
|
if itemIndex < 0 or itemIndex >= curPack.GetCount():
|
continue
|
heroItem = curPack.GetAt(itemIndex)
|
if not heroItem or heroItem.IsEmpty():
|
continue
|
item = heroItem.GetItem()
|
item.SetUserAttr(ShareDefine.Def_IudetHeroPosNum, posNum)
|
|
ResetHeroPack(curPlayer)
|
return
|
|
def ResetHeroPack(curPlayer):
|
tick = GameWorld.GetGameWorld().GetTick()
|
curPlayer.SetResetItemTick(0)
|
ItemControler.ResetItem(curPlayer, ShareDefine.rptHero, 0, 0, tick)
|
return
|
|
def Sync_HeroInfo(curPlayer, heroIDList=None):
|
if heroIDList != None:
|
syncHeroIDList = heroIDList
|
else:
|
syncHeroIDList = []
|
ipyDataMgr = IpyGameDataPY.IPY_Data()
|
for index in range(ipyDataMgr.GetHeroCount()):
|
ipyData = ipyDataMgr.GetHeroByIndex(index)
|
syncHeroIDList.append(ipyData.GetHeroID())
|
|
if not syncHeroIDList:
|
return
|
|
syncInfoList = []
|
for heroID in syncHeroIDList:
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
|
if not heroIpyData:
|
continue
|
if heroIDList == None and not curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID):
|
continue
|
|
hero = ChPyNetSendPack.tagSCHero()
|
hero.HeroID = heroID
|
hero.SkinState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroSkin % heroID)
|
hero.BookInitState = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_HeroBook % heroID) % 10
|
hero.BookStarLV = GetHeroBookStarLV(curPlayer, heroID)
|
hero.BookBreakLV = GetHeroBookBreakLV(curPlayer, heroID)
|
syncInfoList.append(hero)
|
|
if not syncInfoList:
|
return
|
|
clientPack = ChPyNetSendPack.tagSCHeroInfo()
|
clientPack.HeroInfoList = syncInfoList
|
clientPack.HeroCnt = len(clientPack.HeroInfoList)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
