#!/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 ChPyNetSendPack
|
import NetPackCommon
|
import PlayerControl
|
import GameWorld
|
import GameObj
|
import FBCommon
|
import IpyGameDataPY
|
import PlayerOnline
|
import NPCCommon
|
import ShareDefine
|
import PyGameData
|
import IPY_GameWorld
|
import ItemControler
|
import SkillCommon
|
import SkillShell
|
import BaseAttack
|
|
import random
|
import time
|
import json
|
|
PosNumMax = 10 # ×î´óվλ±àºÅ
|
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¶ÔÓ¦
|
) = range(6)
|
|
Def_FactionA = 1
|
Def_FactionB = 2
|
|
class BatLineup():
|
## Õ½¶·ÕóÈÝ
|
|
def __init__(self, faction, num, fightMgr):
|
self.fightMgr = fightMgr
|
self.faction = faction # ËùÊôÕóÓª
|
self.num = num # ¸ÃÕóÈÝËùÔÚÕóÓªÖеıàºÅ£¬²»Í¬ÕóÓª¿ÉÖØ¸´£¬¶àV¶à
|
self.ownerID = 0 # ÕóÈÝËùÊôÍæ¼ÒID£¬¿ÉÄÜΪ0£¬0´ú±í·ÇÍæ¼ÒÕóÈÝ
|
self.npcPosDict = {} # ÕóÈÝNPC {վλ±àºÅ:curNPC, ...}, վλ±àºÅСÓÚ0Ϊ·ÇÖ÷Õ½µ¥Î»£¬ÈçÖ÷¹«¡¢ºìÑÕµÈ
|
self.npcObjIDDict = {} # NPCʵÀýID×Öµä {objID:curNPC, ...}
|
self.shapeType = 0 # ÕóÐÍ
|
self.actionNum = ActionNumStart # Ðж¯Î»Ö㬴Ó1¿ªÊ¼
|
self.lordAttrDict = {} # Ö÷¹«ÊôÐÔ
|
self.npcAttrDict = {} # ÕóÈÝNPCÊôÐÔ {npcID:{attrID:value, ...}, ...}
|
self.fightPower = 0 # ÕóÈÝ×ÜÕ½Á¦
|
|
# Õ½¶·Í³¼Æ
|
self.hurtStatDict = {} # Êä³öͳ¼Æ {objID:totalValue, ...}
|
self.defStatDict = {} # ³ÐÉËͳ¼Æ {objID:totalValue, ...}
|
self.cureStatDict = {} # ÖÎÁÆÍ³¼Æ {objID:totalValue, ...}
|
return
|
|
def getGUID(self): return self.fightMgr.guid
|
def getPlayerID(self): return self.fightMgr.playerID # ·¢ÆðµÄÍæ¼ÒID
|
|
def isEmpty(self): return not self.npcPosDict
|
|
def setLineup(self, lineupInfo):
|
## ÉèÖÃÕóÈÝ
|
# @param lineupInfo: ÕóÈÝÐÅÏ¢
|
self.clearLineup()
|
self.ownerID = lineupInfo.get("PlayerID", 0) # ÕóÈÝËùÊôµÄÍæ¼ÒID
|
self.shapeType = lineupInfo.get("Shape", 0)
|
self.lordAttrDict = lineupInfo.get("LordAttrDict", {})
|
SummonLineupObjs(self, self.faction, self.num, lineupInfo, self.getPlayerID())
|
return
|
|
def refreshFightPower(self):
|
## Ë¢ÐÂÕóÈÝ×ÜÕ½Á¦
|
if self.fightPower:
|
return self.fightPower
|
|
return self.fightPower
|
|
def __resetStat(self):
|
## ÖØÖÃÕ½¶·Í³¼Æ
|
self.actionNum = ActionNumStart
|
self.hurtStatDict = {}
|
self.defStatDict = {}
|
self.cureStatDict = {}
|
return
|
|
def __resetAttrState(self, isReborn=True):
|
## ÖØÖÃÊôÐÔ״̬
|
# @param isReborn: ÊÇ·ñ¸´»î
|
initXP = IpyGameDataPY.GetFuncCfg("AngerXP", 1)
|
for curNPC in self.npcPosDict.values():
|
if not curNPC:
|
continue
|
if GameObj.GetHP(curNPC) <= 0 and not isReborn:
|
continue
|
# »ØÂúѪ£¬Çå³ýbuff
|
GameObj.SetHPFull(curNPC, False)
|
# ÖØÖÃÅÆø
|
GameObj.SetXP(curNPC, initXP, False)
|
# ...
|
|
return
|
|
def resetLineup(self, isReborn=True):
|
## ÖØÖÃÕóÈÝ
|
self.__resetAttrState(isReborn)
|
self.__resetStat()
|
return
|
|
def clearLineup(self):
|
## Çå³ýÕóÈÝ
|
if not self.npcPosDict:
|
return
|
for curNPC in self.npcPosDict.values():
|
if not curNPC:
|
continue
|
NPCCommon.SetDeadEx(curNPC)
|
self.npcPosDict = {}
|
self.npcObjIDDict = {}
|
self.npcAttrDict = {}
|
self.fightPower = 0
|
self.__resetStat()
|
return
|
|
def statHurtValue(self, objID, hurtValue):
|
## ͳ¼ÆÊä³ö
|
if objID not in self.npcObjIDDict:
|
return
|
updValue = self.hurtStatDict.get(objID, 0) + hurtValue
|
self.hurtStatDict[objID] = updValue
|
return updValue
|
|
def statDefValue(self, objID, lostHP):
|
## ͳ¼Æ³ÐÉË
|
if objID not in self.npcObjIDDict:
|
return
|
updValue = self.defStatDict.get(objID, 0) + lostHP
|
self.defStatDict[objID] = updValue
|
return updValue
|
|
def statCureValue(self, objID, cureValue):
|
## ͳ¼ÆÖÎÁÆ
|
if objID not in self.npcObjIDDict:
|
return
|
updValue = self.cureStatDict.get(objID, 0) + cureValue
|
self.cureStatDict[objID] = updValue
|
return updValue
|
|
class BatFaction():
|
## Õ½¶·ÕóÓª
|
|
def __init__(self, faction, fightMgr):
|
self.fightMgr = fightMgr
|
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.fightMgr)
|
self.lineupDict[num] = lineup
|
return lineup
|
|
def resetLineups(self):
|
## ÖØÖÃËùÓÐÕ½¶·ÕóÈÝ
|
for lineup in self.lineupDict.values():
|
lineup.resetLineup()
|
return
|
|
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.turnNum = 1 # µ±Ç°µÚx»ØºÏ£¬Ä¬ÈϵÚ1»ØºÏ¿ªÊ¼
|
self.turnMax = 15 # ×î´ó»ØºÏÊý
|
self.enterLogic = False # ÊÇ·ñÒÑÖ´Ðнø³¡Âß¼
|
self.turnStart = 0 # ÒÑÖ´ÐлغϿªÊ¼Öµ£¬ÈçµÚ1»ØºÏ¿ªÊ¼ÒÑÖ´ÐÐÔòΪ1£¬µÚ2»ØºÏΪ2
|
self.turnEnd = 0 # ÒÑÖ´ÐлغϽáÊøÖµ£¬ÈçµÚ1»ØºÏ½áÊøÒÑÖ´ÐÐÔòΪ1£¬µÚ2»ØºÏΪ2
|
self.winFaction = 0 # ±¾³¡Õ½¶·½áÊø±ê¼Ç£¬»ñʤÕóÓª£¬Îª0ʱ´ú±íδ½áÊø£¬ËùÓÐС¶Ó´òÍê»òʧ°Ü²ÅÓнá¹û£¬0-δ½áÊø£¬>0-»ñʤµÄÕóÓª
|
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.startTime = 0 # ¿ªÊ¼Ê±¼ä´Á£¬Ö§³ÖºÁÃëСÊý
|
self.costTime = 0 # µ¥³¡Õ½¶·×ܺÄʱ£¬Ö§³ÖºÁÃëСÊý
|
return
|
|
def setTurn(self, mapID, funcLineID, turnMax, isNeedReport=False, msgDict={}):
|
## ÉèÖñ¾³¡»ØºÏÕ½¶·É趨
|
self.mapID = mapID
|
self.funcLineID = funcLineID
|
self.turnMax = turnMax # ×î´ó»ØºÏÊý
|
self.isNeedReport = isNeedReport
|
self.msgDict = {}
|
self.resetTurn(msgDict)
|
return
|
|
def resetTurn(self, msgDict):
|
## Ò»°ãÓÃÓÚÍæ¼Ò·¢ÆðµÄÕ½¶·£¬ÔÚÐèÒª±£ÁôÍæ¼ÒÕóÈÝÊôÐÔ¼°×´Ì¬µÄÇé¿öÏ£¬ÖØÖûغϽøÈëÏÂÒ»³¡Õ½¶·
|
self.turnNum = 1
|
self.enterLogic = False
|
self.turnStart = 0
|
self.turnEnd = 0
|
self.winFaction = 0
|
self.batBuffer = "" # Õ½±¨buffer
|
self.msgDict.update(msgDict)
|
self.startTime = time.time()
|
self.costTime = 0
|
return
|
|
def setFactionLineup(self, faction, lineupDict, onlyReset=False):
|
## ÉèÖÃÕóÓªÕóÈÝ
|
# @param lineupDict: {ÕóÈݱàºÅ:ÕóÈÝÐÅÏ¢, ...} ÿ¸öÕóÓªÖ§³Ö¶à¸öÕóÈÝ£¬¼´Ö§³Ö¶àV¶à
|
# @param onlyReset: ÊÇ·ñ½öÖØÖã¬Ò»°ãÓÃÓÚÍæ¼ÒµÄÕóÈÝ£¬Öظ´ÀûÓÃÕóÈÝʵÀý£¬
|
batFaction = self.getBatFaction(faction)
|
if onlyReset:
|
batFaction.resetLineups()
|
else:
|
batFaction.clearLineups()
|
for num, lineupInfo in lineupDict.items():
|
batLineup = batFaction.getBatlineup(num)
|
if onlyReset and not batLineup.isEmpty():
|
continue
|
if not lineupInfo:
|
continue
|
batLineup.setLineup(lineupInfo)
|
batLineup.refreshFightPower()
|
return
|
|
def sortActionQueue(self):
|
## ˢгöÊÖ˳Ðò¶ÓÁÐ
|
sortList = []
|
for batFaction in self.factionDict.values():
|
faction = batFaction.faction
|
for num, batLineup in batFaction.lineupDict.items():
|
fightPower = batLineup.refreshFightPower()
|
sortValue = -(faction * 10 + num)
|
sortList.append([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("ÕóÈÝÕ½Á¦ÅÅÐò[fp, sortV, f, n]: %s" % sortList)
|
GameWorld.DebugLog("ÕóÈÝÐж¯Ë³Ðò[f, n]: %s" % self.actionSortList)
|
return
|
|
def getBatFaction(self, faction=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
|
|
for faction, batFaction in self.factionDict.items():
|
allKilled = True
|
for batLineup in batFaction.lineupDict.values():
|
if not allKilled:
|
break
|
for posNum, curNPC in batLineup.npcPosDict.items():
|
if posNum <= 0:
|
# ·ÇÖ÷սλÖò»ÅжÏ
|
continue
|
if GameObj.GetHP(curNPC) > 0:
|
allKilled = False
|
break
|
|
if allKilled:
|
self.winFaction = Def_FactionA if faction == Def_FactionB else Def_FactionA
|
DoTurnFightOver(self.guid)
|
return self.winFaction
|
|
return 0
|
|
def clearBatFaction(self, faction):
|
batFaction = self.getBatFaction(faction)
|
batFaction.clearLineups()
|
return
|
|
def clearFight(self):
|
self.syncState(FightState_Over)
|
for batFaction in self.factionDict.values():
|
batFaction.clearLineups()
|
return
|
|
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 = []
|
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, curNPC in batLineup.npcPosDict.items():
|
tfObj = ChPyNetSendPack.tagSCTurnFightObj()
|
tfObj.ObjID = curNPC.GetID()
|
tfObj.NPCID = curNPC.GetNPCID()
|
tfObj.HP = curNPC.GetHP()
|
tfObj.HPEx = curNPC.GetHPEx()
|
tfObj.MaxHP = curNPC.GetMaxHP()
|
tfObj.MaxHPEx = curNPC.GetMaxHPEx()
|
tfObj.LV = NPCCommon.GetNPCLV(curNPC)
|
tfObj.PosNum = posNum
|
tfObj.AngreXP = GameObj.GetXP(curNPC)
|
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={}):
|
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, objType, 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)
|
GameWorld.DebugLog("»ØºÏÕ½¶·¹ý³Ì·â°ü: %s, isNeedReport=%s,%s" % (headStr, self.isNeedReport, self.guid))
|
if self.isNeedReport:
|
self.batBuffer += clientPack.GetBuffer()
|
# ÓÐÍæ¼ÒµÄͳһÿ¸ö°üµ¥¶À·¢ËÍ£¬Í¬ÑùÒ²Ö§³ÖÕ½±¨Í³¼Æ
|
if self.curPlayer:
|
NetPackCommon.SendFakePack(self.curPlayer, clientPack)
|
return
|
|
class TurnFightMgr():
|
## »ØºÏÕ½¶·¹ÜÀíÆ÷
|
|
def __init__(self):
|
self.turnFightDict = {} # {guid:TurnFight, ...}
|
self.npcGUIDDict = {} # npcËùÊôµÄij³¡Õ½¶·guid {objID:guid, ...}
|
return
|
|
def addTurnFight(self, mapID, funcLineID=0, playerID=0):
|
tf = TurnFight(mapID, funcLineID, playerID, False)
|
self.turnFightDict[tf.guid] = tf
|
return tf
|
|
def delTurnFight(self, guid):
|
turnFight = self.getTurnFight(guid)
|
if not turnFight:
|
return
|
turnFight.clearFight()
|
self.turnFightDict.pop(guid, None)
|
return
|
|
def getTurnFight(self, guid):
|
tf = None
|
if guid in self.turnFightDict:
|
tf = self.turnFightDict[guid]
|
elif False:
|
tf = TurnFight()
|
return tf
|
|
def getNPCTurnFight(self, objID):
|
## »ñÈ¡NPCËùÔڵĻغÏÕ½¶·£¬Èç¹û¸Ãnpc²»ÊôÓÚij³¡»ØºÏÕ½¶·Ôò·µ»ØNone
|
tf = None
|
if objID in self.npcGUIDDict:
|
guid = self.npcGUIDDict[objID]
|
if guid in self.turnFightDict:
|
tf = self.turnFightDict[guid]
|
if not tf and False:
|
tf = TurnFight()
|
return tf
|
|
def setNPCGUID(self, objID, guid):
|
## ÉèÖÃNPCËùÊô»ØºÏÕ½¶·guid
|
self.npcGUIDDict[objID] = guid
|
GameWorld.DebugLog("ÉèÖÃNPCËùÊô»ØºÏÕ½¶·guid: %s,%s" % (objID, guid))
|
return
|
def delNPCGUID(self, objID):
|
guid = self.npcGUIDDict.pop(objID, None)
|
GameWorld.DebugLog("ɾ³ýNPCËùÊô»ØºÏÕ½¶·guid: %s,%s" % (objID, guid))
|
return
|
|
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.teamNum = 1 # µ±Ç°Ð¡¶Ó
|
self.teamMax = 1 # µ±Ç°²¨×î´óС¶Ó£¬Ä³³¡Õ½¶·¿ÉÄܰüº¬¶à¸öС¶Ó£¬ËùÓÐС¶Ó»ìÁ÷»÷ɱÍê²ÅËã¹ýÁ˱¾²¨
|
self.nextTeam = False # Ï´Îǰ¶ËÇëÇóÕ½¶·ÊÇ·ñÊÇÏÂһС¶Ó£¬·ñÔò¶¼ÊÇÖØÐÂˢе±Ç°½ø¶È¹Ö
|
self.waveLineupList = [] # С¶ÓÁбí
|
self.turnFight = GetTurnFightMgr().addTurnFight(ChConfig.Def_FBMapID_Main, 0, playerID)
|
return
|
|
def isLevelBoss(self):
|
## µ±Ç°Õ½¶·ÊÇ·ñ¹Ø¿¨boss
|
return self.turnFight.mapID == ChConfig.Def_FBMapID_MainBoss
|
|
def clear(self):
|
self.turnFight.clearFight()
|
return
|
|
def playerLogin(self, curPlayer):
|
self.turnFight.curPlayer = curPlayer
|
return
|
|
def playerOffline(self, curPlayer):
|
self.turnFight.curPlayer = None
|
return
|
|
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 GetPlayerLineupByCache(playerID, lineupID):
|
## »ñÈ¡Íæ¼ÒÕóÈÝÐÅÏ¢ - ¸ù¾ÝÍæ¼Ò²é¿´»º´æ
|
return {}
|
|
def GetPlayerLineup(curPlayer, lineupID):
|
## »ñÈ¡Íæ¼ÒÕóÈÝÐÅÏ¢
|
# @param lineupID: ÕóÈÝID
|
# @return: ÕóÈÝÈ«²¿ÐÅÏ¢json×ֵ䣬ǰ¶ËͨÓøñʽ
|
|
playerID = curPlayer.GetPlayerID()
|
|
# Î佫
|
heroDict = {}
|
heroCount = 0
|
curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
|
for index in range(curPack.GetCount()):
|
heroItem = curPack.GetAt(index)
|
if not heroItem or heroItem.IsEmpty():
|
continue
|
lineupCount = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroLineup)
|
if not lineupCount:
|
continue
|
posNum = 0 # վλ
|
for lpIndex in range(lineupCount):
|
lineupValue = heroItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroLineup, lpIndex)
|
#ÕóÈÝÀàÐÍ*10000+ÕóÐÍÀàÐÍ*100+λÖñàºÅ
|
if lineupValue / 10000 != lineupID:
|
continue
|
posNum = lineupValue % 100
|
break
|
|
if not posNum:
|
continue
|
|
heroID = heroItem.GetItemTypeID()
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
|
if not heroIpyData:
|
continue
|
|
npcID = heroIpyData.GetSkinNPCIDList()[0]
|
heroDict[str(posNum)] = {
|
"ID":heroID,
|
"Data":heroItem.GetUserData(),
|
"NPCID":npcID
|
}
|
|
heroCount += 1
|
if heroCount >= ShareDefine.LineupObjMax:
|
break
|
|
# Ö÷¹«ÊôÐÔ
|
lordAttrDict = PlayerControl.GetLordAttr(curPlayer)
|
|
# ÆäËû
|
|
lineupInfo = {"PlayerID":playerID, "LordAttrDict":lordAttrDict, "Hero":heroDict}
|
return lineupInfo
|
|
def GetNPCLineup(lineupID):
|
## »ñÈ¡NPCÕóÈÝÐÅÏ¢
|
# @param lineupID: ÕóÈÝID
|
# @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
|
|
heroDict[str(posNum)] = {"NPCID":npcID}
|
|
lineupInfo = {"Hero":heroDict}
|
return lineupInfo
|
|
def SummonLineupObjs(batLineup, faction, num, lineupInfo, playerID=0):
|
'''ÕÙ»½ÕóÈÝÕ½¶·ÊµÀý
|
@param faction: ËùÊôÕóÓª£¬Ä¿Ç°Ö§³ÖÁ½¸öÕóÓª£¬1»ò2
|
@param num: Õ½¶·ÕóÈÝÔÚ¸ÃÕóÓªÉϵıàºÅ£¬1V1ʱĬÈÏ1£¬¶à¶Ô¶àʱ1~n
|
@param lineupInfo: ÕóÈÝÐÅÏ¢
|
@param playerID: ·¢ÆðµÄÍæ¼ÒID£¬ÏµÍ³³¡´ÎΪ0
|
'''
|
|
'''¹ØÓÚÊÓÒ°²ã¼¶ËµÃ÷ sightLevel
|
Íæ¼Ò·¢ÆðµÄÕ½¶·ÊÓÒ°²ã¼¶Ö»ÄÜÓÃÍæ¼ÒID£¬²ÅÄܴﵽֻ֪ͨ¸ÃÍæ¼ÒµÄЧ¹û
|
µ«ÊÇÓÉÓÚͬ¸öÍæ¼Ò¿ÉÄÜͬʱ´æÔڶೡս¶·£¬ÈçÖ÷ÏßÕ½¶· + ÆäËûÕ½¶·£¬ËùÒÔÊÓÒ°²ã¼¶Ö»ÄÜÓÃ×÷½ö֪ͨ¸ÃÍæ¼ÒµÄ×÷Óã¬
|
²»ÄÜÓÃÓÚ´¦ÀíNPCÊÓÒ°À´±éÀúÉ˺¦¶ÔÏóµÈ£¬ÒòΪ²»Í¬Õ½³¡µÄNPCÊÓÒ°²ã¼¶¿ÉÄÜÏàͬ£¬¶ÔÓÚͬ³¡Õ½¶·NPCµÄ±éÀú´¦ÀíÖ»ÄÜÓà turnFight ¹ÜÀí±éÀú
|
¼øÓÚÊÓÒ°²ã¼¶½öÓÃÓÚ֪ͨµÄ×÷Ó㬹Êϵͳ³¡´ÎÀíÂÛÉÏ¿ÉÒÔÖ»ÓÃÒ»¸öÊÓÒ°²ã¼¶£¬µ«ÊÇΪÁ˼õÉÙ²»±ØÒªµÄÎÊÌ⣬ϵͳ³¡´ÎµÄÊÓÒ°²ã¼¶»¹ÊǾ¡Á¿Çø·Ö¿ªÀ´
|
ÕâÀïÔÝʱÓÃʱ¼ä´ÁµÄºó4λÀ´×ö¶Ìʱ¼äÄÚµÄÀíÂÛÉÏΨһÊÓÒ°²ã¼¶
|
'''
|
GameWorld.DebugLog("SummonLineupObjs faction:%s,num:%s,lineupInfo=%s" % (faction, num, lineupInfo), playerID)
|
if playerID:
|
curPlayer = GameWorld.GetPlayerManager().FindPlayerByID(playerID)
|
if not curPlayer:
|
return
|
posX, posY = curPlayer.GetPosX(), curPlayer.GetPosY()
|
sightLevel = playerID
|
|
# ¿ª·¢¹ý³ÌÖпÉÒÔÏÈ¿ªÆôÊÓÒ°²ã¼¶¼°ÊÓÒ°£¬·½±ã¼ì²éÕ½¶·Ïà¹ØÊÇ·ñÓÐÒÅ©
|
if curPlayer.GetSightLevel() != sightLevel:
|
PlayerControl.SetPlayerSightLevel(curPlayer, sightLevel)
|
sight = ChConfig.Def_PlayerSight_Default * 5
|
if curPlayer.GetSight() != sight:
|
PlayerControl.SetSight(curPlayer, sight)
|
else:
|
gameMap = GameWorld.GetMap()
|
posX, posY = gameMap.GetRebornMapX(), gameMap.GetRebornMapY() # ϵͳս¶·Ä¬ÈÏÈ¡µ±Ç°µØÍ¼µÄ¸´»îµã£¬ÐèÒªÓÅ»¯
|
sightLevel = 2000000000 + int(time.time()) % 10000
|
|
GameWorld.DebugLog("sightLevel=%s,pos=(%s,%s)" % (sightLevel, posX, posY), playerID)
|
|
lineupPlayerID = lineupInfo.get("PlayerID", 0) # ÕóÈÝËùÊôÍæ¼ÒID
|
heroDict = lineupInfo.get("Hero", {})
|
tick = GameWorld.GetGameWorld().GetTick()
|
|
initXP = IpyGameDataPY.GetFuncCfg("AngerXP", 1)
|
tfMgr = GetTurnFightMgr()
|
space = 3
|
for posNumKey, heroInfo in heroDict.items():
|
posNum = int(posNumKey)
|
|
skillIDList = []
|
if lineupPlayerID:
|
heroID = heroInfo.get("ID", 0)
|
npcID = heroInfo.get("NPCID", 0)
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
|
if not heroIpyData:
|
continue
|
normalSkillID = heroIpyData.GetNormalSkillID()
|
angerSkillID = heroIpyData.GetAngerSkillID()
|
skillIDList += [normalSkillID, angerSkillID]
|
else:
|
npcID = heroInfo.get("NPCID", 0)
|
npcDataEx = NPCCommon.GetNPCDataEx(npcID)
|
if not npcDataEx:
|
continue
|
skillIDList += npcDataEx.GetSkillIDList()
|
|
if not npcID:
|
continue
|
|
npcData = GameWorld.GetGameData().FindNPCDataByID(npcID)
|
if not npcData:
|
continue
|
curSummon = GameWorld.GetNPCManager().AddPlayerSummonNPC()
|
if not curSummon:
|
continue
|
objID = curSummon.GetID()
|
batLineup.npcPosDict[posNum] = curSummon
|
batLineup.npcObjIDDict[objID] = curSummon
|
tfMgr.setNPCGUID(objID, batLineup.getGUID())
|
|
curSummon.SetNPCTypeID(npcID)
|
curSummon.SetBornTime(tick)
|
curSummon.SetAIType(0)
|
curSummon.SetSightLevel(sightLevel)
|
curSummon.SetIsNeedProcess(False)
|
curSummon.SetCanAttack(True)
|
curSummon.SetVisible(True)
|
curSummon.SetDict(ChConfig.Def_Obj_Dict_TurnFightPosInfo, num * 100 + posNum)
|
curSummon.SetDict(ChConfig.Def_Obj_Dict_LineupPlayerID, lineupPlayerID)
|
GameObj.SetFaction(curSummon, faction)
|
GameObj.SetXP(curSummon, initXP, False)
|
|
skillManager = curSummon.GetSkillManager()
|
#ÓÐÖ¸¶¨µÄ¼¼ÄÜ£¬ÖØÐÂѧϰ
|
if skillIDList:
|
skillManager.ResetSkill()
|
for skillID in skillIDList:
|
skillManager.LVUPSkillByID(skillID)
|
|
rebornX = posX - space + (faction - 1) * space * 3 + ((posNum - 1) / 3 * space * 2 * (-1 if faction == 1 else 1))
|
rebornY = posY + (posNum - 1) % 3 * space
|
#GameWorld.DebugLog("Reborn ID:%s, faction:%s,posNum=%s, (%s,%s), %s" % (curSummon.GetID(), faction, posNum, rebornX, rebornY, skillIDList))
|
curSummon.Reborn(rebornX, rebornY, False)
|
NPCCommon.NPCControl(curSummon).DoNPCRebornCommLogic(tick)
|
|
return
|
|
#// B4 13 Ö÷ÏßÕ½¶·ÇëÇó #tagCSMainFightReq
|
#
|
#struct tagCSMainFightReq
|
#{
|
# tagHead Head;
|
# BYTE ReqType; // 0-Í£Ö¹Õ½¶·»Ø³Ç£»1-ÉèÖÃÏûºÄ±¶Öµ£»2-ÌôÕ½¹Ø¿¨Ð¡¹Ö£»3-ÌôÕ½¹Ø¿¨boss£»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
|
|
clientPack = ChPyNetSendPack.tagSCTurnFightReportSign()
|
clientPack.Sign = 0
|
NetPackCommon.SendFakePack(curPlayer, clientPack) # ±ê¼Ç¿ªÊ¼
|
|
if reqType == 2: # ǰ¶ËÖ÷¶¯ÇëÇó¿ªÊ¼¹Ø¿¨Ð¡¹ÖµÄÊÓΪ´ÓÐÝÏ¢ÖпªÊ¼
|
__doMainLevelWave(curPlayer, True)
|
elif reqType == 3:
|
__doMainBossStart(curPlayer, tick)
|
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.clearFight()
|
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)
|
if not chapterID:
|
chapterID = 1
|
if not levelNum:
|
levelNum =1
|
if not wave:
|
wave = 1
|
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
|
|
waveLineupList = getattr(levelIpyData, "GetWaveLineupIDList%s" % wave)() # С¶Ó1ÕóÈÝID|С¶Ó2ÕóÈÝID|...
|
if not waveLineupList:
|
return
|
teamMax = len(waveLineupList)
|
teamNum = 1
|
lineupID = waveLineupList[teamNum - 1] # NPCÕóÈÝID
|
|
mainFightMgr = GetMainFightMgr(curPlayer)
|
mainFightMgr.nextTeam = False
|
mainFightMgr.chapterID = chapterID
|
mainFightMgr.levelNum = levelNum
|
mainFightMgr.waveMax = waveMax
|
mainFightMgr.wave = wave
|
mainFightMgr.waveLineupList = waveLineupList
|
mainFightMgr.teamNum = teamNum
|
mainFightMgr.teamMax = teamMax
|
turnMax = IpyGameDataPY.GetFuncCfg("Mainline", 2)
|
mapID, funcLineID = ChConfig.Def_FBMapID_Main, PlayerControl.ComMainLevelValue(chapterID, levelNum, wave)
|
GameWorld.DebugLog("ÉèÖÃÆðʼ¹Ø¿¨²¨: ¹Ø¿¨%s-%s,²¨=%s/%s,teamMax=%s,mapID=%s,funcLineID=%s,lineupID=%s"
|
% (chapterID, levelNum, wave, waveMax, teamMax, mapID, funcLineID, lineupID), playerID)
|
|
turnFight = mainFightMgr.turnFight
|
turnFight.setTurn(mapID, funcLineID, turnMax, False, {"teamNum":teamNum, "teamMax":teamMax})
|
turnFight.setFactionLineup(Def_FactionA, {1:GetPlayerLineup(curPlayer, ShareDefine.Lineup_Main)}, True)
|
turnFight.setFactionLineup(Def_FactionB, {1:GetNPCLineup(lineupID)})
|
turnFight.sortActionQueue()
|
turnFight.syncInit()
|
return
|
|
def __doMainBossStart(curPlayer, tick):
|
## ¿ªÊ¼ÌôÕ½¹Ø¿¨boss
|
playerID = curPlayer.GetPlayerID()
|
chapterID, levelNum, wave = PlayerControl.GetMainLevelPassInfo(curPlayer)
|
if not chapterID:
|
chapterID = 1
|
if not levelNum:
|
levelNum = 1
|
GameWorld.DebugLog("ÇëÇóÌôÕ½¹Ø¿¨Boss! passInfo: chapterID=%s,levelNum=%s,wave=%s" % (chapterID, levelNum, wave), playerID)
|
chapterIpyData = IpyGameDataPY.GetIpyGameData("MainChapter", chapterID)
|
if not chapterIpyData:
|
return
|
levelIpyData = IpyGameDataPY.GetIpyGameData("MainLevel", chapterID, levelNum)
|
if not levelIpyData:
|
return
|
|
nowChapterID, nowLevelNum, _ = PlayerControl.GetMainLevelNowInfo(curPlayer)
|
if chapterID != nowChapterID or levelNum != nowLevelNum:
|
'''Ò»°ãÓÐÁ½ÖÖÇé¿ö»áµ¼ÖÂ
|
1. ÀíÂÛÉÏÍæ¼Òµ±Ç°Ë¢¹ÖµÄÕ½ڹؿ¨Ò»¶¨ÊÇÓë¹ý¹ØµÄÕ½ڹؿ¨ÊÇÒ»Öµģ¬³ýÁËÈ«²¿Õ½ÚÒÑͨ¹Ø
|
µ±Í¨¹ØÊ±£¬Òѹý¹ØµÄ¼Ç¼»á±»ÉèÖÃΪÏÂÒ»Õ½ڵÚ1¹Ø£¨°æ±¾¹Ø¿¨±íʵ¼Ê²»´æÔڸùؿ¨£©
|
µ«Êǵ±Ç°Ë¢¹ÖµÄ»¹Êǰ汾µÄ×îºóÒ»¹Ø£¬¹Ì»á³öÏÖ²»Ò»ÖµÄÇé¿ö
|
ÔÚÔö¼ÓÕ½ڹؿ¨Ð°汾¸üкóÍæ¼ÒÖØµÇ»á×Ô¶¯½øÐÐÐÞ¸´µ±Ç°Ë¢¹Ö½ø¶ÈΪ×îÐÂÕ½ڵÚ1¹Ø
|
2. ÕæµÄ³öÏÖÎÊÌâÁË£¬¿ÉÄÜÊÇbugÒýÆð£¬ÕâÖÖÇé¿öÖ»ÄܽøÐÐbugÐÞ¸´¼°Õë¶ÔÒì³£Õ˺ÅÌØÊâ´¦Àí£¬»òÕßÖØµÇºóÒ²»á×Ô¶¯½øÐÐÐÞÕý
|
'''
|
GameWorld.ErrLog("µ±Ç°Ë¢¹ÖÕ½ڹؿ¨ÓëÌôÕ½µÄbossÕ½ڹؿ¨²»Ò»Ö£¬ÎÞ·¨ÌôÕ½! chapterID=%s,levelNum=%s,nowChapterID=%s,nowLevelNum=%s"
|
% (chapterID, levelNum, nowChapterID, nowLevelNum), playerID)
|
return
|
|
# ±¾¹Ø¿¨×î´ó²¨Êý
|
waveMax = 6
|
while waveMax >= 1 and (not hasattr(levelIpyData, "GetWaveLineupIDList%s" % waveMax) or not getattr(levelIpyData, "GetWaveLineupIDList%s" % waveMax)()):
|
waveMax -= 1
|
|
if wave < waveMax:
|
GameWorld.DebugLog("×îºóÒ»²¨Î´Í¨¹ý£¬ÎÞ·¨ÌôÕ½±¾¹Øboss! passWave=%s < %s" % (wave, waveMax))
|
return
|
|
waveLineupList = levelIpyData.GetBossLineupIDList() # Boss²¨ÕóÈÝIDÁÐ±í£¬Ð¡¶Ó1ÕóÈÝID|С¶Ó2ÕóÈÝID|...
|
if not waveLineupList:
|
return
|
teamMax = len(waveLineupList)
|
teamNum = 1
|
lineupID = waveLineupList[teamNum - 1] # NPCÕóÈÝID
|
|
wave = waveMax = 1 # ¹Ø¿¨boss¹Ì¶¨Ö»ÓÐÒ»²¨
|
|
mainFightMgr = GetMainFightMgr(curPlayer)
|
mainFightMgr.nextTeam = False
|
mainFightMgr.chapterID = chapterID
|
mainFightMgr.levelNum = levelNum
|
mainFightMgr.waveMax = waveMax
|
mainFightMgr.wave = wave
|
mainFightMgr.waveLineupList = waveLineupList
|
mainFightMgr.teamNum = teamNum
|
mainFightMgr.teamMax = teamMax
|
turnMax = IpyGameDataPY.GetFuncCfg("Mainline", 3)
|
mapID, funcLineID = ChConfig.Def_FBMapID_MainBoss, PlayerControl.ComMainLevelValue(chapterID, levelNum, wave)
|
GameWorld.DebugLog("ÉèÖùؿ¨boss: ¹Ø¿¨%s-%s,²¨=%s/%s,teamMax=%s,mapID=%s,funcLineID=%s,lineupID=%s"
|
% (chapterID, levelNum, wave, waveMax, teamMax, mapID, funcLineID, lineupID), playerID)
|
|
turnFight = mainFightMgr.turnFight
|
turnFight.setTurn(mapID, funcLineID, turnMax, False, {"teamNum":teamNum, "teamMax":teamMax})
|
turnFight.setFactionLineup(Def_FactionA, {1:GetPlayerLineup(curPlayer, ShareDefine.Lineup_Main)}, True)
|
turnFight.setFactionLineup(Def_FactionB, {1:GetNPCLineup(lineupID)})
|
turnFight.sortActionQueue()
|
turnFight.syncInit()
|
|
# ÌôÕ½bossÎÞÖмä¹ý³Ì£¬Ã¿´ÎÖ´ÐÐÖ±½ÓÌôÕ½Ò»¶Ó½á¹û
|
__processTurnFight(turnFight.guid, tick)
|
return
|
|
def __doMainFight(curPlayer, tick):
|
## Ö÷ÏßÖ´ÐÐÕ½¶·
|
mainFightMgr = GetMainFightMgr(curPlayer)
|
turnFight = mainFightMgr.turnFight
|
|
isLevelBoss = mainFightMgr.isLevelBoss()
|
winFaction = turnFight.winFaction
|
if winFaction:
|
if mainFightMgr.nextTeam:
|
# ×Ô¶¯¿ªÊ¼ÏÂһС¶Ó
|
teamNum = mainFightMgr.teamNum = mainFightMgr.teamNum + 1
|
GameWorld.DebugLog("¿ªÊ¼½øÈëÏÂһС¶Ó: teamNum=%s" % teamNum)
|
if teamNum < 1 or teamNum > len(mainFightMgr.waveLineupList):
|
GameWorld.DebugLog("111111 teamNum=%s,mainFightMgr.waveLineupList=%s" % (teamNum, mainFightMgr.waveLineupList))
|
return
|
lineupID = mainFightMgr.waveLineupList[teamNum - 1] # NPCÕóÈÝID
|
GameWorld.DebugLog("teamNum=%s,lineupID=%s" % (teamNum, lineupID))
|
|
mainFightMgr.nextTeam = False
|
turnFight.resetTurn({"teamNum":teamNum})
|
# Çл»Ð¡¶Óʱ£¬Íæ¼ÒÕóÈݲ»ÐèÒª´¦Àí£¬±£Áô״̬
|
turnFight.setFactionLineup(Def_FactionB, {1:GetNPCLineup(lineupID)})
|
turnFight.sortActionQueue()
|
turnFight.syncInit()
|
|
if mainFightMgr.isLevelBoss():
|
# ÿ´Î´¦ÀíһС¶ÓµÄÍêÕûÕ½¶·£¬Ï൱ÓÚÒ»´ÎÍêÕûÕ½±¨
|
__processTurnFight(turnFight.guid, tick)
|
return
|
else:
|
__doMainLevelWave(curPlayer, False)
|
return
|
|
if isLevelBoss:
|
## ¹Ø¿¨bossÊÇÒ»´ÎÐÔ´¦ÀíÍêµÄ£¬Ò»°ã²»¿ÉÄÜ×ßµ½ÕâÀÕâ±ß×öÏ·À·¶
|
return
|
|
# ÒÔϾùÊÇ´¦Àí¹Ø¿¨Ð¡¹Ö·Ö¶Îʵʱս¶·
|
|
EntryLogic(turnFight)
|
|
# С¹ÖÕ½¶·£¬Ã¿´ÎÏûºÄ1¸öÕ½´¸
|
fightPoint = max(curPlayer.GetFightPoint(), 1) # Ö÷ÏßÕ½¶·ÏûºÄ±¶Öµ£¬Ä¬ÈÏ1
|
|
# °´ÕóÓªÕóÈÝÖ´ÐÐ˳Ðò£¬Öð¸ö±éÀú
|
doCnt = 0
|
doMax = (PosNumMax + 2) * len(turnFight.actionSortList) # ·ÀÖ¹ËÀÑ»·£¬×ö×î´óÑ»·´ÎÊýÏÞÖÆ = (×î´óλÖÃÊý + Ö÷¹«¡¢ºìÑÕλÖÃ)*Ðж¯ÕóÈÝÊý
|
overLineupList = [] # ±¾»ØºÏÒѾ½áÊøÐж¯µÄÕóÈÝÁбí [(faction, num), ...]£¬ ËùÓÐÕóÈÝÈ«²¿½áÊø´ú±í±¾»ØºÏ½áÊø
|
|
turnNum = turnFight.turnNum
|
unXiantaoCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_UnXiantaoCnt)
|
GameWorld.DebugLog("unXiantaoCnt=%s,turnNum=%s,doMax=%s,actionIndex=%s,%s" % (unXiantaoCnt, turnNum, doMax, turnFight.actionIndex, turnFight.actionSortList))
|
while doCnt < doMax and len(overLineupList) < len(turnFight.actionSortList):
|
doCnt += 1
|
turnNum = turnFight.turnNum
|
# Ö´ÐлغϿªÊ¼Âß¼
|
if turnFight.turnStart < turnNum:
|
GameWorld.DebugLog("Ö´ÐÐÐж¯: turnNum=%s, »ØºÏ¿ªÊ¼" % (turnFight.turnNum))
|
turnFight.syncState(FightState_Fighting)
|
if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint):
|
GameWorld.DebugLog("»ØºÏ¿ªÊ¼Ê±Õ½´¸²»×ã!")
|
return
|
turnFight.turnStart = turnNum
|
turnFight.actionIndex = 0
|
for faction, num in turnFight.actionSortList:
|
batFaction = turnFight.getBatFaction(faction)
|
batLineup = batFaction.getBatlineup(num)
|
batLineup.actionNum = ActionNumStart
|
for curNPC in batLineup.npcPosDict.values():
|
TurnFightObjPerTurnStart(curNPC, None, turnNum, tick)
|
|
if turnFight.actionIndex >= len(turnFight.actionSortList):
|
turnFight.actionIndex = 0
|
|
faction, num = turnFight.actionSortList[turnFight.actionIndex]
|
batFaction = turnFight.getBatFaction(faction)
|
batLineup = batFaction.getBatlineup(num)
|
if batLineup.actionNum > max(batLineup.npcPosDict):
|
if (faction, num) not in overLineupList:
|
overLineupList.append((faction, num))
|
|
turnFight.actionIndex += 1
|
continue
|
|
if faction == Def_FactionA:
|
if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint):
|
GameWorld.DebugLog("Õ½´¸²»×ã!")
|
return
|
GameWorld.DebugLog("Ö´ÐÐÐж¯: turnNum=%s,faction=%s,num=%s,actionNum=%s" % (turnFight.turnNum, faction, num, batLineup.actionNum))
|
|
# Ö÷¹«
|
if batLineup.actionNum == -1:
|
pass
|
|
# ºìÑÕ
|
elif batLineup.actionNum == 0:
|
pass
|
|
# Î佫
|
elif batLineup.actionNum > 0:
|
for posNum in range(batLineup.actionNum, PosNumMax + 1):
|
batLineup.actionNum = posNum
|
if posNum not in batLineup.npcPosDict:
|
continue
|
curNPC = batLineup.npcPosDict[posNum]
|
if not curNPC or GameObj.GetHP(curNPC) <= 0:
|
continue
|
objType = curNPC.GetGameObjType()
|
objID = curNPC.GetID()
|
turnFight.syncObjAction(turnNum, objType, objID)
|
|
objName = GetObjName(curNPC)
|
curHP = GameObj.GetHP(curNPC)
|
|
GameWorld.DebugLog("¡ï»ØºÏ%s %s Ðж¯ : curHP=%s" % (turnNum, objName, curHP))
|
if not DoAttack(curNPC, None, tick):
|
GameWorld.DebugLog(" ¹¥»÷ʧ°Ü")
|
continue
|
|
if faction == Def_FactionA:
|
if not PlayerControl.PayMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint, isNotify=False):
|
return
|
break
|
|
turnFight.actionIndex += 1
|
batLineup.actionNum += 1
|
if batLineup.actionNum > max(batLineup.npcPosDict):
|
GameWorld.DebugLog("¸ÃÕóÈݱ¾»ØºÏÒѾȫ²¿Ðж¯ÍêÁË: turnNum=%s,faction=%s,num=%s,actionNum=%s" % (turnFight.turnNum, faction, num, batLineup.actionNum))
|
if (faction, num) not in overLineupList:
|
overLineupList.append((faction, num))
|
|
if turnFight.checkOverByKilled():
|
break
|
|
nowUnXiantaoCnt = curPlayer.NomalDictGetProperty(ChConfig.Def_PDict_UnXiantaoCnt)
|
if unXiantaoCnt != nowUnXiantaoCnt:
|
# Íæ¼ÒÓÐÏûºÄÕ½´¸ÔòÍ£Ö¹£¬Ò»¶Î¶ÎÖ´ÐÐ
|
GameWorld.DebugLog("Íæ¼ÒÓÐÏûºÄÕ½´¸ÔòÍ£Ö¹,nowUnXiantaoCnt=%s" % (nowUnXiantaoCnt))
|
break
|
|
if turnFight.winFaction:
|
return
|
|
GameWorld.DebugLog("turnNum=%s,doCnt=%s,overLineupList=%s" % (turnNum, doCnt, overLineupList))
|
if len(overLineupList) >= len(turnFight.actionSortList):
|
GameWorld.DebugLog("Ö´ÐÐÐж¯: turnNum=%s, »ØºÏ½áÊø" % (turnFight.turnNum))
|
if turnFight.turnEnd < turnNum:
|
if not PlayerControl.HaveMoney(curPlayer, ShareDefine.TYPE_Price_Xiantao, fightPoint):
|
GameWorld.DebugLog("»ØºÏ½áÊøÊ±Õ½´¸²»×ã!")
|
return
|
turnFight.turnEnd = turnNum
|
for faction, num in turnFight.actionSortList:
|
batFaction = turnFight.getBatFaction(faction)
|
batLineup = batFaction.getBatlineup(num)
|
for curNPC in batLineup.npcPosDict.values():
|
pass
|
|
if turnFight.checkOverByKilled():
|
return
|
|
if turnNum < turnFight.turnMax:
|
turnFight.turnNum += 1
|
else:
|
OnTurnAllOver(turnFight.guid)
|
|
return
|
|
def __processTurnFight(guid, tick):
|
## Ò»´ÎÐÔ´¦ÀíÍêÒ»¸öС¶ÓµÄÕ½¶·
|
turnFight = GetTurnFightMgr().getTurnFight(guid)
|
curPlayer = turnFight.curPlayer
|
turnMax = turnFight.turnMax
|
EntryLogic(turnFight)
|
for turnNum in range(1, turnMax + 1):
|
turnFight.turnNum = turnNum
|
GameWorld.DebugLog("¡¾----- »ØºÏÖÆÕ½¶·ÂÖ´Î: %s -----¡¿" % 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 curNPC in batLineup.npcPosDict.values():
|
TurnFightObjPerTurnStart(curNPC, None, turnNum, tick)
|
|
# Ö÷¹«
|
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 faction, num in turnFight.actionSortList:
|
GameWorld.DebugLog("ºìÑÕÂß¼: turnNum=%s,faction=%s, num=%s" % (turnNum, faction, num))
|
batFaction = turnFight.getBatFaction(faction)
|
batLineup = batFaction.getBatlineup(num)
|
|
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.npcPosDict:
|
continue
|
curNPC = batLineup.npcPosDict[posNum]
|
if not curNPC or GameObj.GetHP(curNPC) <= 0:
|
continue
|
objType = curNPC.GetGameObjType()
|
objID = curNPC.GetID()
|
turnFight.syncObjAction(turnNum, objType, objID)
|
|
objName = GetObjName(curNPC)
|
curHP = GameObj.GetHP(curNPC)
|
|
GameWorld.DebugLog("¡ï»ØºÏ%s %s Ðж¯ : curHP=%s" % (turnNum, objName, curHP))
|
if not DoAttack(curNPC, None, tick):
|
continue
|
|
break
|
|
if turnFight.actionIndex >= len(turnFight.actionSortList) - 1:
|
turnFight.actionIndex = 0
|
else:
|
turnFight.actionIndex += 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 curNPC in batLineup.npcPosDict.values():
|
pass
|
|
if turnFight.checkOverByKilled():
|
break
|
|
if not turnFight.winFaction:
|
OnTurnAllOver(turnFight.guid)
|
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»òÍæ¼ÒID
|
# BYTE ValueCount;
|
# DWORD ValueList[ValueCount]; // ¸½¼ÓÖµÁÐ±í£¬¿ÉÑ¡£¬¾ßÌ庬ÒåÓÉMapID¾ö¶¨
|
#};
|
def OnTurnFight(index, clientData, tick):
|
#curPlayer = GameWorld.GetPlayerManager().GetPlayerByIndex(index)
|
#mapID = clientData.MapID
|
#funcLineID = clientData.FuncLineID
|
return
|
|
def GetObjName(gameObj):
|
objName = gameObj.GetName()
|
faction = GameObj.GetFaction(gameObj)
|
posInfo = gameObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo)
|
npcID = gameObj.GetNPCID()
|
return "%s%s %s[%s-%s]" % ("A" if faction == Def_FactionA else "B", posInfo, objName, gameObj.GetID(), npcID)
|
|
def EntryLogic(turnFight):
|
## Ö´Ðнø³¡Âß¼
|
if turnFight.enterLogic:
|
return
|
GameWorld.DebugLog("Ö´Ðнø³¡Âß¼...")
|
|
turnFight.enterLogic = True
|
return
|
|
def TurnFightObjPerTurnStart(gameObj, tagObj, turnNum, tick):
|
## »ØºÏÖÆÕ½¶·ÊµÀý - ÿ»ØºÏ¿ªÊ¼Ê±´¦Àí
|
if not gameObj:
|
return
|
|
# SetTimeline(gameObj, turnNum, 0)
|
# # ÖØÖÃÁ¬»÷¡¢·´»÷Êý
|
# gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnComboNum, 0)
|
# gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnAtkBackNum, 0)
|
# gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnParryNum, 0)
|
# gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnMissNum, 0)
|
# gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnAtkAddXPCount, 0)
|
# gameObj.SetDict(ChConfig.Def_Obj_Dict_TurnXPUseState, 0)
|
# gameObj.SetDict(ChConfig.Def_PlayerKey_AttrFaintCD, 0) # »÷ÔÎCD
|
#
|
# objType = gameObj.GetGameObjType()
|
# objID = gameObj.GetID()
|
# objName = GetObjName(gameObj)
|
# GameWorld.DebugLog("ObjPerTurnStart: »ØºÏ%s, %s objType-ID-HP(%s-%s-%s)" % (turnNum, objName, objType, objID, GameObj.GetHP(gameObj)))
|
#
|
# # ÿ»ØºÏ¿ªÊ¼¼õ¼¼ÄÜCD
|
# skillManager = gameObj.GetSkillManager()
|
# for i in range(skillManager.GetSkillCount()):
|
# skill = skillManager.GetSkillByIndex(i)
|
# remainTime = skill.GetRemainTime()
|
# if not remainTime:
|
# continue
|
# skillID = skill.GetSkillID()
|
# updRemainTime = max(0, remainTime - ChConfig.Def_PerTurnTick)
|
# skill.SetRemainTime(updRemainTime)
|
# GameWorld.DebugLog(" skillID=%s,remainTime=%s,updRemainTime=%s" % (skillID, remainTime, updRemainTime))
|
#
|
# # ˢж¨Ê±´¦ÀíµÄbuffЧ¹û
|
# SkillShell.ProcessPersistBuff(gameObj, tick)
|
#
|
# PassiveBuffEffMng.OnPassiveSkillTrigger(gameObj, tagObj, None, ChConfig.TriggerType_TurnNum, tick)
|
#
|
# __logGameObjAttr(gameObj)
|
return
|
|
def AddTurnObjCureHP(curObj, srcObj, addValue, cureHP, skillID=0):
|
## »ØºÏ¶ÔÏóÌí¼ÓÖÎÁÆÖµ
|
if not curObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo):
|
return
|
|
curFaction = GameObj.GetFaction(curObj)
|
if not srcObj or curFaction != GameObj.GetFaction(srcObj):
|
# ͬÕóÓªµÄÖÎÁƲÅͳ¼Æ
|
return
|
|
curID = curObj.GetID()
|
srcID = srcObj.GetID()
|
turnFight = GetTurnFightMgr().getNPCTurnFight(curID)
|
if not turnFight:
|
return
|
|
curBatFaction = turnFight.getBatFaction(curFaction)
|
for num in curBatFaction.lineupDict.keys():
|
batLineup = curBatFaction.getBatlineup(num)
|
updStatValue = batLineup.statCureValue(srcID, cureHP)
|
if updStatValue == None:
|
continue
|
GameWorld.DebugLog(" ͳ¼ÆÖÎÁÆ: curTD=%s,srcID=%s,skillID=%s,addValue=%s,cureHP=%s,updStatValue=%s"
|
% (curID, srcID, skillID, addValue, cureHP, updStatValue))
|
break
|
|
return
|
|
def AddTurnObjHurtValue(curObj, tagObj, hurtType, hurtValue, lostHP, curSkill=None):
|
## »ØºÏ¶ÔÏóÌí¼ÓÉ˺¦Öµ
|
if not curObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo):
|
return
|
curID = curObj.GetID()
|
tagID = tagObj.GetID()
|
skillID = curSkill.GetSkillID() if curSkill else 0
|
turnFight = GetTurnFightMgr().getNPCTurnFight(curID)
|
if not turnFight:
|
return
|
|
if curID != tagID:
|
curBatFaction = turnFight.getBatFaction(GameObj.GetFaction(curObj))
|
for num in curBatFaction.lineupDict.keys():
|
batLineup = curBatFaction.getBatlineup(num)
|
updStatValue = batLineup.statHurtValue(curID, lostHP)
|
if updStatValue == None:
|
continue
|
GameWorld.DebugLog(" ͳ¼ÆÉËѪ: curTD=%s,tagID=%s,skillID=%s,hurtType=%s,hurtValue=%s,lostHP=%s,updStatValue=%s,tagHP=%s"
|
% (curID, tagID, skillID, hurtType, hurtValue, lostHP, updStatValue, GameObj.GetHP(tagObj)))
|
break
|
|
tagBatFaction = turnFight.getBatFaction(GameObj.GetFaction(tagObj))
|
for num in tagBatFaction.lineupDict.keys():
|
batLineup = tagBatFaction.getBatlineup(num)
|
updStatValue = batLineup.statDefValue(tagID, lostHP)
|
if updStatValue == None:
|
continue
|
GameWorld.DebugLog(" ͳ¼Æ³ÐÉË: curTD=%s,tagID=%s,skillID=%s,hurtType=%s,hurtValue=%s,lostHP=%s,updStatValue=%s,curHP=%s"
|
% (tagID, curID, skillID, hurtType, hurtValue, lostHP, updStatValue, GameObj.GetHP(tagObj)))
|
break
|
|
else:
|
# È绻ѪÀ༼ÄÜ£¬×ԲеÄÉ˺¦²»ËãÊä³ö
|
GameWorld.DebugLog(" ×Ô²Ð: curTD=%s,tagID=%s,skillID=%s,hurtType=%s,hurtValue=%s,lostHP=%s,curHP=%s"
|
% (curID, tagID, skillID, hurtType, hurtValue, lostHP, GameObj.GetHP(curObj)))
|
|
if lostHP and curID != tagID:
|
AddTurnFightXP(tagObj, __GetAddXP_Defender(tagObj, lostHP), "skillID:%s" % skillID)
|
return
|
|
def __GetAddXP_Attack(attack, curSkill):
|
## ¹¥»÷·½Ôö¼ÓµÄXPÖµ¸ù¾ÝÖ÷¶¯ÆÕ¹¥¼¼ÄÜ»ñµÃ
|
if not curSkill:
|
return 0
|
if not SkillCommon.isNormalAtkSkill(curSkill):
|
return 0
|
return IpyGameDataPY.GetFuncCfg("AngerXP", 3)
|
|
def __GetAddXP_Defender(defender, lostHP):
|
## µôѪ·½Ôö¼ÓµÄXPÖµ¸ù¾ÝµôѪ°Ù·Ö±È»ñµÃ
|
if lostHP <= 0:
|
return 0
|
return IpyGameDataPY.GetFuncCfg("AngerXP", 4)
|
|
def AddTurnFightXP(gameObj, addXP, reason=""):
|
## »ØºÏÕ½¶·Ôö¼ÓXP
|
if addXP <= 0 or not addXP:
|
#GameWorld.DebugLog(" ûÓÐÔö¼ÓXP! curID=%s" % (gameObj.GetID()))
|
return
|
posNum = gameObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo) % 10
|
if posNum <= 0:
|
#·ÇÖ÷Õ½µ¥Î»²»¼Ó
|
return
|
curXP = GameObj.GetXP(gameObj)
|
updXP = curXP + addXP
|
GameObj.SetXP(gameObj, updXP)
|
GameWorld.DebugLog(" ¸üÐÂXP: curID=%s,curXP=%s,addXP=%s,updXP=%s,reason=%s" % (gameObj.GetID(), curXP, addXP, updXP, reason))
|
return
|
|
def DoAttack(curNPC, tagNPC, tick, turnBattleType=ChConfig.TurnBattleType_Normal, useSkill=None):
|
curID = curNPC.GetID()
|
npcID = curNPC.GetNPCID()
|
objName = GetObjName(curNPC)
|
GameWorld.DebugLog(" ¡ñ %s DoAttack: curID=%s,,turnBattleType=%s" % (objName, curID, turnBattleType))
|
|
atkOK = False
|
tagObj = tagNPC
|
curNPC.SetDict(ChConfig.Def_Obj_Dict_TurnBattleType, turnBattleType)
|
|
if turnBattleType == ChConfig.TurnBattleType_AtkBack:
|
if not tagObj:
|
return
|
atkOK = BaseAttack.Attack(curNPC, tagObj, None, tick) # ·´»÷Ϊµ¥ÌåÆÕ¹¥
|
elif turnBattleType == ChConfig.TurnBattleType_Combo:
|
if not tagObj:
|
return
|
atkOK = SkillShell.DoLogic_UseSkill(curNPC, tagObj, useSkill, tick)
|
else:
|
curXP = GameObj.GetXP(curNPC)
|
xpMax = IpyGameDataPY.GetFuncCfg("AngerXP", 2)
|
skillManager = curNPC.GetSkillManager()
|
useSkillList = []
|
GameWorld.DebugLog('skillCount=%s' % skillManager.GetSkillCount(), npcID)
|
for index in range(0, skillManager.GetSkillCount()):
|
useSkill = skillManager.GetSkillByIndex(index)
|
#ÒѾµ½Î²²¿ÁË
|
if not useSkill or useSkill.GetSkillTypeID() == 0:
|
break
|
#±»¶¯¼¼ÄÜÎÞ·¨Ê¹ÓÃ
|
if SkillCommon.isPassiveSkill(useSkill):
|
continue
|
#»¹ÔÚÀäȴʱ¼äÄÚÎÞ·¨ÊÍ·Å
|
if SkillCommon.RefreshSkillRemainTime(useSkill, tick) != 0:
|
continue
|
skillTypeID = useSkill.GetSkillTypeID()
|
# ³£¹æ¹¥»÷ÓÅÏÈxp
|
if SkillCommon.isXPSkill(useSkill) and turnBattleType == ChConfig.TurnBattleType_Normal:
|
if curXP < xpMax:
|
continue
|
useCnt = -1 # xp¼¼ÄÜÓÅÏÈÊÍ·Å
|
else:
|
useCnt = curNPC.GetDictByKey(ChConfig.Def_NPC_Dict_SkillUseCnt % skillTypeID) # ¸Ã¼¼ÄÜÒÑʹÓôÎÊý
|
useSkillList.append([useCnt, index, skillTypeID, useSkill])
|
|
useSkillList.sort() # °´Ê¹ÓôÎÊýÓÅÏÈÉýÐòÅÅ£¬Ê¹ÓôÎÊýµÍµÄÓÅÏÈÅжÏʹÓÃ
|
#GameWorld.DebugLog(' ¼¼ÄÜʹÓÃ˳Ðò = useSkillList%s' % str(useSkillList), npcID)
|
|
for useInfo in useSkillList:
|
useSkill = useInfo[-1]
|
skillID = useSkill.GetSkillID()
|
atkOK, tagObj = DoNPCUseSkill(curNPC, useSkill, tick)
|
if atkOK:
|
AddTurnFightXP(curNPC, __GetAddXP_Attack(curNPC, useSkill), "skillID:%s" % skillID)
|
break
|
|
if not atkOK:
|
tagObj = GetEnemyObj(curNPC)
|
if tagObj:
|
GameWorld.DebugLog(' ÎÞ¼¼Äܿɹ¥»÷£¬Ö±½ÓʹÓÃÆÕ¹¥! tagID=%s(%s)' % (tagObj.GetID(), GetObjName(tagObj)), npcID)
|
atkOK = BaseAttack.Attack(curNPC, tagObj, None, tick)
|
|
curNPC.SetDict(ChConfig.Def_Obj_Dict_TurnBattleType, 0) # ÎÞÂÛ¹¥»÷³É¹¦Óë·ñ¶¼ÖØÖÃÕ½¶·ÀàÐÍ
|
|
tagID = 0
|
tagHP = 0
|
if tagObj:
|
tagID = tagObj.GetID()
|
tagHP = GameObj.GetHP(tagObj)
|
GameWorld.DebugLog(' atkOK=%s,tagID=%s,tagHP=%s' % (atkOK, tagID, tagHP), npcID)
|
if not atkOK:
|
return
|
|
if not tagObj:
|
return
|
|
if GameObj.GetFaction(curNPC) == GameObj.GetFaction(tagObj):
|
# ͬÕóÓªÖ±½Ó·µ»Ø£¬²»´¦ÀíÁ¬»÷¡¢·´»÷
|
return True
|
|
curHP = GameObj.GetHP(curNPC)
|
tagHP = GameObj.GetHP(tagObj)
|
tagID = tagObj.GetID()
|
GameWorld.DebugLog(" curID-HP=(%s-%s),tagID-HP=(%s-%s)" % (curID, curHP, tagID, tagHP))
|
if tagHP <= 0 or curHP <= 0:
|
return True
|
|
# ·´»÷£¬·´»÷¿É´ò¶ÏÁ¬»÷£¬ËùÒÔÓÅÏÈÅжÏ
|
if CanAtkBack(curNPC, tagObj):
|
DoAttack(tagObj, curNPC, tick, ChConfig.TurnBattleType_AtkBack)
|
return True
|
|
# Á¬»÷
|
if CanCombo(curNPC, tagObj):
|
DoAttack(curNPC, tagObj, tick, ChConfig.TurnBattleType_Combo, useSkill)
|
|
return True
|
|
def CanAtkBack(atkObj, defObj):
|
## ¿É·ñ·´»÷
|
posNum = atkObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo) % 100
|
if posNum <= 0:
|
GameWorld.DebugLog(" ±»·ÇÖ÷Õ½µ¥Î»¹¥»÷ʱÎÞ·¨´¥·¢·´»÷: atkID=%s,posNum=%s" % (atkObj.GetID(), posNum))
|
return False
|
defAtkBackRate = GameObj.GetAtkBackRate(defObj) # ·À·½·´»÷ÂÊ
|
atkBackNum = defObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnAtkBackNum) # ÒÑ·´»÷´ÎÊý
|
if atkBackNum > 10:
|
# ÄÚÖÃ×î¸ß·´»÷Êý·À·¶
|
return False
|
if atkBackNum > 0:
|
validPerList = IpyGameDataPY.GetFuncEvalCfg("TurnFight", 4)
|
vaildPer = validPerList[atkBackNum - 1] if len(validPerList) >= atkBackNum else 0
|
defAtkBackRate = int(defAtkBackRate * vaildPer / 100.0)
|
|
atkAtkBackDefRate = GameObj.GetAtkBackDefRate(atkObj) # ¹¥·½µÖ¿¹·´»÷ÂÊ
|
atkBackRate = max(0, defAtkBackRate - atkAtkBackDefRate)
|
if atkBackRate <= 0 or not GameWorld.CanHappen(atkBackRate):
|
GameWorld.DebugLog(" ÎÞ·¨·´»÷: defID=%s,atkBackNum=%s,atkBackRate=%s=(defAtkBackRate=%s - atkAtkBackDefRate=%s)"
|
% (defObj.GetID(), atkBackNum, atkBackRate, defAtkBackRate, atkAtkBackDefRate))
|
return False
|
GameWorld.DebugLog(" ¿ÉÒÔ·´»÷: defID=%s,atkBackNum=%s,atkBackRate=%s=(defAtkBackRate=%s - atkAtkBackDefRate=%s)"
|
% (defObj.GetID(), atkBackNum, atkBackRate, defAtkBackRate, atkAtkBackDefRate))
|
return True
|
|
def CanCombo(atkObj, defObj):
|
## ¿É·ñÁ¬»÷
|
|
atkComboRate = GameObj.GetComboRate(atkObj) # ¹¥·½Á¬»÷ÂÊ
|
comboNum = atkObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnComboNum) # ÒÑÁ¬»÷´ÎÊý
|
if comboNum > 10:
|
# ÄÚÖÃ×î¸ßÁ¬»÷Êý·À·¶
|
return False
|
if comboNum > 0:
|
validPerList = IpyGameDataPY.GetFuncEvalCfg("TurnFight", 3)
|
vaildPer = validPerList[comboNum - 1] if len(validPerList) >= comboNum else 0
|
atkComboRate = int(atkComboRate * vaildPer / 100.0)
|
|
defComboReduce = GameObj.GetComboDefRate(defObj) # ·À·½µÖ¿¹Á¬»÷ÂÊ
|
comboRate = max(0, atkComboRate - defComboReduce)
|
if comboRate <= 0 or not GameWorld.CanHappen(comboRate):
|
GameWorld.DebugLog(" ÎÞ·¨Á¬»÷: atkID=%s,comboNum=%s,comboRate=%s=(atkComboRate=%s - defComboReduce=%s)"
|
% (atkObj.GetID(), comboNum, comboRate, atkComboRate, defComboReduce))
|
return False
|
GameWorld.DebugLog(" ¿ÉÒÔÁ¬»÷: atkID=%s,comboNum=%s,comboRate=%s=(atkComboRate=%s - defComboReduce=%s)"
|
% (atkObj.GetID(), comboNum, comboRate, atkComboRate, defComboReduce))
|
return True
|
|
def DoNPCUseSkill(curNPC, useSkill, tick):
|
'''NPCʹÓü¼ÄÜ
|
@return: ÊÇ·ñ³É¹¦, tagObj
|
'''
|
if not useSkill or useSkill.GetSkillTypeID() == 0:
|
return False, None
|
|
#¼ì²éÊÇ·ñ¼¸ÂÊ´¥·¢
|
rate = useSkill.GetHappenRate()
|
if rate != ChConfig.Def_MaxRateValue and not GameWorld.CanHappen(rate, ChConfig.Def_MaxRateValue):
|
#GameWorld.Log('¼ì²éÊÇ·ñ¼¸ÂÊ´¥·¢ = %sʧ°Ü = %s'%(rate, useSkill.GetSkillName()))
|
return False, None
|
|
tagObj = None
|
skillTag = SkillShell.GetSkillAffectTag(useSkill)
|
skillAim = SkillShell.GetSkillFireAim(useSkill)
|
|
# ×¢£º ¶àV¶àµÄÇé¿öÓѺÃÄ¿±ê½öÕë¶Ô±¾ÕóÈÝ¡¢µÐ¶ÔÄ¿±ê¿ÉÕë¶ÔÈÎÒâµÐ¶ÔÕóÈÝ
|
|
#---¶Ô×Ô¼ºÊÍ·Å,»òÕßÎÞÄ¿±ê¼¼ÄÜ---
|
if skillTag in ChConfig.Def_ST_CanNPCUseSkill or skillAim == ChConfig.Def_UseSkillAim_None:
|
#ÊÍ·Å×ÔÉíÀ༼ÄÜ
|
tagObj = curNPC
|
isOK = SkillShell.DoLogic_UseSkill(curNPC, tagObj, useSkill, tick)
|
return isOK, tagObj
|
|
# ÕÙ»½ÊÞ¶ÔÖ÷ÈËÊͷż¼ÄÜ
|
elif skillTag == ChConfig.Def_UseSkillTag_SummonMaster:
|
if not NPCCommon.IsSummonNPC(curNPC):
|
GameWorld.ErrLog("¸ÃNPC·ÇÕÙ»½ÊÞ£¬ÎÞ·¨»ñµÃÖ÷ÈËÊͷż¼ÄÜ")
|
return False, None
|
|
curSummonOwner = NPCCommon.GetSummonNPCOwner(IPY_GameWorld.gotPlayer, curNPC)
|
if curSummonOwner == None:
|
curSummonOwner = NPCCommon.GetSummonNPCOwner(IPY_GameWorld.gotNPC, curNPC)
|
|
if curSummonOwner == None:
|
GameWorld.ErrLog("ÕÙ»½ÊÞ£¨%s£©¶ÔÖ÷ÈËÊͷż¼ÄÜ£¬ÕÒ²»µ½Ö÷ÈË" % curNPC.GetNPCID())
|
return False, None
|
|
tagObj = curSummonOwner
|
|
# ÓѺÃËÀÍöÄ¿±ê£¬Ò»°ãÊǸ´»î¼¼ÄÜ
|
elif skillTag == ChConfig.Def_UseSkillTag_FriendDeath:
|
deathList = GetFriendDeathList(curNPC)
|
if not deathList:
|
return False, None
|
tagObj = random.choice(deathList) # Ëæ»úѡһ¸ö
|
|
# ÓѺÃÄ¿±ê
|
elif skillTag in ChConfig.Def_ST_CanNPCUseSkillFriend:
|
friendList = GetFriendObjList(curNPC)
|
if not friendList:
|
return False, None
|
tagObj = random.choice(friendList) # Ëæ»úѡһ¸ö£¬¿ÉÀ©Õ¹ÆäËûÑ¡Ôñ¹æÔò
|
|
# µÐ·½Ä¿±ê
|
else:
|
tagObj = GetEnemyObj(curNPC)
|
|
if not tagObj:
|
return False, None
|
|
GameWorld.DebugLog(" ¼¼ÄÜÊÍ·Å: skillID=%s,atkID=%s,def=%s,HP:%s/%s"
|
% (useSkill.GetSkillID(), curNPC.GetID(), GetObjName(tagObj), GameObj.GetHP(tagObj), GameObj.GetMaxHP(tagObj)))
|
isOK = SkillShell.DoLogic_UseSkill(curNPC, tagObj, useSkill, tick)
|
return isOK, tagObj
|
|
def GetFriendDeathList(curNPC):
|
## »ñÈ¡ÓÑ·½ËÀÍöµ¥Î»£¬½öÕë¶Ô±¾ÕóÈÝÖ÷Õ½µ¥Î»
|
objID = curNPC.GetID()
|
turnFight = GetTurnFightMgr().getNPCTurnFight(objID)
|
if not turnFight:
|
return []
|
batFaction = turnFight.getBatFaction(GameObj.GetFaction(curNPC))
|
num = curNPC.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo) / 100
|
batLineup = batFaction.getBatlineup(num)
|
deathList = []
|
for posNum, tagNPC in batLineup.npcPosDict.items():
|
if posNum <= 0 or not tagNPC:
|
continue
|
if GameObj.GetHP(tagNPC) > 0:
|
continue
|
deathList.append(tagNPC)
|
|
return deathList
|
|
def GetFriendObjList(curNPC):
|
## »ñÈ¡ÓÑ·½µ¥Î»£¬½öÕë¶Ô±¾ÕóÈÝÖ÷Õ½µ¥Î»
|
objID = curNPC.GetID()
|
turnFight = GetTurnFightMgr().getNPCTurnFight(objID)
|
if not turnFight:
|
return []
|
batFaction = turnFight.getBatFaction(GameObj.GetFaction(curNPC))
|
num = curNPC.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo) / 100
|
batLineup = batFaction.getBatlineup(num)
|
friendList = []
|
for posNum, tagNPC in batLineup.npcPosDict.items():
|
if posNum <= 0 or not tagNPC:
|
continue
|
if GameObj.GetHP(tagNPC) <= 0:
|
continue
|
friendList.append(tagNPC)
|
return friendList
|
|
def GetEnemyObj(curNPC, ruleType=0):
|
## »ñȡһ¸öµÐ¶Ôµ¥Î»£¬Õë¶ÔËùÓежÔÕóÈÝÖ÷Õ½µ¥Î»£¬ÓÅÏÈÑ¡Ôñ¶ÔλÕóÈݵ¥Î»£¬½öÏÞ»î×ŵĵ¥Î»
|
# @param ruleType: Ñ¡Ôñ¹æÔò£¬Ä¬ÈÏ0ÈÎÒ⣬1-×îµÍѪÁ¿£»2-×î¸ßѪÁ¿
|
objID = curNPC.GetID()
|
faction = GameObj.GetFaction(curNPC)
|
posInfo = curNPC.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo)
|
num = posInfo / 100 # ÕóÈݱàºÅ
|
posNum = posInfo % 100 # ËùÔÚÕóÈÝվλ
|
turnFight = GetTurnFightMgr().getNPCTurnFight(objID)
|
if not turnFight:
|
return
|
|
tagBatFaction = turnFight.getBatFaction(Def_FactionB if faction == Def_FactionA else Def_FactionA)
|
|
tagLineupNumList = [num] # Ä¿±êÕóÈÝÑ¡Ôñ˳Ðò£¬ÓÅÏȶÔλÕóÈÝ£¬ÔÙÆäËûÕóÈÝ
|
if num in tagBatFaction.lineupDict:
|
tagLineupNumList = [num]
|
for tagNum in tagBatFaction.lineupDict.keys():
|
if tagNum not in tagLineupNumList:
|
tagLineupNumList.append(tagNum)
|
|
for tagNum in tagLineupNumList:
|
tagLineup = tagBatFaction.getBatlineup(tagNum)
|
tagPosNumList = [posNum] # ÓÅÏȶÔλλÖã¬ÔÙÆäËûλÖð´Ë³Ðò±éÀú
|
pNumList = tagLineup.npcPosDict.keys()
|
pNumList.sort()
|
for pNum in pNumList:
|
if pNum > 0 and pNum not in tagPosNumList:
|
tagPosNumList.append(pNum)
|
for pNum in tagPosNumList:
|
tagNPC = tagLineup.npcPosDict.get(pNum)
|
if not tagNPC:
|
continue
|
if GameObj.GetHP(tagNPC) <= 0:
|
continue
|
return tagNPC
|
return
|
|
def SetKilled(gameObj, killer=None):
|
if not gameObj.GetDictByKey(ChConfig.Def_Obj_Dict_TurnFightPosInfo):
|
#GameWorld.DebugLog("·Ç»ØºÏÕ½¶·Ö÷Ìå±»»÷ɱ: curID=%s" % gameObj.GetID())
|
return
|
|
GameWorld.DebugLog(" %s »ØºÏÕ½¶·Ö÷Ìå±»»÷ɱ: curID=%s" % (GetObjName(gameObj), gameObj.GetID()))
|
GameObj.SetHP(gameObj, 0) # »ØºÏÖÆËÀÍö½öÉèÖÃΪ0£¬ÊµÀýÔÝʱ²»»ØÊÕ
|
gameObj.SetVisible(False)
|
|
turnFight = GetTurnFightMgr().getNPCTurnFight(gameObj.GetID())
|
if turnFight:
|
clientPack = ChPyNetSendPack.tagMCTurnFightObjDead()
|
clientPack.ObjID = gameObj.GetID()
|
turnFight.addBatPack(clientPack)
|
|
return True
|
|
def OnTurnAllOver(guid):
|
## ËùÓлغÏÒѾȫ²¿Ö´ÐÐÍê±Ï
|
GameWorld.DebugLog("ËùÓлغϽáÊø")
|
turnFight = GetTurnFightMgr().getTurnFight(guid)
|
if not turnFight:
|
return
|
|
if turnFight.winFaction:
|
return
|
|
if turnFight.playerID:
|
# Íæ¼Ò·¢ÆðµÄ£¬Î´»÷ɱ¶Ô·½£¬ËãÍæ¼ÒÊä
|
turnFight.winFaction = Def_FactionB
|
else:
|
# ϵͳ³¡´Î£¬°´Ò»¶¨¹æÔòÀ´£¬ÕâÀïÏÈËæ»ú
|
turnFight.winFaction = random.choice([Def_FactionA, 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
|
GameWorld.DebugLog("--- Õ½¶·½áÊø´¦Àí --- %s, winFaction=%s, costTime=%ss" % (guid, winFaction, turnFight.costTime))
|
|
# ͳ¼ÆÃ÷ϸ
|
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)
|
hurtStatDict = batLineup.hurtStatDict
|
defStatDict = batLineup.defStatDict
|
cureStatDict = batLineup.cureStatDict
|
GameWorld.DebugLog("ÕóÈÝÃ÷ϸ: faction=%s,num=%s" % (faction, num))
|
for posNum, curNPC in batLineup.npcPosDict.items():
|
objID = curNPC.GetID()
|
npcID = curNPC.GetNPCID()
|
atkHurt = hurtStatDict.get(objID, 0)
|
defHurt = defStatDict.get(objID, 0)
|
cureHP = cureStatDict.get(objID, 0)
|
GameWorld.DebugLog(" Pos:%s ID=%s-%s,,HP=%s/%s, Êä³ö=%s,³ÐÉË=%s,ÖÎÁÆ=%s"
|
% (posNum, objID, npcID, GameObj.GetHP(curNPC), GameObj.GetMaxHP(curNPC), atkHurt, defHurt, cureHP))
|
lineupStatInfo[str(posNum)] = {"ObjID":objID, "NPCID":npcID, "AtkHurt":atkHurt, "DefHurt":defHurt, "CureHP":cureHP}
|
|
awardItemList = []
|
playerID = turnFight.playerID
|
if playerID:
|
curPlayer = turnFight.curPlayer
|
isWin = (winFaction == Def_FactionA)
|
# Ö÷ÏßС¹Ö
|
if turnFight.mapID == ChConfig.Def_FBMapID_Main:
|
OnOver_MainLevel(curPlayer, isWin, awardItemList)
|
# Ö÷Ïßboss
|
elif turnFight.mapID == ChConfig.Def_FBMapID_MainBoss:
|
OnOver_MainLevelBoss(curPlayer, isWin, awardItemList)
|
else:
|
pass
|
|
overMsg = {"winFaction":winFaction, "statInfo":statInfo, FBCommon.Over_itemInfo:FBCommon.GetJsonItemList(awardItemList)}
|
turnFight.syncState(FightState_Award, overMsg)
|
|
# ³ýÁËÖ÷ÏßÍ⣬ÆäÓàÕ½¶·½áÊøºó¾ùÖ±½Óɾ³ý
|
if not turnFight.playerID:
|
tfMgr.delTurnFight(guid)
|
return
|
|
def OnOver_MainLevel(curPlayer, isWin, awardItemList):
|
## Õ½¶·½áÊø¶îÍâ´¦Àí - Ö÷Ï߹ؿ¨
|
if not curPlayer:
|
return
|
playerID = curPlayer.GetPlayerID()
|
mainFightMgr = GetMainFightMgr(curPlayer)
|
mainFightMgr.nextTeam = False
|
chapterID, levelNum, wave = PlayerControl.GetMainLevelNowInfo(curPlayer)
|
|
if not isWin:
|
nextWave = max(1, wave - 1)
|
nowValue = PlayerControl.SetMainLevelNowInfo(curPlayer, chapterID, levelNum, nextWave)
|
GameWorld.DebugLog("Ö÷ÏßС¹ÖÕ½¶·Ê§°Ü£¬½µÒ»²¨! chapterID=%s,levelNum=%s,wave=%s,nextWave=%s,nowValue=%s"
|
% (chapterID, levelNum, wave, nextWave, nowValue), playerID)
|
return
|
|
if mainFightMgr.teamNum < mainFightMgr.teamMax:
|
mainFightMgr.nextTeam = True
|
GameWorld.DebugLog("Ö÷ÏßС¹ÖÕ½¶·Ê¤Àû£¬ÏÂһС¶Ó! chapterID=%s,levelNum=%s,wave=%s,teamNum=%s/%s"
|
% (chapterID, levelNum, wave, mainFightMgr.teamNum, mainFightMgr.teamMax), playerID)
|
return
|
|
# »ñʤ¹ý²¨
|
if wave < mainFightMgr.waveMax:
|
nextWave = min(mainFightMgr.waveMax, wave + 1)
|
nowValue = PlayerControl.SetMainLevelNowInfo(curPlayer, chapterID, levelNum, nextWave)
|
GameWorld.DebugLog("Ö÷ÏßС¹Ö²¨Õ½¶·Ê¤Àû£¬ÏÂÒ»²¨! chapterID=%s,levelNum=%s,wave=%s,nextWave=%s,nowValue=%s"
|
% (chapterID, levelNum, wave, nextWave, nowValue), playerID)
|
else:
|
GameWorld.DebugLog("Ö÷ÏßС¹Ö²¨Õ½¶·Ê¤Àû£¬×îºóÒ»²¨Ñ»·Ë¢! chapterID=%s,levelNum=%s,wave=%s" % (chapterID, levelNum, wave), playerID)
|
|
# С¹Ö¿ÉÄÜ»áÍ˲¨£¬ËùÒÔÖ»ÔÚÓг¬¹ýÒѹý¹Ø¿¨½ø¶Èʱ²Å¸üÐÂÖµ
|
hisPassValue = PlayerControl.GetMainLevelPassValue(curPlayer)
|
curPassValue = PlayerControl.ComMainLevelValue(chapterID, levelNum, wave)
|
if curPassValue > hisPassValue:
|
GameWorld.DebugLog("¸üе±Ç°¹ý¹Ø½ø¶È! curPassValue=%s,hisPassValue=%s" % (curPassValue, hisPassValue), playerID)
|
PlayerControl.SetMainLevelPassValue(curPlayer, curPassValue)
|
else:
|
GameWorld.DebugLog("䳬¹ýµ±Ç°¹ý¹Ø½ø¶È£¬²»¸üÐÂ! curPassValue=%s <= hisPassValue=%s" % (curPassValue, hisPassValue), playerID)
|
|
return
|
|
def OnOver_MainLevelBoss(curPlayer, isWin, awardItemList):
|
## Õ½¶·½áÊø¶îÍâ´¦Àí - Ö÷Ï߹ؿ¨boss
|
if not curPlayer:
|
return
|
playerID = curPlayer.GetPlayerID()
|
mainFightMgr = GetMainFightMgr(curPlayer)
|
mainFightMgr.nextTeam = False
|
chapterID, levelNum, _ = PlayerControl.GetMainLevelPassInfo(curPlayer)
|
if not isWin:
|
nowValue = PlayerControl.GetMainLevelNowValue(curPlayer)
|
GameWorld.DebugLog("Ö÷ÏßbossÕ½¶·Ê§°Ü£¡±£³Öµ±Ç°Ë¢¹Ö²¨½ø¶È²»±ä! nowValue=%s" % nowValue, playerID)
|
return
|
|
if mainFightMgr.teamNum < mainFightMgr.teamMax:
|
mainFightMgr.nextTeam = True
|
GameWorld.DebugLog("Ö÷ÏßbossС¶ÓÕ½¶·Ê¤Àû£¬ÏÂһС¶Ó! chapterID=%s,levelNum=%s,teamNum=%s/%s"
|
% (chapterID, levelNum, mainFightMgr.teamNum, mainFightMgr.teamMax), playerID)
|
return
|
|
isAllPass = False # ÊÇ·ñͨ¹Ø
|
if IpyGameDataPY.GetIpyGameDataNotLog("MainLevel", chapterID, levelNum + 1):
|
nextChapterID, nextLevelNum = chapterID, levelNum + 1
|
GameWorld.DebugLog("Ö÷Ïßboss²¨Õ½¶·Ê¤Àû£¡ÏÂÒ»¹Ø! chapterID=%s,levelNum=%s,nextLevelNum=%s"
|
% (chapterID, levelNum, nextLevelNum), playerID)
|
elif IpyGameDataPY.GetIpyGameDataNotLog("MainLevel", chapterID + 1, 1):
|
nextChapterID, nextLevelNum = chapterID + 1, 1
|
GameWorld.DebugLog("Ö÷Ïßboss²¨Õ½¶·Ê¤Àû£¡ÏÂÒ»ÕÂ! chapterID=%s,levelNum=%s,nextChapterID=%s,nextLevelNum=%s"
|
% (chapterID, levelNum, nextChapterID, nextLevelNum), playerID)
|
else:
|
# ÒÑͨ¹ØµÄÔÝʱÏȱ£³Ö²»±ä
|
# ×¢Òâ·À·¶×îºóÒ»¹Ø½±ÀøÖظ´»ñµÃ
|
nextChapterID, nextLevelNum = chapterID + 1, 1
|
GameWorld.DebugLog("Ö÷Ïßboss²¨Õ½¶·Ê¤Àû£¡ÒÑͨ¹Ø! chapterID=%s,levelNum=%s,nextChapterID=%s,nextLevelNum=%s"
|
% (chapterID, levelNum, nextChapterID, nextLevelNum), playerID)
|
isAllPass = True
|
|
updPassValue = PlayerControl.SetMainLevelPassInfo(curPlayer, nextChapterID, nextLevelNum, 0)
|
if isAllPass:
|
# ÒÑͨ¹ØµÄË¢¹Ö½ø¶È±£³Ö²»±ä
|
updNowValue = PlayerControl.GetMainLevelNowValue(curPlayer)
|
GameWorld.DebugLog("ÒÑͨ¹ØµÄË¢¹Ö½ø¶È±£³Ö²»±ä: updNowValue=%s" % updNowValue, playerID)
|
else:
|
updNowValue = PlayerControl.SetMainLevelNowInfo(curPlayer, nextChapterID, nextLevelNum, 1)
|
GameWorld.DebugLog("Ϊͨ¹ØµÄË¢¹Ö½ø¶ÈÉèÖÃΪÏÂÒ»¹ØµÄµÚ1²¨: updNowValue=%s" % updNowValue, playerID)
|
GameWorld.DebugLog("updPassValue=%s,updNowValue=%s" % (updPassValue, updNowValue), playerID)
|
|
# ·¢·Å¹ý¹Ø½±Àø
|
levelIpyData = IpyGameDataPY.GetIpyGameData("MainLevel", chapterID, levelNum)
|
if not levelIpyData:
|
return
|
itemList = levelIpyData.GetAwardItemList()
|
GameWorld.DebugLog("¹ý¹Ø½±Àø: chapterID=%s,levelNum=%s,itemList=%s" % (chapterID, levelNum, itemList), playerID)
|
|
ItemControler.GivePlayerItemOrMail(curPlayer, itemList, event=["MainLevelBoss", False, {}], isNotifyAward=False)
|
|
awardItemList += itemList
|
return
|
|
|
#// B4 14 ²é¿´Õ½±¨ #tagCSTurnFightReportView
|
#
|
#struct tagCSTurnFightReportView
|
#{
|
# tagHead Head;
|
# char GUID[40]; //Õ½±¨guid
|
#};
|
def OnTurnFightReportView(index, clientData, tick):
|
return
|