From ca11e79c7981d66e3d8bdbe12b3f2b44b3ae7063 Mon Sep 17 00:00:00 2001
From: hxp <ale99527@vip.qq.com>
Date: 星期一, 26 一月 2026 16:18:36 +0800
Subject: [PATCH] 438 【方案】方案预设-服务端（武将方案切换时如果为空方案则复制当前武将方案；）
---
ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerOnline.py | 1116 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 1,101 insertions(+), 15 deletions(-)
diff --git a/ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerOnline.py b/ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerOnline.py
index ef64c77..cd3b221 100644
--- a/ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerOnline.py
+++ b/ServerPython/ZoneServerGroup/map1_8G/MapServer/MapServerData/Script/Player/PlayerOnline.py
@@ -9,36 +9,369 @@
# @date 2025-07-02
# @version 1.0
#
-# 详细描述: 在线玩家管理，用于管理在线玩家、准在线玩家的临时数据
+# 详细描述: 在线玩家管理，用于管理在线玩家、准在线玩家的临时数据，重读不会被重置
# 准在线玩家 - 实际不在线，x分钟内离线的玩家，用于支持断线重连，短时间内临时数据可持续
#
#-------------------------------------------------------------------------------
#"""Version = 2025-07-02 17:30"""
#-------------------------------------------------------------------------------
+import BattleObj
import TurnAttack
import PyGameData
+import SkillCommon
+import ShareDefine
+import PlayerPreset
+import PlayerControl
+import IpyGameDataPY
+import FormulaControl
+import PlayerPrestigeSys
+import GameLogic_Dingjunge
+import PlayerMingge
+import PlayerBeauty
+import PlayerFamily
+import PlayerHorse
+import PlayerGubao
+import PlayerHero
+import PlayerHJG
+import GameWorld
+import ChConfig
+import ChEquip
import time
+g_calcDetail = 0
+
+class LineupHero():
+ ## 阵容武将，注意：同一个武将在不同阵容中可能属性不一样
+
+ def __init__(self):
+ self.Clear()
+ return
+
+ def Clear(self):
+ self.itemIndex = 0
+ self.heroID = 0
+ self.skinID = 0
+ self.posNum = 0
+ self.heroBatAttrDict = {} # 武将的最终战斗属性字典， {attrID:value, ...}
+ self.heroSkillIDList = [] # 武将拥有的技能ID列表 [skillID, ...]
+ self.fightPower = 0 # 武将最终战力
+ self.skillFightPower = 0 # 技能战力
+ return
+
+class PresetHero():
+ '''武将阵容预设方案，可用于任何一个全局战斗预设方案
+ 虽然是同个武将物品阵容预设，但是在不同的战斗预设方案中最终的武将属性可能不一样
+ 故该类无关任何武将战力、属性等，只汇总某个武将阵容预设相关公共数据，如武将站位、生效卡牌等
+ '''
+
+ def __init__(self, heroPresetID=1):
+ self.heroPresetID = heroPresetID
+ self.shapeType = 0
+ self.heroItemDict = {} # 阵容武将背包索引信息 {itemIndex:posNum, ...}
+ self._effectiveCardDict = {} # 加成属性生效的武将卡牌信息 {heroID:[cardAddPer, itemIndex, inThis], ...}
+ self.isHeroChange = False
+ return
+
+ def SetHeroItemPreset(self, curPlayer, heroItemDict, shapeType=0, isReload=False):
+ self.shapeType = shapeType
+ self.heroItemDict = heroItemDict
+ if not isReload: # 非重读阵容的视为变更
+ self.isHeroChange = True
+ reloadEffHeroCard(curPlayer, self) # 更新武将阵容强制重刷生效卡牌
+ return
+
+ def OnSwitch(self):
+ self.isHeroChange = True
+ return
+
+ def IsHeroItemIn(self, itemIndex): return itemIndex in self.heroItemDict
+
+ def GetHeroEffectiveCard(self, heroID): return self._effectiveCardDict.get(heroID, [-1, -1, False])
+ def SetHeroEffectiveCard(self, heroID, cardAddPer, itemIndex, inThis):
+ ## 更新某个武将生效的卡牌信息
+ self._effectiveCardDict[heroID] = [cardAddPer, itemIndex, inThis]
+ return
+
+ def SetEffectiveCardDict(self, effectiveCardDict): self._effectiveCardDict = effectiveCardDict
+ def GetEffCardAddPer(self):
+ effCardAddPer = 0
+ for effInfo in self._effectiveCardDict.values():
+ effCardAddPer += effInfo[0]
+ return effCardAddPer
+
+class PresetLineup():
+ ## 全局战斗预设方案
+
+ def __init__(self, playerID, batPresetID, exclusiveMapID=0):
+ self.playerID = playerID
+ self.batPresetID = batPresetID
+ self.exclusiveMapID = exclusiveMapID # 大于0时代表是某个功能地图专用，如定军阁，阵容与主阵容相同，只是属性、战力可能不一样
+ self.olPlayer = None
+ self.__refreshState = 1 # 刷属性标记，初始需要刷新， 0-不需要刷新了，1-需要刷新
+ self.fightPower = 0 # 阵容总战力
+
+ self.__freeLineupHeroObjs = [] # 释放的空闲对象[LineupHero, ...]
+ self.__lineupHeroDict = {} # 刷新阵容后的武将信息 {posNum:LineupHero, ...}
+ return
+
+ def IsEmpty(self): return not self.__lineupHeroDict
+
+ def GetPosNumList(self): return self.__lineupHeroDict.keys()
+
+ def FreeLineupHero(self):
+ ## 释放阵容武将对象，重新计算
+ for freeObj in self.__lineupHeroDict.values():
+ if freeObj not in self.__freeLineupHeroObjs:
+ self.__freeLineupHeroObjs.append(freeObj)
+ self.__lineupHeroDict = {}
+ self.fightPower = 0
+ return
+
+ def GetLineupHero(self, posNum):
+ lineupHero = None
+ if posNum in self.__lineupHeroDict:
+ lineupHero = self.__lineupHeroDict[posNum]
+ elif self.__freeLineupHeroObjs:
+ lineupHero = self.__freeLineupHeroObjs.pop(0)
+ lineupHero.Clear()
+ self.__lineupHeroDict[posNum] = lineupHero
+ else:
+ lineupHero = LineupHero()
+ self.__lineupHeroDict[posNum] = lineupHero
+ return lineupHero
+
+ def GetLineupHeroByID(self, heroID):
+ lineupHero = None
+ for posNum in self.__lineupHeroDict.keys():
+ lineupHero = self.GetLineupHero(posNum)
+ if lineupHero.heroID == heroID:
+ return lineupHero
+ if False:
+ lineupHero = LineupHero()
+ return lineupHero
+
+ def SetNeedRefreshState(self):
+ ## 设置需要刷属性
+ self.__refreshState = 1
+ return
+
+ def RefreshLineupAttr(self, refreshForce=False):
+ self.__refreshState = 1 # 标记要刷新
+ if refreshForce:
+ self.CheckRefreshLineupAttr()
+ return
+
+ def CheckRefreshLineupAttr(self):
+ ## 检查刷新阵容属性
+ if not self.__refreshState:
+ return False
+ self.__refreshState = 0
+ doRefreshLineupAttr(self.olPlayer.curPlayer, self.olPlayer, self)
+ return True
+
class OnlinePlayer():
- ## 准在线玩家临时数据
+ ## 玩家在线临时数据，主要时数据的缓存，逻辑可不在类中处理，方便重读脚本时测试
def __init__(self, playerID):
self.playerID = playerID
+ self.curPlayer = None
+
+ # 属性、阵容
+ self._calcAttrDict = {} # 功能点属性统计 {calcIndex:{attrID:value, ...}, ...}
+ self._calcSpecEffDict = {} # 功能点特殊效果统计 {calcIndex:effInfo, ...}
+ self._heroPresetDict = {} # 武将预设方案公共数据 {heroPresetID:PresetHero, ...}
+ self._presetLineupDict = {} # 战斗预设方案阵容 {lineKey:PresetLineup, ...} lineKey 为 batPresetID 或者 (batPresetID, exclusiveMapID)
+
+ # 主线战斗
self.mainFight = TurnAttack.MainFight(playerID)
return
- def OnPlayerLogin(self, curPlayer):
- self.mainFight.playerLogin(curPlayer)
- return
-
- def OnPlayerOffline(self, curPlayer):
- self.mainFight.playerOffline(curPlayer)
- return
-
def OnClear(self):
- self.mainFight.clear()
+ self.mainFight.turnFight.exitFight()
+ return
+
+ def SetPlayer(self, curPlayer):
+ self.curPlayer = curPlayer
+ self.mainFight.turnFight.curPlayer = curPlayer
+ return
+
+ def IsRealOnline(self):
+ ## 是否真的在线
+ return self.curPlayer != None
+
+ def GetHeroPreset(self, heroPresetID):
+ ## 武将预设方案公共数据
+ if heroPresetID in self._heroPresetDict:
+ heroPreset = self._heroPresetDict[heroPresetID]
+ else:
+ heroPreset = PresetHero(heroPresetID)
+ self._heroPresetDict[heroPresetID] = heroPreset
+ return heroPreset
+
+ def GetPresetLineup(self, batPresetID, checkAttr=True, exclusiveMapID=0):
+ # @param checkAttr: 检查刷新到最新阵容属性
+ lineup = None
+ lineKey = batPresetID
+ if exclusiveMapID:
+ if exclusiveMapID in ChConfig.ExclusiveBatAttrMapIDList:
+ lineKey = (batPresetID, exclusiveMapID)
+ else:
+ exclusiveMapID = 0
+ if lineKey in self._presetLineupDict:
+ lineup = self._presetLineupDict[lineKey]
+ else:
+ lineup = PresetLineup(self.playerID, batPresetID, exclusiveMapID)
+ self._presetLineupDict[lineKey] = lineup
+ GameWorld.DebugLog("创建战斗方案: %s" % str(lineKey))
+
+ lineup.olPlayer = self
+ if checkAttr:
+ lineup.CheckRefreshLineupAttr()
+ return lineup
+
+ def GetCalcSpecInfo(self, calcIndex, presetID=0):
+ calcKey = (calcIndex, presetID) if presetID else calcIndex
+ return self._calcSpecEffDict.get(calcKey, {})
+ def GetCalcAttr(self, calcIndex, presetID=0):
+ calcKey = (calcIndex, presetID) if presetID else calcIndex
+ return self._calcAttrDict.get(calcKey, {})
+ def SetCalcAttr(self, calcIndex, attrDict, specEffInfo=None, presetID=0):
+ ## 设置某个功能点计算的属性
+ # @param specEffDict: 特殊效果缓存，功能自定义数据结构
+ calcKey = (calcIndex, presetID) if presetID else calcIndex
+ self._calcAttrDict[calcKey] = attrDict
+ if specEffInfo != None:
+ self._calcSpecEffDict[calcKey] = specEffInfo
+ return
+
+ def ReCalcAllAttr(self):
+ ## 重置所有功能点计算的属性，一般登录的时候调用一次即可，其他单功能刷新的话一般使用 RefreshRoleAttr
+ curPlayer = self.curPlayer
+ GameWorld.DebugLog("ReCalcAllAttr...", self.playerID)
+
+ self._calcAttrDict = {}
+ self._calcSpecEffDict = {}
+ self._heroPresetDict = {}
+ self._presetLineupDict = {}
+
+ doCalcAllAttr(curPlayer)
+ doReloadLineup(curPlayer, self)
+
+ #至少确保有主线战斗预设刷新，其他的可以用到再处理
+ mainBatPresetID = PlayerPreset.GetBatPresetID(self.curPlayer, ShareDefine.BatPreset_Main)
+ GameWorld.DebugLog("mainBatPresetID=%s" % mainBatPresetID, self.playerID)
+ self.GetPresetLineup(mainBatPresetID)
+ return
+
+ def GetHeroPresetIDList(self): return self._heroPresetDict.keys()
+ def GetBatPresetIDList(self):
+ presetIDList = []
+ for k in self._presetLineupDict.keys():
+ if isinstance(k, int):
+ presetIDList.append(k)
+ return presetIDList
+ def GetPresetLineupDict(self): return self._presetLineupDict
+
+ def RefreshByFuncPreset(self, funcPresetType, funcPresetID):
+ ## 刷新属性，由某个功能预设属性变更引起的刷新，需要同步刷新所有用到该功能预设的
+ curPlayer = self.curPlayer
+ GameWorld.DebugLog("请求刷功能预设属性变更: funcPresetType=%s,funcPresetID=%s" % (funcPresetType, funcPresetID), self.playerID)
+ for presetLineup in self._presetLineupDict.values():
+ batPresetID = presetLineup.batPresetID
+ if funcPresetID and funcPresetID != PlayerPreset.GetFuncPresetID(curPlayer, batPresetID, funcPresetType):
+ continue
+ presetLineup.RefreshLineupAttr()
+ return
+
+ def RefreshBatPreset(self, batPresetID):
+ ## 刷新某个全局战斗预设，一般是预设切换时需要重新刷新一下
+ GameWorld.DebugLog("请求刷全局预设方案属性: batPresetID=%s" % (batPresetID), self.playerID)
+ presetLineup = self.GetPresetLineup(batPresetID, False)
+ presetLineup.RefreshLineupAttr()
+ return
+
+ def RefreshRoleAttr(self, refreshForce=False, isAllLineup=False, exclusiveMapID=0):
+ '''刷新主公属性，影响主公属性的功能点属性变化时统一调用此函数
+ @param refreshForce: 是否强制立马刷新
+ @param isAllLineup: 是否只同步刷所有阵容属性，如果设置False则默认仅刷主阵容属性
+ '''
+ GameWorld.DebugLog("请求刷主公属性: refreshForce=%s,exclusiveMapID=%s" % (refreshForce, exclusiveMapID), self.playerID)
+
+ # 主公属性刷新时，所有阵容都要同步刷新
+ for lineup in self._presetLineupDict.values():
+ if exclusiveMapID and lineup.exclusiveMapID != exclusiveMapID:
+ # 有指定的话只要指定的即可
+ continue
+ lineup.SetNeedRefreshState()
+
+ if refreshForce:
+ self.DoRefreshRoleAttr(isAllLineup, exclusiveMapID)
+ return
+
+ def DoRefreshRoleAttr(self, isAllLineup=False, exclusiveMapID=0):
+ '''执行刷属性，默认只刷当前预设方案阵容，其他阵容可以用到的时候再刷新
+ @param isAllLineup: 是否刷所有阵容，如果设置False则默认仅刷当前预设方案阵容属性
+ @return: 是否有刷属性，0-无；1-有
+ '''
+
+ curPlayer = self.curPlayer
+ batPresetID = PlayerPreset.GetBatPresetID(curPlayer, ShareDefine.BatPreset_Main)
+
+ isRefresh = False
+ # 同步执行阵容属性刷新
+ for lineup in self._presetLineupDict.values():
+ if not isAllLineup:
+ # 有指定的话只要指定的即可
+ if exclusiveMapID:
+ if lineup.exclusiveMapID != exclusiveMapID:
+ continue
+
+ # 否则只刷当前预设方案，指定地图有效的也不需要刷
+ elif lineup.batPresetID != batPresetID or lineup.exclusiveMapID != 0:
+ continue
+ if lineup.CheckRefreshLineupAttr():
+ isRefresh = True
+
+ return isRefresh
+
+ def UpdHeroItemPreset(self, heroPresetID, heroItemDict, shapeType=0, isReload=False):
+ '''变更武将预设阵容时更新
+ @param heroPresetID: 武将预设ID
+ @param heroItemDict: 武将背包索引信息 {itemIndex:posNum, ...}
+ @param shapeType: 阵型
+ @param refreshForce: 是否强制刷属性
+ '''
+ curPlayer = self.curPlayer
+ heroPreset = self.GetHeroPreset(heroPresetID)
+ heroPreset.SetHeroItemPreset(curPlayer, heroItemDict, shapeType, isReload)
+ self.RefreshByFuncPreset(ShareDefine.FuncPreset_Hero, heroPresetID)
+
+ if not isReload:
+ PlayerHero.Sync_HeroPreset(curPlayer, heroPresetID)
+ return
+
+ def OnHeroItemUpate(self, heroItem):
+ '''某个武将物品变化时需要处理的逻辑
+ @param heroItem: 变化武将物品
+ '''
+ curPlayer = self.curPlayer
+ itemIndex = heroItem.GetItemPlaceIndex()
+ for heroPreset in self._heroPresetDict.values():
+ effCardAddPerBef = heroPreset.GetEffCardAddPer()
+
+ checkUpdEffHeroCard(curPlayer, heroPreset, heroItem)
+
+ effCardAddPerAft = heroPreset.GetEffCardAddPer()
+
+ if effCardAddPerBef == effCardAddPerAft:
+ continue
+ heroPresetID = heroPreset.heroPresetID
+ GameWorld.DebugLog("武将物品变化影响: itemIndex=%s,heroPresetID=%s,effCardAddPerBef=%s,effCardAddPerAft=%s"
+ % (itemIndex, heroPresetID, effCardAddPerBef, effCardAddPerAft), self.playerID)
+ self.RefreshByFuncPreset(ShareDefine.FuncPreset_Hero, heroPresetID)
+
return
class OnlineMgr():
@@ -57,7 +390,7 @@
else:
olPlayer = OnlinePlayer(playerID)
self.__onlinePlayerDict[playerID] = olPlayer
-
+ olPlayer.SetPlayer(curPlayer)
return olPlayer
def SetPlayerOnline(self, curPlayer):
@@ -69,7 +402,7 @@
self.__onlinePlayerDict[playerID] = olPlayer
else:
olPlayer = self.__onlinePlayerDict[playerID]
- olPlayer.OnPlayerLogin(curPlayer)
+ olPlayer.SetPlayer(curPlayer)
return
def SetPlayerOffline(self, curPlayer):
@@ -78,7 +411,7 @@
if playerID not in self.__onlinePlayerDict:
return
olPlayer = self.__onlinePlayerDict[playerID]
- olPlayer.OnPlayerOffline(curPlayer)
+ olPlayer.SetPlayer(None)
self.__offlinePlayerTimeDict[playerID] = int(time.time())
return
@@ -104,15 +437,768 @@
mgr = OnlineMgr()
PyGameData.g_onlineMgr = mgr
return mgr
-
+
+def GetOnlinePlayer(curPlayer): return GetOnlineMgr().GetOnlinePlayer(curPlayer)
+
def OnPlayerLogin(curPlayer):
+ ## 需登录逻辑最早调用
GetOnlineMgr().SetPlayerOnline(curPlayer)
return
def OnPlayerLogoff(curPlayer):
+ ## 需下线逻辑最后调用
GetOnlineMgr().SetPlayerOffline(curPlayer)
return
def OnMinute():
GetOnlineMgr().ProcessOffline()
return
+
+def CalcRoleBase(curPlayer):
+ playerID = curPlayer.GetID()
+ playerLV = curPlayer.GetLV()
+ lvIpyData = PlayerControl.GetPlayerLVIpyData(playerLV)
+
+ lvAttrDict = {}
+ if lvIpyData:
+ lvAttrDict = {ChConfig.AttrID_Atk:lvIpyData.GetAtk(),
+ ChConfig.AttrID_Def:lvIpyData.GetDef(),
+ ChConfig.AttrID_MaxHP:lvIpyData.GetMaxHP()
+ }
+
+ GameWorld.DebugLog("角色等级属性: %s" % lvAttrDict, playerID)
+ GetOnlinePlayer(curPlayer).SetCalcAttr(ChConfig.Def_CalcAttr_LV, lvAttrDict)
+ return
+
+def checkUpdEffHeroCard(curPlayer, heroPreset, heroItem, isNotify=True):
+ ## 玩家武将背包卡牌变更时调用
+ # @return: 加成是否变更
+ if not hasattr(heroItem, "GetItemPlaceIndex"):
+ return
+ if not curPlayer:
+ return
+ heroPresetID = heroPreset.heroPresetID
+ itemIndex = heroItem.GetItemPlaceIndex()
+ heroID = heroItem.GetItemTypeID()
+ curAddPer = getHeroCardAddPer(heroItem)
+ effAddPer, effItemIndex, inThis = heroPreset.GetHeroEffectiveCard(heroID)
+ curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
+ hisEffItem = curPack.GetAt(effItemIndex) if curPack.GetCount() > effItemIndex else None
+ if not hisEffItem or hisEffItem.IsEmpty():
+ GameWorld.DebugLog("历史生效的物品不在了，强制设置空! heroPresetID=%s,effAddPer=%s,effItemIndex=%s,inThis=%s" % (heroPresetID, effAddPer, effItemIndex, inThis))
+ effAddPer, effItemIndex, inThis = -1, -1, False
+
+ if itemIndex == effItemIndex:
+ if curAddPer == effAddPer:
+ GameWorld.DebugLog("生效的卡牌不变且加成也不变，不用处理! heroPresetID=%s,heroID=%s,itemIndex=%s,inThis=%s,effAddPer=%s,curAddPer=%s"
+ % (heroPresetID, heroID, itemIndex, inThis, effAddPer, curAddPer))
+ return
+ heroPreset.SetHeroEffectiveCard(heroID, curAddPer, itemIndex, inThis)
+ if curAddPer > effAddPer:
+ GameWorld.DebugLog("生效的卡牌不变且加成提升了! heroPresetID=%s,heroID=%s,itemIndex=%s,inThis=%s,effAddPer=%s,curAddPer=%s"
+ % (heroPresetID, heroID, itemIndex, inThis, effAddPer, curAddPer))
+ return
+ if inThis:
+ GameWorld.DebugLog("生效的卡牌效果加成降低了，但在主阵容中依旧保持生效! heroPresetID=%s,heroID=%s,itemIndex=%s,inThis=%s,effAddPer=%s,curAddPer=%s"
+ % (heroPresetID, heroID, itemIndex, inThis, effAddPer, curAddPer))
+ return
+ GameWorld.DebugLog("生效的卡牌效果加成降低了，未在主阵容中重新检索是否有加成更高的! heroPresetID=%s,heroID=%s,itemIndex=%s,inThis=%s,effAddPer=%s,curAddPer=%s"
+ % (heroPresetID, heroID, itemIndex, inThis, effAddPer, curAddPer))
+ curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
+ for index in range(curPack.GetCount()):
+ if index == itemIndex:
+ continue
+ packItem = curPack.GetAt(index)
+ if not packItem or packItem.IsEmpty():
+ continue
+ if heroID != packItem.GetItemTypeID():
+ continue
+ packCardPer = getHeroCardAddPer(packItem)
+ if packCardPer <= curAddPer:
+ continue
+ GameWorld.DebugLog("有更高加成的同名武将! heroPresetID=%s,heroID=%s,index=%s,packCardPer=%s > curAddPer=%s" % (heroPresetID, heroID, index, packCardPer, curAddPer))
+ checkUpdEffHeroCard(curPlayer, heroPreset, packItem, isNotify)
+ return
+
+ GameWorld.DebugLog("没有更高加成的同名武将，保留本卡生效! heroPresetID=%s,heroID=%s,itemIndex=%s,curAddPer=%s" % (heroPresetID, heroID, itemIndex, curAddPer))
+ return
+
+ if inThis:
+ GameWorld.DebugLog("没有在主阵容中且当前生效的卡牌在主阵容中不处理! heroPresetID=%s,heroID=%s,effItemIndex=%s,itemIndex=%s" % (heroPresetID, heroID, effItemIndex, itemIndex))
+ return
+
+ if curAddPer <= effAddPer:
+ GameWorld.DebugLog("都没有在主阵容中且不高于当前生效卡牌加成不处理! heroPresetID=%s,heroID=%s,itemIndex=%s,curAddPer=%s <= %s,effItemIndex=%s"
+ % (heroPresetID, heroID, itemIndex, curAddPer, effAddPer, effItemIndex))
+ return
+ GameWorld.DebugLog("都没有在主阵容中且高于当前生效卡牌加成替换生效卡牌! heroPresetID=%s,heroID=%s,itemIndex=%s,curAddPer=%s > %s,effItemIndex=%s"
+ % (heroPresetID, heroID, itemIndex, curAddPer, effAddPer, effItemIndex))
+ heroPreset.SetHeroEffectiveCard(heroID, curAddPer, itemIndex, inThis)
+
+ item = heroItem.GetItem()
+ item.AddUserAttr(ShareDefine.Def_IudetHeroEffPresetID, heroPresetID)
+ isNotify and heroItem.Sync_Item()
+
+ if effItemIndex >= 0:
+ curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
+ hisEffItem = curPack.GetAt(effItemIndex) if curPack.GetCount() > effItemIndex else None
+ if hisEffItem and not hisEffItem.IsEmpty():
+ item = hisEffItem.GetItem()
+ item.DelUserAttr(ShareDefine.Def_IudetHeroEffPresetID, heroPresetID)
+ isNotify and hisEffItem.Sync_Item()
+
+ return
+
+def reloadEffHeroCard(curPlayer, heroPreset):
+ ## 重新检查载入生效的卡牌，一般用于比较复杂的情况，直接重新遍历一遍，如登录时、重新保存主阵容时
+ playerID = curPlayer.GetPlayerID()
+ heroPresetID = heroPreset.heroPresetID
+ hisEffCardIndexList = [] # 历史生效的卡牌 [index, ...]
+ updEffectiveCardDict = {} # 更新生效的卡牌 {heroID:[cardAddPer, itemIndex, inThis], ...}
+ curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
+ GameWorld.DebugLog("重新检查载入生效的卡牌: heroPresetID=%s" % (heroPresetID), playerID)
+ for index in range(curPack.GetCount()):
+ heroItem = curPack.GetAt(index)
+ if not heroItem or heroItem.IsEmpty():
+ continue
+
+ inThis = False # 是否在此预设中
+ lineupCount = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroLineup)
+ for lpIndex in range(lineupCount):
+ lineupValue = heroItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroLineup, lpIndex)
+ if PlayerHero.GetLineupValue(lineupValue)[0] == heroPresetID:
+ inThis = True
+ break
+
+ heroID = heroItem.GetItemTypeID()
+ cardAddPer = getHeroCardAddPer(heroItem)
+
+ hisEffPresetIDList = PlayerHero.GetHeroEffPresetIDList(heroItem)
+ # 历史生效的
+ if heroPresetID in hisEffPresetIDList:
+ hisEffCardIndexList.append(index)
+
+ # 最新生效的: 主阵容中的优先生效，非主阵容中的最高加成的生效
+ if inThis:
+ updEffectiveCardDict[heroID] = [cardAddPer, index, inThis]
+ else:
+ effInfo = updEffectiveCardDict.get(heroID, [-1, -1, False])
+ if effInfo[2] == True:
+ pass #GameWorld.Log(" 已经有在阵容中的生效卡了: index=%s" % effInfo[1])
+ elif cardAddPer > effInfo[0]:
+ updEffectiveCardDict[heroID] = [cardAddPer, index, inThis]
+
+ # 更新生效变更的卡牌
+ syncItemDict = {} # 需要同步的异常物品 {index:heroItem, ...}
+ GameWorld.DebugLog(" 历史生效的卡牌索引: %s,%s" % (len(hisEffCardIndexList), hisEffCardIndexList), playerID)
+ GameWorld.DebugLog(" 最新生效的卡牌信息: %s,%s" % (len(updEffectiveCardDict), updEffectiveCardDict), playerID)
+ cardPerTotal = 0
+ heroPreset.SetEffectiveCardDict(updEffectiveCardDict)
+ for heroID, effInfo in updEffectiveCardDict.items():
+ cardAddPer, itemIndex, inThis = effInfo
+ cardPerTotal += cardAddPer
+ if itemIndex in hisEffCardIndexList:
+ hisEffCardIndexList.remove(itemIndex) # 不变的直接移除，剩余未移除的就是失效的
+ #GameWorld.DebugLog(" 生效的卡牌不变的: heroID=%s,itemIndex=%s,inThis=%s,cardAddPer=%s,cardPerTotal=%s" % (heroID, itemIndex, inThis, cardAddPer, cardPerTotal), playerID)
+ else:
+ GameWorld.DebugLog(" 生效的卡牌变化的: heroID=%s,itemIndex=%s,inThis=%s,cardAddPer=%s,cardPerTotal=%s" % (heroID, itemIndex, inThis, cardAddPer, cardPerTotal), playerID)
+ heroItem = curPack.GetAt(itemIndex)
+ item = heroItem.GetItem()
+ item.AddUserAttr(ShareDefine.Def_IudetHeroEffPresetID, heroPresetID)
+ syncItemDict[itemIndex] = heroItem
+
+ # 移除历史失效的卡牌
+ GameWorld.DebugLog(" 移除失效的卡牌索引: %s" % hisEffCardIndexList, playerID)
+ for itemIndex in hisEffCardIndexList:
+ heroItem = curPack.GetAt(itemIndex)
+ item = heroItem.GetItem()
+ item.DelUserAttr(ShareDefine.Def_IudetHeroEffPresetID, heroPresetID)
+ syncItemDict[itemIndex] = heroItem
+
+ GameWorld.DebugLog(" 最终生效卡牌加成: %s,heroPresetID=%s" % (cardPerTotal, heroPresetID), playerID)
+
+ # 同步变更的物品
+ for syncItem in syncItemDict.values():
+ syncItem.Sync_Item()
+
+ return
+
+def getHeroCardAddPer(heroItem):
+ ## 获取该武将卡的卡牌加成
+ heroID = heroItem.GetItemTypeID()
+ heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
+ if not heroIpyData:
+ return 0
+ quality = heroIpyData.GetQuality()
+ qualityIpyData = IpyGameDataPY.GetIpyGameData("HeroQuality", quality)
+ if not qualityIpyData:
+ return 0
+
+ heroLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroLV)
+ star = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)
+ breakLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV)
+
+ starMax = PlayerHero.GetHeroStarMax(heroItem)
+ addPer = qualityIpyData.GetInitAddPer()
+ addPer += qualityIpyData.GetLVAddPer() * max(0, heroLV - 1)
+ addPer += qualityIpyData.GetBreakLVAddPer() * breakLV
+ addPer += qualityIpyData.GetStarAddPer() * min(star, starMax)
+ return addPer
+
+def doReloadLineup(curPlayer, olPlayer):
+ ## 重新载入阵容
+ herpPresetIpyDataList = IpyGameDataPY.GetIpyGameDataList("PresetUnlock", ShareDefine.FuncPreset_Hero)
+ if not herpPresetIpyDataList:
+ return
+ presetIDMax = len(herpPresetIpyDataList) # 最大可用的武将阵容方案ID
+ funcPresetType = ShareDefine.FuncPreset_Hero
+ presetDict = {} # {预设ID:{itemIndex:posNum, ...}, ...}
+ shapeTypeDict = {} # {预设ID:阵型, ...}
+ syncItemDict = {} # 需要同步的异常物品 {index:heroItem, ...}
+ 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
+ delValueList = []
+ for lpIndex in range(lineupCount)[::-1]:
+ lineupValue = heroItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroLineup, lpIndex)
+ heroPresetID, shapeType, posNum = PlayerHero.GetLineupValue(lineupValue)
+ if not heroPresetID or heroPresetID > presetIDMax or not PlayerPreset.GetFuncPresetIDState(curPlayer, heroPresetID, funcPresetType):
+ GameWorld.DebugLog("异常或不可用的武将预设方案ID: index=%s,heroPresetID=%s,lineupValue=%s" % (index, heroPresetID, lineupValue))
+ delValueList.append(lineupValue)
+ continue
+ # 任意取一个武将保存的阵型即可，同阵容的武将理论上保存的阵型是一样的
+ if heroPresetID not in shapeTypeDict:
+ shapeTypeDict[heroPresetID] = shapeType
+ if heroPresetID not in presetDict:
+ presetDict[heroPresetID] = {}
+ heroItemDict = presetDict[heroPresetID]
+
+ # 超出人数限制或位置异常
+ if len(heroItemDict) >= ShareDefine.LineupObjMax or posNum in heroItemDict.values() or index in heroItemDict:
+ delValueList.append(lineupValue)
+ else:
+ heroItemDict[index] = posNum
+
+ if delValueList:
+ item = heroItem.GetItem()
+ for lineupValue in delValueList:
+ item.DelUserAttr(ShareDefine.Def_IudetHeroLineup, lineupValue)
+ syncItemDict[index] = heroItem
+
+ # 同步变更的物品
+ for syncItem in syncItemDict.values():
+ syncItem.Sync_Item()
+
+ GameWorld.DebugLog("重载武将预设阵容: %s" % presetDict, curPlayer.GetPlayerID())
+ for heroPresetID, heroItemDict in presetDict.items():
+ shapeType = shapeTypeDict.get(heroPresetID, 0)
+ olPlayer.UpdHeroItemPreset(heroPresetID, heroItemDict, shapeType, isReload=True)
+
+ PlayerHero.Sync_HeroPreset(curPlayer)
+ return
+
+def doCalcAllAttr(curPlayer):
+ ## 计算所有属性
+ GameWorld.DebugLog("doCalcAllAttr...", curPlayer.GetPlayerID())
+ CalcRoleBase(curPlayer)
+ ChEquip.CalcRoleEquipAttr(curPlayer)
+ PlayerHero.CalcHeroAddAttr(curPlayer)
+ PlayerPrestigeSys.CalcOfficialRankAttr(curPlayer)
+ PlayerGubao.CalcGubaoAttr(curPlayer)
+ PlayerHJG.CalcHJGAttr(curPlayer)
+ PlayerHorse.CalcHorseAttr(curPlayer)
+ PlayerBeauty.CalcBeautyAttr(curPlayer)
+ PlayerMingge.CalcMinggeAttr(curPlayer)
+ GameLogic_Dingjunge.CalcDingjungeAttr(curPlayer)
+ return
+
+def doRefreshLineupAttr(curPlayer, olPlayer, presetLineup):
+ ''' 刷新某个阵容属性
+ 基础属性-面板显示：
+ 1.全体基础固定值=所有穿戴装备【装备基础固定值】+【法宝基础固定值】+【红颜基础固定值】+【其它模块的固定值】
+ 2.全体百分比加成=图鉴加成+【灵兽模块】+【红颜模块】+【其它模块】+所有上阵卡牌【初始加成+升级加成+突破加成+吞噬加成】
+ 3.卡牌继承比例=卡牌品质及职业继承比例不同
+ 4.卡牌自身培养加成=【羁绊加成%+突破词条加成%+天赋加成%】
+ 最终面板生命=【E全体基础固定值】*【1+E全体百分比加成】*【卡牌自身继承比例+ 卡牌自身培养%加成】+【卡牌自身固定值】
+
+ 战斗属性/战斗抗性/特殊属性-面板显示：
+ 1.全体战斗属性值=所有穿戴装备【装备战斗属性值】+【法宝战斗属性值】+【红颜战斗属性值】+【其它模块的战斗属性】
+ 2.卡牌继承比例=默认100%
+ 3.卡牌自身培养战斗属性=【卡牌初始战斗属性+突破词条战斗属性+天赋战斗属性+觉醒战斗属性】+【法则洗炼】+【秘能装备】+【其它模块】
+ 最终面板战斗属性=【E全体战斗属性值】*【卡牌继承比例】+【卡牌自身培养战斗属性】
+ '''
+ playerID = curPlayer.GetPlayerID()
+ batPresetID = presetLineup.batPresetID
+ exclusiveMapID = presetLineup.exclusiveMapID
+
+ heroPresetID = PlayerPreset.GetFuncPresetID(curPlayer, batPresetID, ShareDefine.FuncPreset_Hero)
+ mgPresetID = PlayerPreset.GetFuncPresetID(curPlayer, batPresetID, ShareDefine.FuncPreset_Mingge)
+
+ heroPreset = olPlayer.GetHeroPreset(heroPresetID)
+ heroItemDict = heroPreset.heroItemDict
+
+ GameWorld.DebugLog("刷新战斗预设方案属性: batPresetID=%s,exclusiveMapID=%s" % (batPresetID, exclusiveMapID), playerID)
+ GameWorld.DebugLog(" heroPresetID=%s,itemIndex-posNum : %s" % (heroPresetID, heroItemDict), playerID)
+
+ presetLineup.FreeLineupHero()
+
+ # 因为同阵容的武将ID不能重复，所以字典key可以用武将ID
+ countryHeroInfo = {} # 国家武将统计 {country:[heroID, ...], ...}
+ fetterHeroInfo = {} # 阵容羁绊武将统计信息 {fetterID:[heroID, ...], ...}
+ heroSelfAttrInfo = {} # 武将自身属性 {heroID:{attrID:value, ...}, ...}
+ heroLVAttrInfo = {} # 武将等级属性 {heroID:{attrID:value, ...}, ...}
+ heroStarTalentInfo = {} # 武将星级天赋属性 {heroID:{attrID:value, ...}, ...}
+ heroBreakAttrInfo = {} # 武将突破潜能属性 {heroID:{attrID:value, ...}, ...}
+ heroAwakeTalentInfo = {} # 武将觉醒天赋属性 {heroID:{attrID:value, ...}, ...}
+
+ curPack = curPlayer.GetItemManager().GetPack(ShareDefine.rptHero)
+ for itemIndex, posNum in heroItemDict.items():
+ if itemIndex < 0 or itemIndex >= curPack.GetCount():
+ continue
+ heroItem = curPack.GetAt(itemIndex)
+ if not heroItem or heroItem.IsEmpty():
+ continue
+ heroID = heroItem.GetItemTypeID()
+ heroIpyData = IpyGameDataPY.GetIpyGameData("Hero", heroID)
+ if not heroIpyData:
+ continue
+ quality = heroIpyData.GetQuality()
+ qualityIpyData = IpyGameDataPY.GetIpyGameData("HeroQuality", quality)
+ if not qualityIpyData:
+ continue
+
+ heroLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroLV)
+ #star = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroStar)
+ breakLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroBreakLV)
+ awakeLV = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroAwakeLV)
+ skinIndex = heroItem.GetUserAttr(ShareDefine.Def_IudetHeroSkin)
+
+ skinID = 0
+ skinIDList = heroIpyData.GetSkinIDList()
+ if skinIndex < 0 or skinIndex >= len(skinIDList):
+ skinID = skinIDList[skinIndex]
+ elif skinIDList:
+ skinID = skinIDList[0]
+
+ lineupHero = presetLineup.GetLineupHero(posNum)
+ #if False:
+ # lineupHero = LineupHero()
+ lineupHero.itemIndex = itemIndex
+ lineupHero.posNum = posNum
+ lineupHero.heroID = heroID
+ lineupHero.skinID = skinID
+ lineupHero.heroBatAttrDict = {}
+ lineupHero.heroSkillIDList = []
+ lineupHero.fightPower = 0
+
+ normalSkillID = heroIpyData.GetNormalSkillID()
+ angerSkillID = heroIpyData.GetAngerSkillID()
+ lineupHero.heroSkillIDList.extend([normalSkillID, angerSkillID])
+
+ # 自身属性
+ selfAttrDict = {}
+ selfAttrDict.update({ChConfig.AttrID_AtkInheritPer:heroIpyData.GetAtkInheritPer(),
+ ChConfig.AttrID_DefInheritPer:heroIpyData.GetDefInheritPer(),
+ ChConfig.AttrID_HPInheritPer:heroIpyData.GetHPInheritPer(),
+ })
+ for k, v in heroIpyData.GetBatAttrDict().items():
+ selfAttrDict[int(k)] = v
+ heroSelfAttrInfo[heroID] = selfAttrDict
+
+ # 等级属性
+ heroLVAttrDict = {}
+ heroLVIpyData = IpyGameDataPY.GetIpyGameData("HeroQualityLV", quality, heroLV)
+ if heroLVIpyData:
+ attrIDList = heroLVIpyData.GetAttrIDList()
+ attrValueList = heroLVIpyData.GetAttrValueList()
+ for aIndex in range(min(len(attrIDList), len(attrValueList))):
+ attrID = attrIDList[aIndex]
+ attrValue = attrValueList[aIndex]
+ heroLVAttrDict[attrID] = heroLVAttrDict.get(attrID, 0) + attrValue
+ heroLVAttrInfo[heroID] = heroLVAttrDict
+
+ # 突破潜能
+ breakAttrDict = {}
+ breakIpyDataList = IpyGameDataPY.GetIpyGameDataList("HeroBreak", heroID)
+ if breakIpyDataList:
+ for breakIpyData in breakIpyDataList:
+ if breakIpyData.GetBreakLV() > breakLV:
+ break
+ attrIDList = breakIpyData.GetAttrIDList()
+ attrValueList = breakIpyData.GetAttrValueList()
+ for aIndex in range(min(len(attrIDList), len(attrValueList))):
+ attrID = attrIDList[aIndex]
+ attrValue = attrValueList[aIndex]
+ breakAttrDict[attrID] = breakAttrDict.get(attrID, 0) + attrValue
+ skillID = breakIpyData.GetSkillID()
+ skillIDExList = breakIpyData.GetSkillIDExList()
+ if skillID:
+ lineupHero.heroSkillIDList.append(skillID)
+ if skillIDExList:
+ lineupHero.heroSkillIDList += skillIDExList
+
+ heroBreakAttrInfo[heroID] = breakAttrDict
+
+ # 觉醒天赋
+ maxUnlockSlot = IpyGameDataPY.GetFuncCfg("HeroStarTalent", 1) # 常规天赋槽个数
+ awakeTalentAttrDict = {}
+ awakeIpyDataList = IpyGameDataPY.GetIpyGameDataListNotLog("HeroAwake", heroID)
+ if awakeIpyDataList:
+ for awakeIpyData in awakeIpyDataList:
+ if awakeIpyData.GetAwakeLV() > awakeLV:
+ break
+ unlockTalentSlot = awakeIpyData.GetUnlockTalentSlot()
+ maxUnlockSlot = max(maxUnlockSlot, unlockTalentSlot)
+ attrIDList = awakeIpyData.GetAttrIDList()
+ attrValueList = awakeIpyData.GetAttrValueList()
+ for aIndex in range(min(len(attrIDList), len(attrValueList))):
+ attrID = attrIDList[aIndex]
+ attrValue = attrValueList[aIndex]
+ awakeTalentAttrDict[attrID] = awakeTalentAttrDict.get(attrID, 0) + attrValue
+ skillID = awakeIpyData.GetSkillID()
+ if skillID:
+ lineupHero.heroSkillIDList.append(skillID)
+ heroAwakeTalentInfo[heroID] = awakeTalentAttrDict
+
+ # 星级天赋
+ starTalentAttrDict = {}
+ idCount = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentID)
+ lvCount = heroItem.GetUserAttrCount(ShareDefine.Def_IudetHeroTalentIDLV)
+ for aIndex in range(min(idCount, lvCount, maxUnlockSlot)): # 重生导致已觉醒槽位失效时属性也无效
+ talentID = heroItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentID, aIndex)
+ talentLV = heroItem.GetUserAttrByIndex(ShareDefine.Def_IudetHeroTalentIDLV, aIndex)
+ stIpyData = IpyGameDataPY.GetIpyGameData("HeroTalent", talentID)
+ if not stIpyData:
+ continue
+ attrID = stIpyData.GetAttrID()
+ attrValue = stIpyData.GetAttrValue() * talentLV
+ starTalentAttrDict[attrID] = starTalentAttrDict.get(attrID, 0) + attrValue
+ heroStarTalentInfo[heroID] = starTalentAttrDict
+
+ # 羁绊统计
+ for fetterID in heroIpyData.GetFetterIDList():
+ if fetterID not in fetterHeroInfo:
+ fetterHeroInfo[fetterID] = []
+ fetterHeroIDList = fetterHeroInfo[fetterID]
+ if heroID not in fetterHeroIDList:
+ fetterHeroIDList.append(heroID)
+
+ # 国家统计
+ country = heroIpyData.GetCountry()
+ if country not in countryHeroInfo:
+ countryHeroInfo[country] = []
+ countryHeroIDList = countryHeroInfo[country]
+ if heroID not in countryHeroIDList:
+ countryHeroIDList.append(heroID)
+
+ # 羁绊属性 - 仅羁绊相关武将有效
+ heroFetterAttrInfo = {} # 武将羁绊属性 {heroID:{attrID:value, ...}, ...}
+ for fetterID, fetterHeroIDList in fetterHeroInfo.items():
+ fetterIpyData = IpyGameDataPY.GetIpyGameData("HeroFetter", fetterID)
+ if not fetterIpyData:
+ continue
+ needHeroIDList = fetterIpyData.GetHeroIDList()
+ canFetter = True
+ for needHeroID in needHeroIDList:
+ if needHeroID not in fetterHeroIDList:
+ canFetter = False
+ break
+ if not canFetter:
+ continue
+ attrIDList = fetterIpyData.GetAttrIDList()
+ attrValueList = fetterIpyData.GetAttrValueList()
+ for aIndex in range(min(len(attrIDList), len(attrValueList))):
+ attrID = attrIDList[aIndex]
+ attrValue = attrValueList[aIndex]
+ for heroID in needHeroIDList:
+ if heroID not in heroFetterAttrInfo:
+ heroFetterAttrInfo[heroID] = {}
+ heroFetterAttrDict = heroFetterAttrInfo[heroID]
+ heroFetterAttrDict[attrID] = heroFetterAttrDict.get(attrID, 0) + attrValue
+
+ # 阵容属性 - 阵容所有武将有效
+ lineupHaloAttrInfo = {} # 阵容光环属性 {attrID:value, ...}
+ for country, countryHeroIDList in countryHeroInfo.items():
+ haloIpyDataList = IpyGameDataPY.GetIpyGameDataList("HeroLineupHalo", country)
+ if not haloIpyDataList:
+ continue
+
+ attrIDList, attrValueList = [], []
+ countryHeroCnt = len(countryHeroIDList)
+ for haloIpyData in haloIpyDataList:
+ needHeroCount = haloIpyData.GetNeedHeroCount()
+ if countryHeroCnt < needHeroCount:
+ break
+ attrIDList = haloIpyData.GetAttrIDList()
+ attrValueList = haloIpyData.GetAttrValueList()
+ # 每个国家最多仅生效一条属性，不同国家属性可叠加
+ for aIndex in range(min(len(attrIDList), len(attrValueList))):
+ attrID = attrIDList[aIndex]
+ attrValue = attrValueList[aIndex]
+ lineupHaloAttrInfo[attrID] = lineupHaloAttrInfo.get(attrID, 0) + attrValue
+
+ # --------------------------- 上面统计好了，下面计算武将最终属性 --------------------------------
+ baseAttrFormula = IpyGameDataPY.GetFuncCfg("HeroAttrFormula", 1)
+ otherAttrFormula = IpyGameDataPY.GetFuncCfg("HeroAttrFormula", 2)
+ fightPowerFormula = IpyGameDataPY.GetFuncCfg("HeroAttrFormula", 3)
+ skillFPFormula = IpyGameDataPY.GetFuncCfg("HeroAttrFormula", 4)
+
+ lvAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_LV)
+ equipAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_MainEquip)
+ fatesAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_HeroFates)
+ realmAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_Realm)
+ gubaoAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_Gubao)
+ hjgAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_HJG)
+ horseAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_Horse)
+ beautyAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_Beauty)
+ minggeAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_Mingge, mgPresetID)
+ mgSkillLVDict = olPlayer.GetCalcSpecInfo(ChConfig.Def_CalcAttr_Mingge, mgPresetID)
+ dingjungeAttrDict = olPlayer.GetCalcAttr(ChConfig.Def_CalcAttr_Dingjunge) if exclusiveMapID == ChConfig.Def_FBMapID_Dingjunge else {}
+
+ GameWorld.DebugLog(" 国家武将统计=%s" % countryHeroInfo, playerID)
+ GameWorld.DebugLog(" 羁绊武将统计=%s" % fetterHeroInfo, playerID)
+ GameWorld.DebugLog(" 武将自身属性=%s" % heroSelfAttrInfo, playerID)
+ GameWorld.DebugLog(" 武将等级属性=%s" % heroLVAttrInfo, playerID)
+ GameWorld.DebugLog(" 武将吞噬属性=%s" % heroStarTalentInfo, playerID)
+ GameWorld.DebugLog(" 武将突破潜能=%s" % heroBreakAttrInfo, playerID)
+ GameWorld.DebugLog(" 武将觉醒天赋=%s" % heroAwakeTalentInfo, playerID)
+ GameWorld.DebugLog(" 武将羁绊属性=%s" % heroFetterAttrInfo, playerID)
+ GameWorld.DebugLog(" 阵容光环属性=%s" % lineupHaloAttrInfo, playerID)
+
+ GameWorld.DebugLog(" 主公等级属性=%s" % lvAttrDict, playerID)
+ GameWorld.DebugLog(" 主公装备属性=%s" % equipAttrDict, playerID)
+ GameWorld.DebugLog(" 主公宿缘属性=%s" % fatesAttrDict, playerID)
+ GameWorld.DebugLog(" 主公官职属性=%s" % realmAttrDict, playerID)
+ GameWorld.DebugLog(" 主公古宝属性=%s" % gubaoAttrDict, playerID)
+ GameWorld.DebugLog(" 主幻境阁属性=%s" % hjgAttrDict, playerID)
+ GameWorld.DebugLog(" 主公坐骑属性=%s" % horseAttrDict, playerID)
+ GameWorld.DebugLog(" 主公红颜属性=%s" % beautyAttrDict, playerID)
+ GameWorld.DebugLog(" 主公命格属性=%s,技能:%s,mgPresetID=%s" % (minggeAttrDict, mgSkillLVDict, mgPresetID), playerID)
+ GameWorld.DebugLog(" 定军专属属性=%s" % dingjungeAttrDict, playerID)
+ effCardAddPer = heroPreset.GetEffCardAddPer()
+ effCardAddPer /= 10000.0
+ GameWorld.DebugLog(" 主公卡牌加成=%s" % effCardAddPer, playerID)
+
+ PlayerLV = curPlayer.GetLV()
+ OfficialLV = curPlayer.GetOfficialRank()
+ GameWorld.DebugLog(" PlayerLV=%s,OfficialLV=%s" % (PlayerLV, OfficialLV), playerID)
+
+ mgSkillFightPower = 0
+ for skillTypeID, skillLV in mgSkillLVDict.items():
+ skillID = SkillCommon.GetSkillIDBySkillTypeID(skillTypeID, skillLV)
+ skillData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
+ if not skillData:
+ continue
+ paramDict = {"SkillPower":skillData.GetFightPower(), "PlayerLV":PlayerLV, "OfficialLV":OfficialLV}
+ sFightPower = FormulaControl.Eval("skillFPFormula", skillFPFormula, paramDict, toInt=True)
+ mgSkillFightPower += sFightPower
+ if mgSkillLVDict:
+ GameWorld.DebugLog(" 命格技能战力=%s,mgSkillLVDict=%s" % (mgSkillFightPower, mgSkillLVDict), playerID)
+
+ fpRatioIpyData = IpyGameDataPY.GetIpyGameData("FightPowerRatio", OfficialLV)
+
+ lineupFightPower = 0 # 阵容总战力
+ lineupFightPower += mgSkillFightPower
+
+ for heroID, selfAttrDict in heroSelfAttrInfo.items():
+ lineupHero = presetLineup.GetLineupHeroByID(heroID)
+ if not lineupHero:
+ continue
+ lineupHero.heroBatAttrDict = {}
+ lineupHero.fightPower = 0
+
+ heroLVAttrDict = heroLVAttrInfo.get(heroID, {})
+ starTalentAttrDict = heroStarTalentInfo.get(heroID, {})
+ breakAttrDict = heroBreakAttrInfo.get(heroID, {})
+ awakeTalentAttrDict = heroAwakeTalentInfo.get(heroID, {})
+ fetterAttrDict = heroFetterAttrInfo.get(heroID, {})
+
+ logAttrDict = {}
+ fightPowerParamDict = {}
+ for attrID in ChConfig.CalcBattleAttrIDList:
+ attrPerID = ChConfig.AttrPerDict.get(attrID, 0) # 对应百分比提升的属性ID
+
+ lvValue = lvAttrDict.get(attrID, 0)
+ equipValue = equipAttrDict.get(attrID, 0)
+
+ cardPer = 0 # 卡牌加成，仅对基础三维有用
+ if attrID in ChConfig.BaseAttrIDList:
+ cardPer = effCardAddPer
+
+ fatesValue = fatesAttrDict.get(attrID, 0)
+ fatesPer = fatesAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
+
+ realmValue = realmAttrDict.get(attrID, 0)
+ realmPer = realmAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
+
+ gubaoValue = gubaoAttrDict.get(attrID, 0)
+ gubaoPer = gubaoAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
+
+ hjgValue = hjgAttrDict.get(attrID, 0)
+ hjgPer = hjgAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
+
+ horseValue = horseAttrDict.get(attrID, 0)
+ horsePer = horseAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
+
+ beautyValue = beautyAttrDict.get(attrID, 0)
+ beautyPer = beautyAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
+
+ minggeValue = minggeAttrDict.get(attrID, 0)
+ minggePer = minggeAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
+
+ dingjungeValue = dingjungeAttrDict.get(attrID, 0)
+ dingjungePer = dingjungeAttrDict.get(attrPerID, 0) / 10000.0 if attrPerID else 0
+
+ heroSelfValue, heroSelfPer = selfAttrDict.get(attrID, 0), 0 # 武将自身基值
+ inheritPer = 1 # 继承比例，默认100%
+ if attrID in ChConfig.AttrInheritPerDict:
+ attrInheritPerID = ChConfig.AttrInheritPerDict[attrID] # 继承ID
+ inheritPer = selfAttrDict.get(attrInheritPerID, 10000) # 继承比例从武将自身属性中取
+ inheritPer /= 10000.0
+
+ lineupHaloValue, lineupHaloPer = lineupHaloAttrInfo.get(attrID, 0), 0
+ fetterValue, fetterPer = fetterAttrDict.get(attrID, 0), 0
+ heroLVValue, heroLVPer = heroLVAttrDict.get(attrID, 0), 0
+ starTalentValue, starTalentPer = starTalentAttrDict.get(attrID, 0), 0
+ breakLVValue, breakLVPer = breakAttrDict.get(attrID, 0), 0
+ awakeTalentValue, awakeTalentPer = awakeTalentAttrDict.get(attrID, 0), 0
+ if attrPerID:
+ heroSelfPer = selfAttrDict.get(attrPerID, 0) / 10000.0
+ lineupHaloPer = lineupHaloAttrInfo.get(attrPerID, 0) / 10000.0
+ fetterPer = fetterAttrDict.get(attrPerID, 0) / 10000.0
+ heroLVPer = heroLVAttrDict.get(attrPerID, 0) / 10000.0
+ starTalentPer = starTalentAttrDict.get(attrPerID, 0) / 10000.0
+ breakLVPer = breakAttrDict.get(attrPerID, 0) / 10000.0
+ awakeTalentPer = awakeTalentAttrDict.get(attrPerID, 0) / 10000.0
+
+ # 计算
+ attrParamDict = {"lvValue":lvValue, "equipValue":equipValue, "realmValue":realmValue, "realmPer":realmPer, "cardPer":cardPer,
+ "gubaoValue":gubaoValue, "gubaoPer":gubaoPer, "hjgValue":hjgValue, "hjgPer":hjgPer, "horseValue":horseValue, "horsePer":horsePer,
+ "beautyValue":beautyValue, "beautyPer":beautyPer, "fatesValue":fatesValue, "fatesPer":fatesPer,
+ "dingjungeValue":dingjungeValue, "dingjungePer":dingjungePer, "minggeValue":minggeValue, "minggePer":minggePer,
+ "heroSelfValue":heroSelfValue, "heroSelfPer":heroSelfPer, "inheritPer":inheritPer, "heroLVValue":heroLVValue, "heroLVPer":heroLVPer,
+ "lineupHaloValue":lineupHaloValue, "lineupHaloPer":lineupHaloPer, "fetterValue":fetterValue, "fetterPer":fetterPer,
+ "starTalentValue":starTalentValue, "starTalentPer":starTalentPer, "breakLVValue":breakLVValue, "breakLVPer":breakLVPer,
+ "awakeTalentValue":awakeTalentValue, "awakeTalentPer":awakeTalentPer,
+ }
+ #testDict = {'lineupHaloPer': 0.1, 'minggeValue': 43685, 'heroLVValue': 836851, 'cardPer': 72.276, 'realmValue': 9878456, 'fetterPer': 0.15, 'horseValue': 5040, 'equipValue': 18381400, 'inheritPer': 1.4, 'lvValue': 53600}
+ #testDict = {'inheritPer': 1, 'minggeValue': 905, 'equipValue': 796}
+ #for k in attrParamDict.keys():
+ # v = testDict.get(k, 0)
+ # exec("%s = %s" % (k, v))
+ # attrParamDict[k] = v
+ if attrID in ChConfig.BaseAttrIDList:
+ attrValue = FormulaControl.Eval("baseAttrFormula", baseAttrFormula, attrParamDict, toInt=False, ndigits=2)
+ #GameWorld.DebugLog(" evalValue=%s,attrValue=%s" % (eval(baseAttrFormula), attrValue))
+ else:
+ attrValue = FormulaControl.Eval("otherAttrFormula", otherAttrFormula, attrParamDict, toInt=False, ndigits=2)
+ #GameWorld.DebugLog(" evalValue=%s,attrValue=%s" % (eval(otherAttrFormula), attrValue))
+ # 前端对比刷属性明细时需要
+ if g_calcDetail and attrValue > 0:
+ calcParamDict = {}
+ for k, v in attrParamDict.items():
+ if not v or (k == "inheritPer" and v == 1):
+ continue
+ calcParamDict[k] = v
+ GameWorld.DebugLogEx(" heroID=%s,attrID=%s,attrValue=%s,%s", heroID, attrID, attrValue, calcParamDict)
+
+ attrIpyData = IpyGameDataPY.GetIpyGameData("PlayerAttr", attrID)
+ attrName = attrIpyData.GetParameter() if attrIpyData else "%s" % attrID
+ attrRatioName = "%sRatio" % attrName
+ ratioValue = 0
+ if attrValue and hasattr(fpRatioIpyData, "Get%s" % attrRatioName):
+ ratioValue = getattr(fpRatioIpyData, "Get%s" % attrRatioName)()
+ fightPowerParamDict[attrName] = attrValue
+ fightPowerParamDict[attrRatioName] = ratioValue
+ if attrValue:
+ lineupHero.heroBatAttrDict[attrID] = attrValue
+ logAttrDict["%s-%s" % (attrID, attrName)] = attrValue
+
+ # 计算战力
+ fightPower = FormulaControl.Eval("fightPowerFormula", fightPowerFormula, fightPowerParamDict, toInt=True)
+
+ GameWorld.DebugLog(" heroID=%s,fightPower=%s,heroSkillIDList=%s" % (heroID, fightPower, lineupHero.heroSkillIDList), playerID)
+ skillTypeIDDict = {}
+ for skillID in lineupHero.heroSkillIDList:
+ skillData = IpyGameDataPY.GetIpyGameData("Skill", skillID)
+ if not skillData:
+ continue
+ skillTypeID = skillData.GetSkillTypeID()
+ if skillTypeID not in skillTypeIDDict:
+ skillTypeIDDict[skillTypeID] = skillData
+ else:
+ befSkillData = skillTypeIDDict[skillTypeID]
+ befSkillID = befSkillData.GetSkillID()
+ if befSkillID >= skillID:
+ continue
+ skillTypeIDDict[skillTypeID] = skillData
+
+ skillFightPower = 0
+ lineupHero.heroSkillIDList = []
+ for skillData in skillTypeIDDict.values():
+ skillID = skillData.GetSkillID()
+ lineupHero.heroSkillIDList.append(skillID)
+ paramDict = {"SkillPower":skillData.GetFightPower(), "PlayerLV":PlayerLV, "OfficialLV":OfficialLV}
+ sFightPower = FormulaControl.Eval("skillFPFormula", skillFPFormula, paramDict, toInt=True)
+ skillFightPower += sFightPower
+ GameWorld.DebugLog(" skillFightPower=%s,heroSkillIDList=%s" % (skillFightPower, lineupHero.heroSkillIDList), playerID)
+
+ # 最终战力
+ fightPowerTotal = fightPower + skillFightPower
+ lineupHero.skillFightPower = skillFightPower
+ lineupHero.fightPower = fightPowerTotal
+ lineupFightPower += fightPowerTotal
+
+ GameWorld.DebugLog(" 武将最终战力: heroID=%s,fightPower=%s(%s+%s),%s,skillIDList=%s"
+ % (heroID, fightPowerTotal, fightPower, skillFightPower, logAttrDict, lineupHero.heroSkillIDList), playerID)
+
+ presetLineup.fightPower = lineupFightPower
+ GameWorld.DebugLog(" 阵容最终战力: batPresetID=%s,lineupFightPower=%s,exclusiveMapID=%s" % (batPresetID, lineupFightPower, exclusiveMapID), playerID)
+
+ # 非主线预设方案不处理以下内容
+ if exclusiveMapID or batPresetID != PlayerPreset.GetBatPresetID(curPlayer, ShareDefine.BatPreset_Main):
+ return
+
+ PlayerControl.SetFightPower(curPlayer, lineupFightPower)
+
+ mainFightMgr = TurnAttack.GetMainFightMgr(curPlayer)
+ mainTurnFight = mainFightMgr.turnFight
+ # 主线战斗如果有在战斗中，实时更新
+ if mainTurnFight and mainTurnFight.isInFight():
+ # 如果是阵容变化的，重新开始战斗
+ if heroPreset.isHeroChange:
+ heroPreset.isHeroChange = False
+ GameWorld.DebugLog("主线阵容变化，重新开始战斗", playerID)
+ if mainTurnFight.mapID == ChConfig.Def_FBMapID_Main:
+ TurnAttack.__doMainLevelWave(curPlayer, True)
+
+ # 否则只重新设置战斗属性
+ else:
+ GameWorld.DebugLog("主线阵容卡牌属性变更，更新战斗武将属性", playerID)
+ # lineup 为卡牌的阵容，仅有阵容属性相关，没有战斗对象
+ # batLineup 为卡牌阵容体现到具体战斗的战斗阵容，有具体的战斗对象
+ faction, num = ChConfig.Def_FactionA, 1 # 主线战斗玩家自己默认阵营A的第1个战斗阵容
+ batLineup = mainTurnFight.getBatFaction(faction).getBatlineup(num)
+ batObjMgr = BattleObj.GetBatObjMgr()
+ for posNum, objID in batLineup.getPosObjIDDict().items():
+ batObj = batObjMgr.getBatObj(objID)
+ if not batObj:
+ continue
+ if batObj.GetBatObjType() != ChConfig.BatObjType_BatHero:
+ continue
+ lineupHero = presetLineup.GetLineupHero(posNum)
+ if lineupHero.heroBatAttrDict:
+ batObj.UpdInitBatAttr(lineupHero.heroBatAttrDict, lineupHero.heroSkillIDList)
+ else:
+ GameWorld.DebugLog("主线阵容没有在战斗中，不需要处理", playerID)
+
+ PlayerFamily.RefreshFamilyMember(curPlayer) # 更新公会
+ # 更新排行榜
+
+ return
--
Gitblit v1.8.0