#!/usr/bin/python
|
# -*- coding: GBK -*-
|
#-------------------------------------------------------------------------------
|
#
|
##@package TurnAttack
|
#
|
# @todo:»ØºÏÖƹ¥»÷Âß¼
|
# @author hxp
|
# @date 2023-11-30
|
# @version 1.0
|
#
|
# ÏêϸÃèÊö: »ØºÏÖƹ¥»÷Âß¼£¬¾ùʹÓÃNPCʵÀý×÷Ϊս¶·Ö÷Ìå
|
# ʵʱս¶·£º ½öÓÃÓÚÖ÷Ïߣ¬Ã¿¸öÍæ¼Ò×î¶à½öÔÊÐí´æÔÚÒ»¸öʵʱս¶·
|
# ÓÉÇ°¶Ë¿ØÖÆÕ½¶·Á÷³Ì£¬ºó¶Ë½øÐмÆËã
|
# ˲ʱս¶·£º ÓÃÓÚ·ÇÖ÷ÏßÍâµÄ¸÷ÖÖÕ½¶·£¬È縱±¾PVEÌôÕ½£¬PVPÌôÕ½µÈ£¬Ò»Ñù½öÓÐÒ»¸ö˲ʱս¶·£¬
|
# Ò»´ÎÐÔ´¦ÀíÍ꣬ºó¶Ë¿ØÖÆÕûÌåÕ½¶·Á÷³Ì¼°¼ÆË㣬ǰ¶Ë½ö×öÕ½±¨½âÎö±íÏÖÕ½¶·¹ý³Ì
|
#
|
#-------------------------------------------------------------------------------
|
#"""Version = 2023-11-30 15:30"""
|
#-------------------------------------------------------------------------------
|
|
import ChConfig
|
import PlayerTask
|
import ChPyNetSendPack
|
import NetPackCommon
|
import PlayerControl
|
import GameWorld
|
import IpyGameDataPY
|
import PlayerOnline
|
import NPCCommon
|
import ShareDefine
|
import PyGameData
|
import SkillCommon
|
import BattleObj
|
import TurnPassive
|
import TurnSkill
|
import TurnBuff
|
import ObjPool
|
import FBLogic
|
|
import random
|
import time
|
import json
|
|
TimelineSet = 10000 # µ¥»ØºÏ×î´óʱ¼äÖá
|
PosNumMax = 7 # ×î´óվλ±àºÅ
|
ActionNumStart = -1 # ÆðʼÐж¯Î»ÖñàºÅ£¬Ò»°ãÊÇ´Ó1¿ªÊ¼£¬Èç¹ûÓмÓÖ÷¹«¡¢ºìÑÕµÈÔò¿Û³ýÏàӦλÖÃÖµ£¬Èç´Ó0»ò-1¿ªÊ¼
|
|
# »ØºÏÕ½¶·Á÷³Ì״̬
|
(
|
FightState_Start, # 0 Æðʼ״̬£¬ÎÞÌØÊâÒâÒ壬½ö´ú±í¿ªÊ¼ÁË£¬ÓëOver¶ÔÓ¦
|
FightState_PrepareOK, # 1 ×¼±¸Íê±Ï£¬°üº¬¶ÔÕ½NPCÕÙ»½OK¡¢ÆäËûµÈ
|
FightState_Fighting, # 2 Õ½¶·ÖÐ
|
FightState_FightEnd, # 3 Õ½¶·½áÊø
|
FightState_Award, # 4 ½áËã½±Àø
|
FightState_Over, # 5 ½áÊø״̬£¬ÎÞÌØÊâÒâÒ壬½ö´ú±íËùÓд¦Àí½áÊøÁË£¬ÓëStart¶ÔÓ¦
|
FightState_Rest, # 6 ½áÊø²¢ÐÝÏ¢£¬Ò»°ãÊÇÇ°¶ËÖ÷¶¯Í˳ö²¢ÐÝÏ¢µÄ
|
) = range(7)
|
|
class BatLineup():
|
## Õ½¶·ÕóÈÝ
|
|
def __init__(self, faction, num, turnFight):
|
self.turnFight = turnFight # TurnFight
|
self.faction = faction # ËùÊôÕóÓª
|
self.num = num # ¸ÃÕóÈÝËùÔÚÕóÓªÖеıàºÅ£¬²»Í¬ÕóÓª¿ÉÖظ´£¬¶àV¶à
|
self.ownerID = 0 # ÕóÈÝËùÊôÍæ¼ÒID£¬¿ÉÄÜΪ0£¬0´ú±í·ÇÍæ¼ÒÕóÈÝ
|
self.shapeType = 0 # ÕóÐÍ
|
self.fightPower = 0 # ÕóÈÝ×ÜÕ½Á¦
|
self.posObjIDDict = {} # վλ¶ÔÓ¦Õ½¶·ÊµÌå {վλ±àºÅ:batObjID, ...}, վλ±àºÅСÓÚ0Ϊ·ÇÖ÷Õ½µ¥Î»£¬ÈçÖ÷¹«¡¢ºìÑÕµÈ
|
self.lingshouObjIDDict = {} # ÁéÊÞÕ½¶·µ¥Î» {λÖñàºÅ:batObjID, ...}
|
self.beautyObjIDDict = {} # ºìÑÕÕ½¶·µ¥Î» {λÖñàºÅ:batObjID, ...}
|
self.actionNum = ActionNumStart # Ðж¯Î»Ö㬴Ó1¿ªÊ¼
|
return
|
|
def getPlayerID(self): return self.turnFight.playerID # ·¢ÆðµÄÍæ¼ÒID
|
|
def isEmpty(self): return not self.posObjIDDict
|
|
def setLineup(self, lineupInfo):
|
## ÉèÖÃÕóÈÝ
|
# @param lineupInfo: ÕóÈÝÐÅÏ¢
|
self.clearLineup()
|
self.ownerID = lineupInfo.get("PlayerID", 0) # ÕóÈÝËùÊôµÄÍæ¼ÒID
|
self.shapeType = lineupInfo.get("ShapeType", 0)
|
self.fightPower = lineupInfo.get("FightPower", 0)
|
SummonLineupObjs(self, self.faction, self.num, lineupInfo, self.getPlayerID())
|
return
|
|
def clearLineup(self):
|
## Çå³ýÕóÈÝ
|
batObjMgr = BattleObj.GetBatObjMgr()
|
for objID in self.posObjIDDict.values():
|
batObjMgr.delBatObj(objID)
|
for objID in self.lingshouObjIDDict.values():
|
batObjMgr.delBatObj(objID)
|
for objID in self.beautyObjIDDict.values():
|
batObjMgr.delBatObj(objID)
|
self.posObjIDDict = {}
|
self.lingshouObjIDDict = {}
|
self.beautyObjIDDict = {}
|
self.fightPower = 0
|
return
|
|
class BatFaction():
|
## Õ½¶·ÕóÓª
|
|
def __init__(self, faction, turnFight):
|
self.turnFight = turnFight # TurnFight
|
self.faction = faction
|
self.lineupDict = {} # ¸ÃÕóÓªËùÓÐÕóÈÝÐÅÏ¢ {±àºÅ:BatLineup, ...}
|
return
|
|
def getBatlineup(self, num=1):
|
## »ñÈ¡Õ½¶·ÕóÈÝ
|
lineup = None
|
if num in self.lineupDict:
|
lineup = self.lineupDict[num]
|
else:
|
lineup = BatLineup(self.faction, num, self.turnFight)
|
self.lineupDict[num] = lineup
|
return lineup
|
|
def clearLineups(self):
|
## Çå³ýËùÓÐÕ½¶·ÕóÈÝ
|
for lineup in self.lineupDict.values():
|
lineup.clearLineup()
|
return
|
|
class TurnFight():
|
'''ij³¡»ØºÏÕ½¶·£¬Ö§³Ö¶àV¶à£¬ËùÓÐÕ½¶·Í¨Óã¬Ö÷Ïß¡¢ÅÀËþ¡¢PVPµÈ
|
¿ÉÄÜΪϵͳºǫ́·¢ÆðµÄ£¬Ôò¹¥»÷·½¡¢·ÀÊØ·½ÕóÈÝÒÔÍæ¼ÒËù±£´æµÄÕóÈݾµÏñ½øÐÐÕ½¶·
|
Èç¹ûÍæ¼Ò·¢ÆðµÄ£¬Ôò¹¥»÷·½Îª·¢Æð·½Íæ¼Ò£¬Ä¿±êΪ·ÀÊØ·½£¬Ö§³Ö¶àV¶à£¬Èç×é¶ÓPK
|
¶àV¶àµÄÇé¿öÒ²ÊÇij¸ö¶ÓÔ±¸÷×Ô·¢ÆðÕ½¶·£¬Ö»ÊÇÓõ½¶ÓÓѵľµÏñÕóÈÝÒ»ÆðÕ½¶·£¬¶ÓÓÑÎÞ¸ÐÖª
|
|
¶àV¶à¿ÉʹÓÃÁ½ÖÖģʽ£º
|
1. ¶à¸öÕóÈÝÒ»Æð³ö³¡£¬ÔÚÒ»³¡Õ½¶·ÖÐÍê³É
|
2. ÒÔµ¥ÕóÈÝ·½Ê½ÂÖÁ÷³ö³¡Õ½¶·£¬¸Ã·½Ê½Í¬Ñù¿ÉÒÔʹÓ÷½Ê½1µÄÂ߼ʵÏÖ£¬¹ÌÓÅÏÈʹÓ÷½Ê½1Õ½¶·Âß¼£¬·½±ãÀ©Õ¹
|
'''
|
|
def __init__(self, mapID=0, funcLineID=0, playerID=0, isNeedReport=False):
|
self.guid = GameWorld.GetGUID() # ij³¡Õ½¶·µÄΨһguid£¬¿ÉÓÃÓÚ´æ´¢¼Ç¼ÈçÕ½±¨µÈ
|
self.playerID = playerID # ¿ÉÄÜΪ0£¬ÏµÍ³ºǫ́×Ô¶¯´¦ÀíµÄÕ½¶·Ê±Îª0£¬Ä³¸öÍæ¼Ò·¢ÆðÔòΪ·¢ÆðÍæ¼ÒID£¬Í¬¸öÍæ¼ÒID¿ÉÄÜͬʱ´æÔڶೡս¶·£¬ÈçÖ÷Ïß+ÆäËû
|
self.curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID) if playerID else None
|
self.mapID = mapID
|
self.funcLineID = funcLineID
|
self.state = -1 # -1 ´ú±íδս¶·
|
self.turnNum = 1 # µ±Ç°µÚx»ØºÏ£¬Ä¬ÈϵÚ1»ØºÏ¿ªÊ¼
|
self.turnMax = 15 # ×î´ó»ØºÏÊý
|
self.enterLogic = False # ÊÇ·ñÒÑÖ´Ðнø³¡Âß¼
|
self.winFaction = 0 # ±¾³¡Õ½¶·½áÊø±ê¼Ç£¬»ñʤÕóÓª£¬Îª0ʱ´ú±íδ½áÊø£¬ËùÓÐС¶Ó´òÍê»òʧ°Ü²ÅÓнá¹û£¬0-δ½áÊø£¬>0-»ñʤµÄÕóÓª
|
self.isWin = False
|
self.batBuffer = "" # Õ½±¨buffer£¬Õ½±¨ÔÝʱֻ±£Áô×îºóÒ»¸öС¶ÓµÄ
|
self.isNeedReport = isNeedReport # ÊÇ·ñÐèÒªÕ½±¨
|
self.msgDict = {} # À©Õ¹ÐÅÏ¢×ֵ䣬һ°ãÓÉMapID°ó¶¨µÄ¹¦Äܾö¶¨ÐÅÏ¢ÄÚÈÝ {k:v, ...}
|
|
self.factionDict = {} # Õ½¶·ÕóÓª {faction:BatFaction, ...}£¬Ò»°ãÊÇÖ»ÓÐÁ½¸öÕóÓª£¬factionΪ1»ò2£¬Ã¿¸öÕóÓªÖ§³Ö¶à¸öÕóÈÝ
|
self.actionSortList = [] # ÕóÈÝÐж¯Ë³Ðò [[faction, num], ...]
|
self.actionIndex = 0 # Ðж¯Ë³ÐòË÷Òý
|
self.timeline = 0 # ʱ¼äÖá½Úµã turnNum*1000+actionIndex*100++actionNum
|
self.startTime = 0 # ¿ªÊ¼Ê±¼ä´Á£¬Ö§³ÖºÁÃëСÊý
|
self.costTime = 0 # µ¥³¡Õ½¶·×ܺÄʱ£¬Ö§³ÖºÁÃëСÊý
|
|
# ¶àС¶Ó - Ò»°ãÖ»ÓÐPVEÓõ½
|
self.lineupIndex = 0 # µ±Ç°Ð¡¶ÓË÷Òý
|
self.lineupIDList = [] # npcС¶ÓÁбí
|
self.strongerLV = 0 # npc³É³¤µÈ¼¶
|
self.difficulty = 0 # npcÄѶÈ
|
return
|
|
def setTurnFight(self, mapID, funcLineID, turnMax, isNeedReport=False, msgDict={}, lineupIDList=[], strongerLV=0, difficulty=0):
|
## ÉèÖñ¾³¡»ØºÏÕ½¶·É趨
|
self.mapID = mapID
|
self.funcLineID = funcLineID
|
self.turnMax = turnMax # ×î´ó»ØºÏÊý
|
self.isNeedReport = isNeedReport
|
self.lineupIndex = 0
|
self.lineupIDList = lineupIDList
|
self.strongerLV = strongerLV
|
self.difficulty = difficulty
|
self.msgDict = {}
|
self.nextTurnFight(msgDict)
|
return
|
|
def nextTurnFight(self, msgDict={}):
|
## Ò»°ãÓÃÓÚÍæ¼Ò·¢ÆðµÄÕ½¶·£¬ÔÚÐèÒª±£ÁôÍæ¼ÒÕóÈÝÊôÐÔ¼°×´Ì¬µÄÇé¿öÏ£¬ÖØÖûغϽøÈëÏÂÒ»³¡Õ½¶·
|
self.turnNum = 1
|
self.enterLogic = False
|
self.winFaction = 0
|
self.isWin = False
|
self.msgDict.update(msgDict)
|
self.timeline = 0
|
self.startTime = time.time()
|
self.costTime = 0
|
return
|
|
def haveNextLineup(self):
|
## ÊÇ·ñ¿ÉÒÔ´òÏÂһС¶Ó£¬»ñʤÇÒ»¹ÓÐÏÂһС¶Óʱ¿É´ò
|
return (self.winFaction == ChConfig.Def_FactionA and self.lineupIndex < len(self.lineupIDList) - 1)
|
def nextLineupID(self):
|
## ÏÂһС¶ÓID
|
if not self.haveNextLineup():
|
return 0
|
self.lineupIndex += 1
|
return self.lineupIDList[self.lineupIndex]
|
|
def setFactionLineup(self, faction, lineupDict):
|
## ÉèÖÃÕóÓªÕóÈÝ
|
# @param lineupDict: {ÕóÈݱàºÅ:ÕóÈÝÐÅÏ¢, ...} ÿ¸öÕóÓªÖ§³Ö¶à¸öÕóÈÝ£¬¼´Ö§³Ö¶àV¶à
|
batFaction = self.getBatFaction(faction)
|
batFaction.clearLineups()
|
for num, lineupInfo in lineupDict.items():
|
if not lineupInfo:
|
continue
|
batLineup = batFaction.getBatlineup(num)
|
batLineup.setLineup(lineupInfo)
|
return
|
|
def sortActionQueue(self):
|
## ˢгöÊÖ˳Ðò¶ÓÁÐ
|
sortList = []
|
for batFaction in self.factionDict.values():
|
faction = batFaction.faction
|
for num, batLineup in batFaction.lineupDict.items():
|
isPlayer = 1 if batLineup.ownerID else 0 # Íæ¼ÒÕóÈÝÓÅÏȹ¥»÷
|
fightPower = batLineup.fightPower
|
sortValue = -(faction * 10 + num)
|
sortList.append([isPlayer, fightPower, sortValue, faction, num])
|
sortList.sort(reverse=True) # Õ½Á¦¸ßµÄÏÈÊÖ
|
|
self.actionIndex = 0
|
self.actionSortList = []
|
for _, _, _, faction, num in sortList:
|
self.actionSortList.append([faction, num])
|
|
GameWorld.DebugLog("ÕóÈÝÕ½Á¦ÅÅÐò[isPlayer, fp, sortV, f, n]: %s" % sortList)
|
GameWorld.DebugLog("ÕóÈÝÐж¯Ë³Ðò[f, n]: %s" % self.actionSortList)
|
return
|
|
def getTurnNumStartTimelin(self, turnNum): return turnNum * TimelineSet + 0 # ÿ»ØºÏµÄʱ¼ä½ÚµãÆðµã
|
def getTimeline(self): return self.timeline
|
def setTimeline(self, timeline, isEmpty=False):
|
'''»ØºÏÕ½¶·µÄʱ¼äÖá½Úµã £¬¼´µÚ¼¸»ØºÏ¿ªÊ¼£¬Ã¿¸ö»ØºÏÖ§³Ö9999¸öÐж¯½Úµã
|
@param turnNum: µÚx»ØºÏ
|
'''
|
self.timeline = timeline
|
GameWorld.DebugLog("ʱ¼ä½Úµã¸üÐÂ: %s" % self.timeline)
|
if isEmpty:
|
# ¿ÕλÖõĽڵã¿ÉÖ±½ÓÌø¹ý
|
return timeline
|
|
OnTimelineChange(self)
|
return timeline
|
|
def getBatFaction(self, faction=ChConfig.Def_FactionA):
|
## ĬÈÏÕóÓª1
|
batFaction = None
|
if faction in self.factionDict:
|
batFaction = self.factionDict[faction]
|
else:
|
batFaction = BatFaction(faction, self)
|
self.factionDict[faction] = batFaction
|
return batFaction
|
|
def checkOverByKilled(self):
|
##¼ì²éÊÇ·ñ»÷ɱ½áÊø
|
# @return: 0-ÎÞ»ñʤÕóÓª£¬Í¬Ê±Ò²´ú±íÕ½¶·Î´½áÊø£»>0-»ñʤµÄÕóÓªID£¬Í¬Ê±Ò²´ú±íÕ½¶·ÒÑÈ«²¿½áÊø
|
|
if self.winFaction:
|
return self.winFaction
|
|
batObjMgr = BattleObj.GetBatObjMgr()
|
for faction, batFaction in self.factionDict.items():
|
allKilled = True
|
for batLineup in batFaction.lineupDict.values():
|
if not allKilled:
|
break
|
for posNum, objID in batLineup.posObjIDDict.items():
|
if posNum <= 0:
|
# ·ÇÖ÷սλÖò»ÅжÏ
|
continue
|
batObj = batObjMgr.getBatObj(objID)
|
if not batObj:
|
continue
|
if batObj.IsAlive():
|
allKilled = False
|
break
|
|
if allKilled:
|
self.winFaction = ChConfig.Def_FactionA if faction == ChConfig.Def_FactionB else ChConfig.Def_FactionB
|
DoTurnFightOver(self.guid)
|
return self.winFaction
|
|
return 0
|
|
def exitFight(self, rest=False):
|
## Í˳öÕ½¶·
|
self.syncState(FightState_Over if not rest else FightState_Rest)
|
for batFaction in self.factionDict.values():
|
batFaction.clearLineups()
|
self.state = -1
|
return
|
|
def startFight(self):
|
## ×¼±¸¾ÍÐ÷£¬¿ªÊ¼Õ½¶·
|
self.state = FightState_Start
|
self.turnNum = 1
|
self.timeline = self.getTurnNumStartTimelin(self.turnNum)
|
self.syncInit()
|
return
|
|
def isInFight(self): return self.state != -1
|
|
def syncInit(self):
|
## ³õʼ»¯Í¨Öª
|
msg = json.dumps(self.msgDict, ensure_ascii=False)
|
msg = msg.replace(" ", "")
|
clientPack = ChPyNetSendPack.tagSCTurnFightInit()
|
clientPack.MapID = self.mapID
|
clientPack.FuncLineID = self.funcLineID
|
clientPack.TurnMax = self.turnMax
|
clientPack.Msg = msg
|
clientPack.Len = len(clientPack.Msg)
|
clientPack.FactionList = []
|
|
batObjMgr = BattleObj.GetBatObjMgr()
|
for faction in self.factionDict.keys():
|
batFaction = self.getBatFaction(faction)
|
tfFaction = ChPyNetSendPack.tagSCTurnFightFaction()
|
tfFaction.Faction = faction
|
tfFaction.LineupList = []
|
for num in batFaction.lineupDict.keys():
|
batLineup = batFaction.getBatlineup(num)
|
tfLineup = ChPyNetSendPack.tagSCTurnFightLineup()
|
tfLineup.Num = num
|
tfLineup.OwnerID = batLineup.ownerID
|
tfLineup.ShapeType = batLineup.shapeType
|
tfLineup.ObjList = []
|
for posNum, objID in batLineup.posObjIDDict.items():
|
batObj = batObjMgr.getBatObj(objID)
|
if not batObj:
|
continue
|
tfObj = ChPyNetSendPack.tagSCTurnFightObj()
|
tfObj.ObjID = batObj.GetID()
|
tfObj.NPCID = batObj.GetNPCID()
|
tfObj.HeroID = batObj.GetHeroID()
|
tfObj.SkinID = batObj.GetSkinID()
|
tfObj.HP = batObj.GetHP() % ChConfig.Def_PerPointValue
|
tfObj.HPEx = batObj.GetHP() / ChConfig.Def_PerPointValue
|
tfObj.MaxHP = batObj.GetMaxHP() % ChConfig.Def_PerPointValue
|
tfObj.MaxHPEx = batObj.GetMaxHP() / ChConfig.Def_PerPointValue
|
tfObj.LV = batObj.GetLV()
|
tfObj.PosNum = posNum
|
tfObj.AngreXP = batObj.GetXP()
|
tfLineup.ObjList.append(tfObj)
|
tfLineup.ObjCnt = len(tfLineup.ObjList)
|
tfFaction.LineupList.append(tfLineup)
|
tfFaction.LineupCnt = len(tfFaction.LineupList)
|
clientPack.FactionList.append(tfFaction)
|
clientPack.FactionCnt = len(clientPack.FactionList)
|
self.addBatPack(clientPack)
|
return
|
|
def syncState(self, state, msgDict={}):
|
self.state = state
|
msg = json.dumps(msgDict, ensure_ascii=False)
|
msg = msg.replace(" ", "")
|
clientPack = ChPyNetSendPack.tagMCTurnFightState()
|
clientPack.Clear()
|
clientPack.MapID = self.mapID
|
clientPack.FuncLineID = self.funcLineID
|
clientPack.State = state
|
clientPack.TurnNum = self.turnNum
|
clientPack.Msg = msg
|
clientPack.Len = len(clientPack.Msg)
|
self.addBatPack(clientPack)
|
return
|
|
def syncObjAction(self, turnNum, objID):
|
clientPack = ChPyNetSendPack.tagMCTurnFightObjAction()
|
clientPack.Clear()
|
clientPack.TurnNum = turnNum
|
clientPack.ObjID = objID
|
self.addBatPack(clientPack)
|
return
|
|
def addBatPack(self, clientPack):
|
## Ìí¼ÓÕ½¶·¹ý³Ì·â°ü£¬·ÇÕ½¶·Ïà¹ØµÄ·â°ü¿ÉÒÔ²»Ê¹Óøú¯Êý·¢ËÍ£¬Èç¼Ó¾Ñé¡¢µôÂäµÈ
|
## ×¢£ºÕ½¶·Ïà¹ØµÄ·â°üÐèµ÷Óñ¾º¯Êý·½±ãͳһ¹ÜÀíÕ½±¨
|
if hasattr(clientPack, "Head"):
|
headStr = "%02x%02x" % (clientPack.Head.Cmd, clientPack.Head.SubCmd)
|
else:
|
headStr = "%02x%02x" % (clientPack.Cmd, clientPack.SubCmd)
|
if self.isNeedReport:
|
packBuff = clientPack.GetBuffer()
|
GameWorld.DebugLog("»ØºÏÕ½¶·¹ý³Ì·â°ü: %s" % (headStr))
|
self.batBuffer += packBuff
|
ObjPool.GetPoolMgr().release(clientPack)
|
else:
|
GameWorld.DebugLog("»ØºÏÕ½¶·¹ý³Ì·â°ü: %s" % (headStr))
|
# ÓÐÍæ¼ÒµÄͳһÿ¸ö°üµ¥¶À·¢ËÍ£¬Í¬ÑùÒ²Ö§³ÖÕ½±¨Í³¼Æ
|
if self.curPlayer:
|
NetPackCommon.SendFakePack(self.curPlayer, clientPack)
|
else:
|
ObjPool.GetPoolMgr().release(clientPack)
|
return
|
|
class TurnFightMgr():
|
## »ØºÏÕ½¶·¹ÜÀíÆ÷
|
|
def __init__(self):
|
self.turnFightDict = {} # {guid:TurnFight, ...}
|
return
|
|
def addTurnFight(self, mapID, funcLineID=0, playerID=0, isNeedReport=False):
|
tf = ObjPool.GetPoolMgr().acquire(TurnFight, mapID, funcLineID, playerID, isNeedReport)
|
if not tf:
|
tf = TurnFight(mapID, funcLineID, playerID, isNeedReport) # Ò»°ãÊDz»¿ÉÄÜ£¬ÎªÁ˵ã³ö´úÂë
|
self.turnFightDict[tf.guid] = tf
|
return tf
|
|
def delTurnFight(self, guid):
|
turnFight = self.getTurnFight(guid)
|
if not turnFight:
|
return
|
turnFight.exitFight()
|
self.turnFightDict.pop(guid, None)
|
ObjPool.GetPoolMgr().release(turnFight)
|
return
|
|
def getTurnFight(self, guid):
|
tf = None
|
if guid in self.turnFightDict:
|
tf = self.turnFightDict[guid]
|
elif False:
|
tf = TurnFight()
|
return tf
|
|
def GetTurnFightMgr():
|
tfMgr = None
|
if PyGameData.g_turnFightMgr:
|
tfMgr = PyGameData.g_turnFightMgr
|
else:
|
tfMgr = TurnFightMgr()
|
PyGameData.g_turnFightMgr = tfMgr
|
return tfMgr
|
|
class MainFight():
|
## Ö÷ÏßÕ½¶·¹ÜÀí
|
|
def __init__(self, playerID):
|
self.playerID = playerID
|
self.chapterID = 0 # Õ½ÚID
|
self.levelNum = 0 # ¹Ø¿¨±àºÅ
|
self.waveMax = 6 # ±¾¹Ø×î´ó²¨Êý£¬Ã¿²¨Óжà¸öС¶Ó£¬Ã¿¸öС¶Ó¼´ÎªÒ»ÕÅÕ½¶· TurnFight
|
self.wave = 0 # µ±Ç°Ë¢¹Ö²¨£¬×¢Òâ²»ÊÇÍæ¼Òµ±Ç°½ø¶È²¨£¬±ÈÈç±»»÷ɱ»á»ØÍËÒ»²¨
|
self.turnFight = GetTurnFightMgr().addTurnFight(ChConfig.Def_FBMapID_Main, 0, playerID)
|
return
|
|
def isLevelBoss(self):
|
## µ±Ç°Õ½¶·ÊÇ·ñ¹Ø¿¨boss
|
return self.turnFight.mapID == ChConfig.Def_FBMapID_MainBoss
|
|
def GetMainFightMgr(curPlayer):
|
## »ñÈ¡Ö÷ÏßÕ½¶·¹ÜÀí
|
olPlayer = PlayerOnline.GetOnlineMgr().GetOnlinePlayer(curPlayer)
|
return olPlayer.mainFight
|
|
def OnPlayerLogin(curPlayer):
|
chapterID, levelNum, _ = PlayerControl.GetMainLevelPassInfo(curPlayer)
|
nowChapterID, _, _ = PlayerControl.GetMainLevelNowInfo(curPlayer)
|
if chapterID != nowChapterID:
|
if IpyGameDataPY.GetIpyGameDataNotLog("MainChapter", chapterID) and IpyGameDataPY.GetIpyGameDataNotLog("MainLevel", chapterID, levelNum):
|
fixNowValue = PlayerControl.SetMainLevelNowInfo(curPlayer, chapterID, levelNum, 1)
|
GameWorld.Log("µ±Ç°Ö÷Ï߹ؿ¨Õ½ÚÓë¹ý¹ØÕ½ڲ»Ò»ÖÂʱ£¬ÇÒ¹ý¹Ø½ø¶ÈÕ½ÚÒѾ´æÔÚ£¬Ç¿ÖÆÐÞÕýµ±Ç°Ë¢¹Ö½ø¶ÈΪ¹ý¹ØÕ½ڽø¶È! passChapterID-LV=%s-%s,nowChapterID=%s,fixNowValue=%s"
|
% (chapterID, levelNum, nowChapterID, fixNowValue), curPlayer.GetPlayerID())
|
return
|
|
def GetPlayerLineupInfoByCache(playerID, lineupID):
|
## »ñÈ¡Íæ¼ÒÕóÈÝÐÅÏ¢ - ¸ù¾ÝÍæ¼Ò²é¿´»º´æ
|
lineupInfo = {}
|
return lineupInfo
|
|
def GetPlayerLineupInfo(curPlayer, lineupID):
|
## »ñÈ¡Íæ¼ÒÕóÈÝÐÅÏ¢£¬¿ÉÓÃÓÚÕ½¶·»ò²é¿´»º´æ£¬ÒòΪ¿ÉÄÜÈ¡Íæ¼ÒµÄ»º´æ½øÐжÔÕ½£¬ËùÒÔͳһʹÓÃjson¸ñʽ£¬Ç°¶ËͨÓÃ
|
# @param lineupID: ÕóÈÝID
|
# @return: ÕóÈÝÈ«²¿ÐÅÏ¢json×ֵ䣬ǰ¶ËͨÓøñʽ
|
|
playerID = curPlayer.GetPlayerID()
|
lineup = PlayerOnline.GetOnlinePlayer(curPlayer).GetLineup(lineupID)
|
if not lineup.lineupHeroDict:
|
return {}
|
|
lineupInfo = {"PlayerID":playerID, "FightPower":lineup.fightPower, "ShapeType":lineup.shapeType}
|
heroDict = {}
|
curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
|
for posNum in lineup.lineupHeroDict.keys():
|
hero = lineup.GetLineupHero(posNum)
|
heroID = hero.heroID
|
itemIndex = hero.itemIndex
|
userData = ""
|
heroLV = 1
|
if itemIndex >= 0 and itemIndex < curPack.GetCount():
|
heroItem = curPack.GetAt(itemIndex)
|
if heroItem and not heroItem.IsEmpty():
|
userData = heroItem.GetUserData()
|
heroLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroLV)
|
|
skillIDlist = []
|
skillIDlist += hero.heroSkillIDList
|
heroDict[str(posNum)] = {
|
"HeroID":heroID,
|
"SkinID":hero.skinID,
|
"LV":heroLV,
|
"Data":userData,
|
"FightPower":hero.fightPower,
|
"AttrDict":{str(k):v for k, v in hero.heroBatAttrDict.items() if v > 0},
|
"SkillIDList":skillIDlist,
|
}
|
lineupInfo.update({"Hero":heroDict})
|
|
return lineupInfo
|
|
def GetNPCLineupInfo(lineupID, strongerLV=0, difficulty=0):
|
## »ñÈ¡NPCÕóÈÝÐÅÏ¢
|
# @param lineupID: ÕóÈÝID
|
# @param npcLV: ³É³¤NPCµÈ¼¶
|
# @param difficulty: ³É³¤NPCÄѶÈϵÊý
|
# @return: ÕóÈÝÈ«²¿ÐÅÏ¢json×ֵ䣬ǰ¶ËͨÓøñʽ
|
ipyData = IpyGameDataPY.GetIpyGameData("NPCLineup", lineupID)
|
if not ipyData:
|
return {}
|
|
heroDict = {}
|
for posNum in range(1, 1 + 10):
|
if not hasattr(ipyData, "GetPosNPCID%s" % posNum):
|
break
|
npcID = getattr(ipyData, "GetPosNPCID%s" % posNum)()
|
if not npcID:
|
continue
|
battleDict = GetNPCBattleDict(ipyData, npcID, strongerLV, difficulty)
|
if not battleDict:
|
continue
|
heroDict[str(posNum)] = battleDict
|
|
lineupInfo = {"NPCLineupID":lineupID, "Hero":heroDict}
|
return lineupInfo
|
|
def GetNPCBattleDict(lineupIpyData, npcID, strongerLV=0, difficulty=0):
|
## »ñÈ¡NPCÕ½¶·Ïà¹Ø×ֵ䣬֧³Ö³É³¤NPC
|
# @param strongerLV: ³É³¤µÈ¼¶
|
# @param difficulty: ÄѶÈϵÊý
|
npcData = NPCCommon.GetNPCDataPy(npcID)
|
if not npcData:
|
return
|
heroID = npcData.GetRelatedHeroID()
|
npcLV = npcData.GetLV()
|
|
lvIpyData = None
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID) if heroID else None
|
npcStronger = IpyGameDataPY.GetIpyGameDataNotLog("NPCStronger", npcID)
|
if npcStronger and strongerLV:
|
lvIpyData = IpyGameDataPY.GetIpyGameData("PlayerLV", strongerLV)
|
if lvIpyData:
|
npcLV = strongerLV
|
if not lvIpyData:
|
lvIpyData = IpyGameDataPY.GetIpyGameData("PlayerLV", npcLV)
|
|
if heroIpyData and lvIpyData:
|
skinIDList = heroIpyData.GetSkinIDList()
|
skinID = skinIDList[0] if skinIDList else 0
|
skillIDList = GetNPCHeroSkillIDList(heroID, heroIpyData, lvIpyData.GetReHeroBreakLV(), lvIpyData.GetReHeroAwakeLV())
|
else:
|
heroID = 0
|
skinID = 0
|
skillIDList = [] + npcData.GetSkillIDList()
|
|
# boss¶îÍâËæ»ú¼¼ÄÜ
|
bossID = lineupIpyData.GetBossID()
|
if npcID == bossID:
|
skillIDExList = lineupIpyData.GetSkillIDExList()
|
if skillIDExList:
|
randSkillIDExList = [] + list(skillIDExList)
|
skillExCnt = lineupIpyData.GetSkillExCnt()
|
if skillExCnt > 0 and len(randSkillIDExList) > skillExCnt:
|
random.shuffle(randSkillIDExList)
|
randSkillIDExList = randSkillIDExList[:skillExCnt]
|
skillIDList += randSkillIDExList
|
GameWorld.DebugLog("ÕóÈÝboss¼¼ÄÜ: %s, Ëæ»ú¸½¼Ó¼¼ÄÜ: %s" % (skillIDList, randSkillIDExList))
|
|
# ³É³¤¹ÖÊôÐÔ
|
batAttrDict = GetNPCStrongerAttrDict(npcID, lvIpyData, npcStronger, difficulty)
|
if not batAttrDict:
|
batAttrDict = {ChConfig.AttrID_Atk:npcData.GetAtk(), ChConfig.AttrID_Def:npcData.GetDef(), ChConfig.AttrID_MaxHP:npcData.GetMaxHP(),
|
ChConfig.AttrID_FinalDamPer:npcData.GetFinalDamPer(), ChConfig.AttrID_FinalDamPerDef:npcData.GetFinalDamPerDef(),
|
ChConfig.AttrID_MissRate:npcData.GetMissRate(), ChConfig.AttrID_MissRateDef:npcData.GetMissRateDef(),
|
ChConfig.AttrID_SuperHitRate:npcData.GetSuperHitRate(), ChConfig.AttrID_SuperHitRateDef:npcData.GetSuperHitRateDef(),
|
ChConfig.AttrID_StunRate:npcData.GetStunRate(), ChConfig.AttrID_StunRateDef:npcData.GetStunRateDef(),
|
ChConfig.AttrID_ComboRate:npcData.GetComboRate(), ChConfig.AttrID_ComboRateDef:npcData.GetComboRateDef(),
|
ChConfig.AttrID_ParryRate:npcData.GetParryRate(), ChConfig.AttrID_ParryRateDef:npcData.GetParryRateDef(),
|
ChConfig.AttrID_SuckHPPer:npcData.GetSuckHPPer(), ChConfig.AttrID_SuckHPPerDef:npcData.GetSuckHPPerDef(),
|
}
|
batAttrDict.update(npcData.GetSpecAttrInfo())
|
|
battleDict = {"NPCID":npcID,
|
"HeroID":heroID,
|
"SkinID":skinID,
|
"LV":npcLV,
|
"AttrDict":{str(k):v for k, v in batAttrDict.items() if v > 0},
|
"SkillIDList":skillIDList,
|
}
|
|
GameWorld.DebugLog("GetNPCBattleDict npcID=%s,strongerLV=%s,difficulty=%s,%s" % (npcID, strongerLV, difficulty, battleDict))
|
return battleDict
|
|
def GetNPCHeroSkillIDList(heroID, heroIpyData, breakLV, awakeLV):
|
## »ñÈ¡NPC¶ÔÓ¦Î佫µÄ¼¼ÄÜIDÁбí
|
normalSkillID = heroIpyData.GetNormalSkillID()
|
angerSkillID = heroIpyData.GetAngerSkillID()
|
skillIDList = [normalSkillID, angerSkillID]
|
|
breakIpyDataList = IpyGameDataPY.GetIpyGameDataList("HeroBreak", heroID)
|
if breakIpyDataList:
|
for breakIpyData in breakIpyDataList:
|
if breakIpyData.GetBreakLV() > breakLV:
|
break
|
skillID = breakIpyData.GetSkillID()
|
if skillID:
|
skillIDList.append(skillID)
|
|
awakeIpyDataList = IpyGameDataPY.GetIpyGameDataList("HeroAwake", heroID)
|
if awakeIpyDataList:
|
for awakeIpyData in awakeIpyDataList:
|
if awakeIpyData.GetAwakeLV() > awakeLV:
|
break
|
skillID = awakeIpyData.GetSkillID()
|
if skillID:
|
skillIDList.append(skillID)
|
|
return skillIDList
|
|
def GetNPCStrongerAttrDict(npcID, lvIpyData, npcStronger, difficulty):
|
## »ñÈ¡NPC³É³¤ÊôÐÔ
|
# @param strongerLV: ³É³¤µÈ¼¶
|
# @param difficulty: ÄѶÈϵÊý
|
|
batAttrDict = {}
|
if not lvIpyData or not npcStronger or not difficulty:
|
return batAttrDict
|
lv = lvIpyData.GetLV()
|
for attrID in ChConfig.CalcBattleAttrIDList:
|
attrIpyData = IpyGameDataPY.GetIpyGameData("PlayerAttr", attrID)
|
if not attrIpyData:
|
continue
|
attrName = attrIpyData.GetParameter()
|
if not hasattr(lvIpyData, "GetRe%s" % attrName):
|
continue
|
reValue = getattr(lvIpyData, "GetRe%s" % attrName)() # »ù´¡²Î¿¼Öµ
|
ratio = getattr(npcStronger, "Get%sRatio" % attrName)() if hasattr(npcStronger, "Get%sRatio" % attrName) else 1 # ÊôÐÔϵÊý
|
attrValue = int(reValue * ratio * difficulty)
|
batAttrDict[attrID] = attrValue
|
#GameWorld.DebugLog(" attrID=%s,attrValue=%s,reValue=%s,ratio=%s,difficulty=%s" % (attrID, attrValue, reValue, ratio, difficulty))
|
|
GameWorld.DebugLog("NPC³É³¤ÊôÐÔ: npcID=%s,lv=%s,difficulty=%s,%s" % (npcID, lv, difficulty, batAttrDict))
|
return batAttrDict
|
|
def SummonLineupObjs(batLineup, faction, num, lineupInfo, playerID=0):
|
'''ÕÙ»½ÕóÈÝÕ½¶·ÊµÀý
|
@param faction: ËùÊôÕóÓª£¬Ä¿Ç°Ö§³ÖÁ½¸öÕóÓª£¬1»ò2
|
@param num: Õ½¶·ÕóÈÝÔÚ¸ÃÕóÓªÉϵıàºÅ£¬1V1ʱĬÈÏ1£¬¶à¶Ô¶àʱ1~n
|
@param lineupInfo: ÕóÈÝÐÅÏ¢
|
@param playerID: ·¢ÆðµÄÍæ¼ÒID£¬ÏµÍ³³¡´ÎΪ0
|
'''
|
GameWorld.DebugLog("SummonLineupObjs faction:%s,num:%s,lineupInfo=%s" % (faction, num, lineupInfo), playerID)
|
if playerID:
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
|
if not curPlayer:
|
return
|
|
tfGUID = batLineup.turnFight.guid
|
lineupPlayerID = lineupInfo.get("PlayerID", 0) # ÕóÈÝËùÊôÍæ¼ÒID
|
heroDict = lineupInfo.get("Hero", {})
|
|
batObjMgr = BattleObj.GetBatObjMgr()
|
initXP = IpyGameDataPY.GetFuncCfg("AngerXP", 1)
|
atkBackSkillIDList = IpyGameDataPY.GetFuncEvalCfg("ParryCfg", 2)
|
for posNumKey, heroInfo in heroDict.items():
|
posNum = int(posNumKey)
|
|
atkBackSkillID = 0 # ·´»÷¼¼ÄÜID
|
fightPower = 0
|
skillIDList = [] # Õ½¶·¶ÔÏó¿ÉÄܸıäÊôÐÔ»ò¼¼ÄÜ£¬ÖØд´½¨£¬·ÀÖ¹ÎóÐÞ¸ÄÀ´Ô´Öµ
|
attrDict = {}
|
skillIDList += heroInfo.get("SkillIDList", [])
|
attrDict.update(heroInfo.get("AttrDict", {}))
|
npcID = heroInfo.get("NPCID", 0)
|
heroID = heroInfo.get("HeroID", 0)
|
skinID = heroInfo.get("SkinID", 0)
|
lv = heroInfo.get("LV", 1)
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID) if heroID else None
|
if heroIpyData:
|
atkDistType = heroIpyData.GetAtkDistType()
|
objName = heroIpyData.GetName()
|
country = heroIpyData.GetCountry()
|
sex = heroIpyData.GetSex()
|
|
if lineupPlayerID:
|
fightPower = heroInfo.get("FightPower", 0)
|
if not heroIpyData:
|
continue
|
|
else:
|
npcDataEx = NPCCommon.GetNPCDataPy(npcID)
|
if not npcDataEx:
|
continue
|
if not heroIpyData:
|
atkDistType = npcDataEx.GetAtkDistType()
|
objName = npcDataEx.GetNPCName()
|
country = npcDataEx.GetCountry()
|
sex = npcDataEx.GetSex()
|
|
batObj = batObjMgr.addBatObj()
|
if not batObj:
|
break
|
objID = batObj.GetID()
|
if npcID:
|
batObj.SetNPCID(npcID)
|
elif lineupPlayerID:
|
batObj.SetOwnerID(lineupPlayerID)
|
batObj.SetTFGUID(tfGUID)
|
batObj.SetName(objName)
|
batObj.SetFaction(faction)
|
batObj.SetLineupPos(posNum, num)
|
batObj.SetFightPower(fightPower)
|
batObj.SetLV(lv)
|
batObj.SetAtkDistType(atkDistType)
|
batObj.SetCountry(country)
|
batObj.SetSex(sex)
|
batObj.SetHero(heroID, skinID)
|
|
if atkDistType == ChConfig.AtkDistType_Short:
|
atkBackSkillID = atkBackSkillIDList[0] if len(atkBackSkillIDList) > 0 else 0
|
elif atkDistType == ChConfig.AtkDistType_Long:
|
atkBackSkillID = atkBackSkillIDList[1] if len(atkBackSkillIDList) > 1 else 0
|
if atkBackSkillID:
|
skillIDList.append(atkBackSkillID)
|
skillManager = batObj.GetSkillManager()
|
skillManager.SkillReset()
|
for skillID in skillIDList:
|
skillManager.LearnSkillByID(skillID)
|
|
batLineup.posObjIDDict[posNum] = objID
|
GameWorld.DebugLog("AddBatObj %s,skill=%s" % (GetObjName(batObj), skillManager.GetSkillIDList()))
|
batObj.InitBatAttr({int(k):v for k, v in attrDict.items()}, initXP)
|
|
return
|
|
#// B4 10 »ØºÏÖÆÕ½¶· #tagCMTurnFight
|
#
|
#struct tagCMTurnFight
|
#{
|
# tagHead Head;
|
# DWORD MapID; // ×Ô¶¨ÒåµØͼID£¬¿ÉÓÃÓÚ°ó¶¨Õ½¶·µØͼ³¡¾°¹¦ÄÜ£¨ÈçÖ÷Ïßboss¡¢ÅÀËþ¡¢¾º¼¼³¡µÈ£©
|
# DWORD FuncLineID; // MapID¶ÔÓ¦µÄÀ©Õ¹Öµ£¬Èç¾ßÌåij¸ö¹Ø¿¨µÈ
|
# BYTE TagType; // Ä¿±êÀàÐÍ£¬0-NPCÕóÈÝ£¬1-Íæ¼Ò
|
# DWORD TagID; // Ä¿±êÀàÐͶÔÓ¦µÄID£¬ÈçÍæ¼ÒID
|
# BYTE ValueCount;
|
# DWORD ValueList[ValueCount]; // ¸½¼ÓÖµÁÐ±í£¬¿ÉÑ¡£¬¾ßÌ庬ÒåÓÉMapID¾ö¶¨
|
#};
|
def OnTurnFight(index, clientData, tick):
|
''' ±¾Õ½¶·»áÒ»´ÎÐÔ´¦ÀíÍêËùÓÐС¶ÓÕ½¶·£¬ÒÔÕ½±¨µÄÐÎʽÏ·¢£¬Ä¿Ç°³ýÁËÖ÷ÏßС¹Ö·Ö¶ÎÕ½¶·Í⣬¾ùʹÓøÃÕ½¶·
|
'''
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
mapID = clientData.MapID
|
funcLineID = clientData.FuncLineID
|
tagType = clientData.TagType
|
tagID = clientData.TagID
|
valueList = clientData.ValueList
|
|
GameWorld.DebugLog("»ØºÏÖÆÕ½¶·ÇëÇó: mapID=%s,funcLineID=%s,tagType=%s,tagID=%s,valueList=%s"
|
% (mapID, funcLineID, tagType, tagID, valueList), curPlayer.GetPlayerID())
|
|
reqRet = FBLogic.OnTurnFightRequest(curPlayer, mapID, funcLineID, tagType, tagID, valueList)
|
if not reqRet:
|
return
|
|
# ¹¥·À·½ËùʹÓõÄÕóÈÝID
|
atkLineupID, defLineupID = FBLogic.GetFBPlayerLineupID(curPlayer, mapID, funcLineID)
|
if atkLineupID not in ShareDefine.LineupList or defLineupID not in ShareDefine.LineupList:
|
return
|
|
# Íæ¼Ò
|
if tagType == 1:
|
# OnTurnFightVSPlayer
|
pass
|
|
# NPC
|
else:
|
ret = FBLogic.GetFBNPCLineupInfo(curPlayer, mapID, funcLineID)
|
if not ret:
|
return
|
npcLineupIDList, strongerLV, difficulty = ret
|
OnTurnFightVSNPC(curPlayer, mapID, funcLineID, atkLineupID, npcLineupIDList, strongerLV, difficulty)
|
|
return
|
|
def OnTurnFightVSNPC(curPlayer, mapID, funcLineID, atkLineupID, npcLineupIDList, strongerLV, difficulty):
|
playerID = curPlayer.GetPlayerID()
|
GameWorld.DebugLog("OnTurnFightVSNPC: mapID=%s,funcLineID=%s,atkLineupID=%s,npcLineupIDList=%s,strongerLV=%s,difficulty=%s"
|
% (mapID, funcLineID, atkLineupID, npcLineupIDList, strongerLV, difficulty), playerID)
|
if not npcLineupIDList:
|
return
|
|
lineupMainInfo = GetPlayerLineupInfo(curPlayer, atkLineupID)
|
if not lineupMainInfo:
|
GameWorld.DebugLog("Íæ¼ÒûÓиÃÕóÈÝÊý¾Ý! atkLineupID=%s" % atkLineupID, playerID)
|
return
|
|
turnMax = 15
|
if mapID == ChConfig.Def_FBMapID_MainBoss:
|
turnMax = IpyGameDataPY.GetFuncCfg("Mainline", 3)
|
# Í£Ö¹Ö÷ÏßС¹ÖÕ½¶·¡¢Çå¿Õ
|
mainFightMgr = GetMainFightMgr(curPlayer)
|
mainTF = mainFightMgr.turnFight
|
if mainTF.isInFight():
|
mainTF.exitFight()
|
|
tfMgr = GetTurnFightMgr()
|
turnFight = tfMgr.addTurnFight(mapID, funcLineID, playerID)
|
guid = turnFight.guid
|
|
turnFight.setTurnFight(mapID, funcLineID, turnMax, True, lineupIDList=npcLineupIDList, strongerLV=strongerLV, difficulty=difficulty)
|
turnFight.setFactionLineup(ChConfig.Def_FactionA, {1:lineupMainInfo})
|
|
for index, lineupID in enumerate(npcLineupIDList):
|
turnFight.lineupIndex = index
|
GameWorld.DebugLog("¶ÔÕ½NPCÕóÈÝ: index=%s, lineupID=%s" % (index, lineupID))
|
if index > 0:
|
turnFight.nextTurnFight()
|
turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(lineupID, strongerLV, difficulty)})
|
turnFight.sortActionQueue()
|
turnFight.startFight()
|
|
__processTurnFight(turnFight.guid)
|
|
if not turnFight.isWin:
|
break
|
|
SyncTurnFightReport(curPlayer, guid, turnFight.batBuffer)
|
tfMgr.delTurnFight(guid)
|
return
|
|
#// B4 13 Ö÷ÏßÕ½¶·ÇëÇó #tagCSMainFightReq
|
#
|
#struct tagCSMainFightReq
|
#{
|
# tagHead Head;
|
# BYTE ReqType; // 0-Í£Ö¹Õ½¶·»Ø³Ç£»1-ÉèÖÃÏûºÄ±¶Öµ£»2-ÌôÕ½¹Ø¿¨Ð¡¹Ö£»4-¼ÌÐøÕ½¶·£»
|
# DWORD ReqValue; // ÇëÇóÖµ£¬ReqTypeΪ1ʱ·¢ËÍÏûºÄ±¶Öµ
|
#};
|
def OnMainFightReq(index, clientData, tick):
|
curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
reqType = clientData.ReqType
|
reqValue = clientData.ReqValue
|
|
if reqType == 0:
|
__doExitMainFight(curPlayer)
|
return
|
elif reqType == 1:
|
__doSetFightPoint(curPlayer, reqValue)
|
return
|
|
GameWorld.DebugLog("Ö÷ÏßÕ½¶·ÇëÇó: reqType=%s" % reqType, curPlayer.GetPlayerID())
|
clientPack = ChPyNetSendPack.tagSCTurnFightReportSign()
|
clientPack.Sign = 0
|
NetPackCommon.SendFakePack(curPlayer, clientPack) # ±ê¼Ç¿ªÊ¼
|
|
if reqType == 2: # Ç°¶ËÖ÷¶¯ÇëÇó¿ªÊ¼¹Ø¿¨Ð¡¹ÖµÄÊÓΪ´ÓÐÝÏ¢ÖпªÊ¼
|
__doMainLevelWave(curPlayer, True)
|
elif reqType == 4:
|
__doMainFight(curPlayer, tick)
|
else:
|
pass
|
|
# ±ê¼Ç½áÊø
|
clientPack.Sign = 1
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
def __doExitMainFight(curPlayer):
|
## Ö÷ÏßÍ˳öÕ½¶· - »Ø³ÇÐÝÏ¢
|
mainFightMgr = GetMainFightMgr(curPlayer)
|
turnFight = mainFightMgr.turnFight
|
if turnFight:
|
turnFight.exitFight(True)
|
return
|
|
def __doSetFightPoint(curPlayer, fightPoint):
|
## ÉèÖÃÏûºÄ±¶Öµ
|
GameWorld.DebugLog("ÉèÖÃÕ½´¸ÏûºÄ±¶Öµ: %s" % fightPoint)
|
if fightPoint == 1:
|
pass
|
elif fightPoint == 2:
|
# Ìõ¼þÑéÖ¤
|
pass
|
elif fightPoint == 3:
|
# Ìõ¼þÑéÖ¤
|
pass
|
else:
|
return
|
curPlayer.SetFightPoint(fightPoint)
|
return
|
|
def __doMainLevelWave(curPlayer, isRestStart=False):
|
## ¿ªÊ¼ÐµĹؿ¨²¨
|
# @param isRestStart: ÊÇ·ñ´ÓÐÝϢ״̬ÖØпªÊ¼µÄ
|
playerID = curPlayer.GetPlayerID()
|
chapterID, levelNum, wave = PlayerControl.GetMainLevelNowInfo(curPlayer)
|
GameWorld.DebugLog("ÇëÇó¹Ø¿¨²¨Õ½¶·: chapterID=%s,levelNum=%s,wave=%s,isRestStart=%s" % (chapterID, levelNum, wave, isRestStart), playerID)
|
fightPoint = max(curPlayer.GetFightPoint(), 1)
|
if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint):
|
GameWorld.DebugLog("Õ½´¸²»×㣬ÎÞ·¨¿ªÊ¼!")
|
return
|
chapterIpyData = IpyGameDataPY.GetIpyGameData("MainChapter", chapterID)
|
if not chapterIpyData:
|
return
|
levelIpyData = IpyGameDataPY.GetIpyGameData("MainLevel", chapterID, levelNum)
|
if not levelIpyData:
|
# ÈçÉÏÏߺó¼õÉÙij¸öÕ½ڹؿ¨ÊýµÄÇé¿ö£¬µ¼ÖÂÕÒ²»µ½£¬Ôò´Ó¸ÃÕ½ڻØÍ˵½´æÔڵĹؿ¨¿ªÊ¼
|
while levelNum > 1:
|
levelNum -= 1
|
levelIpyData = IpyGameDataPY.GetIpyGameDataNotLog("MainLevel", chapterID, levelNum)
|
if levelIpyData:
|
break
|
if not levelIpyData:
|
return
|
|
# ±¾¹Ø¿¨×î´ó²¨Êý£¬ÔÝʱ֧³Ö×î´ó6²¨
|
waveMax = 6
|
while waveMax >= 1 and (not hasattr(levelIpyData, "GetWaveLineupIDList%s" % waveMax) or not getattr(levelIpyData, "GetWaveLineupIDList%s" % waveMax)()):
|
waveMax -= 1
|
if waveMax < 1:
|
return
|
if wave > waveMax:
|
wave = waveMax
|
|
lineupIDList = getattr(levelIpyData, "GetWaveLineupIDList%s" % wave)() # С¶Ó1ÕóÈÝID|С¶Ó2ÕóÈÝID|...
|
if not lineupIDList:
|
return
|
lineupID = lineupIDList[0] # NPCÕóÈÝID
|
|
lineupMainInfo = GetPlayerLineupInfo(curPlayer, ShareDefine.Lineup_Main)
|
if not lineupMainInfo:
|
GameWorld.DebugLog("ûÓÐÉèÖÃÖ÷ÕóÈÝ!", playerID)
|
return
|
|
strongerLV = levelIpyData.GetNPCLV()
|
difficulty = levelIpyData.GetDifficulty()
|
mainFightMgr = GetMainFightMgr(curPlayer)
|
mainFightMgr.chapterID = chapterID
|
mainFightMgr.levelNum = levelNum
|
mainFightMgr.waveMax = waveMax
|
mainFightMgr.wave = wave
|
turnMax = IpyGameDataPY.GetFuncCfg("Mainline", 2)
|
mapID, funcLineID = ChConfig.Def_FBMapID_Main, PlayerControl.ComMainLevelValue(chapterID, levelNum, wave)
|
GameWorld.DebugLog("ÉèÖÃÆðʼ¹Ø¿¨²¨: ¹Ø¿¨%s-%s,²¨=%s/%s,lineupIDList=%s,mapID=%s,funcLineID=%s,lineupID=%s,strongerLV=%s,difficulty=%s"
|
% (chapterID, levelNum, wave, waveMax, lineupIDList, mapID, funcLineID, lineupID, strongerLV, difficulty), playerID)
|
|
turnFight = mainFightMgr.turnFight
|
turnFight.setTurnFight(mapID, funcLineID, turnMax, False, lineupIDList=lineupIDList, strongerLV=strongerLV, difficulty=difficulty)
|
turnFight.setFactionLineup(ChConfig.Def_FactionA, {1:lineupMainInfo})
|
turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(lineupID, strongerLV, difficulty)})
|
turnFight.sortActionQueue()
|
turnFight.startFight()
|
|
__doMainFight(curPlayer)
|
return
|
|
def __doMainFight(curPlayer, tick=0):
|
'''Ö´ÐÐÖ÷ÏßÕ½¶·£¬µ¥³¡Õ½¶·¶Ïµçʽս¶·£¬ÒÔÇ°¶ËÍæ¼ÒÊÖ¶¯µã»÷½Úµã×öΪ¶Ïµã´¦
|
ÿ³¡Õ½¶·µÄ³õʼ»¯¡¢½áÊøĬÈ϶ϵ㣬ÓÉÇ°¶Ë¾ö¶¨×Ô¶¯¼ÌÐø»òÕßµã»÷¼ÌÐø
|
'''
|
|
# ÏÞÖÆÇëÇóCD
|
if tick:
|
key = "MainFightReqTick"
|
lastTick = curPlayer.GetDictByKey(key)
|
if lastTick and tick - lastTick <= 1000:
|
GameWorld.DebugLog("Ö÷ÏßÕ½¶·ÇëÇóCDÖÐ")
|
return
|
curPlayer.SetDict(key, tick)
|
|
mainFightMgr = GetMainFightMgr(curPlayer)
|
turnFight = mainFightMgr.turnFight
|
|
isLevelBoss = mainFightMgr.isLevelBoss()
|
if isLevelBoss:
|
## ¹Ø¿¨bossÊÇÒ»´ÎÐÔ´¦ÀíÍêµÄ£¬Ò»°ã²»¿ÉÄÜ×ßµ½ÕâÀÕâ±ß×öÏ·À·¶
|
return
|
|
winFaction = turnFight.winFaction
|
if winFaction:
|
nextLineupID = turnFight.nextLineupID()
|
if nextLineupID:
|
GameWorld.DebugLog("---¿ªÊ¼½øÈëÏÂһС¶Ó: lineupIndex=%s,nextLineupID=%s,%s" % (turnFight.lineupIndex, nextLineupID, turnFight.npcLineupIDList))
|
|
turnFight.nextTurnFight()
|
# Çл»Ð¡¶Óʱ£¬Íæ¼ÒÕóÈݲ»ÐèÒª´¦Àí£¬±£Áô״̬
|
turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(nextLineupID, turnFight.strongerLV, turnFight.difficulty)})
|
turnFight.sortActionQueue()
|
turnFight.startFight()
|
|
__doMainFight(curPlayer)
|
else:
|
__doMainLevelWave(curPlayer, False)
|
return
|
|
# С¹ÖÕ½¶·£¬Ã¿´ÎÏûºÄ1¸öÕ½´¸
|
fightPoint = max(curPlayer.GetFightPoint(), 1) # Ö÷ÏßÕ½¶·ÏûºÄ±¶Öµ£¬Ä¬ÈÏ1
|
if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint):
|
GameWorld.DebugLog("»ØºÏ¿ªÊ¼Ê±Õ½´¸²»×ã!")
|
return
|
|
# ÒÔϾùÊÇ´¦Àí¹Ø¿¨Ð¡¹Ö·Ö¶Îʵʱս¶·
|
isEntry = EntryLogic(turnFight)
|
|
# ÊÇ·ñ¿ªÊ¼¼ì²é¶Ïµã£¬Ô¤Åпɶϵĵ㣬·½±ãÇ°¶Ëµã»÷ÌåÑ飬µãÏÂÈ¥¾ÍÊÇÍæ¼Ò·ÅµÄij¸öÐж¯
|
# ³õʼ¿ªÊ¼½ø³¡ºó£¬Ä¬ÈÏ¿ªÊ¼¶Ïµã
|
checkBreakpoint = True if isEntry else False
|
|
batObjMgr = BattleObj.GetBatObjMgr()
|
turnNum = turnFight.turnNum
|
turnMax = turnFight.turnMax
|
for turnNum in range(turnNum, turnMax + 1):
|
turnTimeline = turnFight.getTurnNumStartTimelin(turnNum) # ±¾»ØºÏÆðʼʱ¼ä½Úµã
|
curTimeline = turnFight.getTimeline()
|
|
# »ØºÏ¿ªÊ¼
|
turnTimeline += 1 # ÿ»ØºÏ¿ªÊ¼ËãÒ»¸öʱ¼ä½Úµã
|
if curTimeline < turnTimeline:
|
curTimeline = turnFight.setTimeline(turnTimeline)
|
GameWorld.DebugLog("¡¾----- »ØºÏÖÆÕ½¶·ÂÖ´Î: %s -----¡¿ curTimeline=%s" % (turnNum, curTimeline))
|
turnFight.turnNum = turnNum
|
if curPlayer:
|
turnFight.syncState(FightState_Fighting)
|
|
for faction, num in turnFight.actionSortList:
|
GameWorld.DebugLog("»ØºÏ¿ªÊ¼Âß¼: turnNum=%s,faction=%s, num=%s" % (turnNum, faction, num))
|
batFaction = turnFight.getBatFaction(faction)
|
batLineup = batFaction.getBatlineup(num)
|
batLineup.actionNum = 1
|
for objID in batLineup.posObjIDDict.values():
|
batObj = batObjMgr.getBatObj(objID)
|
TurnFightPerTurnBigStart(turnFight, batObj, turnNum)
|
|
# ºìÑÕ
|
# ÁéÊÞ
|
|
if turnFight.checkOverByKilled():
|
break
|
|
# Î佫
|
doMax = PosNumMax * len(turnFight.actionSortList)
|
doCnt = 0
|
while doCnt < doMax and turnFight.actionIndex < len(turnFight.actionSortList):
|
doCnt += 1
|
faction, num = turnFight.actionSortList[turnFight.actionIndex]
|
batFaction = turnFight.getBatFaction(faction)
|
batLineup = batFaction.getBatlineup(num)
|
for posNum in range(batLineup.actionNum, PosNumMax + 1):
|
# ÿ¸öÎ佫λËãÒ»¸öʱ¼ä½Úµã
|
#GameWorld.DebugLog("Î佫½Úµã: faction=%s,posNum=%s,curTimeline=%s" % (faction, posNum, curTimeline))
|
if posNum not in batLineup.posObjIDDict:
|
batLineup.actionNum = posNum + 1
|
curTimeline = turnFight.setTimeline(curTimeline + 1, True)
|
#GameWorld.DebugLog("¿Õλ½Úµã: faction=%s,posNum=%s,curTimeline=%s" % (faction, posNum, curTimeline))
|
continue
|
|
objID = batLineup.posObjIDDict[posNum]
|
batObj = batObjMgr.getBatObj(objID)
|
|
# Íæ¼Ò×Ô¼ºÕóÓª£¬Ô¤ÅпɷñÐж¯
|
if checkBreakpoint and faction == ChConfig.Def_FactionA and batObj:
|
if batObj.CanAction():
|
GameWorld.DebugLog("Íæ¼ÒÕóÈÝÏÂÒ»¸ö¿ÉÐж¯µÄÎ佫£¬¶Ïµã: curTimeline=%s,nextPosNum=%s" % (curTimeline, posNum))
|
return
|
|
batLineup.actionNum = posNum + 1
|
curTimeline = turnFight.setTimeline(curTimeline + 1)
|
TurnFightHeroTurnStart(turnFight, batObj, turnNum)
|
if not OnObjAction(turnFight, batObj):
|
continue
|
|
if not checkBreakpoint and faction == ChConfig.Def_FactionA:
|
checkBreakpoint = True
|
|
break
|
|
if turnFight.actionIndex >= len(turnFight.actionSortList) - 1:
|
turnFight.actionIndex = 0
|
else:
|
turnFight.actionIndex += 1
|
|
# »ØºÏ½áÊø
|
curTimeline = turnFight.setTimeline(curTimeline + 1) # ÿ»ØºÏ½áÊøËãÒ»¸öʱ¼ä½Úµã
|
for faction, num in turnFight.actionSortList:
|
GameWorld.DebugLog("»ØºÏ½áÊøÂß¼: turnNum=%s,faction=%s, num=%s" % (turnNum, faction, num))
|
batFaction = turnFight.getBatFaction(faction)
|
batLineup = batFaction.getBatlineup(num)
|
for objID in batLineup.posObjIDDict.values():
|
batObj = batObjMgr.getBatObj(objID)
|
TurnFightPerTurnBigEnd(turnFight, batObj, turnNum)
|
|
if turnFight.checkOverByKilled():
|
break
|
|
if not turnFight.winFaction:
|
OnTurnAllOver(turnFight.guid)
|
|
return
|
|
def __processTurnFight(guid):
|
## Ò»´ÎÐÔ´¦ÀíÍêÒ»¸öС¶ÓµÄÕ½¶·
|
turnFight = GetTurnFightMgr().getTurnFight(guid)
|
curPlayer = turnFight.curPlayer
|
turnMax = turnFight.turnMax
|
EntryLogic(turnFight)
|
batObjMgr = BattleObj.GetBatObjMgr()
|
for turnNum in range(1, turnMax + 1):
|
turnFight.turnNum = turnNum
|
GameWorld.DebugLog("¡¾----- »ØºÏÖÆÕ½¶·ÂÖ´Î: %s -----¡¿" % turnNum)
|
curTimeline = turnFight.getTurnNumStartTimelin(turnNum) # ±¾»ØºÏÆðʼʱ¼ä½Úµã
|
curTimeline = turnFight.setTimeline(curTimeline + 1)
|
if curPlayer:
|
turnFight.syncState(FightState_Fighting)
|
|
# »ØºÏ¿ªÊ¼
|
for faction, num in turnFight.actionSortList:
|
GameWorld.DebugLog("»ØºÏ¿ªÊ¼Âß¼: turnNum=%s,faction=%s, num=%s" % (turnNum, faction, num))
|
batFaction = turnFight.getBatFaction(faction)
|
batLineup = batFaction.getBatlineup(num)
|
batLineup.actionNum = 1
|
for objID in batLineup.posObjIDDict.values():
|
batObj = batObjMgr.getBatObj(objID)
|
TurnFightPerTurnBigStart(turnFight, batObj, turnNum)
|
|
|
# ºìÑÕ
|
# ÁéÊÞ
|
|
if turnFight.checkOverByKilled():
|
break
|
|
# Î佫
|
doMax = PosNumMax * len(turnFight.actionSortList)
|
doCnt = 0
|
while doCnt < doMax and turnFight.actionIndex < len(turnFight.actionSortList):
|
doCnt += 1
|
faction, num = turnFight.actionSortList[turnFight.actionIndex]
|
batFaction = turnFight.getBatFaction(faction)
|
batLineup = batFaction.getBatlineup(num)
|
for posNum in range(batLineup.actionNum, PosNumMax + 1):
|
batLineup.actionNum = posNum + 1
|
if posNum not in batLineup.posObjIDDict:
|
curTimeline = turnFight.setTimeline(curTimeline + 1, True)
|
continue
|
curTimeline = turnFight.setTimeline(curTimeline + 1) # ÿ¸öÎ佫λËãÒ»¸öʱ¼ä½Úµã
|
objID = batLineup.posObjIDDict[posNum]
|
batObj = batObjMgr.getBatObj(objID)
|
TurnFightHeroTurnStart(turnFight, batObj, turnNum)
|
if not OnObjAction(turnFight, batObj):
|
continue
|
|
break
|
|
if turnFight.actionIndex >= len(turnFight.actionSortList) - 1:
|
turnFight.actionIndex = 0
|
else:
|
turnFight.actionIndex += 1
|
|
# »ØºÏ½áÊø
|
curTimeline = turnFight.setTimeline(curTimeline + 1) # ÿ»ØºÏ½áÊøËãÒ»¸öʱ¼ä½Úµã
|
for faction, num in turnFight.actionSortList:
|
GameWorld.DebugLog("»ØºÏ½áÊøÂß¼: turnNum=%s,faction=%s, num=%s" % (turnNum, faction, num))
|
batFaction = turnFight.getBatFaction(faction)
|
batLineup = batFaction.getBatlineup(num)
|
for objID in batLineup.posObjIDDict.values():
|
batObj = batObjMgr.getBatObj(objID)
|
TurnFightPerTurnBigEnd(turnFight, batObj, turnNum)
|
|
if turnFight.checkOverByKilled():
|
break
|
|
if not turnFight.winFaction:
|
OnTurnAllOver(turnFight.guid)
|
return
|
|
def GetObjName(batObj):
|
faction = batObj.faction
|
num = batObj.lineupNum
|
posNum = batObj.posNum
|
heroID = batObj.heroID
|
npcID = batObj.npcID
|
objName = GameWorld.CodeToGbk(batObj.GetName())
|
if heroID:
|
objName += " Hero:%s" % heroID
|
if npcID:
|
objName += " NPC:%s" % npcID
|
return "%s%s-P%s ID:%s %s" % ("A" if faction == ChConfig.Def_FactionA else "B", num, posNum, batObj.GetID(), objName)
|
|
def EntryLogic(turnFight):
|
## Ö´Ðнø³¡Âß¼
|
if turnFight.enterLogic:
|
return
|
GameWorld.DebugLog("Ö´Ðнø³¡Âß¼...")
|
|
batObjMgr = BattleObj.GetBatObjMgr()
|
for faction, num in turnFight.actionSortList:
|
batFaction = turnFight.getBatFaction(faction)
|
batLineup = batFaction.getBatlineup(num)
|
batLineup.actionNum = ActionNumStart
|
for objID in batLineup.posObjIDDict.values():
|
batObj = batObjMgr.getBatObj(objID)
|
TurnPassive.OnTriggerPassiveEffect(turnFight, batObj, ChConfig.TriggerWay_FightStart)
|
|
turnFight.enterLogic = True
|
return True
|
|
def OnTimelineChange(turnFight):
|
## ÿ¸öʱ¼ä½Úµã±ä»¯Ê±´¦Àí
|
|
nowTimeline = turnFight.getTimeline()
|
|
batObjMgr = BattleObj.GetBatObjMgr()
|
for batFaction in turnFight.factionDict.values():
|
for batLineup in batFaction.lineupDict.values():
|
for objID in batLineup.posObjIDDict.values():
|
batObj = batObjMgr.getBatObj(objID)
|
#GameWorld.DebugLog("OnTimelineChange! objID=%s" % (objID))
|
if not batObj or not batObj.IsAlive():
|
continue
|
|
batObj.SetDict(ChConfig.Def_Obj_Dict_TurnComboNum, 0)
|
batObj.SetDict(ChConfig.Def_Obj_Dict_TurnMissNum, 0)
|
batObj.SetDict(ChConfig.Def_Obj_Dict_TurnParryNum, 0)
|
|
curID = batObj.GetID()
|
skillManager = batObj.GetSkillManager()
|
for index in range(0, skillManager.GetSkillCount()):
|
curSkill = skillManager.GetSkillByIndex(index)
|
if not curSkill:
|
continue
|
remainTime = curSkill.GetRemainTime()
|
if not remainTime:
|
continue
|
calcTimeline = curSkill.GetCalcTime()
|
passTurn = __calcPassturn(calcTimeline, nowTimeline, True)
|
if passTurn <= 0:
|
continue
|
skillID = curSkill.GetSkillID()
|
updRemainTime = max(0, remainTime - passTurn)
|
curSkill.SetRemainTime(updRemainTime)
|
curSkill.SetCalcTime(nowTimeline)
|
GameWorld.DebugLog("¸üм¼ÄÜÊ£Óà»ØºÏÊý: curID=%s,skillID=%s,updRemainTime=%s,calcTimeline=%s,passTurn=%s"
|
% (curID, skillID, updRemainTime, calcTimeline, passTurn))
|
|
buffMgr = batObj.GetBuffManager()
|
for index in range(buffMgr.GetBuffCount())[::-1]:
|
buff = buffMgr.GetBuffByIndex(index)
|
buffID = buff.GetBuffID()
|
skillID = buff.GetSkillID()
|
skillData = buff.GetSkillData()
|
if skillData.GetSkillType() in ChConfig.Def_LstBuff_List:
|
#GameWorld.DebugLog(" ³ÖÐøÀàbuffÓÉ´¥·¢Ê±»ú¾ö¶¨Ê£Óàʱ¼ä! curID=%s,index=%s,skillID=%s,buffID=%s" % (curID, index, skillID, buffID))
|
continue
|
remainTime = buff.GetRemainTime()
|
if not remainTime:
|
# ÓÀ¾Ãbuff²»´¦Àí
|
#GameWorld.DebugLog(" ÓÀ¾Ãbuff²»´¦Àí! curID=%s,index=%s,skillID=%s" % (curID, index, skillID))
|
continue
|
calcTimeline = buff.GetCalcTime()
|
passTurn = __calcPassturn(calcTimeline, nowTimeline, False)
|
if passTurn <= 0:
|
#GameWorld.DebugLog(" passTurn <= 0 passTurn=%s,calcTimeline=%s,nowTimeline=%s,skillID=%s" % (passTurn, calcTimeline, nowTimeline, skillID))
|
continue
|
|
updRemainTime = max(0, remainTime - passTurn)
|
GameWorld.DebugLog("¸üÐÂbuffÊ£Óà»ØºÏÊý: curID=%s,buffID=%s,skillID=%s,updRemainTime=%s,calcTimeline=%s,passTurn=%s"
|
% (curID, buffID, skillID, updRemainTime, calcTimeline, passTurn))
|
if updRemainTime > 0:
|
buff.SetRemainTime(updRemainTime)
|
buff.SetCalcTime(nowTimeline)
|
TurnBuff.SyncBuffRefresh(turnFight, batObj, buff)
|
else:
|
TurnBuff.DoBuffDel(turnFight, batObj, buff)
|
|
return
|
|
def __calcPassturn(calcTimeline, nowTimeline, equalOK):
|
## ¼ÆËãÒѾ¹ýÁ˵ĻغÏÊý
|
# @param equalOK: ʱ¼ä½ÚµãÏàͬʱÊÇ·ñËã1»ØºÏ£¬Ò»°ã¼¼ÄÜ¿ÉÒÔË㣬buff²»Ëã
|
calcTurnNum = calcTimeline / TimelineSet
|
calcTimeNode = calcTimeline % TimelineSet
|
nowTurnNum = nowTimeline / TimelineSet
|
nowTimeNode = nowTimeline % TimelineSet
|
if equalOK:
|
if nowTimeNode >= calcTimeNode:
|
return max(0, nowTurnNum - calcTurnNum)
|
return max(0, nowTurnNum - calcTurnNum - 1)
|
else:
|
if nowTimeNode > calcTimeNode:
|
return max(0, nowTurnNum - calcTurnNum)
|
return max(0, nowTurnNum - calcTurnNum - 1)
|
return 0
|
|
def TurnFightPerTurnBigStart(turnFight, batObj, turnNum):
|
## ´ó»ØºÏ¿ªÊ¼Ê±
|
if not batObj:
|
return
|
|
if batObj.GetHP() <= 0:
|
return
|
|
TurnPassive.OnTriggerPassiveEffect(turnFight, batObj, ChConfig.TriggerWay_BigTurnStart)
|
return
|
|
def TurnFightPerTurnBigEnd(turnFight, batObj, turnNum):
|
## ´ó»ØºÏ½áÊøʱ
|
if not batObj:
|
return
|
|
if batObj.GetHP() <= 0:
|
return
|
|
TurnPassive.OnTriggerPassiveEffect(turnFight, batObj, ChConfig.TriggerWay_BigTurnEnd)
|
return
|
|
def TurnFightHeroTurnStart(turnFight, batObj, turnNum):
|
## Î佫»ØºÏ¿ªÊ¼Ê±£¬²»ÄÜÐж¯Ò²Òª´¥·¢
|
if not batObj:
|
return
|
|
if batObj.GetHP() <= 0:
|
return
|
|
TurnPassive.OnTriggerPassiveEffect(turnFight, batObj, ChConfig.TriggerWay_HeroTurnStart)
|
return
|
|
def AddTurnObjCureHP(curObj, srcObj, addValue, cureHP, skillID=0):
|
## »ØºÏ¶ÔÏóÌí¼ÓÖÎÁÆÖµ
|
# @param curObj: »ñµÃÖÎÁƵĶÔÏó
|
# @param srcObj: À´×Ô˵ÄÖÎÁÆ
|
# @param addValue: ÖÎÁÆÖµ
|
# @param cureHP: ʵ¼Ê»ØѪÁ¿
|
if not srcObj:
|
return
|
curID = curObj.GetID()
|
srcID = srcObj.GetID()
|
updStatValue = srcObj.StatCureValue(cureHP)
|
GameWorld.DebugLog(" ͳ¼ÆÖÎÁÆ: curID=%s,srcID=%s,skillID=%s,addValue=%s,cureHP=%s,updStatValue=%s"
|
% (curID, srcID, skillID, addValue, cureHP, updStatValue))
|
|
return
|
|
def AddTurnObjHurtValue(curBatObj, tagBatObj, hurtValue, lostHP, skillID=0, isBounce=False):
|
## »ØºÏ¶ÔÏóÌí¼ÓÉ˺¦Öµ
|
# @param isBounce: ÊÇ·ñ·´µ¯É˺¦
|
if hurtValue <= 0:
|
return
|
curID = curBatObj.GetID()
|
tagID = tagBatObj.GetID()
|
if curID != tagID:
|
updStatValue = curBatObj.StatHurtValue(hurtValue)
|
GameWorld.DebugLog(" ͳ¼ÆÉËѪ: curID=%s,tagID=%s,skillID=%s,hurtValue=%s,lostHP=%s,updStatValue=%s,tagHP=%s,isBounce=%s"
|
% (curID, tagID, skillID, hurtValue, lostHP, updStatValue, tagBatObj.GetHP(), isBounce))
|
|
if tagBatObj:
|
updStatValue = tagBatObj.StatDefValue(hurtValue)
|
GameWorld.DebugLog(" ͳ¼Æ³ÐÉË: curID=%s,tagID=%s,skillID=%s,hurtValue=%s,lostHP=%s,updStatValue=%s,curHP=%s,isBounce=%s"
|
% (tagID, curID, skillID, hurtValue, lostHP, updStatValue, tagBatObj.GetHP(), isBounce))
|
|
else:
|
# È绻ѪÀ༼ÄÜ£¬×ԲеÄÉ˺¦²»ËãÊä³ö
|
GameWorld.DebugLog(" ×Ô²Ð: curID=%s,tagID=%s,skillID=%s,hurtValue=%s,lostHP=%s,curHP=%s"
|
% (curID, tagID, skillID, hurtValue, lostHP, curBatObj.GetHP()))
|
return
|
|
def OnObjAction(turnFight, curBatObj):
|
## Õ½¶·µ¥Î»Ðж¯
|
if not curBatObj:
|
return
|
|
curHP = curBatObj.GetHP()
|
objID = curBatObj.GetID()
|
if curHP <= 0:
|
return
|
|
turnNum = turnFight.turnNum
|
objName = GetObjName(curBatObj)
|
|
# ÊÇ·ñ¿ÉÐж¯×´Ì¬ÅжÏ
|
canAction = curBatObj.CanAction()
|
if not canAction:
|
GameWorld.DebugLog("¡ï»ØºÏ%s %s µ±Ç°×´Ì¬²»¿ÉÐж¯!" % (turnNum, objName))
|
return
|
|
atk = curBatObj.GetAtk()
|
curXP = curBatObj.GetXP()
|
GameWorld.DebugLog("¡ï»ØºÏ%s %s Ðж¯ : atk=%s,curHP=%s/%s,curXP=%s" % (turnNum, objName, atk, curHP, curBatObj.GetMaxHP(), curXP))
|
turnFight.syncObjAction(turnNum, objID)
|
|
TurnPassive.OnTriggerPassiveEffect(turnFight, curBatObj, ChConfig.TriggerWay_HeroActionStart)
|
|
xpMax = IpyGameDataPY.GetFuncCfg("AngerXP", 2)
|
skillManager = curBatObj.GetSkillManager()
|
useSkillList = []
|
#GameWorld.DebugLog('skillCount=%s' % skillManager.GetSkillCount(), npcID)
|
for index in range(0, skillManager.GetSkillCount()):
|
useSkill = skillManager.GetSkillByIndex(index)
|
if not useSkill:
|
continue
|
if useSkill.GetFuncType() not in [ChConfig.Def_SkillFuncType_TurnNormaSkill, ChConfig.Def_SkillFuncType_AngerSkill]:
|
#Ö»ÄÜÖ÷¶¯ÊÍ·ÅÆÕ¹¥»òż¼
|
continue
|
#±»¶¯¼¼ÄÜÎÞ·¨Ê¹ÓÃ
|
if SkillCommon.isPassiveSkill(useSkill):
|
continue
|
#»¹ÔÚÀäȴʱ¼äÄÚÎÞ·¨ÊÍ·Å
|
if useSkill.GetRemainTime():
|
continue
|
skillID = useSkill.GetSkillID()
|
# ³£¹æ¹¥»÷ÓÅÏÈxp
|
if SkillCommon.isAngerSkill(useSkill):
|
if curXP < xpMax:
|
continue
|
if curBatObj.IsInState(ChConfig.BatObjState_Sneer):
|
GameWorld.DebugLog("³°·í״̬Ï£¬ÎÞ·¨Ö÷¶¯ÊÍ·Åż¼!") # ¿É±»¶¯ÊÍ·Åż¼£¬Èçż¼×·»÷
|
continue
|
useCnt = -1 # xp¼¼ÄÜÓÅÏÈÊÍ·Å
|
else:
|
useCnt = curBatObj.GetSkillUseCnt(skillID)
|
useSkillList.append([useCnt, skillID, useSkill])
|
|
useSkillList.sort() # °´Ê¹ÓôÎÊýÓÅÏÈÉýÐòÅÅ£¬Ê¹ÓôÎÊýµÍµÄÓÅÏÈÅжÏʹÓÃ
|
#GameWorld.DebugLog(' ¼¼ÄÜʹÓÃ˳Ðò = useSkillList%s' % str(useSkillList), npcID)
|
|
for useInfo in useSkillList:
|
useSkill = useInfo[-1]
|
if TurnSkill.OnUseSkill(turnFight, curBatObj, useSkill):
|
break
|
|
TurnPassive.OnTriggerPassiveEffect(turnFight, curBatObj, ChConfig.TriggerWay_HeroActionEnd)
|
return True
|
|
def SetObjKilled(turnFight, gameObj, killer=None, useSkill=None):
|
objID = gameObj.GetID()
|
killerObjID = killer.GetID() if killer else 0
|
skillID = useSkill.GetSkillID() if useSkill else 0
|
GameWorld.DebugLog(" %s »ØºÏÕ½¶·Ö÷Ìå±»»÷ɱ: curID=%s,killerObjID=%s,skillID=%s" % (GetObjName(gameObj), objID, killerObjID, skillID))
|
gameObj.SetDead()
|
|
clientPack = ObjPool.GetPoolMgr().acquire(ChPyNetSendPack.tagMCTurnFightObjDead)
|
clientPack.ObjID = objID
|
clientPack.KillerObjID = killerObjID
|
clientPack.SkillID = skillID
|
turnFight.addBatPack(clientPack)
|
|
curPlayer = turnFight.curPlayer
|
# ÔÝʱֻËãÖ÷ÏßС¹Ö
|
if curPlayer and turnFight.mapID == ChConfig.Def_FBMapID_Main and gameObj.GetFaction() != ChConfig.Def_FactionA:
|
PlayerTask.AddTaskValue(curPlayer, ChConfig.TaskType_KillNPC, 1)
|
return True
|
|
def OnTurnAllOver(guid):
|
## ËùÓлغÏÒѾȫ²¿Ö´ÐÐÍê±Ï
|
GameWorld.DebugLog("ËùÓлغϽáÊø")
|
turnFight = GetTurnFightMgr().getTurnFight(guid)
|
if not turnFight:
|
return
|
|
if turnFight.winFaction:
|
return
|
|
if turnFight.playerID:
|
# Íæ¼Ò·¢ÆðµÄ£¬Î´»÷ɱ¶Ô·½£¬ËãÍæ¼ÒÊä
|
turnFight.winFaction = ChConfig.Def_FactionB
|
else:
|
# ϵͳ³¡´Î£¬°´Ò»¶¨¹æÔòÀ´£¬ÕâÀïÏÈËæ»ú
|
turnFight.winFaction = random.choice([ChConfig.Def_FactionA, ChConfig.Def_FactionB])
|
|
DoTurnFightOver(guid)
|
return
|
|
def DoTurnFightOver(guid):
|
## Ö´ÐлغÏÕ½¶·½áËãÂß¼
|
tfMgr = GetTurnFightMgr()
|
turnFight = tfMgr.getTurnFight(guid)
|
if not turnFight:
|
return
|
|
turnFight.costTime = time.time() - turnFight.startTime
|
winFaction = turnFight.winFaction
|
turnFight.isWin = (winFaction == ChConfig.Def_FactionA)
|
GameWorld.DebugLog("--- Õ½¶·½áÊø´¦Àí ---, winFaction=%s, costTime=%ss, %s" % (winFaction, turnFight.costTime, guid))
|
|
# ͳ¼ÆÃ÷ϸ
|
batObjMgr = BattleObj.GetBatObjMgr()
|
statInfo = {}
|
for faction in turnFight.factionDict.keys():
|
if str(faction) not in statInfo:
|
statInfo[str(faction)] = {}
|
facStatInfo = statInfo[str(faction)]
|
batFaction = turnFight.getBatFaction(faction)
|
for num in batFaction.lineupDict.keys():
|
if str(num) not in facStatInfo:
|
facStatInfo[str(num)] = {}
|
lineupStatInfo = facStatInfo[str(num)]
|
batLineup = batFaction.getBatlineup(num)
|
GameWorld.DebugLog("ÕóÈÝÃ÷ϸ: faction=%s,num=%s" % (faction, num))
|
for posNum, objID in batLineup.posObjIDDict.items():
|
batObj = batObjMgr.getBatObj(objID)
|
if not batObj:
|
continue
|
objID = batObj.GetID()
|
npcID = batObj.GetNPCID()
|
heroID = batObj.GetHeroID()
|
atkHurt = batObj.hurtStat
|
defHurt = batObj.defStat
|
cureHP = batObj.cureStat
|
GameWorld.DebugLog(" Pos:%s ID=%s,npcID=%s,heroID=%s,HP=%s/%s, Êä³ö=%s,³ÐÉË=%s,ÖÎÁÆ=%s"
|
% (posNum, objID, npcID, heroID, batObj.GetHP(), batObj.GetMaxHP(), atkHurt, defHurt, cureHP))
|
lineupStatInfo[str(posNum)] = {"ObjID":objID, "HeroID":heroID, "NPCID":npcID, "AtkHurt":atkHurt, "DefHurt":defHurt, "CureHP":cureHP}
|
|
overMsg = {"winFaction":winFaction, "statInfo":statInfo}
|
curPlayer = turnFight.curPlayer
|
mapID = turnFight.mapID
|
funcLineID = turnFight.funcLineID
|
|
FBLogic.OnTurnFightOver(curPlayer, turnFight, mapID, funcLineID, overMsg)
|
|
turnFight.syncState(FightState_Award, overMsg)
|
return
|
|
#// B4 14 ²é¿´Õ½±¨ #tagCSTurnFightReportView
|
#
|
#struct tagCSTurnFightReportView
|
#{
|
# tagHead Head;
|
# char GUID[40]; //Õ½±¨guid
|
#};
|
def OnTurnFightReportView(index, clientData, tick):
|
|
# ͨ¹ý²éÕÒÒÑ´æÔÚµÄÕ½±¨
|
|
#SyncTurnFightReport(curPlayer, guid, reprot)
|
return
|
|
def SyncTurnFightReport(curPlayer, guid, reprot):
|
## ֪ͨÍêÕûÕ½±¨
|
clientPack = ChPyNetSendPack.tagSCTurnFightReport()
|
clientPack.GUID = guid
|
clientPack.Report = reprot
|
clientPack.Len = len(clientPack.Report)
|
NetPackCommon.SendFakePack(curPlayer, clientPack)
|
return
|
|
