def onCmdUpdateArenaRank(self, param):
selfRank = param["selfRank"]
enemyRank = param["enemyRank"]
ERROR_MSG("--onCmdUpdateArenaRank--selfRank--" + str(selfRank) +
"-enemyRank--" + str(enemyRank))
sql = "update tbl_ArenaRow selfT, tbl_ArenaRow enemy set selfT.sm_dbid = enemy.sm_dbid,enemy.sm_dbid = selfT.sm_dbid ,selfT.sm_isRobot = enemy.sm_isRobot,enemy.sm_isRobot = selfT.sm_isRobot where selfT.sm_rank = " + str(
selfRank) + " and enemy.sm_rank =" + str(enemyRank)
ERROR_MSG("onCmdUpdateArenaRank change the rank sql : " + sql)
KBEngine.executeRawDatabaseCommand(sql)
def useSkill(self, mainSkillID, skillLevel, result):
ERROR_MSG("mainSkillID " + str(mainSkillID))
if mainSkillID == 0:
# 没配技能
return
skillConMap = skillMainConfig.SkillMain[mainSkillID]
condition = skillConMap["condition"]
if mainSkillID != 1035:
# 检查主技能的使用条件
check = self.checkCondition(condition, result)
ERROR_MSG(" condition is " + str(condition) +
" result is " + str(result) + " check is " +
str(check))
# 验证不通过
if check is False:
return False
if mainSkillID == 1009:
self.useSkill1009(skillLevel, result)
elif mainSkillID == 1014:
self.useSkill1014(skillLevel, result)
elif mainSkillID == 1035:
self.useSkill1035(result)
else:
subSkillTuple = skillConMap["subSkills"]
ERROR_MSG("subSkills" + subSkillTuple.__str__())
for subSkillID in subSkillTuple:
subSkillID = subSkillID * 100 + skillLevel
subSkillConMap = skillConfig.SkillConfig[subSkillID]
usePercent = subSkillConMap["triggerPer"]
ERROR_MSG("target type is " + str(subSkillConMap["target"]))
targetList = self.filterTarget(subSkillConMap["target"])
# 分开单个人触发效果
for target in targetList:
skillID = subSkillID // 10000
if skillID == 1036:
self.addBuffer(target, subSkillID)
continue
if skillID == 1015 and not self.check1015Pos():
continue
if self.checkTriggerPer(usePercent) is False:
continue
self.addBuffer(target, subSkillID)
#
return True
def useSkill1014(self, skillLevel, result):
if result != ConditionEnum.con_result_None:
return
p = util.randInHundred()
# 消耗对方一个回合
if p < 50:
self.addEffect23(10140101, 23, None, None, [self.id])
ERROR_MSG("useSkill1014 end round ")
else:
self.addEffect18(10140101, 18, None, None, [self.id])
ERROR_MSG("useSkill1014 get yellow card ")
def delBuffer(self, i):
buffer = self.bufferContainer[i]
subSkillID = buffer["subSkillID"]
subSkillConf = skillConfig.SkillConfig[subSkillID]
controller = KBEngine.entities.get(self.controllerID)
ERROR_MSG("delBuffer cardID is " + str(self.id) +
" buffer " + buffer.__str__())
ERROR_MSG(util.printStackTrace("delBuffer "))
noticeClient = subSkillConf["noticeClient"]
if isinstance(controller, Avatar) and noticeClient == 1:
controller.client.onDelBuffer(self.id, subSkillID)
def onCmdCancelApply(self, argMap):
playerMB = argMap["playerMB"]
guildDBID = argMap["guildDBID"]
applyerDBID = argMap["applyerDBID"]
if self.isGuildExist(guildDBID) is False:
ERROR_MSG(
"----------------not exist guild ---------------------------")
playerMB.client.onGuildError(
ErrorCode.GuildModuleError.Guild_guild_not_exist)
return
param = {"applyerDBID": applyerDBID}
def cancelApplyCB(guild, guildDBID, wasActive):
if guildDBID not in self.dbidToMb:
self.dbidToMb[guildDBID] = guild
guild.onCmd("cancelApply", param)
if guildDBID not in self.dbidToMb:
KBEngine.createBaseAnywhereFromDBID("Guild", guildDBID,
cancelApplyCB)
else:
guildMb = self.dbidToMb[guildDBID]
guildMb.onCmd("cancelApply", param)
pass
def onCmdAgreeJoin(self, argMap):
playerMB = argMap["playerMB"]
guildDBID = argMap["guildDBID"]
applyerDBID = argMap["applyerDBID"]
if self.isGuildExist(guildDBID) is False:
ERROR_MSG(
"----------------not exist guild ---------------------------")
playerMB.client.onGuildError(
ErrorCode.GuildModuleError.Guild_guild_not_exist)
return
param = {
"applyerDBID": applyerDBID,
"power": PowerEnmu.member,
"selfDBID": argMap["selfDBID"],
"playerMB": playerMB
}
def CB(guild, guildDBID, wasActive):
if guildDBID not in self.dbidToMb:
self.dbidToMb[guildDBID] = guild
guild.onCmd("agreeJoin", param)
if guildDBID not in self.dbidToMb:
KBEngine.createBaseAnywhereFromDBID("Guild", guildDBID, CB)
else:
guildMb = self.dbidToMb[guildDBID]
guildMb.onCmd("agreeJoin", param)
def onRoomGetCell(self, param):
# 注册
roomID = param["roomID"]
roomMB = param["roomMB"]
roomCellMB = param["roomCellMB"]
actionType = param["actionType"]
self.rooms[roomID] = roomMB
args = self._pendingLogonEntities[roomID]
ERROR_MSG(" onRoomGetCell args: " + str(args))
if actionType == ActionTypeEnum.league_player:
param["leagueDBID"] = args["leagueDBID"]
param["avatarA"] = args["avatarA"]
param["avatarB"] = args["avatarB"]
param["isJoinA"] = args["isJoinA"]
param["isJoinB"] = args["isJoinB"]
leagueMgr = KBEngine.globalData["LeagueMgr"]
leagueMgr.onCmd("onCmdRoomCreateSuccCB", param)
else:
avatarMb = args["avatarMB"]
avatarMb.onPlayerMgrCmd("onRoomCreateSuccCB", param)
del self._pendingLogonEntities[roomID]
def createGuild(self, itemInfo):
dbid = itemInfo["dbid"]
self.guildInfoList.append(itemInfo)
ERROR_MSG("--CreatGUild self.guildInfoList--" +
str(len(self.guildInfoList)))
self.dbidToIndex[dbid] = len(self.guildInfoList) - 1
def getRankCount(result, rownum, error):
count = int(result[0][0])
sql = "select sm_dbid,sm_rank,sm_isRobot from tbl_ArenaRow"
ERROR_MSG("--onCmdGetArenaAllRankValue--count" + str(count))
@util.dbDeco
def rankResult(result, rownum, error):
if result is None:
return
param = []
for i in range(len(result)):
dbid = int(result[i][0])
rank = int(result[i][1])
isRobot = int(result[i][2])
item = {
"dbid": dbid,
"rank": rank,
"isRobot": isRobot,
"count": count
}
param.append(item)
argMap["areanList"] = param
leagueMgr = KBEngine.globalData["LeagueMgr"]
leagueMgr.onCmd("onCmdAreanRankData", argMap)
KBEngine.executeRawDatabaseCommand(sql, rankResult)
def selectCanUseSkills(self):
self.canUseSkillList = []
if not isinstance(self, Avatar.Avatar):
return []
curPart = KBEngine.entities.get(self.roomID).curPart
for id in self.inTeamcardIDList:
card = KBEngine.entities.get(id)
skill = card.skill1_B
skillCon = skillMainConfig.SkillMain[skill]
# 1、检查步骤适合
if curPart not in skillCon["useStep"]:
continue
# 2、检查怒气
if card.anger <100:
continue
# 3、检查condition
condition = skillCon["condition"]
if skill != 1035:
if not card.checkCondition(condition,ConditionEnum.con_result_None):
continue
self.canUseSkillList.append(id)
ERROR_MSG("selectCanUseSkills canUseSkillList " + self.canUseSkillList.__str__())
return self.canUseSkillList
def filterTarget4(self):
roomID = self.roomID
clone = KBEngine.entities.get(roomID)
# TODO:记得检查为什么不亮起来
ERROR_MSG("controllerID is " + str(clone.controllerID) +
" defenderID is " + str(clone.defenderID))
if self.controllerID == clone.controllerID:
enemyID = clone.defenderID
else:
enemyID = clone.controllerID
if enemyID != -1:
print(enemyID)
ERROR_MSG("self id is " + str(self.id) + " enemyid is " +
str(enemyID))
enemy = KBEngine.entities.get(enemyID)
return (enemy.keeperID, )
def skill1036Effect(self, buffer):
roomID = self.roomID
clone = KBEngine.entities.get(roomID)
# 防守回合
if self.controllerID != clone.defenderID:
return
subSkillId = buffer["subSkillID"]
subConfig = skillConfig.SkillConfig[subSkillId]
percent = subConfig["triggerPer"]
p = util.randInHundred()
if p < percent:
# 触发门柱保命
if clone.controllerID == clone.avatarAID:
clone.aScore = clone.aScore - 1
else:
clone.bScore = clone.bScore - 1
clone.roundResult = ConditionEnum.con_result_shoot_fail
self.bufferContainer.remove(buffer)
ERROR_MSG(" 1036 trigger ")
self.noticeClientEffect(subSkillId, self.id,
EffectEnum.effect_GoalPost_Help)
else:
lastRound = buffer["lastRound"]
if lastRound - 1 <= 0:
self.bufferContainer.remove(buffer)
else:
buffer["lastRound"] = lastRound - 1
def addEffect29(self, subSkillID, effectType, valueType, value,
targetList):
room = KBEngine.entities.get(self.roomID)
controllerID = room.controllerID
bID = room.avatarBID
ERROR_MSG(
"addEffect29 chongxin"
)
# 现在攻击的人是b
curAttackIndex = room.curAttackIndex + 1
if bID == controllerID:
if curAttackIndex in room.bAttackList:
# 调整
room.bAttackList.remove(curAttackIndex)
for x in range(curAttackIndex + 1, room.totalAttackTimes):
if x not in room.bAttackList:
room.append(x)
break
else:
# 如果下一轮攻击不是B调整为B
if curAttackIndex not in room.bAttackList:
room.bAttackList.append(curAttackIndex)
room.pop(len(room.bAttackList) - 1)
self.noticeClientEffect(subSkillID, self.id, effectType)
def onCmd(self, methodName, argMap):
if hasattr(self, methodName) is False:
ERROR_MSG(
str(self.__class__) + " not exist method " + methodName)
return
func = getattr(self, methodName)
func(argMap)
def checkCondition114(self,result):
ERROR_MSG(" checkCondition114 result " + str(result))
if result == ConditionEnum.con_result_None:
return False
if result != ConditionEnum.con_result_shoot_fail:
return False
if self.checkCondition2(ConditionEnum.con_result_None) :
return True
return False
def addEffect28(self, subSkillID, effectType, valueType, value,
targetList):
room = KBEngine.entities.get(self.roomID)
# 补射
room.reShootCardID = self.id
room.endRound = False
ERROR_MSG(util.printStackTrace("addEffect28 reshoot "))
room.onCmdSelectSkill(PlayerOp.shoot)
def checkCondition16(self, result):
if result != ConditionEnum.con_result_None:
return False
ERROR_MSG(" checkCondition1 result " + str(result))
roomID = self.roomID
clone = KBEngine.entities.get(roomID)
curAttackID = clone.getCurRoundAtkId(clone.curPart)
ERROR_MSG("curAttackID is " + str(curAttackID) + " myCardId " + str(self.id))
if curAttackID != self.id:
return False
attackCoordinate = clone.getCurRoundAtkCoordinate(clone.curPart)
if attackCoordinate in self.penaltyArea:
return True
return False
def addEffect15(self, subSkillID, effectType, valueType, value,
targetList):
for cardId in targetList:
card = KBEngine.entities.get(cardId)
ERROR_MSG("addEffect15 cardID is " + str(cardId) +
" value is " + str(value))
card.secondStepAttackSkillPer = card.secondStepAttackSkillPer + value / 1000.0
self.noticeClientEffect(subSkillID, cardId, effectType)
def addEffect12(self, subSkillID, effectType, valueType, value,
targetList):
for cardId in targetList:
card = KBEngine.entities.get(cardId)
ERROR_MSG("addEffect12 cardID is " + str(cardId) +
" value is " + str(value))
card.perfectPassballSkillPer = card.perfectPassballSkillPer + value / 1000.0
self.noticeClientEffect(subSkillID, cardId, effectType)
def addEffect4(self, subSkillID, effectType, valueType, value, targetList):
for cardId in targetList:
card = KBEngine.entities.get(cardId)
ERROR_MSG("addEffect4 cardID is " + str(cardId) +
" value is " + str(value))
if valueType == ValueTypeEnmu.value:
card.controllSkillValue = card.controllSkillValue + value
elif valueType == ValueTypeEnmu.percent:
card.controllSkillPer = card.controllSkillPer + value / 1000.0
self.noticeClientEffect(subSkillID, cardId, effectType)
def addEffect13(self, subSkillID, effectType, valueType, value,
targetList):
for cardId in targetList:
card = KBEngine.entities.get(cardId)
ERROR_MSG("addEffect13 cardID is " + str(cardId) +
" value is " + str(value))
if hasattr(card, "anger") is False:
card.anger = 0
card.anger = card.anger + value
self.noticeClientEffect(subSkillID, cardId, effectType)
def addEffect18(self, subSkillID, effectType, valueType, value,
targetList):
room = KBEngine.entities.get(self.roomID)
a = KBEngine.entities.get(room.avatarAID)
b = KBEngine.entities.get(room.avatarBID)
if self.controllerID == a.id:
controller = a
else:
controller = b
for cardId in targetList:
card = KBEngine.entities.get(cardId)
card.yellow = card.yellow + 1
if a.typeStr == "Avatar":
a.client.onYellowCard(cardId)
ERROR_MSG("addEffect18 yellow subSkillID " +
str(subSkillID))
if b.typeStr == "Avatar":
b.client.onYellowCard(cardId)
ERROR_MSG("addEffect18 yellow subSkillID " +
str(subSkillID))
if card.yellow == 2:
card.red = 1
card.yellow = 0
controller.inTeamcardIDList.remove(self.id)
if a.typeStr == "Avatar":
a.client.onRedCard(cardId)
ERROR_MSG("addEffect18 red subSkillID " +
str(subSkillID))
if b.typeStr == "Avatar":
b.client.onRedCard(cardId)
ERROR_MSG("addEffect18 red subSkillID " +
str(subSkillID))
def guildWriteToDB_CB(success, guild):
ERROR_MSG(" create success " + str(guild.databaseID))
value = {
"dbid": guild.databaseID,
"guildName": guildName,
"camp": camp,
"level": 1,
"count": 1,
"leader": playerName,
}
# 保存到数据库（自动）
self.createGuild(value)
#
self.dbidToMb[guild.databaseID] = guild
# 把自己加入公会中
argMap = {
"selfDBID": playerDBID,
"applyerDBID": playerDBID,
"result": 1,
"playerName": playerName,
"offical": officalPosition,
"level": playerLevel,
"power": PowerEnmu.leader,
"playerMB": playerMB
}
# 公会信息改变刷新
guild.onCmd("updateGuildValueRank", {})
guild.onCmd("onCreatGuildAdviser", {})
guild.onCmd("onCreateGuildBuild", {})
guild.onCmd("agreeJoin", argMap)
guildParam = {
"guildDBID": guild.databaseID,
"power": int(PowerEnmu.leader),
"guildLevel": int(PowerEnmu.leader),
"guildName": guildName
}
playerMB.onPlayerMgrCmd("setGuildDBID", guildParam)
# playerMB.guildDBID = guild.databaseID
# playerMB.guildPower = int(PowerEnmu.leader)
# playerMB.guildName = guildName
# playerMB.guildLevel = 1
self.writeToDB()
def onCmdLeaveGuild(self, argMap):
playerMB = argMap["playerMB"]
guildDBID = argMap["guildDBID"]
playerDBID = argMap["playerDBID"]
if self.isGuildExist(guildDBID) is False:
ERROR_MSG(
"----------------not exist guild ---------------------------")
playerMB.client.onGuildError(
ErrorCode.GuildModuleError.Guild_guild_not_exist)
return
if guildDBID not in self.dbidToMb:
KBEngine.createBaseAnywhereFromDBID(
"Guild", guildDBID, partial(self.leaveGuildCB, argMap))
else:
guildMb = self.dbidToMb[guildDBID]
self.leaveGuildCB(argMap, guildMb, guildDBID, True)
def onCmdGetChanllengeMember(self, param):
selfRank = param["selfRank"]
playerMB = param["playerMB"]
rankNum = 3
down = 1000
if selfRank > 1000:
down = selfRank - 100
elif selfRank > 500 and selfRank <= 1000:
down = selfRank - 20
elif selfRank > 200 and selfRank <= 500:
down = selfRank - 15
elif selfRank > 50 and selfRank <= 200:
down = selfRank - 10
elif selfRank > 10 and selfRank <= 50:
down = selfRank - 8
elif selfRank > 1 and selfRank <= 10:
down = selfRank - 5
# 注意判断下限
top = selfRank - 1
sql = "select sm_dbid,sm_rank,sm_isRobot from tbl_ArenaRow where sm_rank between " + str(
down) + " and " + str(top) + " ORDER BY rand() LIMIT " + str(
rankNum)
ERROR_MSG("=========slq== " + sql)
@util.dbDeco
def queryResult(result, rownum, error):
if result is None:
return
param = []
for i in range(len(result)):
dbid = int(result[i][0])
rank = int(result[i][1])
isRobot = int(result[i][2])
item = {"dbid": dbid, "rank": rank, "isRobot": isRobot}
param.append(item)
playerMB.onPlayerMgrCmd("onArenaMgrQueryResult", param)
KBEngine.executeRawDatabaseCommand(sql, queryResult)
def formationValue(self):
avatar = KBEngine.entities.get(self.playerID)
if self.id not in avatar.inTeamcardIDList:
return 0
fightValue = 0
propChangeFight = propChangeFightConfig.PropChangeFightConfig[1]
# 阵型加成
for id in avatar.fomationPropContainer:
formatList = avatar.fomationPropContainer[id]
for info in formatList:
name = info["propName"]
value = info["value"]
# ERROR_MSG("--FormatName--" + str(name) + "--Formatvalue--" + str(value))
fightValue = fightValue + int(propChangeFight[name] * value)
# ERROR_MSG("-- formatFightAdd--" + str(fightValue)+"--avatar.relatPropContainer--"+str(len(avatar.relatPropContainer)))
# 羁绊球员属性加成
if self.id not in avatar.relatPropContainer:
return fightValue
relatePropList = avatar.relatPropContainer[self.id]
relatefightAdd = 0
for propInfo in relatePropList:
name = propInfo["propName"]
value = propInfo["value"]
ERROR_MSG("--propName--" + str(name) + "--propvalue--" +
str(value))
fightValue = fightValue + int(propChangeFight[name] * value)
relatefightAdd = relatefightAdd + int(
propChangeFight[name] * value)
# ERROR_MSG("--relatefightAdd--"+str(relatefightAdd))
return fightValue
def onCmdApplyJoinGuild(self, argMap):
playerMB = argMap["playerMB"]
guildDBID = argMap["guildDBID"]
playerDBID = argMap["playerDBID"]
playerLevel = argMap["playerLevel"]
officalPosition = argMap["officalPosition"]
playerName = argMap["playerName"]
camp = argMap["camp"]
if self.isGuildExist(guildDBID) is False:
ERROR_MSG(
"----------------not exist guild ---------------------------")
playerMB.client.onGuildError(
ErrorCode.GuildModuleError.Guild_guild_not_exist)
return
if guildDBID not in self.dbidToMb:
KBEngine.createBaseAnywhereFromDBID(
"Guild", guildDBID, partial(self.applyJoinGuildCB, argMap))
else:
guildMb = self.dbidToMb[guildDBID]
self.applyJoinGuildCB(argMap, guildMb, guildDBID, True)
def onTimer(self, id, userArg):
ERROR_MSG("ontimer" + str(userArg))
if userArg == TimerDefine.Timer_reset_baby_liking:
config = CommonConfig.CommonConfig[5]
liking = config["value"]
if self.liking >= liking:
self.liking = self.liking - liking
else:
self.liking = 0
self.likingTime = 0
self.client.onGetBabyInfo(self.liking, self.fullTime,
self.closeTouch, self.itemTouch,
self.likingTime, self.GetRewardList)
tech = 0.0
health = 0.0
for i in range(5):
info = BabyLikingStarConfig.BabyLikingStarConfig[i +
1]["liking"]
tech = tech + float(BabyLikingStarConfig.BabyLikingStarConfig[
i + 1]["teamTuple"].split(",")[1])
health = health + float(
BabyLikingStarConfig.BabyLikingStarConfig[
i + 1]["teamTuple"].split(",")[0])
if self.liking <= info:
break
avatar = KBEngine.entities.get(self.playerID)
player = KBEngine.entities.get(avatar.cardID)
if player.tech != tech or player.health != health:
player.tech = tech
player.health = health
self.client.onUpdateCardInfo(self.UpdateBallerInfo(player))
else:
if self.likingTime > 0:
self.likingTime = self.likingTime - 1
else:
self.likingTime = 0
def bufferEffect(self, result=ConditionEnum.con_result_None):
room = KBEngine.entities.get(self.roomID)
isAttackRound = False
if room.controllerID == self.controllerID:
isAttackRound = True
for i in range(len(self.bufferContainer) - 1, -1, -1):
buffer = self.bufferContainer[i]
statrType = buffer["startType"]
targetList = [self.id]
subSkillID = buffer["subSkillID"]
condition = buffer["condition"]
noticeClient = buffer["noticeClient"]
controller = KBEngine.entities.get(self.controllerID)
subSkillConf = skillConfig.SkillConfig[subSkillID]
# 1、一轮之前
if condition == ConditionEnum.con_result_None:
if isAttackRound:
if statrType == StartTypeEnmu.cur_round_and_attack_round or statrType == StartTypeEnmu.next_round_attack_round or statrType == StartTypeEnmu.cur_round:
self.makeEffect(targetList, subSkillConf)
self.bufferAfterUse(i)
else:
if statrType == StartTypeEnmu.cur_round_and_defend_round or statrType == StartTypeEnmu.next_round_defend_round or statrType == StartTypeEnmu.cur_round:
self.makeEffect(targetList, subSkillConf)
self.bufferAfterUse(i)
pass
# 2、一轮之后
else:
ERROR_MSG(" bufferEffect result is " + str(result))
if condition == ConditionEnum.con_result_shoot_succ:
# 如果是内部结果直接pass
if result in self.insideResult:
continue
# 门柱保命
if subSkillID // 10000 == 1036:
# 防守回合
self.skill1036Effect(buffer)
continue
if result != condition:
self.bufferContainer.pop(i)
else:
# 激活下次不检查了
buffer["condition"] = ConditionEnum.con_result_None
if isinstance(controller,
Avatar) and noticeClient == 1:
controller.client.onAddBuffer(self.id, subSkillID)
elif condition == ConditionEnum.con_result_shoot_fail:
# 如果是内部结果直接pass
if result in self.insideResult:
continue
if result != condition:
self.bufferContainer.pop(i)
else:
# 激活下次不检查了 TODO:通知另外一个人
buffer["condition"] = ConditionEnum.con_result_None
if subSkillID // 1000 == 1004:
self.addEffect28(subSkillID, 28, None, None,
[self.id])
if isinstance(controller,
Avatar) and noticeClient == 1:
controller.client.onAddBuffer(self.id, subSkillID)
elif condition == ConditionEnum.con_result_be_steal:
# 如果是内部结果直接pass
if result in self.insideResult:
continue
if result != condition:
self.bufferContainer.pop(i)
else:
# 激活下次不检查了
buffer["condition"] = ConditionEnum.con_result_None
if isinstance(controller,
Avatar) and noticeClient == 1:
controller.client.onAddBuffer(self.id, subSkillID)
elif condition == ConditionEnum.con_result_not_shoot_succ:
# 如果是内部结果直接pass
if result in self.insideResult:
continue
if result == ConditionEnum.con_result_shoot_fail or result == ConditionEnum.con_result_not_shoot_succ:
# 激活下次不检查了
buffer["condition"] = ConditionEnum.con_result_None
if isinstance(controller,
Avatar) and noticeClient == 1:
controller.client.onAddBuffer(self.id, subSkillID)
else:
self.bufferContainer.pop(i)
# 中间结果
elif condition == ConditionEnum.con_result_pass_succ:
if result == ConditionEnum.con_result_be_steal:
self.bufferContainer.pop(i)
else:
# 激活下次不检查了
buffer["condition"] = ConditionEnum.con_result_None
if isinstance(controller,
Avatar) and noticeClient == 1:
controller.client.onAddBuffer(self.id, subSkillID)
elif condition == ConditionEnum.con_result_perfect_pass:
if result != ConditionEnum.con_result_perfect_pass:
self.bufferContainer.pop(i)
else:
# 激活下次不检查了
buffer["condition"] = ConditionEnum.con_result_None
if isinstance(controller,
Avatar) and noticeClient == 1:
controller.client.onAddBuffer(self.id, subSkillID)
elif condition == ConditionEnum.con_result_break_succ:
if result != ConditionEnum.con_result_be_steal:
# 激活下次不检查了
buffer["condition"] = ConditionEnum.con_result_None
if isinstance(controller,
Avatar) and noticeClient == 1:
controller.client.onAddBuffer(self.id, subSkillID)
else:
self.bufferContainer.pop(i)
def addBuffer(self, targetID, subSkillID):
subSkillConf = skillConfig.SkillConfig[subSkillID]
controller = KBEngine.entities.get(self.controllerID)
buffer = {
"startType": subSkillConf["startType"],
"lastRound": subSkillConf["lastRound"],
"noticeClient": subSkillConf["noticeClient"],
"subSkillID": subSkillID,
"condition": subSkillConf["condition"]
}
# 免疫负面状态
impactType = subSkillConf["impactType"]
if self.immuneNegativeBuffer and impactType == ImpactTypeEnum.debuffs:
return
room = KBEngine.entities.get(self.roomID)
isAttackRound = False
if room.controllerID == self.controllerID:
isAttackRound = True
card = KBEngine.entities.get(targetID)
noticeClient = subSkillConf["noticeClient"]
ERROR_MSG("-----------addbuffer-----------targetID----------- " +
str(targetID) + " subskillID " + str(subSkillID))
# 如果是结果型的加进去就行了
if subSkillConf["condition"] != ConditionEnum.con_result_None:
card.bufferContainer.append(buffer)
ERROR_MSG("card.bufferContainer cardID is " + str(card.id) +
" " + card.bufferContainer.__str__())
return
if isinstance(controller, Avatar) and noticeClient == 1:
controller.client.onAddBuffer(targetID, subSkillID)
# 如果是立即生效的看 startType
targetList = [self.id]
startType = subSkillConf["startType"]
if startType == StartTypeEnmu.cur_round:
self.makeEffect(targetList, subSkillConf)
if subSkillConf["lastRound"] > 1:
buffer["lastRound"] = subSkillConf["lastRound"] - 1
card.bufferContainer.append(buffer)
elif startType == StartTypeEnmu.cur_round_and_attack_round:
if isAttackRound:
self.makeEffect(targetList, subSkillConf)
if subSkillConf["lastRound"] > 1:
buffer["lastRound"] = subSkillConf["lastRound"] - 1
card.bufferContainer.append(buffer)
elif startType == StartTypeEnmu.cur_round_and_defend_round:
if not isAttackRound:
self.makeEffect(targetList, subSkillConf)
if subSkillConf["lastRound"] > 1:
buffer["lastRound"] = subSkillConf["lastRound"] - 1
card.bufferContainer.append(buffer)
else:
card.bufferContainer.append(buffer)
ERROR_MSG("card.bufferContainer cardID is " + str(card.id) +
" " + card.bufferContainer.__str__())
