#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
##@package BattleObj
|
#
|
# @todo:Õ½¶·¶ÔÏó
|
# @author hxp
|
# @date 2025-08-06
|
# @version 1.0
|
#
|
# ÏêϸÃèÊö: py×Ô¶¨ÒåµÄÕ½¶·¶ÔÏ󣬿ÉÒÔÊÇÍæ¼Ò¡¢NPCͨÓõģ¬·ÏÆúÔc++µÄPlayer¼°NPC£¬ÍêÈ«ÓÉpy×ÔÐд¦Àí
|
# MMOÏîÄ¿¿ÉÒÔcurPlayer°ó¶¨Ò»¸öÕ½¶·¶ÔÏó£¬curPlayer½ö×öΪÍæ¼ÒµÄÊý¾Ý¶ÔÏó£¬Õ½¶·Ïà¹ØͳһʹÓÃÕ½¶·¶ÔÏó
|
#
|
#-------------------------------------------------------------------------------
|
#"""Version = 2025-08-06 18:30"""
|
#-------------------------------------------------------------------------------
|
|
import GameWorld
|
import PyGameData
|
import TurnAttack
|
import IpyGameDataPY
|
import ChNetSendPack
|
import ShareDefine
|
import ChConfig
|
import ObjPool
|
import TurnPassive
|
import TurnBuff
|
|
class HurtObj():
|
## ÉËѪͳ¼Æ
|
|
def __init__(self):
|
self.Clear()
|
return
|
|
def Clear(self):
|
self._objID = 0
|
self._hurtTypes = 0 # ±¾´ÎÉËѪÀàÐÍ£¬ÈçÉÁ±Ü¡¢±©»÷¡¢¸ñµ²µÈ£¬Í¨¹ý¶þ½øÖÆ»òÔËËãµÃµ½×îÖÕÖµ£¬Ö§³Ö¶àÖÖͬʱ³öÏÖ£¬È籩»÷µÄͬʱ±»¸ñµ²
|
self._hurtHP = 0 # ÉËѪֵ
|
self._lostHP = 0 # ʵ¼ÊµôѪֵ
|
self._curHP = 0 # ¸üÐÂѪÁ¿
|
self._suckHP = 0 # ÎüѪÁ¿
|
self._bounceHP = 0 # ·´µ¯ÑªÁ¿
|
return
|
|
def GetObjID(self): return self._objID
|
def SetObjID(self, objID): self._objID = objID
|
def GetHurtTypes(self): return self._hurtTypes
|
def SetHurtTypes(self, hurtTypes): self._hurtTypes = hurtTypes
|
def AddHurtType(self, hurtType):
|
## Ìí¼ÓÉËѪÀàÐÍ£¬µ¥´ÎÉ˺¦Ö§³Ö¶àÖÖÀàÐÍͬʱ³öÏÖ
|
self._hurtTypes |= pow(2, hurtType)
|
return
|
def HaveHurtType(self, hurtType):
|
## ÅжÏÊÇ·ñ´æÔÚijÖÖÉËѪÀàÐÍ
|
return self._hurtTypes&pow(2, hurtType)
|
def GetHurtHP(self): return self._hurtHP
|
def SetHurtHP(self, hurtHP): self._hurtHP = hurtHP
|
def GetLostHP(self): return self._lostHP
|
def SetLostHP(self, lostHP): self._lostHP = lostHP
|
def GetCurHP(self): return self._curHP
|
def SetCurHP(self, curHP): self._curHP = curHP
|
def GetSuckHP(self): return self._suckHP
|
def SetSuckHP(self, suckHP): self._suckHP = suckHP
|
def GetBounceHP(self): return self._bounceHP
|
def SetBounceHP(self, bounceHP): self._bounceHP = bounceHP
|
|
class Effect():
|
|
def __init__(self, effID, values):
|
self._effID = effID
|
self._values = values
|
return
|
|
def GetEffectID(self): return self._effID
|
def GetEffectValue(self, index): return self._values[index] if len(self._values) > index else 0
|
def GetEffectValueCount(self): return len(self._values)
|
|
class SklllData():
|
|
def __init__(self, ipyData):
|
self._ipyData = ipyData
|
self._effList = [] # [Effect, ...]
|
for num in range(1, 1 + 3):
|
effID = getattr(ipyData, "GetEffectID%s" % num)()
|
values = getattr(ipyData, "GetEffectValues%s" % num)()
|
self._effList.append(ObjPool.GetPoolMgr().acquire(Effect, effID, values))
|
return
|
|
def GetSkillID(self): return self._ipyData.GetSkillID()
|
def GetSkillTypeID(self): return self._ipyData.GetSkillTypeID()
|
def GetSkillMaxLV(self): return self._ipyData.GetSkillMaxLV()
|
def GetSkillName(self): return self._ipyData.GetSkillName()
|
def GetFuncType(self): return self._ipyData.GetFuncType()
|
def GetSkillType(self): return self._ipyData.GetSkillType()
|
def GetHurtType(self): return self._ipyData.GetHurtType()
|
def GetAtkType(self): return self._ipyData.GetAtkType()
|
def GetTagAim(self): return self._ipyData.GetTagAim() # Ãé׼λÖÃ
|
def GetTagFriendly(self): return self._ipyData.GetTagFriendly() # µÐÎÒÄ¿±ê
|
def GetTagSelf(self): return self._ipyData.GetTagSelf() # ÊÇ·ñº¬×Ô¼º
|
def GetTagAffect(self): return self._ipyData.GetTagAffect() # Ä¿±êϸ·Ö
|
def GetTagCount(self): return self._ipyData.GetTagCount() # Ä¿±ê¸öÊý
|
def GetHappenRate(self): return self._ipyData.GetHappenRate() # ÊÍ·Å»òÌí¼Ó¼¸ÂÊ
|
def GetLastTime(self): return self._ipyData.GetLastTime() # ³ÖÐøʱ¼ä
|
def GetCoolDownTime(self): return self._ipyData.GetCoolDownTime()
|
def GetEffect(self, index): return self._effList[index] if len(self._effList) > index else 0
|
def GetEffectCount(self): return len(self._effList)
|
def GetConnSkill(self): return self._ipyData.GetConnSkill() # ¹ØÁª¼¼ÄÜ
|
def GetEnhanceSkillList(self): return self._ipyData.GetEnhanceSkillList() # ¶îÍâ´¥·¢µÄ¼¼ÄÜIDÁбí
|
def GetFightPower(self): return self._ipyData.GetFightPower()
|
|
class PyBuff():
|
|
def __init__(self, ipyData):
|
self._skillData = ObjPool.GetPoolMgr().acquire(SklllData, ipyData)
|
self._buffID = 0
|
self._ownerID = 0
|
self._layer = 0
|
self._remainTime = 0
|
self._valueList = []
|
return
|
|
def GetSkillData(self): return self._skillData
|
def GetSkillID(self): return self._skillData.GetSkillID()
|
def GetBuffID(self): return self._buffID
|
def SetBuffID(self, buffID): self._buffID = buffID
|
def GetOwnerID(self): return self._ownerID
|
def SetOwnerID(self, ownerID): self._ownerID = ownerID
|
def GetLayer(self): return self._layer
|
def SetLayer(self, layer): self._layer = layer
|
def GetRemainTime(self): return self._remainTime
|
def SetRemainTime(self, remainTime): self._remainTime = remainTime
|
def SetValueList(self, valueList): self._valueList = valueList
|
def GetValue(self, index):
|
return self._valueList[index] if len(self._valueList) > index else 0
|
|
class BuffManager():
|
## Õ½¶·¶ÔÏóbuff¹ÜÀíÆ÷
|
|
def __init__(self):
|
self._buffList = [] # [PyBuff, ...]
|
self._buffIDDict = {} # {buffID:PyBuff, ...}
|
self._skillTypeIDBuffIDs = {} # ¼¼ÄÜTypeID¶ÔÓ¦µÄbuff {skillTypeID:[buffID, ...], ...}
|
self._buffStateDict = {} # buffÓ°ÏìµÄ״̬ {state:[buffID, ...], ...}
|
self._buffID = 0 # ¸Ã¶ÔÏóµÄΨһbuffID£¬µÝÔö£¬²»Í¬¶ÔÏóbuffID¿ÉÖظ´£¬buffID·ÇskillID£¬²»Í¬buffIDµÄskillID¿ÉÄÜÒ»Ñù
|
# ¸ÃÏîÄ¿É趨ͬһ¸ö¶ÔÏó¿ÉÄÜͬʱ´æÔÚ¶à¸öÏàͬskillIDµÄbuff£¬¶ÀÁ¢ËãCD
|
return
|
|
def ClearBuff(self):
|
poolMgr = ObjPool.GetPoolMgr()
|
for buff in self._buffList:
|
poolMgr.release(buff)
|
self._buffList = []
|
self._buffIDDict = {}
|
self._skillTypeIDBuffIDs = {}
|
self._buffID = 0
|
return
|
|
def GetBuffCount(self): return len(self._buffList)
|
def GetBuffByIndex(self, index):
|
buff = self._buffList[index]
|
#if False:
|
# buff = PyBuff()
|
return buff
|
|
def AddBuff(self, skillID):
|
buff = None
|
ipyData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
|
if not ipyData:
|
return buff
|
skillTypeID = ipyData.GetSkillTypeID()
|
self._buffID += 1
|
|
buff = ObjPool.GetPoolMgr().acquire(PyBuff, ipyData)
|
buff.SetBuffID(self._buffID)
|
|
self._buffList.append(buff)
|
self._buffIDDict[self._buffID] = buff
|
if skillTypeID not in self._skillTypeIDBuffIDs:
|
self._skillTypeIDBuffIDs[skillTypeID] = []
|
buffIDs = self._skillTypeIDBuffIDs[skillTypeID]
|
if self._buffID not in buffIDs:
|
buffIDs.append(self._buffID)
|
|
#if False:
|
# buff = PyBuff()
|
return buff
|
|
def DelBuff(self, buffID):
|
if buffID not in self._buffIDDict:
|
return
|
buff = self._buffIDDict.pop(buffID)
|
if buff in self._buffList:
|
self._buffList.remove(buff)
|
for skillTypeID, buffIDList in self._skillTypeIDBuffIDs.items():
|
if buffID not in buffIDList:
|
continue
|
buffIDList.remove(buffID)
|
if not buffIDList:
|
self._skillTypeIDBuffIDs.pop(skillTypeID)
|
break
|
return
|
|
def GetBuff(self, buffID):
|
buff = None
|
if buffID in self._buffIDDict:
|
buff = self._buffIDDict[buffID]
|
#if False:
|
# buff = PyBuff()
|
return buff
|
|
def FindBuffIDBySkillID(self, skillID):
|
## ·µ»Ø¸Ã¼¼ÄÜIDµÄËùÓÐbuffIDÁбí
|
skillData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
|
if not skillData:
|
return []
|
return self.FindBuffIDBySkillTypeID(skillData.GetSkillTypeID())
|
def FindBuffIDBySkillTypeID(self, skillTypeID):
|
## ·µ»Ø¸Ã¼¼ÄÜTypeIDµÄËùÓÐbuffIDÁбí
|
if skillTypeID not in self._skillTypeIDBuffIDs:
|
return []
|
buffs = []
|
for buffID in self._skillTypeIDBuffIDs[skillTypeID]:
|
if buffID not in self._buffIDDict:
|
continue
|
buffs.append(self._buffIDDict[buffID])
|
return buffs
|
|
def AddBuffState(self, state, buffID):
|
## Ìí¼ÓbuffÓ°ÏìµÄ״̬£¬ChConfig.BatObjStateList
|
if state not in self._buffStateDict:
|
self._buffStateDict[state] = []
|
buffIDList = self._buffStateDict[state]
|
if buffID not in buffIDList:
|
buffIDList.append(buffID)
|
GameWorld.DebugLog(" AddBuffState state=%s,buffID=%s,%s" % (state, buffID, self._buffStateDict))
|
return
|
|
def DelBuffState(self, state, buffID):
|
## ɾ³ýbuffÓ°ÏìµÄ״̬
|
if state not in self._buffStateDict: return
|
buffIDList = self._buffStateDict[state]
|
if buffID not in buffIDList:
|
return
|
buffIDList.remove(buffID)
|
if not len(buffIDList):
|
self._buffStateDict.pop(state)
|
GameWorld.DebugLog(" DelBuffState state=%s,buffID=%s,%s" % (state, buffID, self._buffStateDict))
|
return
|
|
def IsInBuffState(self, state):
|
## ÊÇ·ñ´¦ÓÚijÖÖ״̬ÏÂ
|
return state in self._buffStateDict and len(self._buffStateDict[state]) > 0
|
|
class PySkill():
|
|
def __init__(self, ipyData):
|
self._skillData = ObjPool.GetPoolMgr().acquire(SklllData, ipyData)
|
self._remainTime = 0
|
self._batType = 0 # Õ½¶·ÀàÐÍ£¬ÆÕͨ¡¢Á¬»÷¡¢·´»÷¡¢×·»÷µÈ
|
self._tagObjList = [] # ±¾´Î¼¼ÄÜÄ¿±êÁбí [BatObj, ...]
|
self._hurtList = [] # ±¾´ÎÉËѪÁÐ±í£¬¿ÉÄÜͬһ¸ö¶ÔÏóÓжà¸öÉ˺¦£¬È絯ÉäµÈ [HurtObj, ...]
|
self._bySkill = None # ÓÉÄĸö¼¼ÄÜ´¥·¢µÄ
|
self._isEnhanceSkill = False # ÊÇ·ñÓÉÖ÷¼¼ÄܶîÍâ´¥·¢µÄ£¨·Ç±»¶¯´¥·¢£¬¼´Ö÷¼¼ÄܵÄEnhanceSkillList×Ö¶ÎÖеļ¼ÄÜ£©
|
return
|
|
def GetSkillID(self): return self._skillData.GetSkillID()
|
def GetSkillTypeID(self): return self._skillData.GetSkillTypeID()
|
def GetSkillMaxLV(self): return self._skillData.GetSkillMaxLV()
|
def GetSkillName(self): return self._skillData.GetSkillName()
|
def GetFuncType(self): return self._skillData.GetFuncType()
|
def GetSkillType(self): return self._skillData.GetSkillType()
|
def GetHurtType(self): return self._skillData.GetHurtType()
|
def GetAtkType(self): return self._skillData.GetAtkType()
|
def GetTagAim(self): return self._skillData.GetTagAim() # Ãé׼λÖÃ
|
def GetTagFriendly(self): return self._skillData.GetTagFriendly() # µÐÎÒÄ¿±ê
|
def GetTagSelf(self): return self._skillData.GetTagSelf() # ÊÇ·ñº¬×Ô¼º
|
def GetTagAffect(self): return self._skillData.GetTagAffect() # Ä¿±êϸ·Ö
|
def GetTagCount(self): return self._skillData.GetTagCount() # Ä¿±ê¸öÊý
|
def GetHappenRate(self): return self._skillData.GetHappenRate() # ÊÍ·Å»òÌí¼Ó¼¸ÂÊ
|
def GetLastTime(self): return self._skillData.GetLastTime() # ³ÖÐøʱ¼ä
|
def GetCoolDownTime(self): return self._skillData.GetCoolDownTime()
|
def GetEffect(self, index): return self._skillData.GetEffect(index)
|
def GetEffectCount(self): return self._skillData.GetEffectCount()
|
def GetConnSkill(self): return self._skillData.GetConnSkill() # ¹ØÁª¼¼ÄÜ
|
def GetEnhanceSkillList(self): return self._skillData.GetEnhanceSkillList() # ¶îÍâ´¥·¢µÄ¼¼ÄÜIDÁбí
|
def GetFightPower(self): return self._skillData.GetFightPower()
|
|
## ---------------------------------- ·Ç¼¼ÄܱíÄÚÈÝ ----------------------------------
|
def GetRemainTime(self): return self._remainTime
|
def SetRemainTime(self, remainTime): self._remainTime = remainTime
|
def GetBatType(self): return self._batType
|
def SetBatType(self, batType): self._batType = batType
|
def GetIsEnhanceSkill(self): return self._isEnhanceSkill
|
def SetIsEnhanceSkill(self, isEnhanceSkill): self._isEnhanceSkill = isEnhanceSkill
|
def GetBySkill(self): return self._bySkill
|
def SetBySkill(self, bySkill): self._bySkill = bySkill
|
def GetTagObjList(self): return self._tagObjList # ¼¼ÄÜÄ¿±êÁбí
|
def SetTagObjList(self, tagObjList): self._tagObjList = tagObjList
|
def ClearHurtObj(self):
|
## Çå¿ÕÉËѪͳ¼Æ
|
poolMgr = ObjPool.GetPoolMgr()
|
for hurtObj in self._hurtList:
|
poolMgr.release(hurtObj)
|
self._hurtList = []
|
return
|
def AddHurtObj(self, tagID):
|
## Ìí¼Óij¸öÉËѪ
|
hurtObj = ObjPool.GetPoolMgr().acquire(HurtObj)
|
hurtObj.SetObjID(tagID)
|
self._hurtList.append(hurtObj)
|
return hurtObj
|
def GetHurtObjList(self): return self._hurtList
|
|
class SkillManager():
|
## Õ½¶·¶ÔÏó¼¼ÄܹÜÀíÆ÷
|
|
def __init__(self):
|
self._skillList = [] # ¼¼ÄÜÁбí [PySkill, ...]
|
self._skillDict = {} # {skillID:PySkill, ...}
|
return
|
|
def SkillReset(self):
|
poolMgr = ObjPool.GetPoolMgr()
|
for skill in self._skillList:
|
poolMgr.release(skill)
|
self._skillList = []
|
self._skillDict = {}
|
return
|
|
def GetSkillCount(self): return len(self._skillList)
|
def GetSkillByIndex(self, index): return self._skillList[index]
|
def FindSkillByID(self, skillID): return self._skillDict.get(skillID, None)
|
def FindSkillByTypeID(self, skillTypeID):
|
skill = None
|
for s in self._skillList:
|
if s.GetSkillTypeID() == skillTypeID:
|
skill = s
|
break
|
return skill
|
|
def LearnSkillByID(self, skillID):
|
ipyData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
|
if not ipyData:
|
return
|
if skillID in self._skillDict:
|
return
|
skillTypeID = ipyData.GetSkillTypeID()
|
curSkill = self.FindSkillByTypeID(skillTypeID)
|
if curSkill:
|
if curSkill.GetSkillID() >= skillID:
|
return
|
self.__deleteSkill(curSkill)
|
|
# ѧм¼ÄÜ
|
curSkill = ObjPool.GetPoolMgr().acquire(PySkill, ipyData)
|
self._skillDict[skillID] = curSkill
|
self._skillList.append(curSkill)
|
return curSkill
|
|
def __deleteSkill(self, curSkill):
|
skillID = curSkill.GetSkillID()
|
self._skillDict.pop(skillID, None)
|
if curSkill in self._skillList:
|
self._skillList.remove(curSkill)
|
ObjPool.GetPoolMgr().release(curSkill)
|
return
|
|
class BatObj():
|
## Õ½¶·ÊµÌå¶ÔÏóÊý¾Ý£¬Ä¿Ç°Óëij¸öNPCObj°ó¶¨
|
|
def __init__(self):
|
self.tfGUID = "" # ËùÊôµÄij³¡»ØºÏÕ½¶·µÄguid
|
self.objID = 0
|
self.objName = ""
|
self.npcID = 0
|
self.ownerID = 0 # ËùÊôÍæ¼ÒID£¬¿ÉÄÜΪ0£¬0´ú±í·ÇÍæ¼ÒµÄÕ½¶·ÊµÌå
|
self.heroID = 0
|
self.skinID = 0
|
self.lv = 1
|
self.fightPower = 0
|
self.faction = 0 # ËùÊôÕóÓª£¬Ò»°ãÖ»ÓÐË«·½ÕóÓª£¬ 1 »ò 2£¬·¢Æð·½Ä¬ÈÏ1
|
self.lineupNum = 1 # ÕóÈÝλÖñàºÅ£¬Ò»°ã¶àV¶àʱÓÐÓã¬Í¨³£Ä¬ÈÏ1
|
self.posNum = 0 # ËùÔÚÕóÈÝվλ
|
self._hp = 0 # µ±Ç°ÉúÃüÖµ
|
self._xp = 0 # µ±Ç°ÅÆøÖµ
|
self._initAttrDict = {} # ³õʼ»¯Ê±µÄÊôÐÔ£¬¹Ì¶¨²»±ä£¬³õʼ»¯Ê±ÒѾËãºÃµÄÊôÐÔ {attrID:value, ...}
|
self._batAttrDict = {} # ʵ¼ÊÕ½¶·ÊôÐÔ£¬°üº¬buff²ã¼¶µÄʵ¼ÊÊôÐÔ
|
self._skillTempAttrDict = {} # ij´Î¼¼ÄÜÊÍ·ÅÖÐÁÙʱµÄÊôÐÔÔö¼õ {attrID:+-value, ...}
|
self._kvDict = {} # ×Ô¶¨Òåkv×Öµä
|
self._skillUseCntDict = {} # ¼¼ÄÜÀÛ¼ÆʹÓôÎÊý {skillID:useCnt, ...}
|
self._skillTurnUseCntDict = {} # ¼¼Äܵ¥»ØºÏÀÛ¼ÆʹÓôÎÊý {skillID:useCnt, ...}
|
self._skillMgr = ObjPool.GetPoolMgr().acquire(SkillManager)
|
self._buffMgr = ObjPool.GetPoolMgr().acquire(BuffManager)
|
|
# ͳ¼Æ
|
self.hurtStat = 0 # Êä³öͳ¼Æ
|
self.defStat = 0 # ³ÐÉËͳ¼Æ
|
self.cureStat = 0 # ÖÎÁÆͳ¼Æ
|
return
|
|
def InitBatAttr(self, initAttrDict, initXP=0):
|
'''³õʼ»¯Õ½¶·ÊôÐÔ
|
@param initAttrDict: ÒѾËãºÃµÄÔÚÕóÈÝÖеÄÊôÐÔ£¬°üº¬î¿°í¡¢ÕóÈÝÊôÐԵȣ¬Õ½¶·ÖÐÖ»Òª¼ÆËãbuffÊôÐÔ¼´¿É
|
@param initXP: ³õʼ»¯µÄÅÆøÖµ
|
'''
|
self._initAttrDict = initAttrDict
|
self._batAttrDict = {}
|
self._batAttrDict.update(initAttrDict)
|
self._skillTempAttrDict = {}
|
self._xp = initXP
|
self._hp = initAttrDict.get(ChConfig.AttrID_MaxHP, 1)
|
TurnBuff.RefreshBuffAttr(self)
|
TurnPassive.RefreshPassive(self)
|
return
|
|
def UpdInitBatAttr(self, initAttrDict):
|
## ¸üÐÂÕ½¶·ÊôÐÔ£¬Ò»°ãÖ»ÓÐÖ÷ÕóÈÝÐèÒª¸üУ¬Õ½¶·ÖÐÑø³É¡¢×°±¸±ä»¯µÈÒýÆðµÄÖ÷ÕóÈÝÊôÐÔ±ä¸üʱÐèҪʵʱ¸üÐÂ
|
self._initAttrDict = initAttrDict
|
TurnBuff.RefreshBuffAttr(self)
|
return
|
|
def ResetBattleEffect(self):
|
self._batAttrDict = {}
|
self._batAttrDict.update(self._initAttrDict)
|
return self._batAttrDict
|
|
def GetTFGUID(self): return self.tfGUID # ËùÊôµÄij³¡Õ½¶·
|
def SetTFGUID(self, tfGUID): self.tfGUID = tfGUID
|
def GetTurnFight(self): return TurnAttack.GetTurnFightMgr().getTurnFight(self.tfGUID)
|
def GetID(self): return self.objID
|
def GetName(self): return self.objName
|
def SetName(self, name): self.objName = name
|
def GetNPCID(self): return self.npcID # Èç¹ûÊÇNPCÕ½¶·µ¥Î»£¬Ôò¸ÃÖµ·Ç0
|
def SetNPCID(self, npcID): self.npcID = npcID # ÉèÖÃËùÊôµÄNPCID
|
def GetOwnerID(self): return self.ownerID # Èç¹ûÊÇÍæ¼ÒÕ½¶·µ¥Î»£¬Ôò¸ÃÖµ·Ç0£¬ÎªËùÊôÍæ¼ÒID
|
def GetHeroID(self): return self.heroID # ½öÍæ¼ÒÓÐÖµ£¬Ä³¸öÎ佫ID
|
def GetSkinID(self): return self.skinID # ½öÍæ¼ÒÓÐÖµ£¬Î佫Ƥ·ô
|
def SetOwnerHero(self, ownerID, heroID, skinID): # ÉèÖÃËùÊôµÄÍæ¼Ò¼°Î佫
|
self.ownerID = ownerID
|
self.heroID = heroID
|
self.skinID = skinID
|
def SetLineupPos(self, posNum, lineupNum=1):
|
## ÉèÖÃÕóÈÝËùÔÚλÖÃ
|
# @param posNum: ÔÚ±¾ÕóÈÝÖеÄվλ
|
# @param lineupNum: ±¾ÕóÈÝÔÚ±¾ÕóÓªÖеÄվ룬һ°ã¶àV¶àʱÓÐÓã¬Ä¬ÈÏ1
|
self.posNum = posNum
|
self.lineupNum = lineupNum
|
def GetLineupNum(self): return self.lineupNum
|
def GetPosNum(self): return self.posNum
|
def GetFaction(self): return self.faction
|
def SetFaction(self, faction): self.faction = faction
|
def GetFightPower(self): return self.fightPower
|
def SetFightPower(self, fightPower): self.fightPower = fightPower
|
def GetLV(self): return self.lv
|
def SetLV(self, lv): self.lv = lv
|
def GetDictByKey(self, key): return self._kvDict.get(key, 0)
|
def SetDict(self, key, value): self._kvDict[key] = value
|
|
def GetSkillManager(self): return self._skillMgr
|
def GetBuffManager(self):return self._buffMgr
|
|
def GetCanAttack(self):
|
## ¿É·ñ±»¹¥»÷
|
# ÎÞµÐbuff
|
#if ÎÞµÐ:
|
# return False
|
return True
|
|
def IsInState(self, state):
|
## ÊÇ·ñ´¦ÓÚijÖÖ״̬ÏÂ
|
return self._buffMgr.IsInBuffState(state)
|
|
# Õ½¶·ÊôÐÔ
|
def GetMaxHP(self): return self._batAttrDict.get(ChConfig.AttrID_MaxHP, 0)
|
def SetMaxHP(self, maxHP, isNotify=False):
|
self._batAttrDict[ChConfig.AttrID_MaxHP] = maxHP
|
if isNotify:
|
NotifyObjInfoRefresh(self, ChConfig.AttrID_MaxHP, maxHP)
|
return
|
def GetHP(self): return self._hp
|
def SetHP(self, hp, isNotify=False):
|
self._hp = hp
|
if isNotify:
|
NotifyObjInfoRefresh(self, ChConfig.AttrID_HP, hp)
|
return
|
def SetHPFull(self, isNotify=True): self.SetHP(self.GetMaxHP(), isNotify)
|
def GetXP(self): return self._xp
|
def SetXP(self, xp, isNotify=True):
|
self._xp = xp
|
if isNotify:
|
NotifyObjInfoRefresh(self, ChConfig.AttrID_XP, xp)
|
return
|
def GetAtk(self): return self.GetBatAttrValue(ChConfig.AttrID_Atk)
|
def GetDef(self): return self.GetBatAttrValue(ChConfig.AttrID_Def)
|
|
def GetBatAttrValue(self, attrID, includeTemp=True):
|
#ChConfig.AttrID_HP ChConfig.AttrID_XP
|
value = self._batAttrDict.get(attrID, 0)
|
if includeTemp and attrID in self._skillTempAttrDict:
|
value += self._skillTempAttrDict[attrID] # Ö§³ÖÕý¸ºÖµ
|
value = max(1, value)
|
return value
|
def SetBatAttrValue(self, attrID, value): self._batAttrDict[attrID] = value
|
def AddSkillTempAttr(self, attrID, value):
|
## Ôö¼Ó¼¼ÄÜÁÙʱÊôÐÔ£¬Ö§³ÖÕý¸ºÖµ
|
# @param value: ÕýÖµ-¼ÓÊôÐÔ£»¸ºÖµ-¼õÊôÐÔ
|
self._skillTempAttrDict[attrID] = self._skillTempAttrDict.get(attrID, 0) + value
|
def ClearSkillTempAttr(self): self._skillTempAttrDict = {}
|
|
def GetSkillUseCnt(self, skillID): return self._skillUseCntDict.get(skillID, 0)
|
def GetSkillTurnUseCnt(self, skillID): return self._skillTurnUseCntDict.get(skillID, 0)
|
def AddSkillUseCnt(self, skillID):
|
self._skillUseCntDict[skillID] = self._skillUseCntDict.get(skillID, 0) + 1
|
self._skillTurnUseCntDict[skillID] = self._skillTurnUseCntDict.get(skillID, 0) + 1
|
|
def StatHurtValue(self, hurtValue):
|
## ͳ¼ÆÊä³ö
|
self.hurtStat += hurtValue
|
return self.hurtStat
|
|
def StatDefValue(self, lostHP):
|
## ͳ¼Æ³ÐÉË
|
self.defStat += lostHP
|
return self.defStat
|
|
def StatCureValue(self, cureValue):
|
## ͳ¼ÆÖÎÁÆ
|
self.cureStat += cureValue
|
return self.cureStat
|
|
def TurnReset(self):
|
## »ØºÏÖØÖÃ
|
self._skillTurnUseCntDict = {}
|
|
class BattleObjMgr():
|
## Õ½¶·¶ÔÏó¹ÜÀíÆ÷
|
|
def __init__(self):
|
self._newID = 0 # ¹ÜÀí´´½¨ÐµÄʵÀýID
|
self._freeIDList = []
|
self.batObjDict = {} # Õ½¶·µ¥Î» {objID:BatObj, ...}
|
return
|
|
def __getNewObjID(self):
|
while self._freeIDList:
|
objID = self._freeIDList.pop(0)
|
if objID not in self.batObjDict:
|
return objID
|
|
maxID = 100000
|
if self._newID >= maxID:
|
self._newID = 0
|
while self._newID < maxID:
|
self._newID += 1
|
if self._newID not in self.batObjDict:
|
return self._newID
|
GameWorld.ErrLog("__getNewObjID error.")
|
return 0
|
|
def addBatObj(self):
|
## Ìí¼ÓÕ½¶·µ¥Î»
|
newBatObj = None
|
newObjID = self.__getNewObjID()
|
if not newObjID:
|
return newBatObj
|
newBatObj = ObjPool.GetPoolMgr().acquire(BatObj)
|
newBatObj.objID = newObjID
|
self.batObjDict[newObjID] = newBatObj
|
GameWorld.DebugLog("Ìí¼ÓÕ½¶·µ¥Î»: objID=%s" % (newObjID))
|
if False:
|
newBatObj = BatObj(None, 0)
|
return newBatObj
|
|
def getBatObj(self, objID):
|
batObj = None
|
if objID in self.batObjDict:
|
batObj = self.batObjDict[objID]
|
elif False:
|
batObj = BatObj(None, 0)
|
return batObj
|
|
def delBatObj(self, objID):
|
if objID not in self.batObjDict:
|
return
|
batObj = self.batObjDict.pop(objID)
|
if not batObj:
|
return
|
objID = batObj.objID
|
GameWorld.DebugLog("»ØÊÕÕ½¶·µ¥Î»: objID=%s" % (objID))
|
turnFight = batObj.GetTurnFight()
|
if turnFight:
|
# //04 07 NPCÏûʧ#tagNPCDisappear ´Ë´¦Í¨ÖªÏûʧ£¬Óë»ØºÏÖÆËÀÍöÇø·Ö
|
clientPack = ChNetSendPack.tagNPCDisappear()
|
clientPack.NPCID = [objID]
|
clientPack.Count = len(clientPack.NPCID)
|
turnFight.addBatPack(clientPack)
|
|
# ×îºó»ØÊÕ¶ÔÏó
|
ObjPool.GetPoolMgr().release(batObj)
|
if objID not in self._freeIDList: # »ØÊÕID£¬Öظ´ÀûÓÃ
|
self._freeIDList.append(objID)
|
return
|
|
def GetBatObjMgr():
|
batObjMgr = PyGameData.g_batObjMgr
|
if not batObjMgr:
|
batObjMgr = BattleObjMgr()
|
PyGameData.g_batObjMgr = batObjMgr
|
return batObjMgr
|
|
def OnMinute():
|
GameWorld.Log("Õ½¶·µ¥Î»ÊýÁ¿: %s" % len(GetBatObjMgr().batObjDict))
|
return
|
|
def NotifyObjInfoRefresh(batObj, attrID, value):
|
##0418֪ͨ¶ÔÏóÊôÐÔË¢ÐÂ
|
if attrID not in ChConfig.CDBRefresh_AttrIDDict:
|
return
|
refreshType, isBig = ChConfig.CDBRefresh_AttrIDDict[attrID]
|
turnFight = TurnAttack.GetTurnFightMgr().getTurnFight(batObj.GetTFGUID())
|
if not turnFight:
|
return
|
clientPack = ObjPool.GetPoolMgr().acquire(ChNetSendPack.tagObjInfoRefresh)
|
clientPack.ObjID = batObj.GetID()
|
clientPack.RefreshType = refreshType
|
if isBig:
|
clientPack.Value = value % ShareDefine.Def_PerPointValue
|
clientPack.ValueEx = value / ShareDefine.Def_PerPointValue
|
else:
|
clientPack.Value = value
|
clientPack.ValueEx = 0
|
turnFight.addBatPack(clientPack)
|
return
|
