#!/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 ItemControler
|
import SkillCommon
|
import AttackCommon
|
import BattleObj
|
import TurnSkill
|
import TurnBuff
|
import ObjPool
|
|
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)
|
|
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.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):
|
## Çå³ýÕóÈÝ
|
if not self.posObjIDDict:
|
return
|
batObjMgr = BattleObj.GetBatObjMgr()
|
for objID in self.posObjIDDict.values():
|
batObjMgr.delBatObj(objID)
|
self.posObjIDDict = {}
|
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.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):
|
## ÉèÖÃÕóÓªÕóÈÝ
|
# @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():
|
fightPower = batLineup.fightPower
|
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=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.GetHP() > 0:
|
allKilled = False
|
break
|
|
if allKilled:
|
self.winFaction = ChConfig.Def_FactionA if faction == ChConfig.Def_FactionB else ChConfig.Def_FactionA
|
DoTurnFightOver(self.guid)
|
return self.winFaction
|
|
return 0
|
|
def exitFight(self):
|
## Í˳öÕ½¶·
|
self.syncState(FightState_Over)
|
for batFaction in self.factionDict.values():
|
batFaction.clearLineups()
|
self.state = -1
|
return
|
|
def startFight(self):
|
## ×¼±¸¾ÍÐ÷£¬¿ªÊ¼Õ½¶·
|
self.state = FightState_Start
|
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)
|
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)
|
else:
|
ObjPool.GetPoolMgr().release(clientPack)
|
return
|
|
class TurnFightMgr():
|
## »ØºÏÕ½¶·¹ÜÀíÆ÷
|
|
def __init__(self):
|
self.turnFightDict = {} # {guid:TurnFight, ...}
|
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.exitFight()
|
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 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 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)
|
|
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):
|
## »ñÈ¡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
|
npcData = NPCCommon.GetNPCDataPy(npcID)
|
if not npcData:
|
continue
|
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())
|
skillIDList = [] + npcData.GetSkillIDList()
|
heroDict[str(posNum)] = {"NPCID":npcID,
|
"AttrDict":{str(k):v for k, v in batAttrDict.items() if v > 0},
|
"SkillIDList":skillIDList
|
}
|
|
lineupInfo = {"NPCLineupID":lineupID, "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
|
'''
|
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", 3)
|
for posNumKey, heroInfo in heroDict.items():
|
posNum = int(posNumKey)
|
|
npcID, heroID, skinID = 0, 0, 0
|
atkBackSkillID = 0 # ·´»÷¼¼ÄÜID
|
fightPower = 0
|
skillIDList = [] # Õ½¶·¶ÔÏó¿ÉÄܸıäÊôÐÔ»ò¼¼ÄÜ£¬ÖØд´½¨£¬·ÀÖ¹ÎóÐÞ¸ÄÀ´Ô´Öµ
|
attrDict = {}
|
skillIDList += heroInfo.get("SkillIDList", [])
|
attrDict.update(heroInfo.get("AttrDict", {}))
|
objName = ""
|
if lineupPlayerID:
|
heroID = heroInfo.get("HeroID", 0)
|
skinID = heroInfo.get("SkinID", 0)
|
lv = heroInfo.get("LV", 1)
|
fightPower = heroInfo.get("FightPower", 0)
|
heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
|
if not heroIpyData:
|
continue
|
atkDistType = heroIpyData.GetAtkDistType()
|
objName = heroIpyData.GetName()
|
else:
|
npcID = heroInfo.get("NPCID", 0)
|
npcDataEx = NPCCommon.GetNPCDataPy(npcID)
|
if not npcDataEx:
|
continue
|
objName = npcDataEx.GetNPCName()
|
atkDistType = npcDataEx.GetAtkDistType()
|
lv = npcDataEx.GetLV()
|
|
batObj = batObjMgr.addBatObj()
|
if not batObj:
|
break
|
objID = batObj.GetID()
|
batObj.SetTFGUID(tfGUID)
|
batObj.SetName(objName)
|
batObj.SetFaction(faction)
|
batObj.SetLineupPos(posNum, num)
|
batObj.SetFightPower(fightPower)
|
batObj.SetLV(lv)
|
if npcID:
|
batObj.SetNPCID(npcID)
|
elif lineupPlayerID:
|
batObj.SetOwnerHero(lineupPlayerID, 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 ID:%s,faction:%s,num=%s,posNum=%s,skill=%s" % (objID, faction, num, posNum, skillIDList))
|
batObj.InitBatAttr({int(k):v for k, v in attrDict.items()}, initXP)
|
|
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)
|
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()
|
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 and not levelNum:
|
PlayerControl.SetMainLevelNowInfo(curPlayer, 1, 1, 1)
|
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
|
|
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
|
|
lineupMainInfo = GetPlayerLineupInfo(curPlayer, ShareDefine.Lineup_Main)
|
if not lineupMainInfo:
|
GameWorld.DebugLog("ûÓÐÉèÖÃÖ÷ÕóÈÝ!", playerID)
|
return
|
|
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(ChConfig.Def_FactionA, {1:lineupMainInfo})
|
turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(lineupID)})
|
turnFight.sortActionQueue()
|
turnFight.startFight()
|
return
|
|
def __doMainBossStart(curPlayer):
|
## ¿ªÊ¼ÌôÕ½¹Ø¿¨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¹Ì¶¨Ö»ÓÐÒ»²¨
|
|
lineupMainInfo = GetPlayerLineupInfo(curPlayer, ShareDefine.Lineup_Main)
|
if not lineupMainInfo:
|
GameWorld.DebugLog("ûÓÐÉèÖÃÖ÷ÕóÈÝ!", playerID)
|
return
|
|
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(ChConfig.Def_FactionA, {1:lineupMainInfo})
|
turnFight.setFactionLineup(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(lineupID)})
|
turnFight.sortActionQueue()
|
turnFight.startFight()
|
|
# ÌôÕ½bossÎÞÖмä¹ý³Ì£¬Ã¿´ÎÖ´ÐÐÖ±½ÓÌôÕ½Ò»¶Ó½á¹û
|
__processTurnFight(turnFight.guid)
|
return
|
|
def __doMainFight(curPlayer, tick):
|
## Ö÷ÏßÖ´ÐÐÕ½¶·
|
|
# ÏÞÖÆÇëÇóCD
|
#if not GameWorld.GetGameWorld().GetDebugLevel():
|
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()
|
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):
|
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(ChConfig.Def_FactionB, {1:GetNPCLineupInfo(lineupID)})
|
turnFight.sortActionQueue()
|
turnFight.startFight()
|
|
if mainFightMgr.isLevelBoss():
|
# ÿ´Î´¦ÀíһС¶ÓµÄÍêÕûÕ½¶·£¬Ï൱ÓÚÒ»´ÎÍêÕûÕ½±¨
|
__processTurnFight(turnFight.guid)
|
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), ...]£¬ ËùÓÐÕóÈÝÈ«²¿½áÊø´ú±í±¾»ØºÏ½áÊø
|
|
batObjMgr = BattleObj.GetBatObjMgr()
|
turnNum = turnFight.turnNum
|
GameWorld.DebugLog("turnNum=%s,doMax=%s,actionIndex=%s,%s" % (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 objID in batLineup.posObjIDDict.values():
|
batObj = batObjMgr.getBatObj(objID)
|
TurnFightObjPerTurnStart(turnFight, batObj, turnNum)
|
|
if turnFight.actionIndex >= len(turnFight.actionSortList):
|
turnFight.actionIndex = 0
|
|
playerHeroAtk = False # Íæ¼ÒÕóÈÝÐж¯±ê¼Ç
|
faction, num = turnFight.actionSortList[turnFight.actionIndex]
|
batFaction = turnFight.getBatFaction(faction)
|
batLineup = batFaction.getBatlineup(num)
|
if batLineup.actionNum > max(batLineup.posObjIDDict):
|
if (faction, num) not in overLineupList:
|
overLineupList.append((faction, num))
|
|
turnFight.actionIndex += 1
|
continue
|
|
if faction == ChConfig.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.posObjIDDict:
|
continue
|
objID = batLineup.posObjIDDict[posNum]
|
batObj = batObjMgr.getBatObj(objID)
|
if not OnObjAction(turnFight, batObj):
|
continue
|
|
if faction == ChConfig.Def_FactionA:
|
playerHeroAtk = True
|
|
break
|
|
turnFight.actionIndex += 1
|
batLineup.actionNum += 1
|
if batLineup.actionNum > max(batLineup.posObjIDDict):
|
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
|
|
if playerHeroAtk:
|
# Íæ¼ÒÎ佫ÓÐÐж¯ÔòÍ£Ö¹£¬Ò»¶Î¶ÎÖ´ÐÐ
|
GameWorld.DebugLog("Íæ¼ÒÎ佫ÓÐÐж¯ÔòÍ£Ö¹£¡")
|
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 objID in batLineup.posObjIDDict.values():
|
pass
|
|
if turnFight.checkOverByKilled():
|
return
|
|
if turnNum < turnFight.turnMax:
|
turnFight.turnNum += 1
|
else:
|
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)
|
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)
|
TurnFightObjPerTurnStart(turnFight, batObj, turnNum)
|
|
# Ö÷¹«
|
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.posObjIDDict:
|
continue
|
objID = batLineup.posObjIDDict[posNum]
|
batObj = batObjMgr.getBatObj(objID)
|
if not OnObjAction(turnFight, batObj):
|
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 objID in batLineup.posObjIDDict.values():
|
pass
|
|
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
|
if not heroID:
|
heroID = batObj.npcID
|
objName = GameWorld.CodeToGbk(batObj.GetName())
|
return "%s%s-%s [%s-%s] %s" % ("A" if faction == ChConfig.Def_FactionA else "B", num, posNum, batObj.GetID(), heroID, objName)
|
|
def EntryLogic(turnFight):
|
## Ö´Ðнø³¡Âß¼
|
if turnFight.enterLogic:
|
return
|
GameWorld.DebugLog("Ö´Ðнø³¡Âß¼...")
|
|
turnFight.enterLogic = True
|
return
|
|
def TurnFightObjPerTurnStart(turnFight, batObj, turnNum):
|
## »ØºÏÖÆÕ½¶·ÊµÀý - ÿ»ØºÏ¿ªÊ¼Ê±´¦Àí
|
if not batObj:
|
return
|
|
if batObj.GetHP() <= 0:
|
return
|
|
curID = batObj.GetID()
|
buffMgr = batObj.GetBuffManager()
|
GameWorld.DebugLog("¸üÐÂbuff: curID=%s,buffCount=%s" % (curID, buffMgr.GetBuffCount()))
|
for index in range(buffMgr.GetBuffCount())[::-1]:
|
buff = buffMgr.GetBuffByIndex(index)
|
curRemainTime = buff.GetRemainTime()
|
if not curRemainTime:
|
# ÓÀ¾Ãbuff²»´¦Àí
|
continue
|
buffID = buff.GetBuffID()
|
skillID = buff.GetSkillID()
|
updRemainTime = curRemainTime - 1
|
GameWorld.DebugLog(" ¸üÐÂbuffÊ£Óà»ØºÏÊý: buffID=%s,skillID=%s,updRemainTime=%s" % (buffID, skillID, updRemainTime))
|
if updRemainTime > 0:
|
buff.SetRemainTime(updRemainTime)
|
TurnBuff.SyncBuffRefresh(turnFight, batObj, buff)
|
else:
|
TurnBuff.DoBuffDel(turnFight, batObj, buff)
|
|
# 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):
|
## »ØºÏ¶ÔÏóÌí¼ÓÖÎÁÆÖµ
|
# @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, curSkill=None, isBounce=False):
|
## »ØºÏ¶ÔÏóÌí¼ÓÉ˺¦Öµ
|
# @param isBounce: ÊÇ·ñ·´µ¯É˺¦
|
curID = curBatObj.GetID()
|
tagID = tagBatObj.GetID()
|
skillID = curSkill.GetSkillID() if curSkill else 0
|
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(lostHP)
|
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 = True
|
|
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)
|
|
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() in [ChConfig.Def_SkillFuncType_AtkbackSkill]:
|
#»ù´¡ÆÕ¹¥²»ÄÜÖ÷¶¯ÊÍ·Å£¬Ä¿Ç°½öÓÃÓÚ·´»÷
|
continue
|
#±»¶¯¼¼ÄÜÎÞ·¨Ê¹ÓÃ
|
if SkillCommon.isPassiveSkill(useSkill):
|
continue
|
#»¹ÔÚÀäȴʱ¼äÄÚÎÞ·¨ÊÍ·Å
|
if useSkill.GetRemainTime():
|
continue
|
skillID = useSkill.GetSkillID()
|
# ³£¹æ¹¥»÷ÓÅÏÈxp
|
if SkillCommon.isAngerSkill(useSkill):
|
if curXP < xpMax:
|
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):
|
return True
|
|
return
|
|
def DoAttack(curBatObj, tagBatObj, tick, turnBattleType=ChConfig.TurnBattleType_Normal, useSkill=None):
|
# curID = curBatObj.GetID()
|
# npcID = curBatObj.GetNPCID()
|
# objName = GetObjName(curBatObj)
|
# GameWorld.DebugLog(" ¡ñ %s DoAttack: curID=%s,,turnBattleType=%s" % (objName, curID, turnBattleType))
|
#
|
# atkOK = False
|
# curBatObj.SetDict(ChConfig.Def_Obj_Dict_TurnBattleType, turnBattleType)
|
#
|
# if turnBattleType == ChConfig.TurnBattleType_AtkBack:
|
# if not tagBatObj:
|
# return
|
# skillManager = curBatObj.GetSkillManager()
|
# for index in range(0, skillManager.GetSkillCount()):
|
# skill = skillManager.GetSkillByIndex(index)
|
# if not skill:
|
# continue
|
# if skill.GetFuncType() == ChConfig.Def_SkillFuncType_AtkbackSkill:
|
# useSkill = skill
|
# break
|
# atkOK = SkillShell.DoLogic_UseSkill(curBatObj, tagBatObj, useSkill, tick)
|
# elif turnBattleType == ChConfig.TurnBattleType_Combo:
|
# if not tagBatObj:
|
# return
|
# atkOK = SkillShell.DoLogic_UseSkill(curBatObj, tagBatObj, useSkill, tick)
|
# else:
|
# curXP = GameObj.GetXP(curBatObj)
|
# 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() in [ChConfig.Def_SkillFuncType_AtkbackSkill]:
|
# #»ù´¡ÆÕ¹¥²»ÄÜÖ÷¶¯ÊÍ·Å£¬Ä¿Ç°½öÓÃÓÚ·´»÷
|
# continue
|
# #±»¶¯¼¼ÄÜÎÞ·¨Ê¹ÓÃ
|
# if SkillCommon.isPassiveSkill(useSkill):
|
# continue
|
# #»¹ÔÚÀäȴʱ¼äÄÚÎÞ·¨ÊÍ·Å
|
# if useSkill.GetRemainTime():
|
# continue
|
# skillID = useSkill.GetSkillID()
|
# # ³£¹æ¹¥»÷ÓÅÏÈxp
|
# if SkillCommon.isAngerSkill(useSkill) and turnBattleType == ChConfig.TurnBattleType_Normal:
|
# if curXP < xpMax:
|
# continue
|
# useCnt = -1 # xp¼¼ÄÜÓÅÏÈÊÍ·Å
|
# else:
|
# useCnt = curBatObj.GetDictByKey(ChConfig.Def_NPC_Dict_SkillUseCnt % skillID) # ¸Ã¼¼ÄÜÒÑʹÓôÎÊý
|
# useSkillList.append([useCnt, index, skillID, useSkill])
|
#
|
# useSkillList.sort() # °´Ê¹ÓôÎÊýÓÅÏÈÉýÐòÅÅ£¬Ê¹ÓôÎÊýµÍµÄÓÅÏÈÅжÏʹÓÃ
|
# #GameWorld.DebugLog(' ¼¼ÄÜʹÓÃ˳Ðò = useSkillList%s' % str(useSkillList), npcID)
|
#
|
# for useInfo in useSkillList:
|
# useSkill = useInfo[-1]
|
# #skillID = useSkill.GetSkillID()
|
# atkOK, tagBatObj = OnUseSkill(curBatObj, useSkill, tick)
|
# if atkOK:
|
# break
|
#
|
# curBatObj.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
|
atkDistType = AttackCommon.GetAtkDistType(defObj)
|
if atkDistType == ChConfig.AtkDistType_Long:
|
if not IpyGameDataPY.GetFuncCfg("ParryCfg", 2):
|
GameWorld.DebugLog(" Ô¶³Ìµ¥Î»²»¿É·´»÷: defID=%s" % (defObj.GetID()))
|
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 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().getTurnFight(curNPC.GetTFGUID())
|
# 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)
|
#
|
# batObjMgr = BattleObj.GetBatObjMgr()
|
# for tagNum in tagLineupNumList:
|
# tagLineup = tagBatFaction.getBatlineup(tagNum)
|
# tagPosNumList = [posNum] # ÓÅÏȶÔλλÖã¬ÔÙÆäËûλÖð´Ë³Ðò±éÀú
|
# pNumList = tagLineup.posObjIDDict.keys()
|
# pNumList.sort()
|
# for pNum in pNumList:
|
# if pNum > 0 and pNum not in tagPosNumList:
|
# tagPosNumList.append(pNum)
|
# for pNum in tagPosNumList:
|
# batObj = batObjMgr.getBatObj(objID)
|
# if not batObj:
|
# continue
|
# if batObj.GetHP( )<= 0:
|
# continue
|
# return batObj
|
# return
|
|
def SetObjKilled(turnFight, gameObj, killer=None, useSkill=None):
|
objID = gameObj.GetID()
|
GameWorld.DebugLog(" %s »ØºÏÕ½¶·Ö÷Ìå±»»÷ɱ: curID=%s" % (GetObjName(gameObj), objID))
|
gameObj.SetHP(0)
|
killerObjID = killer.GetID() if killer else 0
|
skillID = useSkill.GetSkillID() if useSkill else 0
|
|
clientPack = ObjPool.GetPoolMgr().acquire(ChPyNetSendPack.tagMCTurnFightObjDead)
|
clientPack.ObjID = objID
|
clientPack.KillerObjID = killerObjID
|
clientPack.SkillID = skillID
|
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 = 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
|
GameWorld.DebugLog("--- Õ½¶·½áÊø´¦Àí --- %s, winFaction=%s, costTime=%ss" % (guid, winFaction, turnFight.costTime))
|
|
# ͳ¼ÆÃ÷ϸ
|
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-%s-%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}
|
|
awardItemList = []
|
playerID = turnFight.playerID
|
if playerID:
|
curPlayer = turnFight.curPlayer
|
isWin = (winFaction == ChConfig.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
|
