#!/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
|
|
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 PyBuff():
|
|
def __init__(self, skillData):
|
self._skillData = skillData
|
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._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
|
skillData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
|
if not skillData:
|
return buff
|
skillTypeID = skillData.GetSkillTypeID()
|
self._buffID += 1
|
|
buff = ObjPool.GetPoolMgr().acquire(PyBuff, skillData)
|
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 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
|
|
class PySkill():
|
|
def __init__(self, skillData):
|
self._skillData = skillData
|
self._remainTime = 0
|
self._batType = 0 # Õ½¶·ÀàÐÍ£¬ÆÕͨ¡¢Á¬»÷¡¢·´»÷¡¢×·»÷µÈ
|
self._enhanceBySkill = None # ÓÉÄĸöÖ÷¼¼ÄÜ´¥·¢µÄ
|
self._tagObjList = [] # ±¾´Î¼¼ÄÜÄ¿±êÁбí [BatObj, ...]
|
self._hurtList = [] # ±¾´ÎÉËѪÁбí [HurtObj, ...]
|
return
|
|
def SetSkillData(self, skillData): self._skillData = skillData
|
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 FindEffectID(self, effID):
|
## ²éÕÒÊÇ·ñÓÐij¸öЧ¹ûID
|
# @return: ´óÓÚ0¸ÃIDËùÔÚµÄЧ¹ûID±àºÅ£» 0-²»´æÔÚ¸ÃЧ¹ûID
|
for idNum in range(1, 1 + 3):
|
if self.GetEffectID(idNum) == effID:
|
return idNum
|
return 0
|
def GetEffectID(self, idNum):
|
## »ñȡЧ¹ûID
|
# @param idNum: Ч¹ûID±àºÅ£¬´Ó1¿ªÊ¼
|
if idNum == 1:
|
return self._skillData.GetEffectID1()
|
if idNum == 2:
|
return self._skillData.GetEffectID2()
|
if idNum == 3:
|
return self._skillData.GetEffectID3()
|
return 0
|
def GetEffectValue(self, idNum, index):
|
## »ñȡЧ¹û¶ÔÓ¦Öµ
|
# @param idNum: Ч¹ûID±àºÅ£¬´Ó1¿ªÊ¼
|
# @param index: ÖµË÷Òý£¬´Ó0¿ªÊ¼´ú±íµÚ1¸öÖµ
|
if idNum <= 0:
|
return 0
|
if idNum == 1:
|
values = self._skillData.GetEffectValues1()
|
elif idNum == 2:
|
values = self._skillData.GetEffectValues2()
|
elif idNum == 3:
|
values = self._skillData.GetEffectValues3()
|
else:
|
return 0
|
return values[index] if len(values) > index else 0
|
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 GetEnhanceBySkill(self): return self._enhanceBySkill
|
def SetEnhanceBySkill(self, enhanceBySkill): self._enhanceBySkill = enhanceBySkill
|
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
|
def GetHurtObj(self, tagID):
|
## »ñȡij¸öÉËѪ£¬Èç¹ûÄ¿±êûÓÐÔÚÉËѪÁбíÀïÔò·µ»ØNone
|
for hurtObj in self._hurtList:
|
if hurtObj.GetObjID() == tagID:
|
return hurtObj
|
return
|
|
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):
|
skill = self._skillList[index]
|
#if False:
|
# skill = PySkill()
|
return skill
|
def FindSkillByID(self, skillID):
|
skill = self._skillDict.get(skillID, None)
|
#if False:
|
# skill = PySkill()
|
return skill
|
def FindSkillByTypeID(self, skillTypeID):
|
skill = None
|
for s in self._skillList:
|
if s.GetSkillTypeID() == skillTypeID:
|
skill = s
|
break
|
#if False:
|
# skill = PySkill()
|
return skill
|
|
def LearnSkillByID(self, skillID):
|
skillData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
|
if not skillData:
|
return
|
if skillID in self._skillDict:
|
return
|
skillTypeID = skillData.GetSkillTypeID()
|
curSkill = self.FindSkillByTypeID(skillTypeID)
|
if curSkill:
|
if curSkill.GetSkillID() >= skillID:
|
return
|
# Éý¼¶¼¼ÄÜ
|
curSkill.SetSkillData(skillData)
|
else:
|
# ѧм¼ÄÜ
|
curSkill = ObjPool.GetPoolMgr().acquire(PySkill, skillData)
|
self._skillDict[skillID] = curSkill
|
self._skillList.append(curSkill)
|
return curSkill
|
|
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._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):
|
## ³õʼ»¯Õ½¶·ÊôÐÔ
|
self._initAttrDict = initAttrDict
|
self._batAttrDict = {}
|
self._batAttrDict.update(initAttrDict)
|
self._batAttrDict[ChConfig.AttrID_XP] = initXP
|
self._batAttrDict[ChConfig.AttrID_HP] = initAttrDict.get(ChConfig.AttrID_MaxHP, 1)
|
self._skillTempAttrDict = {}
|
return
|
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.heroID # ½öÍæ¼ÒÓÐÖµ£¬Î佫Ƥ·ô
|
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 GetMaxHP(self): return self._batAttrDict.get(ChConfig.AttrID_MaxHP, 0)
|
def SetMaxHP(self, maxHP): self._batAttrDict[ChConfig.AttrID_MaxHP] = maxHP
|
def GetHP(self): return self._batAttrDict.get(ChConfig.AttrID_HP, 0)
|
def SetHP(self, hp, isNotify=False):
|
self._batAttrDict[ChConfig.AttrID_HP] = hp
|
if isNotify:
|
NotifyObjInfoRefresh(self, ChConfig.AttrID_HP, hp)
|
return
|
def SetHPFull(self, isNotify=True): self.SetHP(self.GetMaxHP())
|
def GetXP(self): return self._batAttrDict.get(ChConfig.AttrID_XP, 0)
|
def SetXP(self, xp, isNotify=True):
|
self._batAttrDict[ChConfig.AttrID_XP] = xp
|
if isNotify:
|
NotifyObjInfoRefresh(self, ChConfig.AttrID_XP, xp)
|
return
|
def GetAtk(self): return self.GetAttrValue(ChConfig.AttrID_Atk)
|
def GetDef(self): return self.GetAttrValue(ChConfig.AttrID_Def)
|
|
def GetAttrValue(self, attrID):
|
value = self._batAttrDict.get(attrID, 0)
|
if attrID in self._skillTempAttrDict:
|
value += self._skillTempAttrDict[attrID] # Ö§³ÖÕý¸ºÖµ
|
value = max(1, value)
|
return 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 = {}
|
|
def ResetBatObj(self, isReborn=True):
|
## ÖØÖÃÕ½¶·Ïà¹Ø
|
# @param isReborn: ËÀÍöµÄÊÇ·ñ¸´»î
|
|
# ÖØÖÃͳ¼Æ
|
self.hurtStat = 0
|
self.defStat = 0
|
self.cureStat = 0
|
|
if self.GetHP() <= 0 and not isReborn:
|
return
|
|
# Çå³ýbuff
|
|
# »ØÂúѪ
|
self.SetHPFull()
|
|
# ÖØÖÃÅÆø
|
initXP = IpyGameDataPY.GetFuncCfg("AngerXP", 1)
|
self.SetXP(initXP)
|
return
|
|
|
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
|
