class RoleRpcMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
# 角色升级(roleUpgrade)
# 请求
#
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 角色基础
# 战力(fa, int)
# 等级(lv, int)
# 当前经验值(exp, int)
# 游戏模型 - 角色属性
def rc_roleUpgrade(self):
iCurLv = self.player.base.GetLv()
iNextLv = iCurLv + 1
curRes = Game.res_mgr.res_level.get(iCurLv, None)
nextRes = Game.res_mgr.res_level.get(iNextLv, None)
if not nextRes:
return 0, errcode.EC_MAX_LEVEL
#先扣经验
iCurExp = self.player.base.GetExp()
if iCurExp < curRes.exp:
return 0, errcode.EC_NOT_ENOUGH
iNewExp = iCurExp - curRes.exp
self.player.base.SetExp(iNewExp)
self.player.base.SetLv(iNextLv)
#打包返回信息
dUpdate = {}
dUpdate["base"] = {}
dUpdate["base"]["fa"] = self.player.base.fa
dUpdate["base"]["lv"] = self.player.base.lv
dUpdate["base"]['exp'] = self.player.base.exp
resp = {
"allUpdate": dUpdate,
}
return 1, resp
class ExamMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
# 获取问题(getQuestion)
# 请求
# 第几题(num, int)
# 返回
# 问题id(qid, int)
# 当前分数(score, int)
# 当前排行(rank, int)
def rc_getQuestion(self, num):
if num < 0 or num > 20:
return 0, errcode.EC_PARAMS_ERR
status = Game.rpc_exam_mgr.getStatus()
if not status:
return 0, errcode.EC_CLOSE
questions, startTimePoint = self.player.exam.getExamInfo()
if num == 1 or not questions or not startTimePoint:
questions, startTimePoint = Game.rpc_exam_mgr.getExamInfo()
random.shuffle(questions)
self.player.exam.setExamInfo(questions, startTimePoint)
playerExamInfo = Game.rpc_exam_mgr.getPlayerInfo(self.player.id)
score, rank = 0, 0
if playerExamInfo:
score = playerExamInfo.get("score", 0)
rank = playerExamInfo.get("rank", 0)
if len(questions) < constant.QUESTION_NUM:
return 0, errcode.EC_CLOSE
# 抛事件
self.player.safe_pub(msg_define.MSG_JOIN_EXAM)
resp = {
"qid": questions[num - 1],
"score": score,
"rank": rank,
"ranking": Game.rpc_exam_mgr.getRanking(5),
}
return 1, resp
# 答题(answerQuestion)
# 请求
# 第几题(num, int)
# 答题(answer, int)
# 返回
# 是否正确(correct, int)
def rc_answerQuestion(self, num, answer):
if num < 0 or num > 20:
return 0, errcode.EC_PARAMS_ERR
now = int(time.time())
questions, startTimePoint = self.player.exam.getExamInfo()
if not questions or not startTimePoint:
questions, startTimePoint = Game.rpc_exam_mgr.getExamInfo()
self.player.exam.setExamInfo(questions, startTimePoint)
qid = questions[num - 1]
startPoint = startTimePoint[num - 1]
if now < startPoint:
return 0, errcode.EC_PARAMS_ERR
qRes = Game.res_mgr.res_examQuestionPool.get(qid, None)
if not qRes:
return 0, errcode.EC_NORES
correct = 0
if qRes.correct == answer:
correct = 1
useTime = now - startPoint
if useTime > 10:
useTime = 10
if useTime == 0:
useTime = 1
point = Game.res_mgr.res_result_useTime_answerPoint.get(
(correct, useTime), 0)
self.player.exam.incAnswerTimes()
pid = self.player.id
name = self.player.name
fa = self.player.base.fa
Game.rpc_exam_mgr.updatePlayer(pid,
name,
fa,
point,
useTime,
_no_result=1)
resp = {
"correct": correct,
"point": point,
}
return 1, resp
# 获取排行榜(getExamRank)
# 请求
# 返回
# 排行榜前20(ranking, [json])
# 名字(name, string)
# 分数(score, int)
# 战力(fa, int)
def rc_getExamRank(self):
resp = {
"ranking": Game.rpc_exam_mgr.getRanking(20),
}
return 1, resp
# 获取活动大厅信息(getActivityLobbyInfo)
# 请求
# 返回
# 答题信息(examInfo, json)
# 上期第一名(lastFirst, string)
def rc_getActivityLobbyInfo(self):
examInfo = {}
examInfo["lastFirst"] = Game.rpc_exam_mgr.getLastFirst()
resp = {
"examInfo": examInfo,
}
return 1, resp
class HetiRpcMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
def rc_hetiBuy(self):
vipLv = self.player.vip.GetVipLv()
vipRes = Game.res_mgr.res_vip.get(vipLv, None)
if not vipRes:
return 0, errcode.EC_NORES
buyCostRes = Game.res_mgr.res_common.get("hetiBuyCost")
if not buyCostRes:
return 0, errcode.EC_NORES
hetiBuyNum = Game.res_mgr.res_common.get("hetiBuyNum")
if not hetiBuyNum:
return 0, errcode.EC_NORES
num = self.player.heti.GethetiBuyNum()
if num >= vipRes.hetiBuyNum + hetiBuyNum.i:
return 0, errcode.EC_HETI_BUYMAX
if self.player.heti.HetiNum == 0:
return 0, errcode.EC_HETI_NUMZERO
respBag = self.player.bag.costItem(buyCostRes.arrayint2,
constant.ITEM_COST_HETI,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_COST_ERR
self.player.heti.buyNum()
dUpdate = self.player.packRespBag(respBag)
dUpdate["heti"] = self.player.heti.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_hetiInfo(self):
dUpdate = {}
dUpdate["heti"] = self.player.heti.to_init_data()
# if resp_items or resp_equips:
# dUpdate["bag"] = self.player.bag.to_update_data(items=resp_items, equips=resp_equips)
# if resp_wallet:
# dUpdate["wallet"] = self.player.wallet.to_update_data(resp_wallet)
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_hetiStart(self):
heticishu = Game.res_mgr.res_common.get("heticishu")
if not heticishu:
return 0, errcode.EC_NORES
n = self.player.heti.HetiNum
if heticishu.i <= n:
return 0, errcode.EC_HETI_MAX
self.player.heti.start()
self.player.safe_pub(msg_define.MSG_MINI_GAME_JOIN)
dUpdate = {}
dUpdate["heti"] = self.player.heti.to_init_data()
# if resp_items or resp_equips:
# dUpdate["bag"] = self.player.bag.to_update_data(items=resp_items, equips=resp_equips)
# if resp_wallet:
# dUpdate["wallet"] = self.player.wallet.to_update_data(resp_wallet)
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_hetiAuto(self):
dictx = {}
for key in self.player.heti.obj:
dictx[key] = dictx.get(key, 0) + 1
for key, value in dictx.items():
if (value == max(dictx.values())):
break
print("========", key)
if key == "*-*":
return self.rc_hetiCao(0)
else:
return self.rc_hetiHebing(key, 0, 0)
def rc_hetiCao(self, data):
iCurId = self.player.map.mapSubId
mapSubRes = Game.res_mgr.res_mapSub.get(iCurId)
if not mapSubRes:
return 0, errcode.EC_NORES
hetiTime = Game.res_mgr.res_common.get("hetiTime")
if not hetiTime:
return 0, errcode.EC_NORES
nt = time.time()
if nt > self.player.heti.st + hetiTime.i + 3:
return 0, errcode.EC_HETI_TIMEOUT
if "*-*" not in self.player.heti.obj:
return 0, errcode.EC_HETI_NOFOUND
rid, score, boxtype = self.player.heti.caoPre()
obj = "*-*"
dReward = {}
if rid:
rewardRes = Game.res_mgr.res_reward.get(rid)
if not rewardRes:
return 0, errcode.EC_NORES
dReward = rewardRes.doReward()
keys = list(dReward.keys())
if boxtype == 1: #大奖
for itemid in keys:
if itemid == constant.CURRENCY_COIN:
dReward[itemid] = mapSubRes.offcoin * 300
elif boxtype == 2: #小将
for itemid in keys:
if itemid == constant.CURRENCY_COIN:
dReward[itemid] = mapSubRes.offcoin * 90
else:
obj = self.player.heti.cao()
respBag = self.player.bag.add(dReward,
constant.ITEM_ADD_HETI_REWARD,
wLog=True)
self.player.heti.addReward(dReward)
dUpdate = self.player.packRespBag(respBag)
dUpdate["heti"] = self.player.heti.to_init_data()
resp = {
"allUpdate": dUpdate,
"data": data,
"obj": obj,
"score": score,
}
return 1, resp
def rc_hetiHebing(self, obj, data1, data2):
iCurId = self.player.map.mapSubId
mapSubRes = Game.res_mgr.res_mapSub.get(iCurId)
if not mapSubRes:
return 0, errcode.EC_NORES
hetihebingReward = Game.res_mgr.res_common.get("hetihebingReward")
if not hetihebingReward:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(hetihebingReward.i)
if not rewardRes:
return 0, errcode.EC_NORES
dReward = rewardRes.doReward()
keys = list(dReward.keys())
for itemid in keys:
if itemid == constant.CURRENCY_COIN:
dReward[itemid] = mapSubRes.offcoin * 40
hetiTime = Game.res_mgr.res_common.get("hetiTime")
if not hetiTime:
return 0, errcode.EC_NORES
nt = time.time()
if nt > self.player.heti.st + hetiTime.i + 3:
return 0, errcode.EC_HETI_TIMEOUT
if obj == "*-*":
return 0, errcode.EC_PARAMS_ERR
if self.player.heti.obj.count(obj) < 2:
return 0, errcode.EC_HETI_NOFOUND
objs, score = self.player.heti.hebing(obj)
respBag = self.player.bag.add(dReward,
constant.ITEM_ADD_HETI_REWARD,
wLog=True)
self.player.heti.addReward(dReward)
dUpdate = self.player.packRespBag(respBag)
dUpdate["heti"] = self.player.heti.to_init_data()
resp = {
"allUpdate": dUpdate,
"data1": data1,
"data2": data2,
"obj": objs,
"score": score,
}
return 1, resp
def rc_hetiDel(self, obj, data):
hetiTime = Game.res_mgr.res_common.get("hetiTime")
if not hetiTime:
return 0, errcode.EC_NORES
nt = time.time()
if nt > self.player.heti.st + hetiTime.i + 3:
return 0, errcode.EC_HETI_TIMEOUT
if obj == "*-*":
return 0, errcode.EC_PARAMS_ERR
if obj not in self.player.heti.obj:
return 0, errcode.EC_HETI_NOFOUND
score = self.player.heti.delv(obj)
dUpdate = {}
dUpdate["heti"] = self.player.heti.to_init_data()
# sleep(1)
resp = {
"allUpdate": dUpdate,
"data": data,
"score": score,
"obj": "*-*",
}
return 1, resp
def rc_hetiDone(self):
orank, nrank = self.player.heti.done()
resp = {
"item": self.player.heti.item,
"score": self.player.heti.histscore,
"gold": self.player.heti.histgold,
"rank": nrank,
"rankHis": orank,
}
return 1, resp
class MarryPlayerRpc(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
def getMarryStatus(self):
return self.player.marry.getMarryStatus()
def isMarriedToday(self):
return self.player.marry.isMarriedToday()
def marryPush(self, data):
spawn(self.player.call, "marryPush", data, noresult=True)
def marryResultPush(self, data):
spawn(self.player.call, "marryResultPush", data, noresult=True)
def marrySomeone(self, pid, name, kind, marryId):
marryRes = Game.res_mgr.res_marry.get(marryId, None)
if not marryRes:
return 0
mailRes = Game.res_mgr.res_mail.get(constant.MAIL_ID_MARRY_REWARD,
None)
self.player.marry.marrySomeone(pid, kind, marryId)
reward = copy.deepcopy(marryRes.reward)
if self.player.marry.getMarryTimes() == 1:
for k, v in marryRes.firstReward.items():
reward.setdefault(k, 0)
reward[k] += v
self.player.house.setType(marryId)
content = mailRes.content % name
Game.rpc_mail_mgr.sendPersonMail(self.player.id, mailRes.title,
content, reward)
dUpdate = {}
dUpdate["wallet"] = self.player.wallet.to_update_data(
[constant.CURRENCY_BINDGOLD, constant.CURRENCY_GOLD])
dUpdate["houseInfo"] = self.player.house.to_init_data(),
dUpdate["marryInfo"] = self.player.marry.to_init_data(),
pushData = {
"result": 1,
"targetPid": pid,
"allUpdate": dUpdate,
"houseInfo": self.player.house.to_init_data(),
"marryInfo": self.player.marry.to_init_data(),
}
self.marryResultPush(pushData)
def marryPowerPush(self, id, en, num, pid, name):
self.player.marry.marryPowerPush(id, en, num, pid, name)
dUpdate = {}
dUpdate["marryInfo"] = self.player.marry.to_init_data()
pushData = {
"id": id, # 配置表id
"allUpdate": dUpdate,
}
spawn(self.player.call, "marryPowerPush", pushData, noresult=True)
def divorce(self):
self.player.marry.divorce()
spawn(self.player.call, "divorcePush", {}, noresult=True)
def addHouseExp(self, exp, kind):
self.player.house.addUnrecvExp(exp, kind)
spawn(self.player.call, "houseUpgradePush", {}, noresult=True)
class DiaoyuRpcMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
def rc_diaoyuGetData(self):
resAct = Game.res_mgr.res_activity.get(constant.ACTIVITY_DIAOYU)
serverInfo = self.player.base.GetServerInfo()
if not resAct.isOpen(serverInfo):
return 0, errcode.EC_DIAOYU_NOTOPEN
from game.mgr.room import get_rpc_diaoyu
rpc_diaoyu = get_rpc_diaoyu()
if not rpc_diaoyu:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
data = self.player.getDiaoyuInfo()
import app
rrv = rpc_diaoyu.hello(2, self.player.id, config.serverNo, app.addr,
self.player.name, data, 0, 1)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
rrv = rpc_diaoyu.get(2, self.player.id)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
# 抛事件
self.player.safe_pub(msg_define.MSG_JOIN_DIAOYU)
if not self.player.cycleDay.Query("todayHasJoinDiaoyu", 0):
self.player.safe_pub(msg_define.MSG_ACTIVITY_KF_JOIN)
self.player.cycleDay.Set("todayHasJoinDiaoyu", 1)
return 1, rrv["v"]
def rc_diaoyuExit(self):
respBag = self.player.diaoyu.exitdiaoyu()
dUpdate = self.player.packRespBag(respBag)
dUpdate["diaoyu"] = self.player.diaoyu.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_diaoyuChange(self, roomid):
from game.mgr.room import get_rpc_diaoyu
rpc_diaoyu = get_rpc_diaoyu()
if not rpc_diaoyu:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_diaoyu.changeRoom(2, self.player.id, roomid)
if not rrv:
return 0, errcode.EC_DIAOYU_CHANGEROOM_ERR
return 1, {"roomid": rrv["roomid"]}
def rc_diaoyuStatus(self, status):
self.player.diaoyu.status = status
from game.mgr.room import get_rpc_diaoyu
rpc_diaoyu = get_rpc_diaoyu()
if not rpc_diaoyu:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
data = self.player.getDiaoyuInfo()
rrv = rpc_diaoyu.update(2, self.player.id, data)
if not rrv:
return 0, errcode.EC_DIAOYU_STATUSERR
return 1, {}
def rc_diaoyudiaoyu(self):
resAct = Game.res_mgr.res_activity.get(constant.ACTIVITY_DIAOYU)
serverInfo = self.player.base.GetServerInfo()
if not resAct.isOpen(serverInfo):
return 0, errcode.EC_DIAOYU_NOTOPEN
q = self.player.diaoyu.getFish()
if not q:
return 0, errcode.EC_DIAOYU_DIAOYU_NOABLE
from game.mgr.room import get_rpc_diaoyu
rpc_diaoyu = get_rpc_diaoyu()
if not rpc_diaoyu:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
data = self.player.getDiaoyuInfo()
rrv = rpc_diaoyu.updateNoBroadcast(2, self.player.id, data)
if not rrv:
return 0, errcode.EC_DIAOYU_DIAOYUERR
dUpdate = {}
dUpdate["diaoyu"] = self.player.diaoyu.to_init_data()
resp = {"allUpdate": dUpdate, "id": q}
return 1, resp
def rc_diaoyuReward(self, quality):
respBag = self.player.diaoyu.diaoyuReward(quality)
dUpdate = self.player.packRespBag(respBag)
dUpdate["diaoyu"] = self.player.diaoyu.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_diaoyuGetUser(self, id):
from game.mgr.room import get_rpc_diaoyu
rpc_diaoyu = get_rpc_diaoyu()
if not rpc_diaoyu:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_diaoyu.getOneByServerNo(2, config.serverNo, id)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
# print("1111111111",config.serverNo,id,rrv)
data = rrv["v"]
if len(data) == 0:
return 0, errcode.EC_DIAOYU_NOFOUNDONE
resp = {}
resp["data"] = data[0]
return 1, resp
def rc_diaoyuRob(self, id, quality):
diaoyuCatchNum = Game.res_mgr.res_common.get("diaoyuCatchNum")
if not diaoyuCatchNum:
return 0, errcode.EC_NORES
diaoyuRobNum = Game.res_mgr.res_common.get("diaoyuRobNum")
if not diaoyuRobNum:
return 0, errcode.EC_NORES
diaoyuXdayReward = Game.res_mgr.res_common.get("diaoyuXdayReward")
if not diaoyuXdayReward:
return 0, errcode.EC_NORES
if self.player.diaoyu.getDiaoyuRob() >= diaoyuRobNum.i:
return 0, errcode.EC_DIAOYU_ROB_USEUP
from game.mgr.room import get_rpc_diaoyu
rpc_diaoyu = get_rpc_diaoyu()
if not rpc_diaoyu:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_diaoyu.getOneByServerNo(2, config.serverNo, id)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
data = rrv["v"]
if len(data) == 0:
return 0, errcode.EC_DIAOYU_NOFOUNDONE
if quality not in data[0]["data"]["yulou"]:
return 0, errcode.EC_DIAOYU_NOFOUNDONEFISH
res = Game.res_mgr.res_diaoyu.get(quality)
if not res:
return 0, errcode.EC_NORES
if diaoyuCatchNum.i <= data[0]["data"]["catch"]:
return 0, errcode.EC_DIAOYU_ROB_LIMIT
from game.mgr.logicgame import LogicGame
proxy = get_proxy_by_addr(data[0]["addr"], LogicGame._rpc_name_)
if not proxy:
return 0, errcode.EC_GETD_LOGIC_PROXY_ERR
fdata = self.player.GetFightData()
historydata = {
"id": self.player.id,
"name": self.player.name,
"quality": quality,
"redhp": self.player.diaoyu.hp
}
resp = proxy.diaoyuRob(self.player.id, data[0], fdata, historydata)
if not resp:
return 0, errcode.EC_CALL_LOGIC_PROXY_ERR
redhp = resp["redhp"]
self.player.diaoyu.sethp(redhp)
fightResult = resp["fightLog"]["result"].get("win", 0)
if fightResult:
self.player.diaoyu.robFishOk(quality)
self.player.diaoyu.addDiaoyuRob()
myhistory = {
"id": data[0]["id"],
"name": data[0]["name"],
"quality": quality
}
self.player.diaoyu.addHistory(2, myhistory)
iOpenDay = self.player.base.GetServerOpenDay()
reward = copy.deepcopy(res.reward)
if iOpenDay >= diaoyuXdayReward.i:
reward = copy.deepcopy(res.reward2)
respBag = self.player.bag.add(reward,
constant.ITEM_ADD_DIAOYU_ROBREWARD,
wLog=True)
else:
self.player.safe_pub(msg_define.MSG_XIANSHITUISONGLIBAO_DIAOYU_F)
myhistory = {
"id": data[0]["id"],
"name": data[0]["name"],
"quality": quality
}
self.player.diaoyu.addHistory(3, myhistory)
respBag = {}
dUpdate = self.player.packRespBag(respBag)
dUpdate["diaoyu"] = self.player.diaoyu.to_init_data()
resp["allUpdate"] = dUpdate
return 1, resp
def rc_diaoyuRank(self):
resp = {}
from game.mgr.room import get_rpc_diaoyu
rpc_diaoyu = get_rpc_diaoyu()
if not rpc_diaoyu:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
resp = rpc_diaoyu.getRankList(self.player.id)
if not resp:
return 0, errcode.EC_DIAOYU_CHANGEROOM_ERR
# resp["list"]=[]
# resp["rank"]=666
# resp["score"]=999
return 1, resp
class YishouMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
# 宠物装备穿戴(petEquipWear)
# 请求
# 宠物id(id, int)
# 装备uid(uid, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petEquipWear(self, id, uid):
# 宠物未激活
if id not in self.player.pet.all_pets:
return 0, errcode.EC_PET_NOT_ACT
wearEquip = self.player.pet.yishou_bag.getObj(uid)
if not wearEquip:
return 0, errcode.EC_PET_EQUIP_NOT_FIND
pet = self.player.pet.getPet(id)
equipRes = Game.res_mgr.res_petEquip.get(wearEquip.id)
if not equipRes:
return 0, errcode.EC_NORES
# 穿戴等级
if pet.GetLv() < equipRes.needLv:
return 0, errcode.EC_PET_EQUIP_LV_LIMIT
wearEquip = self.player.pet.yishou_bag.popObj(uid)
pos = equipRes.pos
# 已穿戴，需要替换
takeoffEquipList = []
if pet.equips.get(pos):
takeoffEquipList.append(pet.popEquip(pos))
self.player.pet.yishou_bag.doAdd(
takeoffEquipList, constant.ITEM_ADD_PET_EQUIP_TAKE_OFF)
pet.wearEquip(pos, wearEquip, id)
# 重算宠物装备属性
pet.RecalEquipAttr()
# 重算战力
self.player.attr.RecalFightAbility()
# 打包返回信息
dRole = {}
dRole["roleBase"] = {"fa": self.player.base.fa}
dPet = {}
dPet["actList"] = [pet.to_init_data()]
dPet.update(
self.player.pet.to_update_data(equips=takeoffEquipList,
delequips=[wearEquip]))
dUpdate = {}
dUpdate["pet"] = dPet
dUpdate["role"] = dRole
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物装备卸下(petEquipTakeOff)
# 请求
# 宠物id(id, int)
# 装备uid(uid, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petEquipTakeOff(self, id, uid):
# 宠物未激活
if id not in self.player.pet.all_pets:
return 0, errcode.EC_PET_NOT_ACT
pet = self.player.pet.getPet(id)
wearEquip = pet.getEquipByUid(uid)
if not wearEquip:
return 0, errcode.EC_PET_EQUIP_NOT_FIND
equipRes = Game.res_mgr.res_petEquip.get(wearEquip.id)
if not equipRes:
return 0, errcode.EC_NORES
pos = equipRes.pos
takeoffEquipList = [wearEquip]
rs = self.player.pet.yishou_bag.doAdd(
takeoffEquipList, constant.ITEM_ADD_PET_EQUIP_TAKE_OFF)
if not rs:
return 0, errcode.EC_PET_EQUIP_BAG_SIZE_LIMIT
pet.popEquip(pos)
# 重算宠物装备属性
pet.RecalEquipAttr()
# 重算战力
self.player.attr.RecalFightAbility()
# 打包返回信息
dRole = {}
dRole["roleBase"] = {"fa": self.player.base.fa}
dPet = {}
dPet["actList"] = [pet.to_init_data()]
dPet.update(self.player.pet.to_update_data(equips=takeoffEquipList))
dUpdate = {}
dUpdate["pet"] = dPet
dUpdate["role"] = dRole
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物装备强化(petEquipUpgrade)
# 请求
# 宠物id(id, int) #强化背包装备时传0
# 装备uid(uid, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petEquipUpgrade(self, id, uid):
pet = self.player.pet.getPet(id)
if pet:
equip = pet.getEquipByUid(uid)
else:
equip = self.player.pet.yishou_bag.getObj(uid)
if not equip:
return 0, errcode.EC_PET_EQUIP_NOT_FIND
equipRes = Game.res_mgr.res_petEquip.get(equip.id)
if not equipRes:
return 0, errcode.EC_NORES
nextUpRes = Game.res_mgr.res_qalv_petEquipUpgrade.get(
(equipRes.quality, equip.addlv))
if not nextUpRes:
return 0, errcode.EC_NORES
# 扣道具
respBag = self.player.bag.costItem(
nextUpRes.cost, constant.ITEM_COST_PET_EQUIP_UPGRADE, wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_PET_EQUIP_UPGRADE_NOT_ENOUGH
equip.Upgrade()
if pet:
# 重算宠物装备属性
pet.RecalEquipAttr()
# 重算战力
self.player.attr.RecalFightAbility()
# 打包返回信息
dRole = {}
dRole["roleBase"] = {"fa": self.player.base.fa}
dPet = {}
if pet:
dPet["actList"] = [pet.to_init_data()]
else:
dPet.update(self.player.pet.to_update_data(equips=[equip]))
dUpdate = self.player.packRespBag(respBag)
dUpdate["pet"] = dPet
dUpdate["role"] = dRole
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物装备共鸣替换(petEquipGongmingTihuan)
# 请求
# 宠物id(id, int) #强化背包装备时传0
# 装备uid(uid, int)
# 格子index 0 1 2(idx, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petEquipGongmingTihuan(self, id, uid, idx):
if idx not in [0, 1, 2]:
return 0, errcode.EC_NORES
# print("!!!!!!!!!!!!!!!!!",id, uid, idx)
pet = self.player.pet.getPet(id)
if pet:
equip = pet.getEquipByUid(uid)
else:
equip = self.player.pet.yishou_bag.getObj(uid)
if not equip:
return 0, errcode.EC_PET_EQUIP_NOT_FIND
equip.usegongming(idx)
dRole = {}
if pet:
# 重算宠物装备属性
pet.RecalEquipAttr()
# 重算战力
self.player.attr.RecalFightAbility()
dRole["roleBase"] = {"fa": self.player.base.fa}
dPet = {}
if pet:
dPet["actList"] = [pet.to_init_data()]
else:
dPet.update(self.player.pet.to_update_data(equips=[equip]))
# print("======",dPet)
dUpdate = {}
dUpdate["pet"] = dPet
dUpdate["role"] = dRole
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物装备共鸣(petEquipGongming)
# 请求
# 宠物id(id, int) #强化背包装备时传0
# 装备uid(uid, int)
# 绑定宠物id(bindpet, int) #绑定的宠物id,不绑定传0
# 被吃掉的装备uid(eatuid, int)
# 格子index 0 1 2(idx, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petEquipGongming(self, id, uid, bindpet, eatuid, idx):
# print("!!!!!!!!!!!!!!!!!",id, uid, bindpet, eatuid, idx)
if idx not in [0, 1, 2]:
return 0, errcode.EC_PET_EQUIP_GONGMING_BAD_IDX
pet = self.player.pet.getPet(id)
if pet:
equip = pet.getEquipByUid(uid)
else:
equip = self.player.pet.yishou_bag.getObj(uid)
if not equip:
# print("!!!!!!!!!!!!!!!!!33333")
return 0, errcode.EC_PET_EQUIP_NOT_FIND
if bindpet:
bpet = self.player.pet.getPet(bindpet)
if not bpet:
return 0, errcode.EC_PET_EQUIP_GONGMING_NOFOUND_BIND_PET
eatequip = self.player.pet.yishou_bag.getObj(eatuid)
if not eatequip:
return 0, errcode.EC_PET_EQUIP_GONGMING_NOFOUND_EAT
eatequipRes = Game.res_mgr.res_petEquip.get(eatequip.id)
if not eatequipRes:
return 0, errcode.EC_NORES
equipRes = Game.res_mgr.res_petEquip.get(equip.id)
if not equipRes:
return 0, errcode.EC_NORES
if eatequipRes.quality != equipRes.quality:
return 0, errcode.EC_PET_EQUIP_GONGMING_TYPE_NOTSAME
oriType = 0
if bindpet:
evolveRes = Game.res_mgr.res_idlv_petevolve.get(
(bpet.id, bpet.evolveLv))
if not evolveRes:
# print("!!!!!!!!!!!!!!!!!===")
return 0, errcode.EC_NORES
oriType = evolveRes.oriType
if oriType == 2:
oriType = 1
# 扣道具
equipCost = self.player.pet.yishou_bag.popObj(eatuid)
if not equipCost:
return 0, errcode.EC_PET_EQUIP_GONGMING_EAT_FAIL
choose = []
for kk, vv in Game.res_mgr.res_shoulinggongming.items():
if vv.oriType == oriType and idx == vv.idx:
choose.append((
kk,
vv.weight,
))
cid = utility.Choice(choose)
equip.gongming(idx, cid, bindpet)
dPet = {}
if pet:
dPet["actList"] = [pet.to_init_data()]
dPet.update(self.player.pet.to_update_data(delequips=[equipCost]))
else:
dPet.update(
self.player.pet.to_update_data(equips=[equip],
delequips=[equipCost]))
# print("eeeeeeeeeeeee",dPet)
dUpdate = {}
dUpdate["pet"] = dPet
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物装备强化-定向(petEquipUpgradeDir)
# 请求
# 装备uid(uid, int)
# 道具id(itemid, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petEquipUpgradeDir(self, id, uid, itemid):
pet = self.player.pet.getPet(id)
if pet:
equip = pet.getEquipByUid(uid)
else:
equip = self.player.pet.yishou_bag.getObj(uid)
if not equip:
return 0, errcode.EC_PET_EQUIP_NOT_FIND
itemres = Game.res_mgr.res_item.get(itemid)
if not itemres:
return 0, errcode.EC_NORES
if itemres.type != 2:
return 0, errcode.EC_NORES
if itemres.subType != 16:
return 0, errcode.EC_NORES
equipRes = Game.res_mgr.res_petEquip.get(equip.id)
if not equipRes:
return 0, errcode.EC_NORES
ysDirCardUpLv = Game.res_mgr.res_common.get("ysDirCardUpLv")
if not ysDirCardUpLv:
return 0, errcode.EC_NORES
ysDirCardUseNum = Game.res_mgr.res_common.get("ysDirCardUseNum")
if not ysDirCardUseNum:
return 0, errcode.EC_NORES
nextlv = 0
for v in reversed(ysDirCardUpLv.arrayint1):
if equip.addlv < v:
nextlv = v
if not nextlv:
return 0, errcode.EC_NORES
upnum = nextlv - equip.addlv
cost = {itemid: ysDirCardUseNum.arrayint1[equip.dicnum]}
respBag = self.player.bag.costItem(
cost, constant.ITEM_COST_PET_EQUIP_UPGRADE, wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_PET_EQUIP_UPGRADE_NOT_ENOUGH
addvice = False
for upx in range(upnum):
nextUpRes = Game.res_mgr.res_qalv_petEquipUpgrade.get(
(equipRes.quality, equip.addlv))
if not nextUpRes:
return 0, errcode.EC_NORES
# 扣道具
respBag1 = self.player.bag.costItem(
nextUpRes.cost,
constant.ITEM_COST_PET_EQUIP_UPGRADE,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_PET_EQUIP_UPGRADE_NOT_ENOUGH
respBag = self.player.mergeRespBag(respBag, respBag1)
if upx == upnum - 1:
addvice = True
equip.UpgradeDir(itemres.arg1, addvice)
equip.dicnum += 1
equip.markDirty()
if pet:
# 重算宠物装备属性
pet.RecalEquipAttr()
# 重算战力
self.player.attr.RecalFightAbility()
# 打包返回信息
dRole = {}
dRole["roleBase"] = {"fa": self.player.base.fa}
dPet = {}
if pet:
dPet["actList"] = [pet.to_init_data()]
else:
dPet.update(self.player.pet.to_update_data(equips=[equip]))
dUpdate = self.player.packRespBag(respBag)
dUpdate["pet"] = dPet
dUpdate["role"] = dRole
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物装备回收(petEquipRecycl)
# 请求
# 装备uid列表(uidList, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petEquipRecycl(self, uidList):
delequips = []
reward = {}
for uid in uidList:
equip = self.player.pet.yishou_bag.popObj(uid)
if not equip:
continue
equipRes = Game.res_mgr.res_petEquip.get(equip.id)
if not equipRes:
continue
upRes = Game.res_mgr.res_qalv_petEquipUpgrade.get(
(equipRes.quality, equip.addlv))
if not upRes:
continue
for id, num in upRes.recycl.items():
if id in reward:
reward[id] += num
else:
reward[id] = num
delequips.append(equip)
respBag = self.player.bag.add(reward,
constant.ITEM_ADD_PET_EQUIP_RECYCL,
wLog=True)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dPet = dUpdate.setdefault("pet", {})
dPet.update(self.player.pet.to_update_data(delequips=delequips))
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物装备上锁(petEquipLock)
# 请求
# 宠物id(id, int) #背包装备时传0
# 装备uid(uid, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petEquipLock(self, id, uid):
pet = self.player.pet.getPet(id)
if pet:
equip = pet.getEquipByUid(uid)
else:
equip = self.player.pet.yishou_bag.getObj(uid)
if not equip:
return 0, errcode.EC_PET_EQUIP_NOT_FIND
equip.Lock()
# 打包返回信息
dPet = {}
if pet:
dPet["actList"] = [pet.to_init_data()]
else:
dPet.update(self.player.pet.to_update_data(equips=[equip]))
dUpdate = {}
dUpdate["pet"] = dPet
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物装备解锁(petEquipUnLock)
# 请求
# 宠物id(id, int) #背包装备时传0
# 装备uid(uid, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petEquipUnLock(self, id, uid):
pet = self.player.pet.getPet(id)
if pet:
equip = pet.getEquipByUid(uid)
else:
equip = self.player.pet.yishou_bag.getObj(uid)
if not equip:
return 0, errcode.EC_PET_EQUIP_NOT_FIND
equip.UnLock()
# 打包返回信息
dPet = {}
if pet:
dPet["actList"] = [pet.to_init_data()]
else:
dPet.update(self.player.pet.to_update_data(equips=[equip]))
dUpdate = {}
dUpdate["pet"] = dPet
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物装备弃置(petEquipSetWaste)
# 请求
# 宠物id(id, int) #背包装备时传0
# 装备uid(uid, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petEquipSetWaste(self, id, uid):
pet = self.player.pet.getPet(id)
if pet:
equip = pet.getEquipByUid(uid)
else:
equip = self.player.pet.yishou_bag.getObj(uid)
if not equip:
return 0, errcode.EC_PET_EQUIP_NOT_FIND
equip.setWaste()
# 打包返回信息
dPet = {}
if pet:
dPet["actList"] = [pet.to_init_data()]
else:
dPet.update(self.player.pet.to_update_data(equips=[equip]))
dUpdate = {}
dUpdate["pet"] = dPet
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物装备不弃置(petEquipUnSetWaste)
# 请求
# 宠物id(id, int) #背包装备时传0
# 装备uid(uid, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petEquipUnSetWaste(self, id, uid):
pet = self.player.pet.getPet(id)
if pet:
equip = pet.getEquipByUid(uid)
else:
equip = self.player.pet.yishou_bag.getObj(uid)
if not equip:
return 0, errcode.EC_PET_EQUIP_NOT_FIND
equip.UnSetWaste()
# 打包返回信息
dPet = {}
if pet:
dPet["actList"] = [pet.to_init_data()]
else:
dPet.update(self.player.pet.to_update_data(equips=[equip]))
dUpdate = {}
dUpdate["pet"] = dPet
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物装备背包扩容(petEquipBagSizeBuy)
# 请求
# 扩容次数(count, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petEquipBagSizeBuy(self, count):
yishouBagBuyAddSizeRes = Game.res_mgr.res_common.get(
"yishouzhilingBuyBagSizeSpacing")
if not yishouBagBuyAddSizeRes:
return 0, errcode.EC_NORES
yishouBagBuyMaxCountRes = Game.res_mgr.res_common.get(
"yishouBagBuyMaxCount")
if not yishouBagBuyMaxCountRes:
return 0, errcode.EC_NORES
yishouBagBuyCostRes = Game.res_mgr.res_common.get(
"yishouzhilingBuyBagSizeCost")
if not yishouBagBuyCostRes:
return 0, errcode.EC_NORES
if count + self.player.pet.yishou_bag.buy_count > yishouBagBuyMaxCountRes.i:
return 0, errcode.EC_PET_EQUIP_ADD_BAG_SIZE_MAX
total = 0
curCount = self.player.pet.yishou_bag.buy_count
for i in range(count):
curCount += 1
for one in yishouBagBuyCostRes.arrayint2:
start, end, price = one
if start <= curCount <= end:
total += price
# 扣道具
cost = {constant.CURRENCY_GOLD: total}
respBag = self.player.bag.costItem(
cost, constant.ITEM_COST_YISHOU_BAG_SIZE_ADD, wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_PET_EQUIP_ADD_BAG_SIZE
self.player.pet.yishou_bag.addSize(yishouBagBuyAddSizeRes.i * count)
self.player.pet.yishou_bag.addBuyCount(count)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dPet = dUpdate.setdefault("pet", {})
dPet["yishou_bag"]["size"] = self.player.pet.yishou_bag.size
dPet["yishou_bag"]["buyCount"] = self.player.pet.yishou_bag.buy_count
dUpdate["pet"] = dPet
resp = {
"allUpdate": dUpdate,
}
return 1, resp
class ZhudaoxunliRpcMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
def rc_zhudaoxunliInit(self):
if not self.player.zhudaoxunli.time:
self.player.zhudaoxunli.time=time.time()
self.player.zhudaoxunli.markDirty()
dUpdate = {}
dUpdate["zhudaoxunli"] = self.player.zhudaoxunli.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_zhudaoxunliBuyScore(self,num):
if not self.player.zhudaoxunli.time:
return 0,errcode.EC_ZHUDAOXUNLI_NOTOPEN
zhudaoxunliBuy = Game.res_mgr.res_common.get("zhudaoxunliBuy")
if not zhudaoxunliBuy:
return 0, errcode.EC_NORES
cost={}
for k,v in zhudaoxunliBuy.arrayint2.items():
cost[k]=v*num
respBag = self.player.bag.costItem(cost, constant.ITEM_COST_ZHUDAOXUNLI_BUYSOCRE, wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_NOT_ENOUGH
self.player.zhudaoxunli.addscore(num*zhudaoxunliBuy.i)
dUpdate = self.player.packRespBag(respBag)
dUpdate["zhudaoxunli"] = self.player.zhudaoxunli.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_zhudaoxunliReward(self,resid):
if not self.player.zhudaoxunli.time:
return 0,errcode.EC_ZHUDAOXUNLI_NOTOPEN
res = Game.res_mgr.res_zhudaoxunliReward.get(resid)
if not res:
return 0, errcode.EC_NORES
d=None
for v in self.player.zhudaoxunli.data:
if v["qihao"]==res.qihao:
d=v
break
if not d:
return 0, errcode.EC_NORES
if d["score"]<res.need:
return 0,errcode.EC_ZHUDAOXUNLI_NONEED
if res.id in d["reward"]:
return 0,errcode.EC_ZHUDAOXUNLI_ALREADY
respBag = self.player.bag.add(res.reward, constant.ITEM_ADD_ZHUDAOXUNLI_REWARD, wLog=True)
self.player.zhudaoxunli.setreward(res.qihao,res.id)
dUpdate = self.player.packRespBag(respBag)
dUpdate["zhudaoxunli"] = self.player.zhudaoxunli.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_zhudaoxunliRewardVip(self,resid):
if not self.player.zhudaoxunli.time:
return 0,errcode.EC_ZHUDAOXUNLI_NOTOPEN
res = Game.res_mgr.res_zhudaoxunliReward.get(resid)
if not res:
return 0, errcode.EC_NORES
d=None
for v in self.player.zhudaoxunli.data:
if v["qihao"]==res.qihao:
d=v
break
if not d:
return 0, errcode.EC_NORES
if not d["isVip"]:
return 0,errcode.EC_ZHUDAOXUNLI_NOVIP
if d["score"]<res.need:
return 0,errcode.EC_ZHUDAOXUNLI_NONEED
if res.id in d["rewardVip"]:
return 0,errcode.EC_ZHUDAOXUNLI_ALREADY
respBag = self.player.bag.add(res.rewardVip, constant.ITEM_ADD_ZHUDAOXUNLI_REWARD, wLog=True)
self.player.zhudaoxunli.setrewardVip(res.qihao,res.id)
dUpdate = self.player.packRespBag(respBag)
dUpdate["zhudaoxunli"] = self.player.zhudaoxunli.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
class VipMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
def rc_vipDayReward(self, lv):
"""vip每日奖励"""
vipLv = self.player.vip.GetVipLv()
vipRes = Game.res_mgr.res_vip.get(lv, None)
if not vipRes:
return 0, errcode.EC_NORES
if vipLv < lv:
return 0, errcode.EC_VIP_REWARD_ALREADY
getList = self.player.vip.GetVIPDayRewardList()
if lv in getList:
return 0, errcode.EC_VIP_REWARD_NOTABLE
reward = copy.deepcopy(vipRes.dayReward)
resAct = Game.res_mgr.res_activity.get(constant.ACTIVITY_VIPDAYREWARD)
serverInfo = self.player.base.GetServerInfo()
if resAct.isOpen(serverInfo):
for k, v in reward.items():
reward[k] = reward[k] * 2
respBag = self.player.bag.add(reward,
constant.ITEM_ADD_VIP_DAY_REWARD,
wLog=True)
getList.append(lv)
self.player.vip.SetVIPDayRewardList(getList)
dUpdate = self.player.packRespBag(respBag)
dUpdate["vipInfo"] = self.player.vip.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_vipReward(self, lv):
res = Game.res_mgr.res_vip.get(lv)
if not res:
return 0, errcode.EC_NORES
retval = self.player.vip.vipReward(lv)
if retval == 1:
return 0, errcode.EC_VIP_REWARD_ALREADY
elif retval == 2:
return 0, errcode.EC_VIP_REWARD_NOTABLE
respBag = self.player.bag.costItem(res.cost,
constant.ITEM_COST_VIP_REWARD,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_COST_ERR
respBag1 = self.player.bag.add(res.reward,
constant.ITEM_ADD_VIP_REWARD,
wLog=True)
respBag = self.player.mergeRespBag(respBag, respBag1)
self.player.vip.setVipReward(lv)
dUpdate = self.player.packRespBag(respBag)
dUpdate["vipInfo"] = self.player.vip.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_vipMonthReward(self):
res = Game.res_mgr.res_common.get("monthCardDailyReward")
if not res:
return 0, errcode.EC_NORES
retval = self.player.vip.vipRewardMonth()
if not retval:
return 0, errcode.EC_VIP_REWARD_NOTABLE_MONTH
respBag = self.player.bag.add(res.arrayint2,
constant.ITEM_ADD_VIP_REWARD_MONTH,
wLog=True)
dUpdate = self.player.packRespBag(respBag)
dUpdate["vipInfo"] = self.player.vip.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_vipWeekReward(self):
res = Game.res_mgr.res_common.get("weekCardDailyReward")
if not res:
return 0, errcode.EC_NORES
retval = self.player.vip.vipRewardWeek()
if not retval:
return 0, errcode.EC_VIP_REWARD_NOTABLE_WEEK
respBag = self.player.bag.add(res.arrayint2,
constant.ITEM_ADD_VIP_REWARD_WEEK,
wLog=True)
dUpdate = self.player.packRespBag(respBag)
dUpdate["vipInfo"] = self.player.vip.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_schdGift(self):
res = Game.res_mgr.res_schd.get(self.player.charge.schdCharge + 1)
if not res:
return 0, errcode.EC_NORES
if self.player.charge.schdChargeRMB < res.rmb:
return 0, errcode.EC_VIP_REWARD_NOTABLE
self.player.charge.schdChargeReward()
respBag = self.player.bag.add(res.reward,
constant.ITEM_ADD_SCHD,
wLog=True)
dUpdate = self.player.packRespBag(respBag)
dUpdate["chargeInfo"] = self.player.charge.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_dbscGift(self, id):
res = Game.res_mgr.res_charge.get(id)
if not res:
return 0, errcode.EC_NORES
if id not in self.player.charge.dbscid:
return 0, errcode.EC_DBSC_REWARD_NOTABLE
if id in self.player.charge.dbscreward:
return 0, errcode.EC_DBSC_REWARD_ALREADY
Game.glog.log2File("rc_dbscGift", "%s %s" % (self.player.id, id))
self.player.charge.dbscReward(id)
reward = copy.deepcopy(res.dbscReward)
resAct = Game.res_mgr.res_activity.get(
constant.ACTIVITY_CHARGE_TLREWAD)
if resAct:
serverInfo = self.player.base.GetServerInfo()
if resAct.isOpen(serverInfo):
if id not in self.player.charge.ChargeIDs:
self.player.charge.ChargeIDs.append(id)
for k, v in res.tlreward.items():
reward[k] = reward.get(k, 0) + v
respBag = self.player.bag.add(reward,
constant.ITEM_ADD_DBSC,
wLog=True)
dUpdate = self.player.packRespBag(respBag)
dUpdate["chargeInfo"] = self.player.charge.to_init_data()
resp = {
"allUpdate": dUpdate,
}
Game.glog.log2File("rc_dbscGift", "%s|%s" % (self.player.id, resp))
return 1, resp
def rc_vipBattleJump(self):
battleJumpNum = self.player.vip.getBattleJumpNum()
if battleJumpNum == -1:
return 1, {}
elif battleJumpNum == 0:
#扣道具
costRes = Game.res_mgr.res_common.get("battleJumpCost")
if not costRes:
return 0, errcode.EC_NORES
respBag = self.player.bag.costItem(costRes.arrayint2,
constant.ITEM_COST_BATTLE_JUMP,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_BATTLE_JUMP_NOT_ENOUGH
dUpdate = self.player.packRespBag(respBag)
dUpdate["vipInfo"] = self.player.vip.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
else:
#扣次数
battleJumpNum -= 1
self.player.vip.setBattleJumpNum(battleJumpNum)
dUpdate = {}
dUpdate["vipInfo"] = self.player.vip.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_vipZhiZunReward(self):
res = Game.res_mgr.res_common.get("zhizunCardDailyReward")
if not res:
return 0, errcode.EC_NORES
if not self.player.vip.zhizunCardFlag:
return 0, errcode.EC_ZHIZUN_CARD_NO_HAVE
isGet = self.player.vip.GetTodayZhiZunRewardFlag()
if isGet:
return 0, errcode.EC_ZHIZUN_CARD_DAYREWARD_HAS_GET
respBag = self.player.bag.add(res.arrayint2,
constant.ITEM_ADD_VIP_REWARD_ZHIZUN,
wLog=True)
self.player.vip.SetTodayZhiZunRewardFlag(1)
dUpdate = self.player.packRespBag(respBag)
dUpdate["vipInfo"] = self.player.vip.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
class FriendMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
# 获取关注列表(getFollowList)
# 请求
# 返回
# 关注列表(followList, [json])
# 玩家id(pid, int)
# 角色名字(name, string)
# 战力(fa, int)
# 等级(lv, int)
# vip等级(vip, int)
# 性别(sex, int)
# 0=? 1=男 2=女
# 在线状态(online, int)
# 0=不在线 1=在线
# 赠送状态(presentStatus, int)
# 0=未赠送 1=已赠送
# 是否粉丝(isFan, int)
# 0=否 1=是
def rc_getFollowList(self):
fl, num = Game.rpc_friend_mgr.getFollowList(self.player.id)
resp = {
"followList": fl,
"presentNum": num,
}
return 1, resp
# 获取粉丝列表(getFanList)
# 请求
# 返回
# 粉丝列表(fanList, [json])
# 玩家id(pid, int)
# 角色名字(name, string)
# 战力(fa, int)
# 等级(lv, int)
# vip等级(vip, int)
# 性别(sex, int)
# 0=? 1=男 2=女
# 在线状态(online, int)
# 0=不在线 1=在线
# 接收状态(receiveStatus, int)
# 0=未接收 1=已接收
# 是否粉丝(isFan, int)
# 0=否 1=是
# 能否接收(canReceive, int)
# 0=不能 1=能
def rc_getFanList(self):
fl, num = Game.rpc_friend_mgr.getFanList(self.player.id)
resp = {
"fanList": fl,
"receiveNum": num,
}
return 1, resp
# 获取黑名单(getBlackList)
# 请求
# 返回
# 黑名单(blackList, [json])
# 玩家id(pid, int)
# 角色名字(name, string)
# 战力(fa, int)
# 等级(lv, int)
# vip等级(vip, int)
# 性别(sex, int)
# 0=? 1=男 2=女
# 在线状态(online, int)
# 0=不在线 1=在线
def rc_getBlackList(self):
resp = {"blackList": Game.rpc_friend_mgr.getBlackList(self.player.id)}
return 1, resp
# 获取推荐列表(getRecommendList)
# 请求
# 返回
# 黑名单(recommendList, [json])
# 玩家id(pid, int)
# 角色名字(name, string)
# 战力(fa, int)
# 等级(lv, int)
# vip等级(vip, int)
# 性别(sex, int)
# 0=? 1=男 2=女
# 在线状态(online, int)
# 0=不在线 1=在线
def rc_getRecommendList(self):
resp = {
"recommendList":
Game.rpc_friend_mgr.getRecommendList(self.player.id)
}
return 1, resp
# 关注(addFollow)
# 请求
# 玩家id(pid, int)
# 返回
# 玩家id(pid, int)
def rc_addFollow(self, pid):
code, status = Game.rpc_friend_mgr.addFollow(self.player.id, pid)
if code:
return 0, code
# 抛事件
self.player.safe_pub(msg_define.MSG_ADD_FOLLOW_FRIEND)
return 1, {"pid": pid, "presentStatus": status}
# 取消关注(delFollow)
# 请求
# 玩家id(pid, int)
# 返回
# 玩家id(pid, int)
def rc_delFollow(self, pid):
code = Game.rpc_friend_mgr.delFollow(self.player.id, pid)
if code:
return 0, code
return 1, {"pid": pid}
# 拉入黑名单(addBlack)
# 请求
# 玩家id(pid, int)
# 返回
# 玩家id(pid, int)
def rc_addBlack(self, pid):
code = Game.rpc_friend_mgr.addBlack(self.player.id, pid)
if code:
return 0, code
return 1, {"pid": pid}
# 取消黑名单(delBlack)
# 请求
# 玩家id(pid, int)
# 返回
# 玩家id(pid, int)
def rc_delBlack(self, pid):
code = Game.rpc_friend_mgr.delBlack(self.player.id, pid)
if code:
return 0, code
return 1, {"pid": pid}
# 赠送(presentFollow)
# 请求
# 玩家id(pid, int)
# 返回
# 玩家id(pid, int)
# 赠送状态(presentStatus, int)
# 0=未发送 1=已发送
def rc_presentFollow(self, pid):
code = Game.rpc_friend_mgr.presentFollow(self.player.id, pid)
if code:
return 0, code
# 抛事件
self.player.safe_pub(msg_define.MSG_FRIEND_SEND)
return 1, {"pid": pid}
# 一键赠送(oneKeyPresentFollow)
# 请求
# 返回
def rc_oneKeyPresentFollow(self):
code = Game.rpc_friend_mgr.oneKeyPresentFollow(self.player.id)
if code:
return 0, code
# 抛事件
self.player.safe_pub(msg_define.MSG_FRIEND_SEND)
return 1, None
# 接收(receiveFan)
# 请求
# 玩家id(pid, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-货币
# 玩家id(pid, int)
# 接收状态(receiveStatus, int)
# 0=未接收 1=已接收
def rc_receiveFan(self, pid):
code = Game.rpc_friend_mgr.receiveFan(self.player.id, pid)
if code:
return 0, code
respBag = self.player.bag.add({constant.CURRENCY_FRIEND_COIN: 1},
constant.ITEM_ADD_FRIEND_RECEIVE,
wLog=True)
dUpdate = self.player.packRespBag(respBag)
resp = {
"allUpdate": dUpdate,
"pid": pid,
}
return 1, resp
# 一键接收(oneKeyReceiveFan)
# 请求
# 玩家id列表(pidList, [int])
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 货币
def rc_oneKeyReceiveFan(self, pidList):
code, num = Game.rpc_friend_mgr.oneKeyReceiveFan(
self.player.id, pidList)
if code:
return 0, code
respBag = self.player.bag.add({constant.CURRENCY_FRIEND_COIN: num},
constant.ITEM_ADD_FRIEND_RECEIVE,
wLog=True)
dUpdate = self.player.packRespBag(respBag)
resp = {
"allUpdate": dUpdate,
}
return 1, resp
class BasePlayerHander(AbsExport):
DEBUG = 0
MAIN_RPC = 1 # 是否rpc主连接
if 0:
from game.core import player as player_md
player = player_md.Player()
from game.common.gateway import Processer
rpc = Processer()
def __init__(self):
setattr(self, 'player', None)
setattr(self, 'rpc', None)
@property
def pid(self):
return self.player.data.id if self.player else None
@property
def addr(self):
return self.rpc.addr
def uninit(self):
setattr(self, 'player', None)
self.set_rpc(None)
def set_player(self, player):
setattr(self, 'player', player)
def set_rpc(self, process):
log.debug('player(%s) handler(%s) set_rpc(%s)', self.pid, id(self),
id(process) if process is not None else process)
if self.rpc:
self.rpc.close(client=bool(self.MAIN_RPC))
setattr(self, 'rpc', process)
if process:
self.rpc.set_export(self)
def on_close(self, process):
""" 断线处理 """
log.debug('[handler]player(%s)on_close', self.pid)
self.set_rpc(None)
if self.player:
self.player.on_close()
def call(self, fname, data, noresult=False, timeout=None):
if self.rpc is None:
log.warning('***send(fname=%s, data=%s) error: player(%s).handler(%s) ?? handler(%s) rpc_is_None', fname, data,
id(self.player) if self.player else None,
id(self.player._handler) if self.player else None,
id(self))
return
if self.DEBUG:
log.debug('send-- fname %s, data %s', fname, data)
self.rpc.call(fname, data, noresult=noresult, timeout=timeout)
def getProcesserInfo(self):
if self.rpc is None:
log.warning('***getProcesserInfo error: player(%s).handler(%s) ?? handler(%s) rpc_is_None',
id(self.player) if self.player else None,
id(self.player._handler) if self.player else None,
id(self))
return
return self.rpc.getProcesserInfo()
def stop(self):
log.debug('[handler]player(%s)stop', self.pid)
self.set_rpc(None)
def force_close(self):
""" 服务器强制网关断开连接 """
self.rpc.force_close()
def router(self, addr_fnams):
"""
添加gateway router
addr_fnames为{"addr":["f1","f2"]}格式
"""
if self.rpc:
self.rpc.router(addr_fnams)
def remove_router(self, addr):
self.rpc.remove_router(addr)
class GuildRpcMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
# 打开帮会主界面(openGuildUI)
# 请求
# 帮会id(guildId, string)
# 返回
# 公告(notice, string) 做时间戳校验，客户端如果取到空不做处理
# 帮主名称(bzName, string)
# 帮会资金(exp, int)
# 帮会人数(num, int)
def rc_openGuildUI(self, guildId):
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
resp = rpc_guild.to_openUI_dict()
return 1, resp
# 创建帮会(createGuild)
# 请求
# 帮会名称(name, string)
# 帮会等级(lv, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 帮会信息
# 游戏模型 - 货币
def rc_createGuild(self, name, lv):
guildlvRes = Game.res_mgr.res_guildlv.get(lv)
if not guildlvRes:
return 0, errcode.EC_NORES
createLvRes = Game.res_mgr.res_common.get("guildCreateLv", [])
if not createLvRes:
return 0, errcode.EC_NORES
if lv not in createLvRes.arrayint1:
return 0, errcode.EC_GUILD_CREATE_LV_ERR
#vip限制
iVip = self.player.vip.GetVipLv()
if iVip < guildlvRes.vip:
return 0, errcode.EC_GUILD_CREATE_VIP_LIMIT
d = Game.store.query_loads(Guild.DATA_CLS.TABLE_NAME, dict(name=name))
if d:
return 0, errcode.EC_GUILD_NAME_REPET
# 扣道具
respBag = self.player.bag.costItem(guildlvRes.cost,
constant.ITEM_COST_CREATE_GUILD,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_GUILD_CREATE_NOT_ENOUGH
#个人信息
playerInfo = self.player.guild.to_guild_update()
rs, guildId = Game.rpc_guild_mgr.CreateGuild(name, lv, playerInfo)
if not rs:
#返回扣除的材料
self.player.bag.add(guildlvRes.cost,
constant.ITEM_ADD_GUILD_CREATE_FAIL,
wLog=True)
return 0, errcode.EC_GUILD_CREATE_FAIL
self.player.guild.SetGuildId(guildId)
# self.player.task.initGuildActTasks()
# self.player.task.initGuildActRewardTasks()
# 抛事件
self.player.safe_pub(msg_define.MSG_JOIN_GUILD)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["guildInfo"] = self.player.guild.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 申请/取消入帮(enterGuild)
# 请求
# 帮会id(guildId, string)
# 类型(type, int)
# 0=取消 1=申请
# 返回
# 帮会id(guildId, string)
# 类型(type, int)
# 0=未申请 1=已申请
def rc_enterGuild(self, guildId, type):
if self.player.guild.GetGuildId():
return 0, errcode.EC_GUILD_HAS_JOIN
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
playerInfo = self.player.guild.to_guild_update()
rs, err = rpc_guild.enterGuild(type, playerInfo)
if not rs:
return rs, err
# 打包返回信息
resp = {
"guildId": guildId,
"type": type,
}
return 1, resp
# 帮会申请批复respGuild
# 请求
# 角色id(rid, int)
# 类型(type, int)
# 0=拒绝 1=同意
# 返回
# 角色id(rid, int)
# 类型(type, int)
# 0=拒绝 1=同意
def rc_respGuild(self, rid, type):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
rs, data = rpc_guild.respGuild(self.player.id, rid, type)
if not rs:
return rs, data
# 打包返回信息
resp = {
"rid": rid,
"type": type,
"num": data,
}
return 1, resp
# 帮会成员操作(guildOper)
# 请求
# 角色id(rid, int)
# 类型(type, int)
# 1=禅让 2=升职 3=降职 4=踢出
# 返回
# 角色id(rid, int)
# 类型(type, int)
# 1=禅让 2=升职 3=降职 4=踢出
def rc_guildOper(self, rid, type):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
rs, data = rpc_guild.guildOper(self.player.id, rid, type)
if not rs:
return rs, data
# 打包返回信息
resp = {
"rid": rid,
"type": type,
"num": data,
}
return 1, resp
# 退出帮会(exitGuild)
# 请求
# 返回
# 注意：客户端要清除帮会模块的本地数据
def rc_exitGuild(self):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
rs, err = rpc_guild.exitGuild(self.player.id)
if not rs:
return rs, err
self.player.guild.SetGuildId(0)
# 打包返回信息
return 1, None
# 帮会改名(guildChangeName)
# 请求
# 帮会名称(name, string)
# 返回
# 帮会名称(name, string)
def rc_guildChangeName(self, name):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
d = Game.store.query_loads(Guild.DATA_CLS.TABLE_NAME, dict(name=name))
if d:
return 0, errcode.EC_GUILD_NAME_REPET
rs, err = rpc_guild.changeName(self.player.id, name)
if not rs:
return rs, err
# 打包返回信息
resp = {
"name": name,
}
return 1, resp
# 帮会改颜色(guildChangeColor)
# 请求
# 帮会名称(color, string)
# 返回
# 帮会名称(color, string)
def rc_guildChangeColor(self, color):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
rs, err = rpc_guild.changeColor(self.player.id, color)
if not rs:
return rs, err
# 打包返回信息
resp = {
"color": color,
}
return 1, resp
# 修改帮会公告(fixGuildNotice)
# 请求
# 帮会公告(notice, string)
# 返回
# 帮会公告(notice, string)
def rc_fixGuildNotice(self, notice):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
rs, err = rpc_guild.fixNotice(self.player.id, notice)
if not rs:
return rs, err
# 打包返回信息
resp = {
"notice": notice,
}
return 1, resp
# 查看帮会记录(getGuildRecord)
# 请求
# 返回
# 记录列表(recordList, [json])
# 类型(type, int)
# 1=加入帮会 2=退出帮会 3=被踢 4=升职 5=降职 6=禅让
# 参数(args, [string])
# 时间戳(time, int)
def rc_getGuildRecord(self):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
logs = rpc_guild.getLogs()
recordList = []
for one in logs:
iTime, args, type = one
recordList.append({"type": type, "time": iTime, "args": args})
# 打包返回信息
resp = {
"recordList": recordList,
}
return 1, resp
# 请求帮会成员列表(getGuildMember)
# 请求
# 返回
# 成员列表(roleList, [json])
# 角色id(rid, int)
# 角色名字(name, string)
# 战力(fa, int)
# 最后一次离线时间戳(time, int)
# 0=在线
# 性别(sex, int)
# 0=? 1=男 2=女
# 职位(job, int)
# 1=帮主 2=副帮主 3=成员
# 对当前帮会的累计贡献(bgCoin, int)
def rc_getGuildMember(self):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
roleList = rpc_guild.getMembers()
# 打包返回信息
resp = {
"roleList": roleList,
}
return 1, resp
# 查看帮会申请列表(getEnterGuild)
# 请求
# 返回
# 申请列表(enterList, [json])
# 角色id(rid, int)
# 角色名字(name, string)
# 战力(fa, int)
# 性别(sex, int)
# 0=? 1=男 2=女
# 等级(lv, int)
# 是否自动入帮(autoEnter, int)
# 自动入帮战力(autoFa, int)
def rc_getEnterGuild(self):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
resp = rpc_guild.getApplyData()
return 1, resp
# 修改自动入帮条件(fixEnterGuild)
# 请求
# 是否自动入帮(autoEnter, int)
# 自动入帮战力(autoFa, int)
# 返回
# 是否自动入帮(autoEnter, int)
# 自动入帮战力(autoFa, int)
def rc_fixEnterGuild(self, autoEnter, autoFa):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
rs, err = rpc_guild.fixAutoEnter(self.player.id, autoEnter, autoFa)
if not rs:
return rs, err
# 打包返回信息
resp = {
"autoEnter": autoEnter,
"autoFa": autoFa,
}
return 1, resp
# 查看帮会列表(getGuildList)
# 请求
# 返回
# 帮会列表(guildList, [json])
# 帮会id(guildId, string)
# 帮会名称(name, string)
# 帮主名称(bzName, string)
# 帮会等级(guildLv, int)
# 当前人数(num, int)
# 需要战力(fa, int)
# 是否已申请(status, int)
# 0=未申请 1=已申请
def rc_getGuildList(self):
guildList = Game.rpc_guild_mgr.getGuildList(self.player.id)
# 打包返回信息
resp = {
"guildList": guildList,
}
return 1, resp
# 请求帮会上香记录(getGuildSxList)
# 请求
# 返回
# 上香列表(sxList, [json])
# 上香时间戳(time, int)
# 上香人名字(name, string)
# 上香id(id, int)
def rc_getGuildSxList(self):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
sxList = rpc_guild.getSxList()
# 打包返回信息
resp = {
"sxList": sxList,
}
return 1, resp
# 帮会上香(guildSx)
# 请求
# 上香id(id, int)
# 返回
# 帮会上香进度(sxBar, int)
# 帮会每日清0
# 帮会上香次数(sxNum, int)
# 帮会每日清0
# 本人今日是否已上香(finish, int)
# 个人每日清0
# 0=未上香 1=已上香
# 同步给帮会在线的所有人
# 帮会上香进度(sxBar, int)
# 帮会每日清0
# 帮会上香次数(sxNum, int)
# 帮会每日清0
def rc_guildSx(self, id):
sxRes = Game.res_mgr.res_guildSx.get(id)
if not sxRes:
return 0, errcode.EC_NORES
if self.player.guild.GetTodaySXFinish():
return 0, errcode.EC_GUILD_TODAY_HAS_SX
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
# 扣道具
respBag = self.player.bag.costItem(sxRes.cost,
constant.ITEM_COST_GUILD_SX,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_GUILD_SX_NOT_ENOUGH
rs, data = rpc_guild.guildSx(self.player.id, id)
if not rs:
# 返回扣除的材料
self.player.bag.add(sxRes.cost,
constant.ITEM_ADD_GUILD_SX_FAIL,
wLog=True)
return rs, data
sxBar, sxNum = data
self.player.guild.SetTodaySXFinish(1)
#上香奖励
respBag1 = self.player.bag.add(sxRes.reward,
constant.ITEM_ADD_GUILD_SX,
wLog=True)
respBag = self.player.mergeRespBag(respBag, respBag1)
# 统计次数
shangxiangNum = self.player.guild.GetShangxiangNum()
shangxiangNum += 1
self.player.guild.SetShangxiangNum(shangxiangNum)
#抛事件
self.player.safe_pub(msg_define.MSG_GUILD_SX)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
resp = {
"sxBar": sxBar,
"sxNum": sxNum,
"finish": 1,
"allUpdate": dUpdate,
}
return 1, resp
# 领取帮会上香奖励(getGuildSxReward)
# 请求
# 上香奖励id(id, int)
# 返回
# 上香奖励已领取列表(getList, [int])
def rc_getGuildSxReward(self, id):
sxBarRes = Game.res_mgr.res_guildSxBar.get(id)
if not sxBarRes:
return 0, errcode.EC_NORES
getList = self.player.guild.GetTodaySXGetList()
if id in getList:
return 0, errcode.EC_GUILD_TODAY_HAS_SX
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
sxInfo = rpc_guild.GetSxInfo()
sxBar = sxInfo.get("sxBar", 0)
if sxBar < sxBarRes.num:
return 0, errcode.EC_GUILD_SX_REWARD_NOT_ENOUGH
# 上香奖励
respBag = self.player.bag.add(sxBarRes.reward,
constant.ITEM_ADD_GUILD_SX_REWARD,
wLog=True)
getList.append(id)
self.player.guild.SetTodaySXGetList(getList)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
resp = {
"getList": getList,
"allUpdate": dUpdate,
}
return 1, resp
# 进入帮会地图(enterGuildScene)
# 请求
# 返回
# 场景人员列表(roleList, [json])
def rc_enterGuildScene(self):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
roleList = []
pids = rpc_guild.enterGuildScene()
from game.mgr.player import get_rpc_player
for pid in pids:
rpc_player = get_rpc_player(pid)
info = rpc_player.GetFightData()
roleList.append(info)
resp = {
"roleList": roleList,
}
return 1, resp
# 帮会采集(guildCj)
# 请求
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-帮会信息
# 场景任务(taskList, [json])
# 任务表id(taskId, int)
# 当前进度(num, int)
# 是否已领取(status, int)
# 0=未领取 1=已领取
# 当前已刷新次数(refeNum, int)
# 直推当前任务数据
def rc_guildCj(self):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
info = self.player.guild.GetSceneTaskInfo(constant.GUILD_TASK_TYPE_1)
taskId = info.get("taskId", 0)
taskRes = Game.res_mgr.res_guildTask.get(taskId)
if not taskRes:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(int(taskRes.arg2))
if not rewardRes:
return 0, errcode.EC_NORES
guildTaskRewardTimeRes = Game.res_mgr.res_common.get(
"guildTaskRewardTime")
if not guildTaskRewardTimeRes:
return 0, errcode.EC_NORES
iNum = info.get("num", 0)
if iNum >= taskRes.condition:
return 0, errcode.EC_GUILD_TASK_HAS_FINISH
iHour = current_hour()
iAdd = 1
if guildTaskRewardTimeRes.arrayint1[
0] <= iHour < guildTaskRewardTimeRes.arrayint1[1]:
iAdd = 5
info["num"] = iNum + iAdd
if info["num"] >= taskRes.condition:
info["num"] = taskRes.condition
self.player.guild.SetSceneTaskInfo(constant.GUILD_TASK_TYPE_1, info)
#采集奖励
respBag = {}
for i in range(iAdd):
dReward = rewardRes.doReward()
respBag1 = self.player.bag.add(dReward,
constant.ITEM_ADD_GUILD_TASK,
wLog=True)
respBag = self.player.mergeRespBag(respBag, respBag1)
#统计采集次数
collectNum = self.player.guild.GetCollectNum()
collectNum += iAdd
self.player.guild.SetCollectNum(collectNum)
# 抛事件
self.player.safe_pub(msg_define.MSG_GUILD_COLLECT)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["guildInfo"] = {"scene": {"taskList": [info]}}
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 帮会打怪(guildKillMst)
# 请求
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-帮会信息
# 场景任务(taskList, [json])
# 任务表id(taskId, int)
# 当前进度(num, int)
# 是否已领取(status, int)
# 0=未领取 1=已领取
# 当前已刷新次数(refeNum, int)
# 直推当前任务数据
def rc_guildKillMst(self):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
info = self.player.guild.GetSceneTaskInfo(constant.GUILD_TASK_TYPE_2)
taskId = info.get("taskId", 0)
taskRes = Game.res_mgr.res_guildTask.get(taskId)
if not taskRes:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(int(taskRes.arg2))
if not rewardRes:
return 0, errcode.EC_NORES
iNum = info.get("num", 0)
if iNum >= taskRes.condition:
return 0, errcode.EC_GUILD_TASK_HAS_FINISH
guildTaskRewardTimeRes = Game.res_mgr.res_common.get(
"guildTaskRewardTime")
if not guildTaskRewardTimeRes:
return 0, errcode.EC_NORES
#初始化副本
fightobj = Game.fight_mgr.createFight(constant.FIGHT_TYPE_110)
rs = fightobj.init_by_barrId(self.player, int(taskRes.arg1))
if not rs:
return 0, errcode.EC_INIT_BARR_FAIL
fightLog = fightobj.doFight()
fightResult = fightLog["result"].get("win", 0)
#更新数据
respBag = {}
if fightResult:
iHour = current_hour()
iAdd = 1
if guildTaskRewardTimeRes.arrayint1[
0] <= iHour < guildTaskRewardTimeRes.arrayint1[1]:
iAdd = 5
info["num"] = iNum + iAdd
if info["num"] >= taskRes.condition:
info["num"] = taskRes.condition
self.player.guild.SetSceneTaskInfo(constant.GUILD_TASK_TYPE_2,
info)
# 打怪奖励
for i in range(iAdd):
dReward = rewardRes.doReward()
respBag1 = self.player.bag.add(dReward,
constant.ITEM_ADD_GUILD_TASK,
wLog=True)
respBag = self.player.mergeRespBag(respBag, respBag1)
# 统计次数
monsterNum = self.player.guild.GetMonsterNum()
monsterNum += iAdd
self.player.guild.SetMonsterNum(monsterNum)
# 抛事件
self.player.safe_pub(msg_define.MSG_GUILD_MONSTER_KILL)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["guildInfo"] = {"scene": {"taskList": [info]}}
resp = {
"fightLog": fightLog,
"allUpdate": dUpdate,
}
return 1, resp
# 帮会任务一键完成(guildTaskOneKeyFinish)
# 请求
# 任务表id(taskId, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-帮会信息
# 场景任务(taskList, [json])
# 任务表id(taskId, int)
# 当前进度(num, int)
# 是否已领取(status, int)
# 0=未领取 1=已领取
# 当前已刷新次数(refeNum, int)
# 直推当前任务数据
def rc_guildTaskOneKeyFinish(self, taskId):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
taskRes = Game.res_mgr.res_guildTask.get(taskId)
if not taskRes:
return 0, errcode.EC_NORES
info = self.player.guild.GetSceneTaskInfo(taskRes.type)
if not info:
return 0, errcode.EC_GUILD_TASK_NOT_FOUND
rewardRes = Game.res_mgr.res_reward.get(int(taskRes.arg2))
if not rewardRes:
return 0, errcode.EC_NORES
iNum = info.get("num", 0)
if iNum >= taskRes.condition:
return 0, errcode.EC_GUILD_TASK_HAS_FINISH
# 扣道具
respBag = self.player.bag.costItem(
taskRes.finishCost,
constant.ITEM_COST_GUILD_TASK_FINISH,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_GUILD_TASK_FINISH_NOT_ENOUGH
# 更新数据
iAdd = taskRes.condition - iNum
info["num"] = taskRes.condition
self.player.guild.SetSceneTaskInfo(taskRes.type, info)
for i in range(iAdd):
dReward = rewardRes.doReward()
respBag1 = self.player.bag.add(dReward,
constant.ITEM_ADD_GUILD_TASK,
wLog=True)
respBag = self.player.mergeRespBag(respBag, respBag1)
if taskRes.type == constant.GUILD_TASK_TYPE_1:
#统计采集次数
collectNum = self.player.guild.GetCollectNum()
collectNum += iAdd
self.player.guild.SetCollectNum(collectNum)
# 抛事件
self.player.safe_pub(msg_define.MSG_GUILD_COLLECT)
if taskRes.type == constant.GUILD_TASK_TYPE_2:
# 统计次数
monsterNum = self.player.guild.GetMonsterNum()
monsterNum += iAdd
self.player.guild.SetMonsterNum(monsterNum)
# 抛事件
self.player.safe_pub(msg_define.MSG_GUILD_MONSTER_KILL)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["guildInfo"] = {"scene": {"taskList": [info]}}
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 帮会任务重置(guildTaskReset)
# 请求
# 任务表id(taskId, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-帮会信息
# 场景任务(taskList, [json])
# 任务表id(taskId, int)
# 当前进度(num, int)
# 是否已领取(status, int)
# 0=未领取 1=已领取
# 当前已刷新次数(refeNum, int)
# 直推当前任务数据
def rc_guildTaskReset(self, taskId):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
taskRes = Game.res_mgr.res_guildTask.get(taskId)
if not taskRes:
return 0, errcode.EC_NORES
info = self.player.guild.GetSceneTaskInfo(taskRes.type)
if not info:
return 0, errcode.EC_GUILD_TASK_NOT_FOUND
iVipLv = self.player.vip.GetVipLv()
vipRes = Game.res_mgr.res_vip.get(iVipLv)
if not vipRes:
return 0, errcode.EC_NORES
#刷新次数判断
iRefeNum = info.get("refeNum", 0)
if iRefeNum >= vipRes.guildTaskResetNum:
return 0, errcode.EC_GUILD_TASK_RESET_MAX_NUM
# 扣道具
respBag = self.player.bag.costItem(taskRes.resetCost,
constant.ITEM_COST_GUILD_TASK_RESET,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_GUILD_TASK_RESET_NOT_ENOUGH
# 更新数据
info["num"] = 0
info["status"] = 0
info["refeNum"] = iRefeNum + 1
self.player.guild.SetSceneTaskInfo(taskRes.type, info)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["guildInfo"] = {"scene": {"taskList": [info]}}
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 帮会任务奖励领取(guildTaskGetReward)
# 请求
# 任务表id(taskId, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-帮会信息
# 场景任务(taskList, [json])
# 任务表id(taskId, int)
# 当前进度(num, int)
# 是否已领取(status, int)
# 0=未领取 1=已领取
# 当前已刷新次数(refeNum, int)
# 直推当前任务数据
def rc_guildTaskGetReward(self, taskId):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
taskRes = Game.res_mgr.res_guildTask.get(taskId)
if not taskRes:
return 0, errcode.EC_NORES
info = self.player.guild.GetSceneTaskInfo(taskRes.type)
if not info:
return 0, errcode.EC_GUILD_TASK_NOT_FOUND
if info["status"] == 1:
return 0, errcode.EC_GUILD_TASK_REWARD_HAS_GET
respBag = self.player.bag.add(taskRes.rewardArrayint2,
constant.ITEM_ADD_GUILD_TASK,
wLog=True)
# 更新数据
info["status"] = 1
self.player.guild.SetSceneTaskInfo(taskRes.type, info)
# 抛事件
if taskRes.type == constant.GUILD_TASK_TYPE_1:
self.player.safe_pub(msg_define.MSG_GUILD_SCENE_CJ)
# 抛事件
if taskRes.type == constant.GUILD_TASK_TYPE_2:
self.player.safe_pub(msg_define.MSG_GUILD_SCENE_BARR)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["guildInfo"] = {"scene": {"taskList": [info]}}
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 帮会兑换(guildExchange)
# 请求
# 兑换索引(id, int) 0,1,2,3
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-帮会信息
# 直推当前兑换数据
# 兑换id列表(exList, [json])
# 兑换id(exId, int)
# 状态(status, int)
# 0=未兑换 1=已兑换
def rc_guildExchange(self, id):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
if id + 1 > len(self.player.guild.exList):
return 0, errcode.EC_NORES
exId, status = self.player.guild.exList[id]
if status is None:
return 0, errcode.EC_GUILD_EXCHANGE_NOT_FOUND
if status == 1:
return 0, errcode.EC_GUILD_EXCHANGE_HAS_BUY
exRes = Game.res_mgr.res_exchange.get(exId)
if not exRes:
return 0, errcode.EC_NORES
# 背包检测
addEquip = {}
if exRes.equipId:
addEquip[exRes.equipId] = exRes.num
iFree = self.player.bag.getFreeSize()
if iFree < exRes.num:
return 0, errcode.EC_BAG_FULL
# 扣道具
respBag = self.player.bag.costItem(exRes.cost,
constant.ITEM_COST_GUILD_EXCHANGE,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_GUILD_EXCHANGE_NOT_ENOUGH
# 加道具
additem = {}
itemRes = None
if exRes.itemId:
itemRes, itemobj = CreatItem(exRes.itemId)
for i in range(exRes.num):
reward = itemobj.getReward()
for iNo, iNum in reward.items():
if iNo in additem:
additem[iNo] += iNum
else:
additem[iNo] = iNum
respBag1 = self.player.bag.add(additem,
constant.ITEM_ADD_GUILD_EXCHANGE,
wLog=True)
respBag = self.player.mergeRespBag(respBag, respBag1)
# 加装备
equipobjs = []
for equipNo, num in addEquip.items():
for i in range(num):
equipRes, equipobj = CreatEquip(equipNo)
if not equipobj:
break
equipobjs.append(equipobj)
rs, _resp_equip = self.player.bag.addEquip(
equipobjs, constant.ITEM_ADD_GUILD_EXCHANGE)
respBag = self.player.mergeRespBag(respBag, {"equips": _resp_equip})
#修改状态
self.player.guild.exList[id] = (exId, 1)
self.player.guild.markDirty()
#抛事件
if itemRes:
self.player.safe_pub(msg_define.MSG_GUILD_EXCHANGE,
itemRes.quality)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["guildInfo"] = {
"scene": {
"exList": self.player.guild.to_exchange_data()
}
}
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 帮会兑换免费刷新(guildFreeExRef)
# 请求
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 帮会信息
# 兑换id列表(exList, [json])
# 兑换id(exId, int)
# 状态(status, int)
# 0 = 未兑换
# 1 = 已兑换
def rc_guildFreeExRef(self):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
iGuildLv = rpc_guild.GetLevel()
guildlvRes = Game.res_mgr.res_guildlv.get(iGuildLv)
if not guildlvRes:
return 0, errcode.EC_NORES
now = int(time.time())
if now < self.player.guild.refTime:
return 0, errcode.EC_GUILD_EX_FREE_REF_TIME_ERR
self.player.guild.reSetRefTime()
exList = []
for i in range(4):
exId = utility.Choice(guildlvRes.exchange)
exList.append((exId, 0))
self.player.guild.SetExList(exList)
# 打包返回信息
dUpdate = {}
dUpdate["guildInfo"] = {
"scene": {
"refTime": self.player.guild.refTime,
"exList": self.player.guild.to_exchange_data()
}
}
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 帮会兑换刷新(guildExRef)
# 请求
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-帮会信息
# 兑换可刷新次数(exRefNum, int)
# 兑换id列表(exList, [json])
# 兑换id(exId, int)
# 状态(status, int)
# 0=未兑换 1=已兑换
# 游戏模型-货币
def rc_guildExRef(self):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
iGuildLv = rpc_guild.GetLevel()
guildlvRes = Game.res_mgr.res_guildlv.get(iGuildLv)
if not guildlvRes:
return 0, errcode.EC_NORES
guildRefCostRes = Game.res_mgr.res_common.get(
"guildRefCost") # 帮会兑换刷新消耗
guildRefNumRes = Game.res_mgr.res_common.get(
"guildRefNum") # 帮会兑换每日可刷新次数
if not guildRefCostRes or not guildRefNumRes:
return 0, errcode.EC_NORES
iTodayNum = self.player.guild.GetTodayExRefNum()
if iTodayNum >= guildRefNumRes.i:
return 0, errcode.EC_GUILD_EXCHANGE_REFESH_MAX
# 扣道具
respBag = self.player.bag.costItem(
guildRefCostRes.arrayint2,
constant.ITEM_COST_GUILD_EXCHANGE_REFE,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_GUILD_EXCHANGE_REFE_NOT_ENOUGH
iTodayNum += 1
self.player.guild.SetTodayExRefNum(iTodayNum)
exList = []
for i in range(4):
exId = utility.Choice(guildlvRes.exchange)
exList.append((exId, 0))
self.player.guild.SetExList(exList)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["guildInfo"] = {
"scene": {
"exRefNum": guildRefNumRes.i - iTodayNum,
"exList": self.player.guild.to_exchange_data()
}
}
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 帮会活跃升级(guildActUp)
# 请求
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-帮会信息
# 帮会活跃(act, json)
# 帮会活跃等级(actLv, int)
# 帮会活跃经验(actExp, int)
# 游戏模型-货币
# 游戏模型-角色背包-道具列表
# 游戏模型-角色基础-战力
# 游戏模型-角色属性
def rc_guildActUp(self):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
iActLv = self.player.guild.GetActLv()
actRes = Game.res_mgr.res_guildAct.get(iActLv)
if not actRes:
return 0, errcode.EC_NORES
nextRes = Game.res_mgr.res_guildAct.get(iActLv + 1)
if not nextRes:
return 0, errcode.EC_NORES
iActExp = self.player.guild.GetActExp()
if iActExp < actRes.exp:
return 0, errcode.EC_GUILD_ACT_UPGRADE_EXP_NOT_ENOUGH
iActExp -= actRes.exp
self.player.guild.SetActLv(iActLv + 1)
self.player.guild.SetActExp(iActExp)
respBag = self.player.bag.add(actRes.reward,
constant.ITEM_ADD_GUILD_ACT_UPGRADE,
wLog=True)
resp_attr = []
#删除旧属性
self.player.attr.delAttr(actRes.attr, constant.FIGHTABILITY_TYPE_18)
resp_attr.extend(list(actRes.attr.keys()))
#添加新属性
self.player.attr.addAttr(nextRes.attr, constant.FIGHTABILITY_TYPE_18)
resp_attr.extend(list(nextRes.attr.keys()))
# 战力重算
self.player.attr.RecalFightAbility()
# 打包返回信息
resp_attr = set(resp_attr)
dUpdate = self.player.packRespBag(respBag,
fa=self.player.base.fa,
roleAttr=resp_attr)
dUpdate["guildInfo"] = {
"act": {
"actLv": self.player.guild.actLv,
"actExp": self.player.guild.actExp
}
}
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 帮会今日活跃奖励领取(getGuildActReward)
# 请求
# 活跃任务id(id, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-帮会信息
# 帮会活跃(act, json)
# 活跃每日奖励已领取列表(getList, [int])
# 当前任务数据
# 活跃任务id
# 游戏模型-货币
# 游戏模型-角色背包-道具列表
# def rc_getGuildActReward(self, id):
# guildId = self.player.guild.GetGuildId()
# if not guildId:
# return 0, errcode.EC_NO_GUILD
# todayActGetList = self.player.guild.GetTodayActGetList()
# if id in todayActGetList:
# return 0, errcode.EC_GUILD_ACT_TASK_REWARD_HAS_GET
# taskRes = Game.res_mgr.res_task.get(id)
# if not taskRes:
# return 0, errcode.EC_NORES
# taskobj = self.player.task.guild_act_reward_tasks.get(id)
# if not taskobj:
# return 0, errcode.EC_GUILD_ACT_TASK_NOT_FIND
# if not taskobj.finish:
# return 0, errcode.EC_GUILD_ACT_TASK_NOT_FINISH
# if taskobj.GetGetReward():
# return 0, errcode.EC_GUILD_ACT_TASK_REWARD_HAS_GET
# taskobj.SetGetReward(1)
# todayActGetList.append(id)
# self.player.guild.SetTodayActGetList(todayActGetList)
# #发放奖励
# respBag = self.player.bag.add(taskRes.finishReward, constant.ITEM_ADD_GUILD_ACT_TASK, wLog=True)
# #统计次数
# actRewardNum = self.player.guild.GetActRewardNum()
# self.player.guild.SetActRewardNum(actRewardNum+1)
# # 抛事件
# self.player.safe_pub(msg_define.MSG_GET_GUILD_ACT_REWARD)
# #打包返回信息
# dUpdate = self.player.packRespBag(respBag)
# dUpdate["guildInfo"] = {
# "act": {"getList": todayActGetList}
# }
# resp = {
# "allUpdate": dUpdate,
# }
# return 1, resp
# 帮会捐献(guildDonate)
# 请求
# 道具id(id, string)
# 数量(num, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-角色背包-道具列表
# 帮会资金(exp, int)
def rc_guildDonate(self, id, num):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
itemRes = Game.res_mgr.res_item.get(id)
if not itemRes:
return 0, errcode.EC_NORES
dCost = {id: num}
# 扣道具
respBag = self.player.bag.costItem(dCost,
constant.ITEM_COST_GUILD_DONATE,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_GUILD_DONATE_NOT_ENOUGH
iAddExp = int(itemRes.arg1) * num
exp, level = rpc_guild.addExp(iAddExp)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
resp = {
"allUpdate": dUpdate,
"exp": exp,
"level": level,
}
return 1, resp
# 帮会技能升级(guildSkillUp)
# 请求
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-帮会信息
# 帮会技能列表(skill, [json])
# 部位(pos, int)
# 等级(lv, int)
# 游戏模型-货币
# 游戏模型-角色基础-战力
# 游戏模型-角色属性
def rc_guildSkillUp(self):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
iGuildLv = rpc_guild.GetLevel()
guildlvRes = Game.res_mgr.res_guildlv.get(iGuildLv)
if not guildlvRes:
return 0, errcode.EC_NORES
minPos = 0
minLv = 0
for pos in constant.ALL_GUILD_SKILL:
if not minPos:
minPos = pos
minLv = self.player.guild.GetSkillLv(pos)
else:
if self.player.guild.GetSkillLv(pos) < minLv:
minPos = pos
minLv = self.player.guild.GetSkillLv(pos)
if minLv >= guildlvRes.skillMax:
return 0, errcode.EC_GUILD_SKILL_UP_LIMIT
key = (minPos, minLv)
guildSkillRes = Game.res_mgr.res_poslv_guildSkill.get(key)
if not guildSkillRes:
return 0, errcode.EC_NORES
nextKey = (minPos, minLv + 1)
nextRes = Game.res_mgr.res_poslv_guildSkill.get(nextKey)
if not nextRes:
return 0, errcode.EC_NORES
# 扣道具
respBag = self.player.bag.costItem(guildSkillRes.cost,
constant.ITEM_COST_GUILD_SKULL_UP,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_GUILD_SKILL_UP_NOT_ENOUGH
#修改等级
self.player.guild.SetSkillLv(minPos, minLv + 1)
resp_attr = []
# 删除旧属性
self.player.attr.delAttr(guildSkillRes.attr,
constant.FIGHTABILITY_TYPE_18)
resp_attr.extend(list(guildSkillRes.attr.keys()))
# 添加新属性
self.player.attr.addAttr(nextRes.attr, constant.FIGHTABILITY_TYPE_18)
resp_attr.extend(list(nextRes.attr.keys()))
# 战力重算
self.player.attr.RecalFightAbility()
#统计次数
skillUpNum = self.player.guild.GetSkillUpNum()
self.player.guild.SetSkillUpNum(skillUpNum + 1)
# 抛事件
self.player.safe_pub(msg_define.MSG_GUILD_SKILL_UPGRADE)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag,
fa=self.player.base.fa,
roleAttr=set(resp_attr))
dUpdate["guildInfo"] = {"skill": self.player.guild.to_skill_data()}
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 帮会副本挑战(guildBarrChallenge)
# 请求
# 帮会副本配置表id(id, int)
# 队伍id(teamId, int)
# 返回
# 全队推送(guildBarrChallengeNotice)只推送真人，机器人过滤
# 帮会副本配置表id(id, int)
# 战报(fightLog, json)
# 主动推送刷新(allUpdate, json)
# 游戏模型-货币
# 游戏模型-角色基础-经验
# 游戏模型-角色背包
# 游戏模型-帮会信息
# 帮会副本(barr, json)
# 已协助次数(helpNum, int)
# 已挑战次数(fightNum, int)
# 已首通帮会id列表(firstKill, [int])
def rc_guildBarrChallenge(self, id, teamId):
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
resGuidlBarr = Game.res_mgr.res_guildBarr.get(id)
if not resGuidlBarr:
return 0, errcode.EC_NORES
barrRes = Game.res_mgr.res_barrier.get(resGuidlBarr.barrId)
if not barrRes:
return 0, errcode.EC_NORES
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
iGuildLv = rpc_guild.GetLevel()
if iGuildLv < resGuidlBarr.lv:
return 0, errcode.EC_GUILD_BARR_LIMIT
members = Game.rpc_team_mgr.GetTeamInfo(teamId)
if not members:
return 0, errcode.EC_TEAM_ERROR
from game.mgr.player import get_rpc_player
players = [(None, 1), (None, 1)]
index = 0
names = []
for one in members:
pid = one.get("rid", 0)
if not pid:
continue
names.append(one.get("name", ""))
if pid == self.player.id:
if not one.get("main", 0):
return 0, errcode.EC_TEAM_NOT_MAIN
else:
continue
rpc_player = get_rpc_player(pid)
if not rpc_player:
continue
players[index] = (rpc_player, one.get("isRobot", 1))
index += 1
fightobj = Game.fight_mgr.createFight(constant.FIGHT_TYPE_140)
rs = fightobj.init_by_barrId(resGuidlBarr.barrId,
player1=self.player,
player2=players[0][0],
player3=players[1][0])
if not rs:
return 0, errcode.EC_INIT_BARR_FAIL
fightLog = fightobj.doFight()
self.player.sendGuildBarrChallengeNotice(id, fightLog, self.player.id)
pps = []
if players[0][0]:
pps.extend(players[0][0].GetPetIDs())
if players[1][0]:
pps.extend(players[1][0].GetPetIDs())
self.player.PostPartnerPets(pps, constant.FIGHT_TYPE_140)
if players[0][0] and not players[0][1]:
pps = self.player.GetPetIDs()
if players[1][0]:
pps.extend(players[1][0].GetPetIDs())
players[0][0].PostPartnerPets(pps, constant.FIGHT_TYPE_140)
if players[1][0] and not players[1][1]:
pps = self.player.GetPetIDs()
pps.extend(players[0][0].GetPetIDs())
players[1][0].PostPartnerPets(pps, constant.FIGHT_TYPE_140)
# 机器人不推送
for playerData in players:
if playerData[1]:
continue
playerData[0].sendGuildBarrChallengeNotice(id,
fightLog,
self.player.id,
_no_result=True)
# 解散队伍
Game.rpc_team_mgr.DeleteTeam(teamId)
# 抛事件
self.player.safe_pub(msg_define.MSG_GUILD_BARR)
return 1, None
class ShopMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
def rc_shopData(self):
# 打包返回信息
dUpdate = {}
dUpdate["shop"] = self.player.shop.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_shopRefreshFree(self, resid):
res = Game.res_mgr.res_shopConst.get(resid)
if not res:
return 0, errcode.EC_NORES
if not res.freeRefersh:
return 0, errcode.EC_NOT_ABLE
xnum = self.player.shop.getRefreshFreeNum()
if res.freeRefersh - xnum[resid]["refershnum"] <= 0:
return 0, errcode.EC_TIMES_FULL
# print("xnum",xnum)
self.player.shop.manualRefresh(res)
self.player.shop.CostRefreshFreeNum(resid)
# 打包返回信息
dUpdate = {}
dUpdate["shop"] = self.player.shop.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_shopRefreshCost(self, resid):
res = Game.res_mgr.res_shopConst.get(resid)
if not res:
return 0, errcode.EC_NORES
if not res.costRefersh:
return 0, errcode.EC_NOT_ABLE
xnum = self.player.shop.getRefreshCostNum()
if res.costRefersh - xnum[resid]["refershnum"] <= 0:
return 0, errcode.EC_TIMES_FULL
costidx = xnum[resid]["refershnum"]
if costidx >= len(res.costLadder):
costidx = len(res.costLadder) - 1
if costidx == -1:
return 0, errcode.EC_NORES
cost = {}
cost[res.costLadder[costidx][0]] = res.costLadder[costidx][1]
respBag = self.player.bag.costItem(cost,
constant.ITEM_COST_ZHUANPAN_RESET,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_COST_ERR
# print("xnum",xnum)
self.player.shop.manualRefresh(res)
self.player.shop.CostRefreshCostNum(resid)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["shop"] = self.player.shop.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_shopBuy(self, resid, idx, iscost2, num):
res = Game.res_mgr.res_shopConst.get(resid)
if not res:
return 0, errcode.EC_NORES
if idx >= len(res.manualgroup):
print("==========")
return 0, errcode.EC_NORES
sd = self.player.shop.getshopdata()
gid = sd[resid][idx]["id"]
gnum = sd[resid][idx]["buynum"]
gres = Game.res_mgr.res_shopGroup.get(gid)
if not gres:
return 0, errcode.EC_NORES
if gres.limitNum:
lnum = gres.limitNum - gnum
if lnum < num:
return 0, errcode.EC_EXHAUSTED
cost = {}
reward = {}
for _ in range(num):
onecost = gres.cost1
if iscost2:
onecost = gres.cost2
for k, v in onecost.items():
cost[k] = cost.get(k, 0) + v
for k, v in gres.reward.items():
reward[k] = reward.get(k, 0) + v
respBag1 = self.player.bag.costItem(cost,
constant.ITEM_COST_SHOP,
wLog=True)
if not respBag1.get("rs", 0):
return 0, errcode.EC_COST_ERR
dd = self.player.shop.getGroupID2BuyNum(gres.refCycle)
dd[gid] = gnum + num
self.player.shop.setGroupID2BuyNum(gres.refCycle, dd)
respBag = self.player.bag.add(reward,
constant.ITEM_ADD_SHOP,
wLog=True,
mail=True)
respBag = self.player.mergeRespBag(respBag, respBag1)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["shop"] = self.player.shop.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
class HouseMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
# 获取房子信息(getHouseInfo)
# 请求
# 返回
# 对象个人数据(spouseInfo, json)
# 角色名称(name, string)
# 角色外形列表(showList, [json])
# 模块类型(modeType, int)
# 1=坐骑 2=翅膀 7=天仙 8=神兵
# 幻化类型(imageType, int)
# 1=坐骑 2=坐骑皮肤 (其他模块通用)
# 幻化id(imageId, int)
# 根据类型读取不同的配置表
# 称号id(title, int)
# 时装id(fashion, int)
# 性别(sex, int)
# 0=? 1=男 2=女
# 套装id(outfit, int)
def rc_getHouseInfo(self):
if not self.player.getMarryStatus():
return 1, None
spousePid = self.player.marry.getSpousePid()
from game.mgr.player import get_rpc_player
spousePlayer = get_rpc_player(spousePid, offline=True)
if not spousePlayer:
return 0, errcode.EC_NOFOUND
resp = {
"spouseInfo": spousePlayer.packbaseInfo(),
}
return 1, resp
# 升阶(houseUpgrade)
# 请求
# 是否自动(auto, int)
# 返回
# 房子id(houseId, int)
# 经验(exp, int)
# 主动推送刷新(allUpdate,json)
# 游戏模型-货币
# 游戏模型-角色背包
# 游戏模型-角色属性
# 游戏模型-角色基础-战力
def rc_houseUpgrade(self, auto):
houseType = self.player.house.getHouseType()
houseId = self.player.house.getHouseId()
leftExp = self.player.house.getExp()
if not houseType:
return 0, errcode.EC_HOUSE_NO_HOUSE
if not self.player.marry.getMarryStatus():
return 0, errcode.EC_MARRY_NOT_MARRY
houseRes = Game.res_mgr.res_house.get(houseId, None)
if not houseRes:
return 0, errcode.EC_NORES
if not houseRes.exp:
return 0, errcode.EC_HOUSE_MAX_LEVEL
respBag = self.player.bag.costItem(houseRes.cost,
constant.ITEM_COST_HOUSE_UPGRADE,
wLog=True,
auto=auto)
if not respBag.get("rs", 0):
return 0, errcode.EC_HOUSE_UPGRADE_NOT_ENOUGH
leftExp += houseRes.addExp
if leftExp >= houseRes.exp:
leftExp -= houseRes.exp
oldAttr = Game.res_mgr.res_marry_house_attr.get(
(houseType, houseId), None)
if oldAttr:
self.player.attr.delAttr(oldAttr, constant.PKM2_FA_TYPE_10,
constant.PKM2_ATTR_CONTAINER_GLOBAL)
houseId += 1
self.player.house.setHouseId(houseId)
newAttr = Game.res_mgr.res_marry_house_attr.get(
(houseType, houseId), None)
self.player.attr.addAttr(newAttr, constant.PKM2_FA_TYPE_10,
constant.PKM2_ATTR_CONTAINER_GLOBAL)
self.player.attr.RecalFightAbility()
self.player.house.setExp(leftExp)
# 给对象加经验
spousePid = self.player.marry.getSpousePid()
from game.mgr.player import get_rpc_player
spousePlayer = get_rpc_player(spousePid, offline=True)
if spousePlayer:
spousePlayer.addHouseExp(houseRes.addExp,
self.player.marry.getKind())
dUpdate = self.player.packRespBag(respBag)
dUpdate["attr"] = self.player.attr.to_update_data()
resp = {
"allUpdate": dUpdate,
"houseId": houseId,
"exp": leftExp,
}
return 1, resp
# 获取未领取经验信息(getUnrecvExpInfo)
# 请求
# 返回
# 经验列表(expList, [json]
# 时间(time, int)
# 经验(exp, int)
# 我当时类型(kind, int)
def rc_getUnrecvExpInfo(self):
unrecvExp = self.player.house.getUnrecvExp()
resp = {
"expList": unrecvExp,
}
return 1, resp
# 领取经验(receiveExp)
# 请求
# 返回
# 房子id(houseId, int)
# 经验(exp, int)
# 主动推送刷新(allUpdate,json)
# 游戏模型-角色属性
# 游戏模型-角色基础-战力
def rc_receiveExp(self):
houseType = self.player.house.getHouseType()
houseId = self.player.house.getHouseId()
leftExp = self.player.house.getExp()
if not houseType:
return 0, errcode.EC_HOUSE_NO_HOUSE
houseRes = Game.res_mgr.res_house.get(houseId, None)
if not houseRes:
return 0, errcode.EC_NORES
if not houseRes.exp:
return 0, errcode.EC_HOUSE_MAX_LEVEL
unrecvExp = self.player.house.getUnrecvExp()
self.player.house.resetUnrecvExp()
for item in unrecvExp:
leftExp += item.get("exp", 0)
while leftExp >= houseRes.exp:
leftExp -= houseRes.exp
oldAttr = Game.res_mgr.res_marry_house_attr.get(
(houseType, houseId), None)
if oldAttr:
self.player.attr.delAttr(oldAttr, constant.PKM2_FA_TYPE_10,
constant.PKM2_ATTR_CONTAINER_GLOBAL)
houseId += 1
self.player.house.setHouseId(houseId)
newAttr = Game.res_mgr.res_marry_house_attr.get(
(houseType, houseId), None)
self.player.attr.addAttr(newAttr, constant.PKM2_FA_TYPE_10,
constant.PKM2_ATTR_CONTAINER_GLOBAL)
self.player.attr.RecalFightAbility()
houseRes = Game.res_mgr.res_house.get(houseId, None)
if not houseRes:
break
self.player.house.setExp(leftExp)
dUpdate = {}
dUpdate["base"] = {"fa": self.player.base.fa}
dUpdate["attr"] = self.player.attr.to_update_data()
resp = {
"allUpdate": dUpdate,
"houseId": houseId,
"exp": leftExp,
}
return 1, resp
class MailMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
# 请求邮件列表(getMailList)
# 请求
# 返回
# 邮件列表(mailList, [json])
# 邮件id(mid, int)
# 标题(title, string)
# 时间戳(addTime, int)
# 状态(status, int)
# 0=未读未领取 1=已读未领取 2=已读已领取
def rc_getMailList(self):
mailList = Game.rpc_mail_mgr.getMailList(self.player.id)
resp = {
"mailList": mailList,
}
return 1, resp
# 请求邮件详情(getOneMail)
# 请求
# 邮件id(mid, int)
# 返回
# 邮件id(mid, int)
# 内容(content, string)
# 附件列表(attachment, [json])
# 道具或装备配置表id(id, int)
# 数量(num, int)
def rc_getOneMail(self, mid):
detailInfo = Game.rpc_mail_mgr.getOneMail(self.player.id, mid)
resp = detailInfo
return 1, resp
# 领取附件(getMailItem)
# 请求
# 邮件id(mid, int)
# 返回
# 邮件id(mid, int)
# 状态(status, int)
# 0=未读未领取 1=已读未领取 2=已读已领取
# 主动推送刷新(allUpdate, json)
# 游戏模型-货币
# 游戏模型-角色背包
def rc_getMailItem(self, mid):
detailInfo = Game.rpc_mail_mgr.getOneMail(self.player.id,
mid,
pack=False)
status = detailInfo.get("status", 0)
if status == constant.MAIL_STATUS_3:
return 0, errcode.EC_MAIL_ALERAY_GET_ATTACHMENT
attachment = detailInfo.get("attachment", {})
respBag = self.player.bag.add(attachment,
constant.ITEM_ADD_MAIL_ATTACHMENT,
wLog=True)
Game.rpc_mail_mgr.takeAttachment(self.player.id, mid)
dRole = {}
dRole["roleBase"] = self.player.base.to_init_data()
dUpdate = self.player.packRespBag(respBag)
dUpdate["role"] = dRole
resp = {
"mid": mid,
"allUpdate": dUpdate,
}
return 1, resp
# 一键领取附件(OneKeyGetMailItem)
# 请求
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-货币
# 游戏模型-角色背包
def rc_OneKeyGetMailItem(self):
mailList = Game.rpc_mail_mgr.getMailList(self.player.id)
reward = {}
# freeSize = self.player.bag.getFreeSize()
untake = []
for mail in mailList:
mid = mail.get("mid", 0)
hasAttachment = mail.get("hasAttachment", 0)
status = mail.get("status", 0)
if hasAttachment and status != constant.MAIL_STATUS_3:
detailInfo = Game.rpc_mail_mgr.getOneMail(self.player.id,
mid,
pack=False)
attachment = detailInfo.get("attachment", {})
# equipCount = 0
# for k, v in attachment.items():
# if k >= constant.EQUIP_START_NO:
# equipCount += v
# if freeSize >= equipCount:
# freeSize -= equipCount
for k, v in attachment.items():
if k in reward:
reward[k] = reward[k] + v
else:
reward[k] = v
Game.rpc_mail_mgr.takeAttachment(self.player.id, mid)
# else:
# Game.rpc_mail_mgr.readMail(self.player.id, mid)
# untake.append(mid)
else:
Game.rpc_mail_mgr.readMail(self.player.id, mid)
respBag = self.player.bag.add(
reward,
constant.ITEM_ADD_MAIL_ATTACHMENT,
wLog=True,
)
dRole = {}
dRole["roleBase"] = self.player.base.to_init_data()
dUpdate = self.player.packRespBag(respBag)
dUpdate["role"] = dRole
resp = {
"untake": untake,
"allUpdate": dUpdate,
}
return 1, resp
class BagRpcMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
# 背包扩容(bagAddSize)
# 请求
# 类型(tp, int) 1=装备背包
# 扩容数(add, int)
#
# 返回
# 容量(size, int)
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 货币
def rc_bagAddSize(self, tp, add):
if add <= 0:
return 0, errcode.EC_VALUE
bag = None
if tp == 1:
bag = self.player.bag.equip_bag
if not bag:
return 0, errcode.EC_NOFOUND
iOldSize = bag.size
maxRes = Game.res_mgr.res_common.get("bagMaxSize", None)
if iOldSize + add > maxRes.i:
return 0, errcode.EC_BAG_SIZE_MAX
#先扣钱，再扩容
res = Game.res_mgr.res_common.get("bagAddSizeCost", None)
dCost = {}
for itemNo, num in res.arrayint2.items():
dCost[itemNo] = num * add
respBag = self.player.bag.costItem(dCost,
constant.ITEM_COST_ADD_BAGSIZE,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_COST_ERR
iNewSize = bag.addSize(add)
#记录日志
Game.glog.log2File(
"rc_bagAddSize",
"%s|%s|%s|%s|%s" % (self.player.id, tp, iOldSize, add, iNewSize))
#打包返回信息
dUpdate = self.player.packRespBag(respBag)
resp = {
"size": bag.size,
"allUpdate": dUpdate,
}
return 1, resp
# 道具使用(itemUse)
# 请求
# 道具uid(uid, string)
# 数量(num, int)
#
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 角色背包 - 道具列表
# 游戏模型 - 其他各种数据变化
def rc_itemUse(self, uid, num):
if num <= 0:
return 0, errcode.EC_PARAMS_ERR
itemobj = self.player.bag.item_bag.getObj(uid)
if not itemobj:
return 0, errcode.EC_NOFOUND
if itemobj.getNum() < num:
return 0, errcode.EC_NOT_ENOUGH
itemRes = Game.res_mgr.res_item.get(itemobj.resID)
if not itemRes:
return 0, errcode.EC_NORES
if not itemRes.use:
return 0, errcode.EC_TIMES_FULL
itemobj.Use(num)
return 1, None
# 可选宝箱使用(selectBoxUse)
# 请求
# 道具uid(uid, string)
# 数量(num, int)
# 选择道具id(select, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 角色背包 - 道具列表
# 游戏模型 - 其他各种数据变化
def rc_selectBoxUse(self, uid, num, select):
if num <= 0:
return 0, errcode.EC_PARAMS_ERR
itemobj = self.player.bag.item_bag.getObj(uid)
if not itemobj:
return 0, errcode.EC_NOFOUND
if itemobj.getNum() < num:
return 0, errcode.EC_NOT_ENOUGH
itemRes = Game.res_mgr.res_item.get(itemobj.resID)
if not itemRes:
return 0, errcode.EC_NORES
if not itemRes.use:
return 0, errcode.EC_TIMES_FULL
itemobj.Use(num, select)
return 1, None
# 道具合成(itemCompound)
# 请求
# 道具uid(uid, string)
# 数量(num, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 角色背包 - 道具列表
def rc_itemCompound(self, uid, num):
if num <= 0:
return 0, errcode.EC_PARAMS_ERR
itemobj = self.player.item_bag.getObj(uid)
if not itemobj:
return 0, errcode.EC_NOFOUND
itemRes = Game.res_mgr.res_item.get(itemobj.resID)
if not itemRes or not itemRes.compound:
return 0, errcode.EC_NORES
iNeed = itemRes.compound[0] * num
iCompoundId = itemRes.compound[1]
isRewardID = 0
if len(itemRes.compound) >= 3:
isRewardID = itemRes.compound[2]
rewardRes = None
if isRewardID:
rewardRes = Game.res_mgr.res_reward.get(iCompoundId)
if not rewardRes:
return 0, errcode.EC_NORES
else:
itemCompoundRes = Game.res_mgr.res_item.get(iCompoundId)
if not itemCompoundRes:
return 0, errcode.EC_NORES
if itemobj.getNum() < iNeed:
return 0, errcode.EC_NOT_ENOUGH
dCost = {itemobj.resID: iNeed}
respBag = self.player.bag.costItem(dCost,
constant.ITEM_COST_COMPOUND,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_COST_ERR
if rewardRes:
dReward = rewardRes.doReward()
respBag1 = self.player.bag.add(dReward,
constant.ITEM_ADD_COMPOUND,
wLog=True)
else:
dAdd = {iCompoundId: num}
respBag1 = self.player.bag.add(dAdd,
constant.ITEM_ADD_COMPOUND,
wLog=True)
respBag = self.player.mergeRespBag(respBag, respBag1)
# 打包返回信息
cost_update = self.player.packRespBag(respBag)
resp = {
"allUpdate": cost_update,
}
return 1, resp
class DaoGuanMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
# 挑战道馆(daoguanChallenge)
# 请求
# 道馆id(daoguanId, int)
# 副本id(fbId, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 道馆
# 游戏模型 - 货币
# 游戏模型 - 角色背包
# 游戏模型 - 角色属性
# 游戏模型 - 角色基础 - 战力
# 战报(fightLog, json)
def rc_daoguanChallenge(self, daoguanId, fbId):
daoguanRes = Game.res_mgr.res_pavilion.get(daoguanId)
if not daoguanRes:
return 0, errcode.EC_NORES
if fbId not in daoguanRes.challengeList:
return 0, errcode.EC_DAOGUAN_FIGHT_ID_ERROR
barrRes = Game.res_mgr.res_barrier.get(fbId)
if not barrRes:
return 0, errcode.EC_NORES
if self.player.daoguan.area != daoguanRes.area:
return 0, errcode.EC_DAOGUAN_FIGHT_AREA_ERROR
daoguanObj = self.player.daoguan.getPavilion(daoguanId)
if not daoguanObj:
return 0, errcode.EC_DAOGUAN_NOT_FIND
if not daoguanObj.hasAllTaskFinish():
return 0, errcode.EC_DAOGUAN_FIGHT_LIMIT
if daoguanObj.firstFinish:
return 0, errcode.EC_DAOGUAN_HAS_FIRST_FINISH
if self.player.daoguan.getHaveChallengeNum() <= 0:
return 0, errcode.EC_DAOGUAN_FIGHT_NUM_LIMIT
if fbId in daoguanObj.finishChallengeList:
return 0, errcode.EC_DAOGUAN_BARR_HAS_FINISH
rewardRes = Game.res_mgr.res_reward.get(barrRes.rewardId)
firstRewardRes = Game.res_mgr.res_reward.get(daoguanRes.firstRewardId)
if not firstRewardRes:
return 0, errcode.EC_NORES
# fightobj = Game.fight_mgr.createFight(constant.FIGHT_TYPE_114)
# rs = fightobj.init_by_barrId(self.player, barrRes.id)
# if not rs:
# return 0, errcode.EC_INIT_BARR_FAIL
# fightobj.fixEleValue(daoguanRes.increase, daoguanRes.decrease)
# fightLog = fightobj.doFight()
# fightResult = fightLog["result"].get("win", 0)
fightobj = createFight(constant.FIGHT_TYPE_100)
rs = fightobj.init_data(
self.player.GetFightData(constant.BATTLE_ARRAY_TYPE_NORMAL),
100000)
if not rs:
return 0, errcode.EC_INIT_BARR_FAIL
fightLog = fightobj.doFight()
log_end = fightLog.get("end", {})
winerList = log_end.get("winerList", [])
fightResult = 1 if self.player.id in winerList else 0
respBag = {}
resp_attr = []
if fightResult:
dReward = {}
if rewardRes:
dReward = rewardRes.doReward()
if dReward:
respBag = self.player.bag.add(dReward,
constant.ITEM_ADD_DAOGUAN,
wLog=True)
#已挑战副本
ls = daoguanObj.getFinishChallengeList()
ls.append(fbId)
daoguanObj.setFinishChallengeList(ls)
#加入已扫荡列表
ls = self.player.daoguan.GetDaoGuanDaySweepList()
if daoguanId not in ls:
ls.append(daoguanId)
self.player.daoguan.SetDaoGuanDaySweepList(ls)
if daoguanObj.hasAllFinish():
#首通道馆 属性 和 奖励
respBag1 = self.player.bag.add(firstRewardRes.doReward(),
constant.ITEM_ADD_DAOGUAN_FIRST,
wLog=True)
respBag = self.player.mergeRespBag(respBag, respBag1)
# 附加过关属性
self.player.attr.addAttr(daoguanRes.attr,
constant.FIGHTABILITY_TYPE_36)
resp_attr.extend(list(daoguanRes.attr.keys()))
daoguanObj.doFirstFinish()
self.player.safe_pub(msg_define.MSG_PASS_DAO_GUAN)
#当前地区全部通关，去往下一个地区的道馆
if self.player.daoguan.hasAllFinish():
self.player.daoguan.enterNextArea()
else:
#失败扣除次数
#今日挑战次数
iNum = self.player.daoguan.GetDaoGuanDayChallengeNum()
iNum += 1
self.player.daoguan.SetDaoGuanDayChallengeNum(iNum)
if daoguanRes.eleType == 1:
self.player.safe_pub(
msg_define.MSG_XIANSHITUISONGLIBAO_DAOGUAN_1_F)
elif daoguanRes.eleType == 2:
self.player.safe_pub(
msg_define.MSG_XIANSHITUISONGLIBAO_DAOGUAN_2_F)
elif daoguanRes.eleType == 3:
self.player.safe_pub(
msg_define.MSG_XIANSHITUISONGLIBAO_DAOGUAN_3_F)
elif daoguanRes.eleType == 4:
self.player.safe_pub(
msg_define.MSG_XIANSHITUISONGLIBAO_DAOGUAN_4_F)
elif daoguanRes.eleType == 5:
self.player.safe_pub(
msg_define.MSG_XIANSHITUISONGLIBAO_DAOGUAN_5_F)
# 重算战力
self.player.attr.RecalFightAbility()
# 打包返回信息
dUpdate = self.player.packRespBag(respBag,
fa=self.player.base.fa,
roleAttr=resp_attr)
dUpdate["daoguan"] = self.player.daoguan.to_init_data()
resp = {
"fightLog": fightLog,
"allUpdate": dUpdate,
}
return 1, resp
# 扫荡道馆(daoguanSweep)
# 请求
# 道馆id(daoguanId, int)
# 返回
# 主动推送刷新(allUpdate,json)
# 游戏模型-道馆
# 游戏模型-货币
# 游戏模型-角色背包
def rc_daoguanSweep(self, daoguanId):
daoguanRes = Game.res_mgr.res_pavilion.get(daoguanId)
if not daoguanRes:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(daoguanRes.rewardId)
if not rewardRes:
return 0, errcode.EC_NORES
ls = self.player.daoguan.GetDaoGuanDaySweepList()
if daoguanId in ls:
return 0, errcode.EC_DAOGUAN_HAS_SWEEP
iPass = 0
if self.player.daoguan.getArea() > daoguanRes.area:
iPass = 1
elif self.player.daoguan.getArea() == daoguanRes.area:
daoguanObj = self.player.daoguan.getPavilion(daoguanId)
if not daoguanObj:
return 0, errcode.EC_DAOGUAN_NOT_FIND
if daoguanObj.firstFinish:
iPass = 1
if not iPass:
return 0, errcode.EC_DAOGUAN_SWEEP_LIMIT
dReward = rewardRes.doReward()
respBag = self.player.bag.add(dReward,
constant.ITEM_ADD_DAOGUAN,
wLog=True)
ls.append(daoguanId)
self.player.daoguan.SetDaoGuanDaySweepList(ls)
# 打包返回信息
dUpdate = self.player.packRespBag(
respBag, fa=self.player.base.GetFightAbility())
dUpdate["daoguan"] = self.player.daoguan.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 一键扫荡道馆(daoguanOneKeySweep)
# 请求
# 返回
# 主动推送刷新(allUpdate,json)
# 游戏模型-道馆
# 游戏模型-货币
# 游戏模型-角色背包
def rc_daoguanOneKeySweep(self):
#vip X 才开启一键扫荡
iVipLv = self.player.vip.GetVipLv()
vipRes = Game.res_mgr.res_vip.get(iVipLv)
if not vipRes:
return 0, errcode.EC_NORES
if not vipRes.daoguanSweep:
return 0, errcode.EC_DAOGUAN_SWEEP_LIMIT
dReward = {}
for daoguanId, daoguanRes in Game.res_mgr.res_pavilion.items():
rewardRes = Game.res_mgr.res_reward.get(daoguanRes.rewardId)
if not rewardRes:
continue
ls = self.player.daoguan.GetDaoGuanDaySweepList()
if daoguanId in ls:
continue
iPass = 0
if self.player.daoguan.getArea() > daoguanRes.area:
iPass = 1
elif self.player.daoguan.getArea() == daoguanRes.area:
daoguanObj = self.player.daoguan.getPavilion(daoguanId)
if not daoguanObj:
continue
if daoguanObj.firstFinish:
iPass = 1
if not iPass:
continue
_dReward = rewardRes.doReward()
ls.append(daoguanId)
self.player.daoguan.SetDaoGuanDaySweepList(ls)
for itemId, num in _dReward.items():
if itemId in dReward:
dReward[itemId] += num
else:
dReward[itemId] = num
respBag = self.player.bag.add(dReward,
constant.ITEM_ADD_DAOGUAN,
wLog=True)
# 打包返回信息
dUpdate = self.player.packRespBag(
respBag, fa=self.player.base.GetFightAbility())
dUpdate["daoguan"] = self.player.daoguan.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 道馆挑战次数购买(daoguanChallengeBuy)
# 请求
# 返回
# 主动推送刷新(allUpdate,json)
# 游戏模型-道馆
# 游戏模型-货币
# 游戏模型-角色背包
def rc_daoguanChallengeBuy(self):
iTodayBuy = self.player.daoguan.GetDaoGuanDayBuyChallengeNum()
iVipLv = self.player.vip.GetVipLv()
vipRes = Game.res_mgr.res_vip.get(iVipLv)
if not vipRes:
return 0, errcode.EC_NORES
if iTodayBuy >= vipRes.daoguanBuyNum:
return 0, errcode.EC_DAOGUAN_VIP_BUY_LIMIT
costRes = Game.res_mgr.res_common.get("daoguanChallengeBuyCost")
if not costRes:
return 0, errcode.EC_NORES
if len(costRes.arrayint1) <= iTodayBuy:
return 0, errcode.EC_DAOGUAN_VIP_BUY_LIMIT
iCost = costRes.arrayint1[iTodayBuy]
dCost = {constant.CURRENCY_BINDGOLD: iCost}
# 扣道具
respBag = self.player.bag.costItem(dCost,
constant.ITEM_COST_DAOGUAN_BUG_NUM,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_DAOGUAN_VIP_BUY_NOT_ENOUGH
self.player.daoguan.SetDaoGuanDayBuyChallengeNum(iTodayBuy + 1)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["daoguan"] = self.player.daoguan.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
class PetMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
# 宠物升级(petUpGrade)
# 请求
# 宠物唯一id(uid, str)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
# 游戏模型 - 角色背包 - 道具列表
# 游戏模型 - 角色基础 - 战力
def rc_petUpGrade(self, uid):
# 宠物未激活
pet = self.player.pet.getPet(uid)
if not pet:
return 0, errcode.EC_PET_NOT_ACT
res = Game.res_mgr.res_pet.get(pet.resID)
if not res:
return 0, errcode.EC_NORES
#等级上限限制
evolveRes = Game.res_mgr.res_idlv_petevolve.get(
(pet.resID, pet.evolveLv))
if not evolveRes:
return 0, errcode.EC_NORES
iCurLv = pet.GetLv()
if iCurLv >= evolveRes.lvLimit:
return 0, errcode.EC_MAX_LEVEL
#当前等级资源
curRes = Game.res_mgr.res_qalv_petlv.get((res.quality, iCurLv))
if not curRes:
return 0, errcode.EC_NORES
# 如果没有下一阶
iNextLv = iCurLv + 1
nextRes = Game.res_mgr.res_qalv_petlv.get((res.quality, iNextLv))
if not nextRes:
return 0, errcode.EC_MAX_LEVEL
# 扣道具
respBag = self.player.bag.costItem(curRes.cost,
constant.ITEM_COST_PET_UPGRADE,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_PET_UPGRADE_NOT_ENOUGH
#设置等级
pet.SetLv(iNextLv)
#重算宠物属性
pet.attr.recalAttr([
constant.PET_ATTR_MODULE_LV_EVOLVE, constant.PET_ATTR_MODULE_SKILL
])
# 重算战力
self.player.attr.RecalFightAbility()
# 抛事件
self.player.safe_pub(msg_define.MSG_PET_UPGRADE)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dPet = dUpdate.setdefault("pet", {})
dPet["all_pets"] = [pet.to_init_data()]
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物进化(petEvolve)
# 请求
# 宠物唯一id(uid, str)
# 消耗宠物列表(costPet, [str])
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
# 游戏模型 - 角色背包 - 道具列表
# 游戏模型 - 角色基础 - 战力
def rc_petEvolve(self, uid, costPet):
#不能吃自己
if uid in costPet:
return 0, errcode.EC_PET_EVOLVE_EAT_SELF
# 宠物未激活
pet = self.player.pet.getPet(uid)
if not pet:
return 0, errcode.EC_PET_NOT_ACT
res = Game.res_mgr.res_pet.get(pet.resID)
if not res:
return 0, errcode.EC_NORES
# 等级不足
iCurEvolveLv = pet.GetEvolveLv()
curRes = Game.res_mgr.res_idlv_petevolve.get((pet.resID, iCurEvolveLv))
if not curRes:
return 0, errcode.EC_NORES
if curRes.needLv > pet.GetLv():
return 0, errcode.EC_NOLEVEL
# 下一阶
iNextEvolveLv = iCurEvolveLv + 1
nextRes = Game.res_mgr.res_idlv_petevolve.get(
(pet.resID, iNextEvolveLv))
if not nextRes:
if curRes.changeID:
iNextEvolveLv = 1
nextRes = Game.res_mgr.res_idlv_petevolve.get(
(curRes.changeID, iNextEvolveLv))
else:
return 0, errcode.EC_MAX_LEVEL
#检查是否消耗宠物
if curRes.costPet1 or curRes.costPet2:
rs, code = self.player.pet.getCostPet(costPet, curRes.costPet1,
curRes.costPet2)
if not rs:
if code == 1: #1=没有足够的宠物
return 0, errcode.EC_PET_EVOLVE_NOT_ENOUGH
elif code == 2: #2=宠物身上有装备，有各种物品时不可消耗
return 0, errcode.EC_PET_CAN_NOT_COST_WEAR
elif code == 3: #3=宠物已出战
return 0, errcode.EC_PET_CAN_NOT_COST_FIGHT
else:
return 0, errcode.EC_PET_EVOLVE_NOT_ENOUGH
# 扣道具
respBag = self.player.bag.costItem(curRes.cost,
constant.ITEM_COST_PET_EVOLVE,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_PET_EVOLVE_NOT_ENOUGH
#扣宠物
if costPet:
backAdd = self.player.pet.costPet(constant.ITEM_COST_PET_EVOLVE,
costPet,
wLog=True)
#返还材料
respBag1 = self.player.bag.add(backAdd,
constant.ITEM_ADD_PET_EVOLVE_BACK)
respBag = self.player.mergeRespBag(respBag, respBag1)
#是否变宠物ID
if curRes.changeID:
pet.SetResID(curRes.changeID)
#设置进化等级
pet.SetEvolveLv(iNextEvolveLv)
#增加被动技能
pet.setPrivate(nextRes.private)
pet.addPeculiarity(nextRes.peculiarityAdd)
# 图鉴激活
if curRes.changeID:
self.player.pet.actAlbum(pet)
# 战力重算
pet.attr.recalAttr([
constant.PET_ATTR_MODULE_LV_EVOLVE,
constant.PET_ATTR_MODULE_PECULIARITY
])
self.player.attr.RecalFightAbility()
# 抛事件
self.player.safe_pub(msg_define.MSG_PET_EVOLVE, uid)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["attr"] = self.player.attr.to_update_data()
dPet = dUpdate.setdefault("pet", {})
dPet["all_pets"] = [pet.to_init_data()]
dPet["del_pets"] = costPet
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 上传布阵(rc_uploadBattleArray)
# 请求
# 出战队伍类型(tp, int)
# 阵位列表(position, [json]) 位置(str): 宠物唯一id(str)
# 返回
# 出战队伍类型(tp, int)
# 阵位列表(position, [json]) 位置(str): 宠物唯一id(str)
def rc_uploadBattleArray(self, tp, position):
#检查宠物互斥
for one in position:
petList = list(one.values())
if not self.player.pet.checkPetMutex(petList):
return 0, errcode.EC_PET_MUTEX_LIMIT
#数据转化
all = []
for one in position:
data = {}
for k, v in one.items():
data[int(k)] = v
all.append(data)
obj = self.player.battle_array.getBattleArray(tp)
change = obj.setPosition(all)
# 出战队伍战力
if tp == constant.BATTLE_ARRAY_TYPE_NORMAL:
self.player.attr.RecalFightAbility()
# 打包返回
dUpdate = {}
dUpdate["base"] = {"fa": self.player.base.GetFightAbility()}
dPet = dUpdate.setdefault("pet", {})
dPet["all_pets"] = [pet.to_init_data() for pet in change]
resp = {"allUpdate": dUpdate, "tp": tp, "position": position}
return 1, resp
# 宠物技能洗练(petSkillWash)
# 请求
# 宠物唯一id(uid, str)
# 洗练类型(type, int) 1 = 普通 2 = 高级
# 是否自动购买(auto, int) 补足当次需要材料 0 = 不自动 1 = 自动
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
# 游戏模型 - 角色背包 - 道具列表
# 游戏模型 - 货币
def rc_petSkillWash(self, uid, type, auto):
# 宠物未激活
pet = self.player.pet.getPet(uid)
if not pet:
return 0, errcode.EC_PET_NOT_ACT
res = Game.res_mgr.res_pet.get(pet.resID)
if not res:
return 0, errcode.EC_NORES
washRes = Game.res_mgr.res_idstar_petwash.get(
(pet.resID, pet.washStar))
if not washRes:
return 0, errcode.EC_NORES
#1 = 普通 2 = 高级
if type == 1:
costRes = Game.res_mgr.res_common.get("petNormalWashCost")
addRes = Game.res_mgr.res_common.get("petNormalWashExp")
elif type == 2:
costRes = Game.res_mgr.res_common.get("petAdvWashCost")
addRes = Game.res_mgr.res_common.get("petAdvWashExp")
else:
costRes = None
addRes = None
if not costRes or not addRes:
return 0, errcode.EC_NORES
lockCostRes = Game.res_mgr.res_common.get("petWashLockCost")
if not lockCostRes:
return 0, errcode.EC_NORES
#获取锁定技能个数，如果全锁定，不能洗练
iCostGold = 0
if len(pet.peculiarity):
iLockNum = pet.GetLockPeculiarityNum()
if iLockNum >= len(pet.peculiarity):
return 0, errcode.EC_PET_WASH_ALL_LOCK
#如果锁定了还要扣元宝
iCostGold = lockCostRes.arrayint2.get(iLockNum, 0)
if iCostGold:
dCost = {constant.CURRENCY_GOLD: iCostGold}
else:
dCost = {}
dCost.update(costRes.arrayint2)
# 扣道具
respBag = self.player.bag.costItem(dCost,
constant.ITEM_COST_PET_WASH,
wLog=True,
auto=auto)
if not respBag.get("rs", 0):
return 0, errcode.EC_PET_WASH_NOT_ENOUGH
#洗练技能
pet.WashPeculiarity()
#增加洗练次数
iWashNum = pet.GetWashNum()
iWashNum += addRes.i
pet.SetWashNum(iWashNum)
#升星
iWashStar = pet.GetWashStar()
starRes = Game.res_mgr.res_petwashstar.get(iWashStar)
nextRes = Game.res_mgr.res_petwashstar.get(iWashStar + 1)
if starRes and nextRes and iWashNum >= starRes.cnt:
iWashStar += 1
pet.SetWashStar(iWashStar)
#抛事件
self.player.safe_pub(msg_define.MSG_PET_SKILL_WASH)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dPet = dUpdate.setdefault("pet", {})
dPet["all_pets"] = [pet.to_init_data()]
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物技能洗练锁定(petSkillWashLock)
# 请求
# 宠物唯一id(uid, str)
# 技能部位(pos, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petSkillWashLock(self, uid, pos):
# 宠物未激活
pet = self.player.pet.getPet(uid)
if not pet:
return 0, errcode.EC_PET_NOT_ACT
res = Game.res_mgr.res_pet.get(pet.resID)
if not res:
return 0, errcode.EC_NORES
#宠物初始化有多少技能就固定了,不会扩充
if not pet.peculiarity.get(pos):
return 0, errcode.EC_PET_WASH_POS_ERROR
pet.LockPeculiarity(pos)
# 打包返回信息
dUpdate = {}
dPet = dUpdate.setdefault("pet", {})
dPet["all_pets"] = [pet.to_init_data()]
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物技能洗练解锁(petSkillWashUnLock)
# 请求
# 宠物唯一id(uid, str)
# 技能部位(pos, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petSkillWashUnLock(self, uid, pos):
# 宠物未激活
pet = self.player.pet.getPet(uid)
if not pet:
return 0, errcode.EC_PET_NOT_ACT
res = Game.res_mgr.res_pet.get(pet.resID)
if not res:
return 0, errcode.EC_NORES
# 宠物初始化有多少技能就固定了,不会扩充
if not pet.peculiarity.get(pos):
return 0, errcode.EC_PET_WASH_POS_ERROR
pet.UnLockPeculiarity(pos)
# 打包返回信息
dUpdate = {}
dPet = dUpdate.setdefault("pet", {})
dPet["all_pets"] = [pet.to_init_data()]
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物技能更换(petSkillChange)
# 请求
# 宠物唯一id(uid, str)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petSkillChange(self, uid):
# 宠物未激活
pet = self.player.pet.getPet(uid)
if not pet:
return 0, errcode.EC_PET_NOT_ACT
res = Game.res_mgr.res_pet.get(pet.resID)
if not res:
return 0, errcode.EC_NORES
#宠物技能更换
pet.PeculiarityChange()
#重算宠物属性
pet.attr.recalAttr([constant.PET_ATTR_MODULE_PECULIARITY])
self.player.attr.RecalFightAbility()
# 打包返回信息
dUpdate = {}
dUpdate["base"] = {"fa": self.player.base.GetFightAbility()}
dPet = dUpdate.setdefault("pet", {})
dPet["all_pets"] = [pet.to_init_data()]
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物锁定(petLock)
# 请求
# 宠物唯一id(uid, str)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petLock(self, uid):
# 宠物未激活
pet = self.player.pet.getPet(uid)
if not pet:
return 0, errcode.EC_PET_NOT_ACT
res = Game.res_mgr.res_pet.get(pet.resID)
if not res:
return 0, errcode.EC_NORES
pet.SetLock(1)
# 打包返回信息
dUpdate = {}
dPet = dUpdate.setdefault("pet", {})
dPet["all_pets"] = [pet.to_init_data()]
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 宠物解锁(petUnLock)
# 请求
# 宠物唯一id(uid, str)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 宠物模块（只刷当前操作的）
def rc_petUnLock(self, uid):
# 宠物未激活
pet = self.player.pet.getPet(uid)
if not pet:
return 0, errcode.EC_PET_NOT_ACT
res = Game.res_mgr.res_pet.get(pet.resID)
if not res:
return 0, errcode.EC_NORES
pet.SetLock(0)
# 打包返回信息
dUpdate = {}
dPet = dUpdate.setdefault("pet", {})
dPet["all_pets"] = [pet.to_init_data()]
resp = {
"allUpdate": dUpdate,
}
return 1, resp
class TotemMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
#图腾激活(totemAct)
#请求
# 部位(pos, int)
#
#
#返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 图腾模块（只刷当前操作的）
# 游戏模型 - 角色背包 - 道具列表
# 游戏模型 - 货币
def rc_totemAct(self, pos):
res = Game.res_mgr.res_poslv_totem.get((pos, 0), None)
if not res:
return 0, errcode.EC_NORES
nextRes = Game.res_mgr.res_poslv_totem.get((pos, 1), None)
if not res:
return 0, errcode.EC_NORES
if pos in self.player.totem.actList:
return 0, errcode.EC_TOTEM_HAS_ACT
respBag = self.player.bag.costItem(res.tpCost,
constant.ITEM_COST_TOTEM_ACT,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_TOTEM_ACT_NOT_ENOUGH
self.player.totem.actTotem(nextRes)
# 战力重算
self.player.attr.RecalFightAbility()
dTotem = {}
totem = self.player.totem.getTotem(pos)
dTotem["actList"] = [totem.to_init_data()]
dUpdate = self.player.packRespBag(respBag)
dUpdate["attr"] = self.player.attr.to_update_data()
dUpdate["totem"] = dTotem
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 图腾升级(totemUp)
# 请求
# 部位(pos, int)
# 次数(num, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-图腾模块（只刷当前操作的）
# 游戏模型-角色背包-道具列表
# 游戏模型-货币
def rc_totemUp(self, pos, num, auto):
totem = self.player.totem.getTotem(pos)
if not totem:
return 0, errcode.EC_NOT_FIND_TOTEM
oldlv = totem.getLv()
res = Game.res_mgr.res_poslv_totem.get((pos, oldlv), None)
if not res:
return 0, errcode.EC_NORES
leftExp = totem.getExp()
if res.tpCost and leftExp >= res.exp:
return 0, errcode.EC_TOTEM_NEED_TP
totalAddExp = 0
totalMulti = 0
respBag = {}
for i in range(num):
oldlv = totem.getLv()
res = Game.res_mgr.res_poslv_totem.get((pos, oldlv), None)
respBag1 = self.player.bag.costItem(
res.cost,
constant.ITEM_COST_TOTEM_UPGRADE,
wLog=True,
auto=auto)
if not respBag1.get("rs", 0):
return 0, errcode.EC_TOTEM_UPGRADE_NOT_ENOUGH
respBag = self.player.mergeRespBag(respBag, respBag1)
oldExp = totem.getExp()
oldBjId = totem.getBjResId()
oldUpgradeTimes = totem.getUpgradeTimes()
bjRes = Game.res_mgr.res_totemBj.get(oldBjId)
multi = 1
if oldUpgradeTimes + 1 >= bjRes.num:
multi = bjRes.multi
nextBjId = oldBjId + 1
nextBjRes = Game.res_mgr.res_totemBj.get(nextBjId)
if not nextBjRes:
nextBjId = oldBjId
totem.setBjResId(nextBjId)
totem.setUpgradeTimes(0)
else:
totem.setUpgradeTimes(oldUpgradeTimes + 1)
randomBj = utility.Choice(Game.res_mgr.res_random_totem)
randomBjRes = Game.res_mgr.res_totemRan.get(randomBj, None)
multi = randomBjRes.multi
addRes = Game.res_mgr.res_common.get("totemsUpExp", None)
addExp = addRes.i * multi
newExp = oldExp + addExp
if newExp > res.exp and not res.tpCost:
newlv = oldlv + 1
nextRes = Game.res_mgr.res_poslv_totem.get((pos, newlv), None)
if nextRes:
leftExp = newExp - res.exp
totem.setLv(newlv, res, nextRes)
totem.setExp(leftExp)
else:
totem.setExp(newExp)
else:
totem.setExp(newExp)
if multi > 1:
totalMulti += multi
totalAddExp += addExp
# 战力重算
self.player.attr.RecalFightAbility()
dTotem = {}
dTotem["actList"] = [totem.to_init_data()]
dUpdate = self.player.packRespBag(respBag)
dUpdate["attr"] = self.player.attr.to_update_data()
dUpdate["totem"] = dTotem
resp = {
"allUpdate": dUpdate,
"multi": totalMulti,
"addExp": totalAddExp,
}
return 1, resp
# 图腾突破(totemTp)
# 请求
# 部位(pos, int)
#
#
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 图腾模块（只刷当前操作的）
# 图腾部位(pos, int)
# 等级(lv, int)
# 经验(exp, int)
# 已升级次数(upNum, int)
# 图腾暴击配置表id(bjId, int)
# 游戏模型 - 角色背包 - 道具列表
# 游戏模型 - 货币
def rc_totemTp(self, pos):
totem = self.player.totem.getTotem(pos)
if not totem:
return 0, errcode.EC_NOT_FIND_TOTEM
res = Game.res_mgr.res_poslv_totem.get((pos, totem.getLv()), None)
if not res:
return 0, errcode.EC_NORES
if not res.tpCost:
return 0, errcode.EC_TOTEM_NOT_NEED_TP
leftExp = totem.getExp()
if leftExp < res.exp:
return 0, errcode.EC_TOTEM_CAN_NOT_TP
nextRes = Game.res_mgr.res_poslv_totem.get((pos, totem.getLv() + 1),
None)
if not nextRes:
return 0, errcode.EC_NORES
respBag = self.player.bag.costItem(res.tpCost,
constant.ITEM_COST_TOTEM_ACT,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_TOTEM_ACT_NOT_ENOUGH
while True:
leftExp -= res.exp
totem.setLv(nextRes.level, res, nextRes)
if not nextRes.exp:
break
res = nextRes
nextRes = Game.res_mgr.res_poslv_totem.get(
(pos, totem.getLv() + 1), None)
if leftExp < nextRes.exp:
break
totem.setExp(leftExp)
# 战力重算
self.player.attr.RecalFightAbility()
dTotem = {}
dTotem["actList"] = [totem.to_init_data()]
dUpdate = self.player.packRespBag(respBag)
dUpdate["attr"] = self.player.attr.to_update_data()
dUpdate["totem"] = dTotem
resp = {
"allUpdate": dUpdate,
}
return 1, resp
class BossPlayerRpc(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
def sendYwBossKillReward(self, bossId, isTimeout=1):
"""击杀野外boss奖励"""
resYwBoss = Game.res_mgr.res_ywBoss.get(bossId)
if not resYwBoss:
return
barrRes = Game.res_mgr.res_barrier.get(resYwBoss.fbId)
if not barrRes:
return
rewardRes = Game.res_mgr.res_reward.get(barrRes.rewardId)
if not rewardRes:
return
dReward = rewardRes.doReward()
respBag = self.player.bag.add(dReward,
constant.ITEM_ADD_YWBOSS_REWARD,
wLog=True)
iTodayNum = self.player.boss.GetYwBossTodayTZ()
# 修改挑战次数
self.player.boss.SetYwBossTodayTZ(iTodayNum + 1)
# 修改最后挑战时间
now = int(time.time())
self.player.boss.SetYwBossLastTZTime(now)
#抛事件
self.player.safe_pub(msg_define.MSG_KILL_YW_BOSS)
if isTimeout:
dUpdate = self.player.packRespBag(respBag)
resp = {
"allUpdate": dUpdate,
}
spawn(self.player.call, "ywBossKill", resp, noresult=True)
return respBag
def ssjBossTZNotice(self, id, fightLog, pid):
ssjRes = Game.res_mgr.res_ssjBoss.get(id)
if not ssjRes:
return
barrRes = Game.res_mgr.res_barrier.get(ssjRes.fbId)
if not barrRes:
return
helpres = Game.res_mgr.res_common.get("ssjBossHelpNum")
if not helpres:
return
fightResult = fightLog["result"].get("win", 0)
respBag = {}
if fightResult:
dReward = {}
if not self.player.boss.GetSsjBossTodayKill(id):
rewardRes = Game.res_mgr.res_reward.get(barrRes.rewardId)
if rewardRes:
dReward = rewardRes.doReward()
#是否已首通
isFirst = self.player.boss.GetSsjBossFirst(id)
if not isFirst:
self.player.boss.SetSsjBossFirst(id)
dReward.update(barrRes.firstReward)
#设置击杀
self.player.boss.SetSsjBossTodayKill(id)
#是否协助
if pid != self.player.id:
iHelpNum = self.player.boss.GetSsjBossTodayHelp()
if iHelpNum < helpres.i:
rewardRes = Game.res_mgr.res_reward.get(
barrRes.helpRewardId)
if rewardRes:
dHelpReward = rewardRes.doReward()
for iNo, iNum in dHelpReward.items():
if dReward.get(iNo):
dReward[iNo] += iNum
else:
dReward[iNo] = iNum
self.player.boss.SetSsjBossTodayHelp(iHelpNum + 1)
respBag = self.player.bag.add(dReward,
constant.ITEM_ADD_SSJBOSS_REWARD,
wLog=True)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["boss"] = self.player.boss.to_ssjboss_data([id])
resp = {
"id": id,
"fightLog": fightLog,
"allUpdate": dUpdate,
}
spawn(self.player.call, "ssjBossTZNotice", resp, noresult=True)
def sendYwBossTZ(self, resp):
spawn(self.player.call, "ywBossTZ", resp, noresult=True)
class ChatRpcMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
# 发送世界聊天(sendWorldMSG)
# 请求
# 聊天内容(content,string)
# 返回
# 全服广播(worldMSGNotice)
# 玩家id(rid,int)
# 聊天内容(content,string)
def rc_sendWorldMSG(self, content, type=0):
if self.player.isShutup():
return
if type == 0:
for addr, logic in Game.rpc_logic_game:
if logic:
logic.sendWorldMSG(self.player.id, content)
elif type == 2:
from game.mgr.room import get_rpc_diaoyu
rpc_diaoyu = get_rpc_diaoyu()
if not rpc_diaoyu:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_diaoyu.msg(2, self.player.id, content)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
elif type == 3:
from game.mgr.room import get_rpc_wakuang
rpc_wakuang = get_rpc_wakuang()
if not rpc_wakuang:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
data = self.player.zudui.getTeamInfo(0)
rrv = rpc_wakuang.msg(3, data["id"], content)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
elif type == 4:
from game.mgr.room import get_rpc_boss
rpc_boss = get_rpc_boss()
if not rpc_boss:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_boss.msg(4, self.player.id, content)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
elif type == 5:
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_gongcheng.msg(5, self.player.id, content)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
elif type == 6:
from game.mgr.room import get_rpc_jiujiyishou
rpc_jiujiyishou = get_rpc_jiujiyishou()
if not rpc_jiujiyishou:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_jiujiyishou.msg(6, self.player.id, content)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
# 抛事件
self.player.safe_pub(msg_define.MSG_SEND_WORLD_MSG)
return 1, {}
# 发送私聊(privateChatSend)
# 请求
# 玩家id(rid,int)
# 聊天内容(content,string)
# 返回
# 玩家id(rid,int)
# 聊天内容(content,string)
# 时间(sendTime, int)
def rc_privateChatSend(self, rid, content):
sendTime = int(time.time())
info = self.player.toChatInfo()
from game.mgr.player import get_rpc_player
rpc_player = get_rpc_player(rid)
chatinfo = rpc_player.privateChatReceive(self.player.id, info, content,
sendTime)
self.player.chat.privateChatSend(rid, chatinfo, content, sendTime)
resp = {}
resp["rid"] = rid
resp["content"] = content
resp["sendTime"] = sendTime
return 1, resp
# 获取私聊列表(getPrivateChatList)
# 请求
# 返回
# 私聊玩家列表(chatList, [json])
# 玩家id(rid,int)
# 名称(name, string)
# 性别(sex, int)
# 0=? 1=男 2=女
# 等级(lv, int)
# vip等级(vipLv, int)
# 战力(fa, int)
# 是否在线(isOnline, int)
def rc_getPrivateChatList(self):
chatList = self.player.chat.getPrivateChatList()
resp = {"chatList": chatList}
return 1, resp
# 获取私聊数据(getPrivateChatData)
# 请求
# 玩家id(rid,int)
# 返回
# 玩家id(rid,int)
# 内容列表(contentList)
# 玩家id(rid,int)
# 聊天内容(content,string)
# 时间(sendTime, int)
def rc_getPrivateChatData(self, rid):
contentList = self.player.chat.getPrivateChatData(rid)
resp = {"rid": rid, "contentList": contentList}
return 1, resp
# 清除玩家私聊(cleanPrivateChat)
# 请求
# 玩家id(rid,int)
# 返回
# 玩家id(rid,int)
def rc_cleanPrivateChat(self, rid):
self.player.chat.cleanPrivateChat(rid)
resp = {"rid": rid}
return 1, resp
# 发送小助手聊天(sendHelperChat)
# 请求
# 聊天内容(content,string)
# 返回
# 聊天内容(content,string)
# 时间(sendTime, int)
def rc_sendHelperChat(self, content):
Game.glog.log2File(
"rc_sendHelperChat",
"%s|%s|%s" % (self.player.id, self.player.name, content))
resp = {"content": content, "sendTime": int(time.time())}
return 1, resp
class MarryMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
# 检查对方可否结婚(marryCheck)
# 请求
# 对方pid(targetPid, int)
#
# 返回
def rc_marryCheck(self, targetPid):
if not Game.rpc_player_mgr.is_online(targetPid):
return 0, errcode.EC_MARRY_NOT_ONLINE
from game.mgr.player import get_rpc_player
targetPlayer = get_rpc_player(targetPid, offline=False)
if not targetPlayer:
return 0, errcode.EC_NOFOUND
if self.player.marry.getMarryStatus() or targetPlayer.getMarryStatus():
return 0, errcode.EC_MARRY_ALREAY_MARRY
if self.player.marry.isMarriedToday() or targetPlayer.isMarriedToday():
return 0, errcode.EC_MARRY_ALEARY_TODAY
return 1, {}
# 求婚(marrySomeone)
# 请求
# 对方pid(targetPid, int)
# 身份类型(kind, int)
# 结婚类型id(marryId, int)
# 返回
def rc_marrySomeone(self, targetPid, kind, marryId):
marryRes = Game.res_mgr.res_marry.get(marryId, None)
if not marryRes:
return 0, errcode.EC_NORES
if not Game.rpc_player_mgr.is_online(targetPid):
return 0, errcode.EC_MARRY_NOT_ONLINE
from game.mgr.player import get_rpc_player
targetPlayer = get_rpc_player(targetPid, offline=False)
if not targetPlayer:
return 0, errcode.EC_NOFOUND
if self.player.marry.getMarryStatus() or targetPlayer.getMarryStatus():
return 0, errcode.EC_MARRY_ALREAY_MARRY
if self.player.marry.isMarriedToday() or targetPlayer.isMarriedToday():
return 0, errcode.EC_MARRY_ALEARY_TODAY
canCost = self.player.bag.canCostItem(marryRes.cost)
if not canCost.get("rs", 0):
return 0, errcode.EC_MARRY_NOT_ENOUGH
pushData = {
"targetName": self.player.name,
"targetPid": self.player.id,
"marryId": marryId,
"kind": kind,
}
targetPlayer.marryPush(pushData)
return 1, None
# 求婚回应(marryAnswer)
# 请求
# 选择(option, int)
# 1 答应 2拒绝
# 你的身份(kind, int)
# 1 夫君 2 妻子
# 对方pid(targetPid, int)
# 结婚类型(marryId, int)
# 返回
def rc_marryAnswer(self, option, kind, targetPid, marryId):
from game.mgr.player import get_rpc_player
targetPlayer = get_rpc_player(targetPid, offline=False)
if not targetPlayer:
return 0, errcode.EC_NOFOUND
if option == 2:
pushData = {
"result": 3,
"targetPid": self.player.id,
}
targetPlayer.marryResultPush(pushData)
return 1, {}
marryRes = Game.res_mgr.res_marry.get(marryId, None)
if not marryRes:
return 0, errcode.EC_NORES
if self.player.getMarryStatus() or targetPlayer.getMarryStatus():
return 0, errcode.EC_MARRY_ALREAY_MARRY
respBag = targetPlayer.costItem(marryRes.cost,
constant.ITEM_COST_MARRY,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_COST_ERR
myPid = self.player.id
myName = self.player.name
targetName = targetPlayer.getName()
successPushData = {
"husbandName": targetName,
"husbandPid": targetPid,
"wifeName": myName,
"wifePid": myPid,
}
targetKind = 1
if kind == 1:
targetKind = 2
successPushData = {
"husbandName": myName,
"husbandPid": myPid,
"wifeName": targetName,
"wifePid": targetPid,
}
self.player.marrySomeone(targetPid, targetName, kind, marryId)
targetPlayer.marrySomeone(myPid, myName, targetKind, marryId)
Game.rpc_player_mgr.broadcast("marrySuccessPush", successPushData,
[myPid, targetPid])
return 1, None
# 赠送结婚礼金(presentMarryGfit)
# 请求
# 礼金类型(giftId, int)
# 丈夫pid(husbandPid, int)
# 妻子pid(wifePid, int)
# 返回
# 主动推送刷新(allUpdate,json)
# 游戏模型-货币
# 游戏模型-角色背包
def rc_presentMarryGfit(self, giftId, husbandPid, wifePid):
giftRes = Game.res_mgr.res_marryGift.get(giftId, None)
giftMailRes1 = Game.res_mgr.res_mail.get(constant.MAIL_ID_MARRY_GIFT,
None)
giftMailRes2 = Game.res_mgr.res_mail.get(
constant.MAIL_ID_MARRY_RETGIFT, None)
if not giftRes or not giftMailRes1 or not giftMailRes2:
return 0, errcode.EC_NORES
respBag = self.player.bag.costItem(giftRes.cost,
constant.ITEM_COST_MARRY_GIFT,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_COST_ERR
content = giftMailRes1.content % self.player.name
Game.rpc_mail_mgr.sendPersonMail(self.player.id, giftMailRes2.title,
giftMailRes2.content, giftRes.reward)
Game.rpc_mail_mgr.sendPersonMail(husbandPid, giftMailRes1.title,
content, giftRes.reward)
Game.rpc_mail_mgr.sendPersonMail(wifePid, giftMailRes1.title, content,
giftRes.reward)
dUpdate = self.player.packRespBag(respBag)
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 离婚(divorce)
# 请求
# 返回
def rc_divorce(self):
if not self.player.getMarryStatus():
return 0, errcode.EC_MARRY_NOT_MARRY
spousePid = self.player.marry.getSpousePid()
from game.mgr.player import get_rpc_player
spousePlayer = get_rpc_player(spousePid, offline=True)
if not spousePlayer:
return 0, errcode.EC_NOFOUND
self.player.marry.divorce()
myMailRes = Game.res_mgr.res_mail.get(constant.MAIL_ID_DIVORCE, None)
if myMailRes:
Game.rpc_mail_mgr.sendPersonMail(spousePid, myMailRes.title,
myMailRes.content, {})
spousePlayer.divorce()
return 1, None
# 亲密度时间到了需要刷新一下
def rc_MarryRefresh(self):
# self.player.marry.checkEn()
dUpdate = {}
dUpdate["marryInfo"] = self.player.marry.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 已读亲密度真爱
def rc_MarryTureLoveRead(self):
self.player.marry.TrueLoveRead()
return 1, {}
# 已读亲密度真爱
def rc_MarryMsgRead(self):
self.player.marry.MsgRead()
return 1, {}
# 赠送亲密度
def rc_MarryPowerBuy(self, id, num, bynum, costtype, costnum):
res = Game.res_mgr.res_marryPower.get(id, None)
if not res:
return 0, errcode.EC_NORES
if not self.player.marry.spousePid:
return 0, errcode.EC_MARRY_NOT_MARRY
self.player.marry.checkEn()
en = 0
for x in self.player.marry.powerEn:
if x["id"] == id:
en = x["en"]
break
if res.enlimit and not en:
return 0, errcode.EC_MARRY_NOT_EN
useids = self.player.marry.getMarryUseIDs()
usenum = useids.count(id)
if res.uselimit and usenum >= res.uselimit:
return 0, errcode.EC_MARRY_NOT_TODAY_LIMIT
cost = copy.deepcopy(res.cost)
for k, v in cost.items():
cost[k] = cost[k] * (num - bynum)
if costtype and costnum:
cost[costtype] = cost.get(costtype, 0) + costnum
delkey = []
for k, v in cost.items():
if not v:
delkey.append(k)
for k in delkey:
del cost[k]
# print("!!!!!!!",cost)
respBag = self.player.bag.costItem(cost,
constant.ITEM_COST_MARRY_POWER,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_NOT_ENOUGH
self.player.marry.addPower(id, res.add * num, res.uselimit,
res.enlimit, num)
from game.mgr.player import get_rpc_player
targetPlayer = get_rpc_player(self.player.marry.spousePid,
offline=False)
if targetPlayer:
targetPlayer.marryPowerPush(id, res.add * num, num, self.player.id,
self.player.name)
dUpdate = self.player.packRespBag(respBag)
dUpdate["marryInfo"] = self.player.marry.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 亲密度等级领奖
def rc_MarryLvReward(self, id):
res = Game.res_mgr.res_marryLv.get(id, None)
if not res:
return 0, errcode.EC_NORES
if id in self.player.marry.powerLvReward:
return 0, errcode.EC_NORES
if self.player.marry.power < res.power:
return 0, errcode.EC_NORES
respBag = self.player.bag.add(res.reward,
constant.ITEM_ADD_MARRY_POWER,
wLog=True)
self.player.marry.powerLvReward.append(id)
self.player.marry.markDirty()
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["marryInfo"] = self.player.marry.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
class RescueMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
def rc_rescueSave(self,resid):
res = Game.res_mgr.res_rescueSystem.get(resid)
if not res:
return 0, errcode.EC_NORES
if self.player.rescue.keyinfo[resid]["ok"]:
return 0, errcode.EC_ALREADY_REWARD
ok=True
if res.num1>self.player.rescue.keyinfo[resid]["num1"]:
ok=False
elif res.num2>self.player.rescue.keyinfo[resid]["num2"]:
ok=False
elif res.num3>self.player.rescue.keyinfo[resid]["num3"]:
ok=False
elif res.num4>self.player.rescue.keyinfo[resid]["num4"]:
ok=False
elif res.num5>self.player.rescue.keyinfo[resid]["num5"]:
ok=False
if not ok:
return 0, errcode.EC_NO_FINISH
# if ok and not self.keyinfo[k]["ok"]:
# self.keyinfo[k]["ok"]=1
# self.score+=1
# if self.player.map.mapSubId<res.mapsubid:
# return 0, errcode.EC_NOT_ABLE
self.player.rescue.keyinfo[resid]["ok"]=1
self.player.rescue.score+=1
self.player.rescue.markDirty()
# 打包返回信息
dUpdate = {}
dUpdate["rescue"] = self.player.rescue.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_rescueDing(self,resid):
res = Game.res_mgr.res_rescueSystem.get(resid)
if not res:
return 0, errcode.EC_NORES
if self.player.map.mapSubId<res.mapsubid:
return 0, errcode.EC_NOT_ABLE
self.player.rescue.Ding=resid
self.player.rescue.markDirty()
# 打包返回信息
dUpdate = {}
dUpdate["rescue"] = self.player.rescue.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_rescueReward(self,resid):
res = Game.res_mgr.res_rescueReward.get(resid)
if not res:
return 0, errcode.EC_NORES
if resid in self.player.rescue.rewards:
return 0, errcode.EC_ALREADY_REWARD
if self.player.rescue.score<res.score:
return 0, errcode.EC_NOT_ENOUGH
self.player.rescue.rewards.append(resid)
self.player.rescue.markDirty()
respBag = self.player.bag.add(res.reward, constant.ITEM_ADD_RESCUE_REWARD, wLog=True)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["rescue"] = self.player.rescue.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_rescueRefresh(self):
sentFree = Game.res_mgr.res_common.get("sentFree")
sentCost1 = Game.res_mgr.res_common.get("sentCost1")
sentCost2 = Game.res_mgr.res_common.get("sentCost2")
n=self.player.rescue.getfreshNum()
respBag={}
isGold=False
if n>=sentFree.i:
respBag = self.player.bag.costItem(sentCost1.arrayint2, constant.ITEM_COST_SENT_REFRESH, wLog=True)
if not respBag.get("rs", 0):
isGold=True
respBag = self.player.bag.costItem(sentCost2.arrayint2, constant.ITEM_COST_SENT_REFRESH, wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_COST_ERR
self.player.rescue.refreshTaskUser(isGold)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["rescue"] = self.player.rescue.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_rescueFastXhour(self,idx,x):
if not self.player.rescue.taskData[idx]["et"]:
return 0, errcode.EC_NO_START
nt = time.time()
if self.player.rescue.taskData[idx]["et"]<=nt:
return 0, errcode.EC_ALREADY_FINISH
res = Game.res_mgr.res_rescueTask.get(self.player.rescue.taskData[idx]["id"])
if not res:
return 0, errcode.EC_NORES
cost={}
for _ in range(x):
for k,v in res.cost.items():
cost[k]=cost.get(k,0)+v
respBag = self.player.bag.costItem(cost, constant.ITEM_COST_SENT_FAST, wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_COST_ERR
self.player.rescue.taskData[idx]["et"]-=x*3600
self.player.rescue.markDirty()
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["rescue"] = self.player.rescue.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_rescueFinishAll(self):
reward={}
newtaskData=[]
for idx in range(len(self.player.rescue.taskData)):
if not self.player.rescue.taskData[idx]["et"]:
newtaskData.append(self.player.rescue.taskData[idx])
continue
nt = time.time()
if self.player.rescue.taskData[idx]["et"]>nt:
newtaskData.append(self.player.rescue.taskData[idx])
continue
res = Game.res_mgr.res_rescueTask.get(self.player.rescue.taskData[idx]["id"])
if not res:
newtaskData.append(self.player.rescue.taskData[idx])
continue
if res.rescueSystemKey:
self.player.rescue.rescueSystemKey(res.rescueSystemKey)
if res.rescueAuto:
for _ in range(res.rescueAuto):
self.player.rescue.rescueAuto()
for k,v in res.reward.items():
reward[k]=reward.get(k,0)+v
respBag = self.player.bag.add(reward, constant.ITEM_ADD_RESCUE_SENT, wLog=True)
self.player.rescue.taskData=newtaskData
self.player.rescue.markDirty()
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["rescue"] = self.player.rescue.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_rescueFinish(self,idx):
if not self.player.rescue.taskData[idx]["et"]:
return 0, errcode.EC_NO_START
nt = time.time()
if self.player.rescue.taskData[idx]["et"]>nt:
return 0, errcode.EC_NO_FINISH
res = Game.res_mgr.res_rescueTask.get(self.player.rescue.taskData[idx]["id"])
if not res:
return 0, errcode.EC_NORES
if res.rescueSystemKey:
self.player.rescue.rescueSystemKey(res.rescueSystemKey)
if res.rescueAuto:
for _ in range(res.rescueAuto):
self.player.rescue.rescueAuto()
respBag = self.player.bag.add(res.reward, constant.ITEM_ADD_RESCUE_SENT, wLog=True)
self.player.rescue.taskData.pop(idx)
self.player.rescue.markDirty()
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["rescue"] = self.player.rescue.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_rescueSent(self,idx,uids):
if self.player.rescue.taskData[idx]["et"]:
return 0, errcode.EC_CODE_10003
res = Game.res_mgr.res_rescueTask.get(self.player.rescue.taskData[idx]["id"])
if not res:
return 0, errcode.EC_NORES
if len(res.petid)!=len(uids):
return 0, errcode.EC_NOT_ENOUGH
for uidsidx in range(len(uids)):
uid=uids[uidsidx]
pet = self.player.pet.getPet(uid)
if not pet:
return 0, errcode.EC_PET_NOT_ACT
petres = Game.res_mgr.res_pet.get(pet.resID)
if not petres:
return 0, errcode.EC_NORES
evolveRes = Game.res_mgr.res_idlv_petevolve.get((pet.resID, pet.evolveLv))
if not evolveRes:
return 0, errcode.EC_NORES
for td in self.player.rescue.taskData:
if uid in td["petuid"]:
return 0, errcode.EC_CODE_10004
if res.petid[uidsidx]:
if res.petid[uidsidx]!=pet.resID:
return 0, errcode.EC_CODE_10005
if res.eleType[uidsidx]:
if res.eleType[uidsidx]!=petres.eleType:
return 0, errcode.EC_CODE_10006
if res.showStar[uidsidx]:
if res.showStar[uidsidx]>evolveRes.showStar:
return 0, errcode.EC_CODE_10007
respBag = self.player.bag.costItem(res.explore, constant.ITEM_COST_SENT_PET, wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_COST_ERR
self.player.rescue.taskData[idx]["et"]=time.time()+res.hour*3600
self.player.rescue.taskData[idx]["petuid"]=uids
self.player.rescue.markDirty()
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["rescue"] = self.player.rescue.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_rescueXXX(self):
# 打包返回信息
dUpdate = {}
dUpdate["rescue"] = self.player.rescue.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
class BossMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
# 挑战(grBossTZ)
# 请求
# 个人bossid(id, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-货币
# 游戏模型-角色基础-经验
# 游戏模型-boss模块
# 个人boss(grBoss, json)
# boss列表(bossList, [json]) #只推送更新的
# 个人bossId(id, int)
# 今日已挑战次数(num, int)
# 是否首通(first, int)0=未首通 1=已首通
# 是否已击杀(kill, int)0=未击杀 1=已击杀
# 游戏模型-角色背包
# 战报(fightLog, json)
def rc_grBossTZ(self, id):
bossRes = Game.res_mgr.res_grBoss.get(id)
if not bossRes:
return 0, errcode.EC_NORES
barrRes = Game.res_mgr.res_barrier.get(bossRes.fbId)
if not barrRes:
return 0, errcode.EC_NORES
mstRes = Game.res_mgr.res_monster.get(bossRes.mstId)
if not mstRes:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(barrRes.rewardId)
if not rewardRes:
return 0, errcode.EC_NORES
#判断人物的等级是否大于怪
iLv = self.player.base.GetLv()
if iLv < mstRes.level:
return 0, errcode.EC_GRBOSS_LV_NOT_ENOUGH
iKill = self.player.boss.GetGrBossTodayKill(id)
if iKill:
return 0, errcode.EC_GRBOSS_HAS_KILL
# fightobj = Game.fight_mgr.createFight(constant.FIGHT_TYPE_200)
# rs = fightobj.init_by_barrId(self.player, barrRes.id)
# if not rs:
# return 0, errcode.EC_INIT_BARR_FAIL
iNum = self.player.boss.GetGrBossTodayTZ(id)
if iNum >= barrRes.num: #一天只能挑战一次
return 0, errcode.EC_GRBOSS_NUM_NOT_ENOUGH
# fightLog = fightobj.doFight()
fightobj = createFight(constant.FIGHT_TYPE_100)
rs = fightobj.init_data(
self.player.GetFightData(constant.BATTLE_ARRAY_TYPE_NORMAL),
100000)
if not rs:
return 0, errcode.EC_INIT_BARR_FAIL
fightLog = fightobj.doFight()
log_end = fightLog.get("end", {})
winerList = log_end.get("winerList", [])
fightResult = 1 if self.player.id in winerList else 0
respBag = {}
if fightResult:
iNum += 1
self.player.boss.SetGrBossTodayTZ(id, iNum)
#设置击杀
self.player.boss.SetGrBossTodayKill(id)
# 奖励判断是否已首通
dReward = rewardRes.doReward()
if not self.player.boss.IsGrBossFirst(id):
dReward.update(barrRes.firstReward) #首通奖励
self.player.boss.SetGrBossFirst(id)
respBag = self.player.bag.add(dReward,
constant.ITEM_ADD_GRBOSS_REWARD,
wLog=True)
# 抛事件
self.player.safe_pub(msg_define.MSG_GR_BOSS)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["bossInfo"] = self.player.boss.to_grboss_data([id])
resp = {
"fightLog": fightLog,
"allUpdate": dUpdate,
}
return 1, resp
# 扫荡(grBossSD)
# 请求
# 个人bossid(id, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-货币
# 游戏模型-角色基础-经验
# 游戏模型-boss模块
# 个人boss(grBoss, json)
# boss列表(bossList, [json]) 只推送更新的
# 个人bossId(id, int)
# 今日已挑战次数(num, int)
# 是否首通(first, int)0=未首通 1=已首通
# 是否已击杀(kill, int)0=未击杀 1=已击杀
# 游戏模型-角色背包
def rc_grBossSD(self, id):
bossRes = Game.res_mgr.res_grBoss.get(id)
if not bossRes:
return 0, errcode.EC_NORES
barrRes = Game.res_mgr.res_barrier.get(bossRes.fbId)
if not barrRes:
return 0, errcode.EC_NORES
mstRes = Game.res_mgr.res_monster.get(bossRes.mstId)
if not mstRes:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(barrRes.rewardId)
if not rewardRes:
return 0, errcode.EC_NORES
#没有首通的不允许扫荡
if not self.player.boss.IsGrBossFirst(id):
return 0, errcode.EC_GRBOSS_NOT_KILLED
#判断人物的等级是否大于怪
iLv = self.player.base.GetLv()
if iLv < mstRes.level:
return 0, errcode.EC_GRBOSS_LV_NOT_ENOUGH
iKill = self.player.boss.GetGrBossTodayKill(id)
if iKill:
return 0, errcode.EC_GRBOSS_HAS_KILL
#设置挑战次数
iNum = self.player.boss.GetGrBossTodayTZ(id)
if iNum >= 1: # 一天只能挑战一次
return 0, errcode.EC_GRBOSS_NUM_NOT_ENOUGH
iNum += 1
self.player.boss.SetGrBossTodayTZ(id, iNum)
#设置击杀
self.player.boss.SetGrBossTodayKill(id)
#击杀奖励
dReward = rewardRes.doReward()
respBag = self.player.bag.add(dReward,
constant.ITEM_ADD_GRBOSS_REWARD,
wLog=True)
# 抛事件
self.player.safe_pub(msg_define.MSG_GR_BOSS)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["bossInfo"] = self.player.boss.to_grboss_data([id])
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 一键扫荡(grBossOneKeySD)
# 请求
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-货币
# 游戏模型-角色基础-经验
# 游戏模型-boss模块
# 个人boss(grBoss, json)
# boss列表(bossList, [json]) 只推送更新的
# 个人bossId(id, int)
# 今日已挑战次数(num, int)
# 是否首通(first, int)0=未首通 1=已首通
# 是否已击杀(kill, int)0=未击杀 1=已击杀
# 游戏模型-角色背包
def rc_grBossOneKeySD(self):
vipLv = self.player.vip.GetVipLv()
vipRes = Game.res_mgr.res_vip.get(vipLv, None)
if not vipRes:
return 0, errcode.EC_NORES
if not vipRes.grBossOneKey:
return 0, errcode.EC_GR_BOSS_SWEEP_VIP_LIMIT
keys = list(Game.res_mgr.res_grBoss.keys())
keys.sort()
respBag = {}
resp_keys = []
for id in keys:
bossRes = Game.res_mgr.res_grBoss.get(id)
if not bossRes:
continue
barrRes = Game.res_mgr.res_barrier.get(bossRes.fbId)
if not barrRes:
continue
mstRes = Game.res_mgr.res_monster.get(bossRes.mstId)
if not mstRes:
continue
rewardRes = Game.res_mgr.res_reward.get(barrRes.rewardId)
if not rewardRes:
continue
# 没有首通的不允许扫荡
if not self.player.boss.IsGrBossFirst(id):
continue
# 判断人物的等级是否大于怪
iLv = self.player.base.GetLv()
if iLv < mstRes.level:
continue
iKill = self.player.boss.GetGrBossTodayKill(id)
if iKill:
continue
# 设置挑战次数
iNum = self.player.boss.GetGrBossTodayTZ(id)
if iNum >= 1: # 一天只能挑战一次
continue
iNum += 1
self.player.boss.SetGrBossTodayTZ(id, iNum)
# 设置击杀
self.player.boss.SetGrBossTodayKill(id)
# 击杀奖励
dReward = rewardRes.doReward()
respBag1 = self.player.bag.add(dReward,
constant.ITEM_ADD_GRBOSS_REWARD,
wLog=True)
respBag = self.player.mergeRespBag(respBag, respBag1)
resp_keys.append(id)
# 抛事件
self.player.safe_pub(msg_define.MSG_GR_BOSS)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["bossInfo"] = self.player.boss.to_grboss_data(resp_keys)
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 打开主界面(qmBossOpenUI)
# 请求
# 返回
# 全民boss列表(bossList, [json])
# 全民bossid(id, int)
# 当前血量(curHp, int)
# 总血量(maxHp, int)
# 争夺人数(num, int)
# 状态(status, int)0=未击杀 1=已击杀
# 重生时间戳(time, int)
def rc_qmBossOpenUI(self):
bossList = Game.rpc_qmboss_mgr.GetAllBossInfo()
resp = {
"bossList": bossList,
}
return 1, resp
# 刷新挑战次数(qmBossRefreNum)
# 请求
# 返回
# 剩余挑战次数(num, int)
# 下次恢复时间戳(time, int)
def rc_qmBossRefreNum(self):
num = self.player.boss.GetQmBossTZ()
iTime = self.player.boss.GetQmBossTime()
resp = {
"num": num,
"time": iTime,
}
return 1, resp
# 购买挑战次数(qmBossBuyNum)
# 请求
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-vip模块
# 全民boss已购买挑战次数(qmBossTz, int)
# 游戏模型-boss模块
# 全民boss(qmBoss, json)
# 剩余挑战次数(num, int)
# 下次恢复时间戳(time, int)
# 游戏模型-货币
def rc_qmBossBuyNum(self):
resQmBossTzCnt = Game.res_mgr.res_common.get("qmBossTzCnt")
resQmBossBuyNum = Game.res_mgr.res_common.get("qmBossBuyNum")
resQmBossTzPirce = Game.res_mgr.res_common.get("qmBossTzPirce")
if not resQmBossTzCnt or not resQmBossBuyNum or not resQmBossTzPirce:
return 0, errcode.EC_NORES
iVipLv = self.player.vip.GetVipLv()
vipRes = Game.res_mgr.res_vip.get(iVipLv)
if not vipRes:
return 0, errcode.EC_NORES
iBuyCnt = self.player.vip.GetBuyQmBossTz()
if iBuyCnt >= vipRes.qmBossTz:
return 0, errcode.EC_QMBOSS_BUY_CNT_LIMIT
iNum = self.player.boss.GetQmBossTZ()
if iNum >= resQmBossTzCnt.i: #已经是满的，不需要
return 0, errcode.EC_QMBOSS_NUM_FULL
dCost = resQmBossTzPirce.arrayint2
# 扣道具
respBag = self.player.bag.costItem(dCost,
constant.ITEM_COST_QMBOSS_BUY,
wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_QMBOSS_BUY_NOT_ENOUGH
self.player.boss.addQmBossTZ(resQmBossBuyNum.i)
self.player.vip.SetBuyQmBossTz(iBuyCnt + 1)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["bossInfo"] = {
"qmBoss":
dict(num=self.player.boss.GetQmBossTZ(),
time=self.player.boss.GetQmBossTime())
}
dUpdate["vipInfo"] = dict(qmBossTz=self.player.vip.GetBuyQmBossTz())
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 请求争夺人数(qmBossFighterNum)
# 请求
# 全民bossid(id, int)
# 返回
# 争夺列表(fighters, [json])
# 名次(rank, int)
# 玩家名称(name, string)
# 伤害(hurt, int)
def rc_qmBossFighterNum(self, id):
fighters = Game.rpc_qmboss_mgr.GetFighterData(id)
resp = {
"fighters": fighters,
}
return 1, resp
# 请求击杀列表(qmBossKillRecord)
# 请求
# 全民bossid(id, int)
# 返回
# 击杀列表(killList, [json])
# 击杀时间戳(time, int)
# 玩家名称(name, string)
# 战力(fa, int)
def rc_qmBossKillRecord(self, id):
killList = Game.rpc_qmboss_mgr.GetKillList(id)
resp = {
"killList": killList,
}
return 1, resp
# boss提醒设置(qmBossSetNotice)
# 请求
# 提醒列表(NoticeList, [int])
# 全民bossid
# 注意：发上来的服务器置1提醒，剩下的全部清0
# 返回
def rc_qmBossSetNotice(self, NoticeList):
self.player.boss.SetQmBossRemind(NoticeList)
return 1, None
# 挑战(qmBossTZ)
# 请求
# 全民bossid(id, int)
# 返回
# 自己的伤害(hurt, int)
# 争夺列表(fighters, [json])
# 名次(rank, int)
# 玩家名称(name, int)
# 伤害(hurt, int)
# 战报(fightLog, json)
# 注意：挑战之后主动请求界面数据
def rc_qmBossTZ(self, id):
resQmBoss = Game.res_mgr.res_qmBoss.get(id)
if not resQmBoss:
return 0, errcode.EC_NORES
barrRes = Game.res_mgr.res_barrier.get(resQmBoss.fbId)
if not barrRes:
return 0, errcode.EC_NORES
tzRewardRes = Game.res_mgr.res_reward.get(resQmBoss.tzReward)
if not tzRewardRes:
return 0, errcode.EC_NORES
killRewardRes = Game.res_mgr.res_reward.get(resQmBoss.killReward)
if not killRewardRes:
return 0, errcode.EC_NORES
iTZNum = self.player.boss.GetQmBossTZ()
if iTZNum <= 0:
return 0, errcode.EC_QMBOSS_TZ_NOT_ENOUGH
#异步获取boss数据
bossInfo = Game.rpc_qmboss_mgr.GetTZInfo(id, self.player.id)
if not bossInfo:
return 0, errcode.EC_QMBOSS_NOT_FIND
status = bossInfo.get("status", 0)
if status:
return 0, errcode.EC_QMBOSS_HAS_KILL
# fightobj = Game.fight_mgr.createFight(constant.FIGHT_TYPE_201)
# rs = fightobj.init_by_barrId(self.player, barrRes.id)
# if not rs:
# return 0, errcode.EC_INIT_BARR_FAIL
#扣除挑战次数
self.player.boss.delQmBossTZ(1)
#修改怪物血量
# curHp = bossInfo.get("curHp", 0)
# fightobj.fix_monster_hp({resQmBoss.mstId:curHp})
#战斗
# fightLog = fightobj.doFight(logMstId=resQmBoss.mstId)
fightobj = createFight(constant.FIGHT_TYPE_100)
rs = fightobj.init_data(
self.player.GetFightData(constant.BATTLE_ARRAY_TYPE_NORMAL),
100000)
if not rs:
return 0, errcode.EC_INIT_BARR_FAIL
fightLog = fightobj.doFight()
log_end = fightLog.get("end", {})
winerList = log_end.get("winerList", [])
fightResult = 1 if self.player.id in winerList else 0
#同步数据
# hurt = curHp - fightLog.get("mstData", {}).get(constant.ATTR_HP, 0)
hurt = 999
fightInfo = {
"pid": self.player.id,
"name": self.player.name,
"fa": self.player.base.fa,
"portrait": self.player.myhead.getPortrait(), # 头像
"headframe": self.player.myhead.getHeadframe(), # 头像框
"hurt": hurt
}
#是否击杀由远端精确控制
isKill = Game.rpc_qmboss_mgr.FightBoss(id, fightInfo)
if isKill: #击杀
print("=============kill qmboss====")
mailRes = Game.res_mgr.res_mail.get(
constant.MAIL_ID_BOSS_KILL_REWARD_LK, None)
Game.rpc_mail_mgr.sendPersonMail(self.player.id,
mailRes.title,
mailRes.content,
resQmBoss.lkmailReward,
push=False)
dReward = killRewardRes.doReward()
else:
dReward = tzRewardRes.doReward()
respBag = self.player.bag.add(dReward,
constant.ITEM_ADD_QMBOSS_REWARD,
wLog=True)
# 抛事件
self.player.safe_pub(msg_define.MSG_QM_BOSS)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
#全民boss 看到的都是挑战成功
# fightLog["result"]={}
# fightLog["end"]["win"] = 1
fightLog["end"]["winerList"] = [self.player.id]
resp = {
"id": id,
"hurt": bossInfo.get("myHurt", 0),
"fighters": bossInfo.get("fighters", []),
"fightLog": fightLog,
"allUpdate": dUpdate,
}
return 1, resp
# 复活并挑战(qmBossFHandTZ)
# 请求
# 全民bossid(id, int)
# 返回
# 自己的伤害(hurt, int)
# 争夺列表(fighters, [json])
# 名次(rank, int)
# 玩家名称(name, int)
# 伤害(hurt, int)
# 战报(fightLog, json)
# 主动推送刷新(allUpdate, json)
# 游戏模型-货币
# 游戏模型-角色背包
# 游戏模型-角色基础-经验
# 注意：挑战之后主动请求界面数据
def rc_qmBossFHandTZ(self, id):
# 全民boss是否可复活 vip 控制
iVipLv = self.player.vip.GetVipLv()
vipRes = Game.res_mgr.res_vip.get(iVipLv)
if not vipRes:
return 0, errcode.EC_NORES
if not vipRes.qmBossFh:
return 0, errcode.EC_QMBOSS_REBORN_LIMIT
resQmBoss = Game.res_mgr.res_qmBoss.get(id)
if not resQmBoss:
return 0, errcode.EC_NORES
if not resQmBoss.relive: #不可复活
return 0, errcode.EC_QMBOSS_REBORN_LIMIT
barrRes = Game.res_mgr.res_barrier.get(resQmBoss.fbId)
if not barrRes:
return 0, errcode.EC_NORES
tzRewardRes = Game.res_mgr.res_reward.get(resQmBoss.tzReward)
if not tzRewardRes:
return 0, errcode.EC_NORES
killRewardRes = Game.res_mgr.res_reward.get(resQmBoss.killReward)
if not killRewardRes:
return 0, errcode.EC_NORES
monsterRes = Game.res_mgr.res_monster.get(resQmBoss.mstId)
if not monsterRes:
return 0, errcode.EC_NORES
iTZNum = self.player.boss.GetQmBossTZ()
if iTZNum <= 0:
return 0, errcode.EC_QMBOSS_TZ_NOT_ENOUGH
# 异步获取boss数据
bossInfo = Game.rpc_qmboss_mgr.GetTZInfo(id, self.player.id)
if not bossInfo:
return 0, errcode.EC_QMBOSS_NOT_FIND
status = bossInfo.get("status", 0)
if not status:
return 0, errcode.EC_QMBOSS_ALIVE
# fightobj = Game.fight_mgr.createFight(constant.FIGHT_TYPE_201)
# rs = fightobj.init_by_barrId(self.player, barrRes.id)
# if not rs:
# return 0, errcode.EC_INIT_BARR_FAIL
#复活材料判断
# 扣道具
respBag = self.player.bag.costItem(resQmBoss.cost1,
constant.ITEM_COST_QMBOSS_REBORN,
wLog=True)
if not respBag.get("rs", 0):
# 扣道具
respBag1 = self.player.bag.costItem(
resQmBoss.cost2, constant.ITEM_COST_QMBOSS_REBORN, wLog=True)
respBag = self.player.mergeRespBag(respBag, respBag1)
if not respBag1.get("rs", 0):
return 0, errcode.EC_QMBOSS_REBORN_NOT_ENOUGH
#扣除挑战次数
self.player.boss.delQmBossTZ(1)
#战斗
# fightLog = fightobj.doFight(logMstId=resQmBoss.mstId)
#同步数据
fightobj = createFight(constant.FIGHT_TYPE_100)
rs = fightobj.init_data(
self.player.GetFightData(constant.BATTLE_ARRAY_TYPE_NORMAL),
100000)
if not rs:
return 0, errcode.EC_INIT_BARR_FAIL
fightLog = fightobj.doFight()
log_end = fightLog.get("end", {})
winerList = log_end.get("winerList", [])
fightResult = 1 if self.player.id in winerList else 0
# curHp = monsterRes.attr.get(constant.ATTR_HP, 0)
# hurt = curHp - fightLog.get("mstData", {}).get(constant.ATTR_HP, 0)
curHp = monsterRes.attr.get(constant.ATTR_HP, 0)
hurt = curHp - fightLog.get("mstData", {}).get(constant.ATTR_HP, 0)
fightInfo = {
"pid": self.player.id,
"name": self.player.name,
"fa": self.player.base.fa,
"portrait": self.player.myhead.getPortrait(), # 头像
"headframe": self.player.myhead.getHeadframe(), # 头像框
"hurt": hurt
}
#是否击杀由远端精确控制
isKill = Game.rpc_qmboss_mgr.FightBoss(id, fightInfo, reborn=1)
if isKill: #击杀
print("=============kill qmboss=2===")
mailRes = Game.res_mgr.res_mail.get(
constant.MAIL_ID_BOSS_KILL_REWARD_LK, None)
Game.rpc_mail_mgr.sendPersonMail(self.player.id,
mailRes.title,
mailRes.content,
resQmBoss.lkmailReward,
push=False)
dReward = killRewardRes.doReward()
else:
dReward = tzRewardRes.doReward()
respBag2 = self.player.bag.add(dReward,
constant.ITEM_ADD_QMBOSS_REWARD,
wLog=True)
respBag = self.player.mergeRespBag(respBag, respBag2)
# 抛事件
self.player.safe_pub(msg_define.MSG_QM_BOSS)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
# 全民boss 看到的都是挑战成功
fightLog["result"]["win"] = 1
fightLog["result"]["winerList"] = [self.player.id]
resp = {
"hurt": bossInfo.get("myHurt", 0),
"killList": bossInfo.get("fighters", []),
"fightLog": fightLog,
"allUpdate": dUpdate,
}
return 1, resp
# 打开野外Boss主界面(ywBossOpenUI)
# 请求
# 返回
# 野外Boss列表(ywBossList, [json])
# 野外BossId(id, int)
# 状态(status, int)1=已刷新 2=已逃跑 3=已击杀
def rc_ywBossOpenUI(self):
bossList = Game.rpc_ywboss_mgr.GetAllBossInfo()
resp = {
"ywBossList": bossList,
}
return 1, resp
# 进入野外Boss详情界面(ywBossInfo)
# 请求
# 野外BossId(id, int)
# 返回
# 野外BossId(id, int)
# 当前血量(curHp, int)
# 总血量(maxHp, int)
# 占领者id(rid, int)
# 占领者性别(sex, int)
# 占领者名称(name, string)
# 占领结束时间戳(time, int)
# 野外Boss今日已挑战次数(todayNum, int)
# 野外Boss今日最后一次挑战时间(LastTime, int)
def rc_ywBossInfo(self, id):
resp = Game.rpc_ywboss_mgr.GetBossInfo(id)
resp["todayNum"] = self.player.boss.GetYwBossTodayTZ()
resp["LastTime"] = self.player.boss.GetYwBossLastTZTime()
resp["id"] = id
return 1, resp
# 野外Boss挑战(ywBossTZ)
# 请求
# 野外BossId(id, int)
# 是否花元宝清除cd(clean, int)
# 返回
# 野外BossId(id, int)
# 当前血量(curHp, int)
# 总血量(maxHp, int)
# 占领者id(rid, int)
# 占领者性别(sex, int)
# 占领者名称(name, string)
# 占领结束时间戳(time, int)
# 状态(status, int)1=已刷新 2=已逃跑 3=已击杀
# 战报(fightLog, json)
# 主动推送刷新(allUpdate, json)
# 游戏模型-货币
# 游戏模型-角色基础-经验
# 游戏模型-角色背包
def rc_ywBossTZ(self, id, clean):
resYwBoss = Game.res_mgr.res_ywBoss.get(id)
if not resYwBoss:
return 0, errcode.EC_NORES
barrRes = Game.res_mgr.res_barrier.get(resYwBoss.fbId)
if not barrRes:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(barrRes.rewardId)
if not rewardRes:
return 0, errcode.EC_NORES
monsterRes = Game.res_mgr.res_monster.get(resYwBoss.mstId)
if not monsterRes:
return 0, errcode.EC_NORES
#等级不够
iLv = self.player.base.GetLv()
if iLv < monsterRes.level:
return 0, errcode.EC_YWBOSS_LV_LIMIT
rs, bossInfo = Game.rpc_ywboss_mgr.CheckYwBossTZ(self.player.id, id)
if not rs:
return 0, errcode.EC_YWBOSS_HAS_OCCUPY
status = bossInfo.get("status", 0)
if status != 1: #1=已刷新
return 0, errcode.EC_YWBOSS_STATUS_ERR
resYwBossFreeNum = Game.res_mgr.res_common.get(
"ywBossFreeNum") # 野外boss免CD挑战次数
resYwBossCdArr = Game.res_mgr.res_common.get(
"ywBossCdArr") # 野外boss免CD次数之后的挑战CD(分钟)
resYwBossCleanCdCost = Game.res_mgr.res_common.get(
"ywBossCleanCdCost") # 野外boss清除1分钟cd消耗钻石
if not resYwBossFreeNum and not resYwBossCdArr and not resYwBossCleanCdCost:
return 0, errcode.EC_NORES
iTodayNum = self.player.boss.GetYwBossTodayTZ()
dCost = {}
if iTodayNum >= resYwBossFreeNum.i:
cdNum = iTodayNum + 1 - resYwBossFreeNum.i
cdTime = resYwBossCdArr.arrayint2.get(cdNum)
if not cdTime:
maxKey = max(list(resYwBossCdArr.arrayint2.keys()))
cdTime = resYwBossCdArr.arrayint2.get(maxKey)
now = int(time.time())
iLastTZTime = self.player.boss.GetYwBossLastTZTime()
passTime = now - iLastTZTime
needTime = cdTime * 60 - passTime
if needTime > 0:
if clean:
dCost[constant.
CURRENCY_BINDGOLD] = resYwBossCleanCdCost.i * int(
(needTime / 60 + 1))
else:
return 0, errcode.EC_YWBOSS_CD
respBag = {}
# 高级boss挑战需要挑战令，失去归属权时不返还挑战令
# 归属权是自己时候再次挑战不消耗令
rid = bossInfo.get("rid", 0)
if rid != self.player.id:
dCost.update(resYwBoss.cost)
# 扣道具
respBag1 = self.player.bag.costItem(
dCost, constant.ITEM_COST_YWBOSS_FIGHT, wLog=True)
respBag = self.player.mergeRespBag(respBag, respBag1)
if not respBag1.get("rs", 0):
return 0, errcode.EC_YWBOSS_FIGHT_NOT_ENOUGH
#有占领者
bossStatus = 0
other = None
if rid and rid != self.player.id:
from game.mgr.player import get_rpc_player
# fightobj = Game.fight_mgr.createFight(constant.FIGHT_TYPE_204)
# other = get_rpc_player(rid)
# if not other:
# return 0, errcode.EC_INIT_BARR_FAIL
# rs = fightobj.init_players(self.player, other)
# if not rs:
# return 0, errcode.EC_INIT_BARR_FAIL
# fightobj.SetRounds(30)
# fightLog = fightobj.doFight()
fightobj = createFight(constant.FIGHT_TYPE_100)
rs = fightobj.init_data(
self.player.GetFightData(constant.BATTLE_ARRAY_TYPE_NORMAL),
100000)
if not rs:
return 0, errcode.EC_INIT_BARR_FAIL
fightLog = fightobj.doFight()
log_end = fightLog.get("end", {})
winerList = log_end.get("winerList", [])
fightResult = 1 if self.player.id in winerList else 0
if fightResult:
fightInfo = {
"pid": self.player.id, # 占领者id(rid, int)
"sex": self.player.base.GetSex(), # 占领者性别(sex, int)
"name": self.player.name, # 占领者名称(name, string)
"fa": self.player.base.fa, # 占领者战力(fa, int)
"portrait": self.player.myhead.getPortrait(), #占领者头像
"headframe": self.player.myhead.getHeadframe(), #占领者头像框
}
Game.rpc_ywboss_mgr.occupyBoss(id, fightInfo, rid)
else: #无占领者
# fightobj = Game.fight_mgr.createFight(constant.FIGHT_TYPE_202)
# rs = fightobj.init_by_barrId(self.player, barrRes.id)
# if not rs:
# return 0, errcode.EC_INIT_BARR_FAIL
# 修改怪物血量
# curHp = bossInfo.get("curHp", 0)
# fightobj.fix_monster_hp({resYwBoss.mstId: curHp})
# 战斗
# fightLog = fightobj.doFight(logMstId=resYwBoss.mstId)
fightobj = createFight(constant.FIGHT_TYPE_100)
rs = fightobj.init_data(
self.player.GetFightData(constant.BATTLE_ARRAY_TYPE_NORMAL),
100000)
if not rs:
return 0, errcode.EC_INIT_BARR_FAIL
fightLog = fightobj.doFight()
log_end = fightLog.get("end", {})
winerList = log_end.get("winerList", [])
fightResult = 1 if self.player.id in winerList else 0
# 同步数据
# hurt = curHp - fightLog.get("mstData", {}).get(constant.ATTR_HP, 0)
hurt = 999
fightInfo = {
"pid": self.player.id, # 占领者id(rid, int)
"sex": self.player.base.GetSex(), # 占领者性别(sex, int)
"name": self.player.name, # 占领者名称(name, string)
"fa": self.player.base.fa, # 占领者战力(fa, int)
"portrait": self.player.myhead.getPortrait(), # 占领者头像
"headframe": self.player.myhead.getHeadframe(), # 占领者头像框
"hurt": hurt
}
# 是否击杀由远端精确控制
bossStatus = Game.rpc_ywboss_mgr.FightBoss(id, fightInfo)
isKill = 0
if bossStatus == 3:
isKill = 1
# 打包返回信息
bossInfo = Game.rpc_ywboss_mgr.GetBossInfo(id)
#直接击杀奖励
if isKill:
respBag2 = self.player.sendYwBossKillReward(id, isTimeout=0)
respBag = self.player.mergeRespBag(respBag, respBag2)
dUpdate = self.player.packRespBag(respBag)
resp = {
"id": bossInfo.get("id", 0),
"curHp": bossInfo.get("curHp", 0),
"maxHp": bossInfo.get("maxHp", 0),
"rid": bossInfo.get("rid", 0),
"sex": bossInfo.get("sex", 0),
"name": bossInfo.get("name", ''),
"time": bossInfo.get("time", 0),
"status": bossInfo.get("status", 0),
"fightLog": fightLog,
"allUpdate": dUpdate,
"todayNum": self.player.boss.GetYwBossTodayTZ(),
"LastTime": self.player.boss.GetYwBossLastTZTime(),
}
#同步给另外一个玩家
if other:
other.sendYwBossTZ(resp, _no_result=True)
return 1, resp
# 查看生死劫记录(ssjBossRecord)
# 请求
# 生死劫配置表id(id, int)
# 返回
# 全服首杀队伍名称列表(firstNames, [string]) 首杀者名字
# 首杀回合数(firstRounds, int)
# 首杀时间戳(firstTime, int)
# 最少回合队伍名称列表(minNames, [string]) 名字
# 最少回合数(minRounds, int)
# 最少回合击杀时间戳(minTime, int)
def rc_ssjBossRecord(self, id):
resp = Game.rpc_ssjboss_mgr.GetBossInfo(id)
return 1, resp
# 挑战(ssjBossTZ)
# 请求
# 生死劫配置表id(id, int)
# 队伍id(teamId, int)
# 返回
# 全队推送(ssjBossTZNotice)只推送真人，机器人过滤
# 生死劫配置表id(id, int)
# 战报(fightLog, json)
# 主动推送刷新(allUpdate, json)
# 游戏模型-货币
# 游戏模型-角色基础-经验
# 游戏模型-角色背包
# 游戏模型-boss模块
# 生死劫(ssjBoss, json)
# 章节数据(allData, [json])
# 配置表id(id, int)
# 是否已首通(firstFinish, int)
# 今天是否已通关(finish, int)
# 今日剩余协助次数(num, int)
def rc_ssjBossTZ(self, id, teamId):
ssjRes = Game.res_mgr.res_ssjBoss.get(id)
if not ssjRes:
return 0, errcode.EC_NORES
barrRes = Game.res_mgr.res_barrier.get(ssjRes.fbId)
if not barrRes:
return
#前置关卡必须通关
if id != 1 and not self.player.boss.GetSsjBossFirst(id - 1):
return 0, errcode.EC_SSJBOSS_BARR_LIMIT
# 是否开启
if not self.player.checkOpenLimit(constant.SSJ_BOSS_OPEN_ID):
return 0, errcode.EC_NOLEVEL
# if self.player.boss.GetSsjBossTodayKill(id):
# return 0, errcode.EC_SSJBOSS_HAS_KILLED
members = Game.rpc_team_mgr.GetTeamInfo(teamId)
if not members:
return 0, errcode.EC_TEAM_ERROR
from game.mgr.player import get_rpc_player
players = [(None, 1), (None, 1)]
index = 0
names = []
for one in members:
pid = one.get("rid", 0)
if not pid:
continue
names.append(one.get("name", ""))
if pid == self.player.id:
if not one.get("main", 0):
return 0, errcode.EC_TEAM_NOT_MAIN
else:
continue
rpc_player = get_rpc_player(pid)
if not rpc_player:
continue
players[index] = (rpc_player, one.get("isRobot", 1))
index += 1
# fightobj = Game.fight_mgr.createFight(constant.FIGHT_TYPE_203)
# rs = fightobj.init_by_barrId(ssjRes.fbId, player1=self.player, player2=players[0][0], player3=players[1][0])
# if not rs:
# return 0, errcode.EC_INIT_BARR_FAIL
# fightLog = fightobj.doFight()
# Game.glog.log2File("AttackHandle", "44444|%s"%fightLog)
fightobj = createFight(constant.FIGHT_TYPE_100)
rs = fightobj.init_data(
self.player.GetFightData(constant.BATTLE_ARRAY_TYPE_NORMAL),
100000)
if not rs:
return 0, errcode.EC_INIT_BARR_FAIL
fightLog = fightobj.doFight()
log_end = fightLog.get("end", {})
winerList = log_end.get("winerList", [])
fightResult = 1 if self.player.id in winerList else 0
self.player.ssjBossTZNotice(id, fightLog, self.player.id)
#机器人不推送
for playerData in players:
if playerData[1]:
continue
playerData[0].ssjBossTZNotice(id,
fightLog,
self.player.id,
_no_result=True)
#解散队伍
Game.rpc_team_mgr.DeleteTeam(teamId)
fightResult = fightLog["result"].get("win", 0)
if fightResult:
#上传生死劫结果
FightInfo = {}
FightInfo["ssjId"] = id
FightInfo["round"] = fightLog.get("useRound", 999)
FightInfo["names"] = names
Game.rpc_ssjboss_mgr.ReportFight(FightInfo)
else:
self.player.safe_pub(msg_define.MSG_XIANSHITUISONGLIBAO_SSJ_F)
# import ujson
# Game.glog.log2File("testSsjBossTZ", "%s" % ujson.dumps(fightLog))
#抛事件
self.player.safe_pub(msg_define.MSG_SSJ_BOSS)
return 1, None
# 扫荡(ssjBossSD)
# 请求
# 生死劫配置表id(id, int)
# 返回
# 生死劫配置表id(id, int)
# 主动推送刷新(allUpdate, json)
# 游戏模型-货币
# 游戏模型-角色基础-经验
# 游戏模型-角色背包
# 游戏模型-boss模块
# 生死劫(ssjBoss, json)
# 章节数据(allData, [json])
# 配置表id(id, int)
# 是否已首通(firstFinish, int)
# 今天是否已通关(finish, int)
# 今日剩余协助次数(num, int)
def rc_ssjBossSD(self, id):
ssjRes = Game.res_mgr.res_ssjBoss.get(id)
if not ssjRes:
return 0, errcode.EC_NORES
# 关卡必须通关
if not self.player.boss.GetSsjBossFirst(id):
return 0, errcode.EC_SSJBOSS_BARR_LIMIT
# 是否开启
if not self.player.checkOpenLimit(constant.SSJ_BOSS_OPEN_ID):
return 0, errcode.EC_NOLEVEL
if self.player.boss.GetSsjBossTodayKill(id):
return 0, errcode.EC_SSJBOSS_HAS_KILLED
barrRes = Game.res_mgr.res_barrier.get(ssjRes.fbId)
if not barrRes:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(barrRes.rewardId)
if not rewardRes:
return 0, errcode.EC_NORES
self.player.boss.SetSsjBossTodayKill(id)
dReward = rewardRes.doReward()
respBag = self.player.bag.add(dReward,
constant.ITEM_ADD_SSJBOSS_REWARD,
wLog=True)
# 抛事件
self.player.safe_pub(msg_define.MSG_SSJ_BOSS)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["bossInfo"] = self.player.boss.to_ssjboss_data([id])
resp = {
"id": id,
"allUpdate": dUpdate,
}
return 1, resp
# 一键扫荡(ssjBossOnekeySD)
# 请求
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型-货币
# 游戏模型-角色基础-经验
# 游戏模型-角色背包
# 游戏模型-boss模块
# 生死劫(ssjBoss, json)
# 章节数据(allData, [json])
# 配置表id(id, int)
# 是否已首通(firstFinish, int)
# 今天是否已通关(finish, int)
# 今日剩余协助次数(num, int)
def rc_ssjBossOnekeySD(self):
keys = list(Game.res_mgr.res_ssjBoss.keys())
keys.sort()
respBag = {}
resp_keys = []
for id in keys:
ssjRes = Game.res_mgr.res_ssjBoss.get(id)
if not ssjRes:
continue
# 关卡必须通关
if not self.player.boss.GetSsjBossFirst(id):
continue
if self.player.boss.GetSsjBossTodayKill(id):
continue
barrRes = Game.res_mgr.res_barrier.get(ssjRes.fbId)
if not barrRes:
continue
rewardRes = Game.res_mgr.res_reward.get(barrRes.rewardId)
if not rewardRes:
continue
self.player.boss.SetSsjBossTodayKill(id)
dReward = rewardRes.doReward()
respBag1 = self.player.bag.add(dReward,
constant.ITEM_ADD_SSJBOSS_REWARD,
wLog=True)
respBag = self.player.mergeRespBag(respBag, respBag1)
# 抛事件
self.player.safe_pub(msg_define.MSG_SSJ_BOSS)
resp_keys.append(id)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["bossInfo"] = self.player.boss.to_ssjboss_data(resp_keys)
resp = {
"allUpdate": dUpdate,
}
return 1, resp
class GongchengRpcMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
def rc_gongchengQuanmingReward(self):
gongchengActiveSerNum = Game.res_mgr.res_common.get("gongchengActiveSerNum")
if not gongchengActiveSerNum:
return 0, errcode.EC_NORES
if config.serverNo not in Game.res_mgr.res_List_kuafuServerNo:
return 0, errcode.EC_NORES
idx=Game.res_mgr.res_List_kuafuServerNo.index(config.serverNo)
startidx=(idx+1)-gongchengActiveSerNum.i
if startidx<0:
startidx=0
slist=Game.res_mgr.res_List_kuafuServerNo[startidx:startidx+gongchengActiveSerNum.i]
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
iOpenServiceDay = self.player.base.GetServerOpenDay() # 开服天数
t = self.player.base.GetServerOpenTime() # 开服时间戳
for k,v in Game.res_mgr.res_gongchengActive.items():
if v.lastDay:
if v.lastDayRank and v.openDay<=iOpenServiceDay<v.openDay+v.lastDay and v.openDay+v.lastDayRank<=iOpenServiceDay:
data=rpc_gongcheng.gongchengQuanmingRank()
newdata={}
ymds=[]
for x in range(v.lastDayRank):
tt=t+ (x+v.openDay-1) *3600*24
ymd=gtime.getYYYYMMDDbyT(tt)
ymds.append(ymd)
bestGuild={}
for x in data:
if x["d"] in ymds:
for kk,vv in x["s"].items():
if kk in slist:
newdata[kk]=newdata.get(kk,{"sno":kk,"list":[],"gnum":0,"score":0})
newdata[kk]["score"]+=vv["score"]
for kkk,vvv in vv["ghid"].items():
bestGuild[kkk]=bestGuild.get(kkk,{"sno":kkk,"name":vvv["name"],"score":0})
bestGuild[kkk]["score"]+=vvv["score"]
# 去重计算工会数量
if kkk not in newdata[kk]["list"]:
newdata[kk]["list"].append(kkk)
newdata[kk]["gnum"]+=1
bgs=list(newdata.values())
bgs = sorted(bgs, key=lambda fff: fff["score"], reverse=True)
if not len(bgs):
return 0, errcode.EC_GONGCHENG_QUANMING_NORANK #
if k in self.player.gongcheng.isRankRewardList:
return 0, errcode.EC_GONGCHENG_QUANMING_ALREADY #
self.player.gongcheng.gongchengisRankReward(k)
reward=v.reward2
if bgs[0]["sno"]==config.serverNo:
reward=v.reward1
respBag = self.player.bag.add(reward, constant.ITEM_ADD_GONGCHENG_QUANMING_RANK, wLog=True)
dUpdate = self.player.packRespBag(respBag)
dUpdate["gongcheng"] = self.player.gongcheng.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
return 0, errcode.EC_GONGCHENG_QUANMING_NOOPEN #
def rc_gongchengQuanmingRank(self):
#同步攻城任务数据
self.rc_gongchengGetData()
gongchengActiveSerNum = Game.res_mgr.res_common.get("gongchengActiveSerNum")
if not gongchengActiveSerNum:
return 0, errcode.EC_NORES
if config.serverNo not in Game.res_mgr.res_List_kuafuServerNo:
return 0, 15
idx=Game.res_mgr.res_List_kuafuServerNo.index(config.serverNo)
startidx=(idx+1)-gongchengActiveSerNum.i
if startidx<0:
startidx=0
slist=Game.res_mgr.res_List_kuafuServerNo[startidx:startidx+gongchengActiveSerNum.i]
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
iOpenServiceDay = self.player.base.GetServerOpenDay() # 开服天数
t = self.player.base.GetServerOpenTime() # 开服时间戳
for k,v in Game.res_mgr.res_gongchengActive.items():
if v.lastDay:
if v.lastDayRank and v.openDay<=iOpenServiceDay<v.openDay+v.lastDay:
data=rpc_gongcheng.gongchengQuanmingRank()
newdata={}
bestGuildName=""
bestGuildScore=0
ymds=[]
for x in range(v.lastDayRank):
tt=t+ (x+v.openDay-1) *3600*24
ymd=gtime.getYYYYMMDDbyT(tt)
ymds.append(ymd)
bestGuild={}
for x in data:
if x["d"] in ymds:
for kk,vv in x["s"].items():
if kk in slist:
newdata[kk]=newdata.get(kk,{"list":[],"gnum":0,"score":0})
newdata[kk]["score"]+=vv["score"]
for kkk,vvv in vv["ghid"].items():
bestGuild[kkk]=bestGuild.get(kkk,{"name":vvv["name"],"score":0})
bestGuild[kkk]["score"]+=vvv["score"]
# 去重计算工会数量
if kkk not in newdata[kk]["list"]:
newdata[kk]["list"].append(kkk)
newdata[kk]["gnum"]+=1
bgs=list(bestGuild.values())
bgs = sorted(bgs, key=lambda fff: fff["score"], reverse=True)
if len(bgs):
bestGuildName=bgs[0]["name"]
bestGuildScore=bgs[0]["score"]
return 1,{"serverNo":config.serverNo,"rank":newdata,"bestGuildName":bestGuildName,"bestGuildScore":bestGuildScore}
return 1,{"serverNo":config.serverNo,"rank":{},"bestGuildName":"","bestGuildScore":0}
def rc_gongchengGetData(self):
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
self.player.gongcheng.enter()
data = self.player.getGongchengInfo()
import app
rrv = rpc_gongcheng.hello(5,self.player.id,config.serverNo,app.addr,self.player.name,data,0,0)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
rrv = rpc_gongcheng.getByServerNo(5,config.serverNo)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
ghid=self.player.guild.GetGuildId()
ghname = ""
ghcolor = 0
ghlv = 0
guildRpc = get_rpc_guild(ghid)
if guildRpc:
ghname = guildRpc.getName()
ghcolor = guildRpc.getColor()
ghlv = guildRpc.GetLevel()
if ghid==0:
return 0, errcode.EC_NO_GUILD
fdata=self.player.GetFightData()
pdata=self.player.GetAllPetData()
rrv3=rpc_gongcheng.gongchengFightData(self.player.id,fdata,pdata,ghid,ghname,ghcolor,ghlv,self.player.gongcheng.serverNo)
if not rrv3:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
if rrv3["err"]!=0:
return 0, rrv3["err"]
rrv2=rpc_gongcheng.gongchengGetAllTeam(self.player.id)
if not rrv2:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
if rrv2["err"]!=0:
return 0, rrv2["err"]
# a=bytearray(os.urandom(100*1024))
# rrv["common"]["xxyy"]=a
# retval={"list":rrv["v"],"common":rrv["common"],"team":rrv2["team"],"myteam":rrv2["myteam"]}
retval={"list":[],"common":rrv["common"],"team":rrv2["team"],"myteam":rrv2["myteam"]}
# 同步攻城任务数据
self.player.gongcheng.rsyncRpcGongchengTaskData()
return 1,retval
def rc_gongchengExit(self):
self.player.gongcheng.exit()
dUpdate = {}
dUpdate["gongcheng"] = self.player.gongcheng.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1,resp
# 创建队伍(gongchengTeamCreate)
# 请求
# 队伍(team, [宠物id])
# 返回
def rc_gongchengTeamCreate(self,team):
# 宠物互斥
petList = copy.deepcopy(team)
rs = self.player.pet.checkSpecMutex(petList)
if not rs:
return 0, errcode.EC_PET_MUTEX_LIMIT
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_gongcheng.gongchengTeamCreate(self.player.id,team)
if not rrv:
return 0, errcode.EC_GONGCHENG_ERR
if rrv["err"]!=0:
return 0, rrv["err"]
return 1,{"team":rrv["team"]}
# 解除队伍(gongchengTeamDestroy)
# 请求
# 队伍(team, string)
# 返回
def rc_gongchengTeamDestroy(self,team,reborn):
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
respBag = {}
if reborn:
res = Game.res_mgr.res_common.get("gongchengReborn")
respBag = self.player.bag.costItem(res.arrayint2, constant.ITEM_COST_GONGCHENG_REBORN, wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_KFBOSS_REVIVE_NOT_ENOUGH
rrv = rpc_gongcheng.gongchengTeamDestroy(self.player.id,team,reborn)
if not rrv:
return 0, errcode.EC_GONGCHENG_ERR
if rrv["err"]!=0:
return 0, rrv["err"]
dUpdate = self.player.packRespBag(respBag)
resp = {
"team":team,
"allUpdate": dUpdate,
}
return 1, resp
def rc_gongchengSend(self,team,city,atk):
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_gongcheng.gongchengSend(self.player.id,team,city,atk)
if not rrv:
return 0, errcode.EC_GONGCHENG_ERR
if rrv["err"]!=0:
return 0, rrv["err"]
self.player.safe_pub(msg_define.MSG_GUILD_WAR_SEND)
return 1,{}
# 创建队伍(gongchengTeamCreate)
# 请求
# 队伍(team, [宠物id])
# 返回
def rc_gongchengTeamCreateSend(self,team,city,atk):
# 宠物互斥
petList = copy.deepcopy(team)
rs = self.player.pet.checkSpecMutex(petList)
if not rs:
return 0, errcode.EC_PET_MUTEX_LIMIT
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_gongcheng.gongchengTeamCreate(self.player.id,team)
if not rrv:
return 0, errcode.EC_GONGCHENG_ERR
if rrv["err"]!=0:
return 0, rrv["err"]
rrv1 = rpc_gongcheng.gongchengSend(self.player.id,rrv["teamid"],city,atk)
if not rrv1:
return 0, errcode.EC_GONGCHENG_ERR
if rrv1["err"]!=0:
rpc_gongcheng.gongchengTeamDestroy(list(self.player.id,rrv["team"].keys()),False)
return 0, rrv1["err"]
self.player.safe_pub(msg_define.MSG_GUILD_WAR_SEND)
return 1,{"team":rrv["team"]}
def rc_gongchengGetPlayer(self,players):
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_gongcheng.gongchengGetPlayer(self.player.id,players)
if not rrv:
return 0, errcode.EC_GONGCHENG_ERR
if rrv["err"]!=0:
return 0, rrv["err"]
return 1,{"data":rrv["data"]}
# 弃城操作
# 一天只能弃1次城，有是否弃城的提示面板进行询问
def rc_gongchengGiveup(self,cityid):
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_gongcheng.gongchengGiveup(self.player.id,cityid)
if not rrv:
return 0, errcode.EC_GONGCHENG_ERR
if rrv["err"]!=0:
return 0, rrv["err"]
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
rpc_guild.GiveupCity()
dUpdate = {}
dUpdate["guildInfo"] = self.player.guild.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1,resp
def rc_gongchengLogList(self,city):
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_gongcheng.gongchengLogList(self.player.id,city)
if not rrv:
return 0, errcode.EC_GONGCHENG_ERR
if rrv["err"]!=0:
return 0, rrv["err"]
return 1,{"data":rrv["data"]}
def rc_gongchengHistory(self):
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
guildId = self.player.guild.GetGuildId()
rrv = rpc_gongcheng.gongchengHistory(self.player.id,guildId)
if not rrv:
return 0, errcode.EC_GONGCHENG_ERR
if rrv["err"]!=0:
return 0, rrv["err"]
return 1,{"data":rrv["data"]}
def rc_gongchengLogData(self,fightlog):
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_gongcheng.gongchengLogData(self.player.id,fightlog)
if not rrv:
return 0, errcode.EC_GONGCHENG_ERR
if rrv["err"]!=0:
return 0, rrv["err"]
return 1,{"fightLog":rrv["fightlog"]}
# 个人排行榜(gongchengRankPerson)
# 请求
# 上期(pre, int) 1 上期
# 返回
# 榜单(data, map[string]json)
# 名字(name, json)
# 分数(score, int)
# 公会名字(ghname, string)
# 公会排行榜(gongchengRankGuild)
# 请求
# 上期(pre, int) 1 上期
# 返回
# 榜单(data, map[string]json)
# 公会名字(name, json)
# 分数(score, int)
def rc_gongchengRankPerson(self,pre):
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_gongcheng.gongchengRankPerson(self.player.id,pre)
if not rrv:
return 0, errcode.EC_GONGCHENG_ERR
if rrv["err"]!=0:
return 0, rrv["err"]
return 1,{"data":rrv["data"]}
def rc_gongchengRankGuild(self,pre):
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_gongcheng.gongchengRankGuild(self.player.id,pre)
if not rrv:
return 0, errcode.EC_GONGCHENG_ERR
if rrv["err"]!=0:
return 0, rrv["err"]
return 1,{"data":rrv["data"]}
def rc_gongchengTag(self,city):
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_gongcheng.gongchengTag(self.player.id,city)
if not rrv:
return 0, errcode.EC_GONGCHENG_ERR
if rrv["err"]!=0:
return 0, rrv["err"]
return 1,{}
def rc_gongchengCleanTag(self,city):
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_gongcheng.gongchengCleanTag(self.player.id,city)
if not rrv:
return 0, errcode.EC_GONGCHENG_ERR
if rrv["err"]!=0:
return 0, rrv["err"]
return 1,{}
# 宣战操作
#
def rc_gongchengWar(self,city):
from game.mgr.room import get_rpc_gongcheng
rpc_gongcheng = get_rpc_gongcheng()
if not rpc_gongcheng:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_gongcheng.gongchengWar(self.player.id,city)
if not rrv:
return 0, errcode.EC_GONGCHENG_ERR
if rrv["err"]!=0:
return 0, rrv["err"]
guildId = self.player.guild.GetGuildId()
if not guildId:
return 0, errcode.EC_NO_GUILD
rpc_guild = get_rpc_guild(guildId)
if not rpc_guild:
return 0, errcode.EC_NOT_FOUND_GUILD
from game.mgr.player import get_rpc_player
nowtime=time.time()
members = rpc_guild.getMembers()
for one in members:
rid = one.get("rid", 0)
if not rid:
continue
# isRobot = one.get("isRobot", 1)
# if isRobot:
# continue
rpc_player = get_rpc_player(rid)
if not rpc_player:
continue
rpc_player.gongchengNotiyGuild(city,True,nowtime)
rpc_guild.WarCity()
dUpdate = {}
dUpdate["guildInfo"] = self.player.guild.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1,resp
class FubenRpcMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
# 挑战(clfbChallenge)
# 请求
# 材料副本id(id, int)
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 货币
# 游戏模型 - 角色背包
# 游戏模型 - 角色属性
# 游戏模型 - 角色基础 - 战力
# 战报(fightLog, json)
# 材料副本id(id, int)
# 当日已挑战次数(challengeNum, int)
def rc_clfbChallenge(self, fubenId):
res = Game.res_mgr.res_clfb.get(fubenId, None)
if not res:
return 0, errcode.EC_NORES
lv = self.player.base.GetLv()
if lv < res.openLv:
return 0, errcode.EC_CLFB_LEVEL_TOO_LOW
num = self.player.fuben.getClbzChanllengeNum(fubenId)
if num >= res.freeCount:
return 0, errcode.EC_CLFB_ALREADY_CHALLENGE
#按等级获取副本
barrierId = 0
for data in res.barrierId:
startLv = data[0]
endLv = data[1]
if startLv <= self.player.base.GetLv() <= endLv:
barrierId = data[2]
barrierRes = Game.res_mgr.res_barrier.get(barrierId)
if not barrierRes:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(barrierRes.rewardId)
if not rewardRes:
return 0, errcode.EC_NORES
fightobj = Game.fight_mgr.createFight(constant.FIGHT_TYPE_190)
rs = fightobj.init_by_barrId(self.player, barrierRes.id)
if not rs:
return 0, errcode.EC_INIT_BARR_FAIL
respBag = {}
fightLog = fightobj.doFight()
fightResult = fightLog["result"].get("win", 0)
if fightResult:
dReward = rewardRes.doReward()
respBag = self.player.bag.add(dReward, constant.ITEM_ADD_CLFB_REWARD, wLog=True)
self.player.fuben.setClbzChanllengeNum(fubenId, num+1)
self.player.fuben.IncClfbSuccessCount()
self.player.fuben.IncClfbFightNum(fubenId)
iTotal = self.player.fuben.getClbzChanllengeNumTotal()
self.player.fuben.setClbzChanllengeNumTotal(iTotal + 1)
# 抛事件
self.player.safe_pub(msg_define.MSG_PASS_CLFB, fubenId)
# 抛事件
self.player.safe_pub(msg_define.MSG_CLFB_FIGHT)
self.player.fuben.addClbfId(fubenId)
dRole = {}
dRole["roleBase"] = self.player.base.to_init_data()
dRole["roleAttr"] = self.player.attr.to_update_data()
dUpdate = self.player.packRespBag(respBag)
dUpdate["role"] = dRole
resp = {
"fightLog": fightLog,
"allUpdate": dUpdate,
"fubenId": fubenId,
"challengeNum": num+fightResult,
}
return 1, resp
# 扫荡(clfbSweep)
# 请求
# 材料副本id(id,int)
# 返回
# 主动推送刷新(allUpdate,json)
# 游戏模型-货币
# 游戏模型-角色背包
# 游戏模型-角色属性
# 游戏模型-角色基础-战力
# 材料副本id(id,int)
# 当日已挑战次数(challengeNum, int)
def rc_clfbSweep(self, fubenId):
res = Game.res_mgr.res_clfb.get(fubenId, None)
if not res:
return 0, errcode.EC_NORES
vipLv = self.player.vip.GetVipLv()
vipRes = Game.res_mgr.res_vip.get(vipLv, None)
if not vipRes:
return 0, errcode.EC_NORES
# maxSweepCount = res.freeCount + res.baseSweepCount + vipRes.clbzSweepCount
maxSweepCount = res.freeCount + vipRes.clbzSweepCount
lv = self.player.base.GetLv()
num = self.player.fuben.getClbzChanllengeNum(fubenId)
if num >= maxSweepCount:
return 0, errcode.EC_CLFB_SWEEP_MAX_TIMES
if num == 0 and lv < res.sweepLv:
return 0, errcode.EC_CLFB_SWEEP_LEVEL_TOO_LOW
#按等级获取副本
barrierId = 0
for data in res.barrierId:
startLv = data[0]
endLv = data[1]
if startLv <= self.player.base.GetLv() <= endLv:
barrierId = data[2]
barrierRes = Game.res_mgr.res_barrier.get(barrierId)
if not res:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(barrierRes.rewardId)
if not rewardRes:
return 0, errcode.EC_NORES
dReward = rewardRes.doReward()
# if num > 0: # 非每日首次不得绑钻
# dReward[3] = 0
respBag = self.player.bag.add(dReward, constant.ITEM_ADD_CLFB_REWARD, wLog=True)
self.player.fuben.setClbzChanllengeNum(fubenId, num+1)
self.player.fuben.IncClfbSuccessCount()
self.player.fuben.IncClfbFightNum(fubenId)
iTotal = self.player.fuben.getClbzChanllengeNumTotal()
self.player.fuben.setClbzChanllengeNumTotal(iTotal + 1)
# 抛事件
self.player.safe_pub(msg_define.MSG_PASS_CLFB, fubenId)
# 抛事件
self.player.safe_pub(msg_define.MSG_CLFB_FIGHT)
dRole = {}
dRole["roleBase"] = self.player.base.to_init_data()
dRole["roleAttr"] = self.player.attr.to_update_data()
dUpdate = self.player.packRespBag(respBag)
dUpdate["role"] = dRole
resp = {
"allUpdate": dUpdate,
"fubenId": fubenId,
"challengeNum": num + 1,
}
return 1, resp
# 一键扫荡(clfbOneKeySweep)
# 请求
# 扫荡材料副本id列表(fubenIdList, [int])
# 返回
# 主动推送刷新(allUpdate, json)
# 游戏模型 - 货币
# 游戏模型 - 角色背包
# 游戏模型 - 角色属性
# 游戏模型 - 角色基础 - 战力
#
# 扫荡材料副本id列表(fubenIdList, [int])
# 当日已挑战次数列表(challengeNumList, [int])
def rc_clfbOneKeySweep(self, fubenIdList):
vipLv = self.player.vip.GetVipLv()
vipRes = Game.res_mgr.res_vip.get(vipLv, None)
if not vipRes:
return 0, errcode.EC_NORES
sweepIdList = []
sweepIdNum = []
lv = self.player.base.GetLv()
respBag = {}
for fubenId in fubenIdList:
res = Game.res_mgr.res_clfb.get(fubenId, None)
if not res:
return 0, errcode.EC_NORES
maxSweepCount = res.freeCount + vipRes.clbzSweepCount
if lv < res.sweepLv: # 等级不够
continue
num = self.player.fuben.getClbzChanllengeNum(res.fubenId)
if num >= maxSweepCount: # 已达最大次数
continue
sweepIdList.append(res.fubenId)
sweepIdNum.append(num+1)
#按等级获取副本
barrierId = 0
for data in res.barrierId:
startLv = data[0]
endLv = data[1]
if startLv <= self.player.base.GetLv() <= endLv:
barrierId = data[2]
barrierRes = Game.res_mgr.res_barrier.get(barrierId)
if not res:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(barrierRes.rewardId)
if not rewardRes:
return 0, errcode.EC_NORES
dReward = rewardRes.doReward()
# if num > 0: # 非每日首次不得绑钻
# dReward[3] = 0
respBag1 = self.player.bag.add(dReward, constant.ITEM_ADD_CLFB_REWARD, wLog=True)
respBag = self.player.mergeRespBag(respBag, respBag1)
self.player.fuben.setClbzChanllengeNum(res.fubenId, num+1)
self.player.fuben.IncClfbSuccessCount()
self.player.fuben.IncClfbFightNum(res.fubenId)
iTotal = self.player.fuben.getClbzChanllengeNumTotal()
self.player.fuben.setClbzChanllengeNumTotal(iTotal + 1)
# 抛事件
self.player.safe_pub(msg_define.MSG_PASS_CLFB, res.fubenId)
# 抛事件
self.player.safe_pub(msg_define.MSG_CLFB_FIGHT)
dRole = {}
dRole["roleBase"] = self.player.base.to_init_data()
dRole["roleAttr"] = self.player.attr.to_update_data()
dUpdate = self.player.packRespBag(respBag)
dUpdate["role"] = dRole
resp = {
"allUpdate": dUpdate,
"fubenIdList": sweepIdList,
"fubenIdNum": sweepIdNum,
}
return 1, resp
# 请求材料副本数据(clfbGetInfo)
# 请求
# 返回
# 材料副本列表(clbz, [json])
# 副本id(fubenId, int)
# 副本挑战次数(challengeNum, int)
def rc_clfbGetInfo(self):
resp = self.player.fuben.clfbGetInfo()
return 1, resp
# 挑战(lwbzChallenge)
# 请求
# 关卡id(id,int)
# 返回
# 主动推送刷新(allUpdate,json)
# 游戏模型-货币
# 游戏模型-角色背包
# 游戏模型-角色属性
# 游戏模型-角色基础-战力
# 战报(fightLog, json)
# 关卡id(id,int)
# 星数(star,int)
def rc_lwbzChallenge(self, levelId):
res = Game.res_mgr.res_lwbz.get(levelId, None)
if not res:
return 0, errcode.EC_NORES
cangbaotu = self.player.fuben.getCangbaotu(res.baotuId)
levelStatus = cangbaotu.getDailyStatus(levelId)
barrierRes = Game.res_mgr.res_barrier.get(res.barrierId)
if not barrierRes:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(barrierRes.rewardId)
if not rewardRes:
return 0, errcode.EC_NORES
starRes = None
if res.type == 1:
starRes = Game.res_mgr.res_common.get("LwbzNoramlStarJudge", {})
elif res.type == 2:
starRes = Game.res_mgr.res_common.get("LwbzHardStarJudge", {})
if not starRes:
return 0, errcode.EC_NORES
starJudge = starRes.arrayint2
fightobj = Game.fight_mgr.createFight(constant.FIGHT_TYPE_191)
rs = fightobj.init_by_barrId(self.player, barrierRes.id)
if not rs:
return 0, errcode.EC_INIT_BARR_FAIL
fightLog = fightobj.doFight()
fightResult = fightLog["result"].get("win", 0)
useRound = fightLog.get("useRound", 0)
respBag = {}
if fightResult:
oldStar = cangbaotu.getLevelStar(levelId)
resReward = rewardRes.doReward()
reward = copy.deepcopy(resReward)
if not oldStar:
for k, v in barrierRes.firstReward.items():
if k in reward:
reward[k] = reward[k]+v
else:
reward[k] = v
if not levelStatus:
respBag = self.player.bag.add(reward, constant.ITEM_ADD_LWBZ_REWARD, wLog=True)
cangbaotu.markDailyStatus(levelId)
# 计算星数
newStar = 0
roundList = list(starJudge.values())
roundList.sort()
round = 0
for r in roundList:
if useRound <= r:
round = r
break
for k, v in starJudge.items():
if v == round:
newStar = k
break
if newStar > oldStar:
cangbaotu.setLevelStar(levelId, newStar)
self.player.rank.uploadRank(constant.RANK_TYPE_LWBZ)
else:
self.player.safe_pub(msg_define.MSG_XIANSHITUISONGLIBAO_LWBZ_F)
# 抛事件
self.player.safe_pub(msg_define.MSG_PASS_LWBZ)
# import ujson
# Game.glog.log2File("testLwbzChallenge", "%s" % ujson.dumps(fightLog))
dRole = {}
dRole["roleBase"] = self.player.base.to_init_data()
dRole["roleAttr"] = self.player.attr.to_update_data()
dUpdate = self.player.packRespBag(respBag)
dUpdate["role"] = dRole
resp = {
"fightLog": fightLog,
"allUpdate": dUpdate,
"levelId": levelId,
"star": cangbaotu.getLevelStar(levelId),
}
return 1, resp
# 一键挑战(lwbzOneKeyChallenge)
# 请求
# 返回
# 主动推送刷新(allUpdate,json)
# 游戏模型-货币
# 游戏模型-角色背包
# 游戏模型-角色属性
# 游戏模型-角色基础-战力
def rc_lwbzOneKeyChallenge(self):
vipLv = self.player.vip.GetVipLv()
vipRes = Game.res_mgr.res_vip.get(vipLv, None)
if not vipRes:
return 0, errcode.EC_NORES
if not vipRes.lwbzOneKey:
return 0, errcode.EC_LWBZ_SWEEP_VIP_LIMIT
unChallengeLevel = self.player.fuben.getLwbzUnChallengeLevel()
reward = {}
for levelId in unChallengeLevel:
res = Game.res_mgr.res_lwbz.get(levelId, None)
if not res:
return 0, errcode.EC_NORES
barrierRes = Game.res_mgr.res_barrier.get(res.barrierId)
if not barrierRes:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(barrierRes.rewardId)
if not rewardRes:
return 0, errcode.EC_NORES
resReward = rewardRes.doReward()
for k, v in resReward.items():
if k in reward:
reward[k] = reward[k] + v
else:
reward[k] = v
# 抛事件
self.player.safe_pub(msg_define.MSG_PASS_LWBZ)
for levelId in unChallengeLevel:
res = Game.res_mgr.res_lwbz.get(levelId, None)
cangbaotu = self.player.fuben.getCangbaotu(res.baotuId)
cangbaotu.markDailyStatus(levelId)
respBag = self.player.bag.add(reward, constant.ITEM_ADD_LWBZ_REWARD, wLog=True)
dRole = {}
dRole["roleBase"] = self.player.base.to_init_data()
dRole["roleAttr"] = self.player.attr.to_update_data()
dUpdate = self.player.packRespBag(respBag)
dUpdate["role"] = dRole
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 领取星数宝箱(lwbzGetStarReward)
# 请求
# 星数id(startId,int)
# 1，2，3
# 返回
# 主动推送刷新(allUpdate,json)
# 游戏模型-货币
# 游戏模型-角色背包
# 游戏模型-角色属性
# 游戏模型-角色基础-战力
def rc_lwbzGetStarReward(self, starId, baotuId):
res = Game.res_mgr.res_lwbzStarReward.get(baotuId, None)
if not res:
return 0, errcode.EC_NORES
cangbaotu = self.player.fuben.getCangbaotu(baotuId)
totalStar = cangbaotu.getTotalStar()
if starId < 1 or starId > 4:
return 0, errcode.EC_LWBZ_UNKNOWN_STARID
targetStar = 0
if starId == 1:
targetStar = 6
elif starId == 2:
targetStar = 12
elif starId == 3:
targetStar = 18
if totalStar < targetStar:
return 0, errcode.EC_LWBZ_STAR_NO_ENOUGH
status = cangbaotu.getStarRewardStatus(starId)
if status:
return 0, errcode.EC_LWBZ_STAR_REWARD_ALREADY_OPEN
reward = res.reward.get(starId, None)
if not reward:
return 0, errcode.EC_NORES
cangbaotu.markStarRewardStatus(starId)
respBag = self.player.bag.add(reward, constant.ITEM_ADD_LWBZ_REWARD, wLog=True)
self.player.fuben.IncLwbzRewardNum()
# 抛事件
self.player.safe_pub(msg_define.MSG_GET_LWBZ_STAR_REWARD)
dRole = {}
dRole["roleBase"] = self.player.base.to_init_data()
dRole["roleAttr"] = self.player.attr.to_update_data()
dUpdate = self.player.packRespBag(respBag)
dUpdate["role"] = dRole
resp = {
"allUpdate": dUpdate,
"starId": starId,
"baotuId": baotuId,
}
return 1, resp
def rc_xlysBuyBuff(self,key):
canbuy=self.player.fuben.getXlysBuffCanBuy()
if key not in canbuy:
return 0, errcode.EC_XLYS_BUFF_BUY
res=Game.res_mgr.res_xlysBuff.get(key,None)
if not res:
return 0, errcode.EC_NORES
buff=self.player.fuben.getXlysBuff()
xlysBuffLimitRes = Game.res_mgr.res_common.get("xlysBuffLimit")
if not xlysBuffLimitRes:
return 0, errcode.EC_NORES
iTotal = 0
for val in buff.values():
iTotal += val.get("count", 0)
if iTotal >= xlysBuffLimitRes.i:
return 0, errcode.EC_TIMES_FULL
count=buff[key]["count"]
costl=len(res.cost)
if count>=costl:
count=costl-1
cost={}
cost[res.cost[count][0]]=res.cost[count][1]
respBag = self.player.bag.costItem(cost, constant.ITEM_COST_XLYS_BUFF, wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_COST_ERR
self.player.fuben.addXlysBuff(key)
dUpdate = self.player.packRespBag(respBag)
dUpdate["fubenInfo"]=self.player.fuben.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 挑战(xlysChallenge)
# 请求
# 关卡id(id,int)
# 返回
# 主动推送刷新(allUpdate,json)
# 游戏模型-货币
# 游戏模型-角色背包
# 游戏模型-角色属性
# 游戏模型-角色基础-战力
# 战报(fightLog, json)
# 关卡id(id,int)
def rc_xlysChallenge(self, levelId):
oldLevelId = self.player.fuben.getXlysMaxLevelId()
if levelId != oldLevelId + 1:
return 0, errcode.EC_XLYS_LEVEL_ERROR
res = Game.res_mgr.res_xlys.get(levelId, None)
if not res:
return 0, errcode.EC_NORES
barrierRes = Game.res_mgr.res_barrier.get(res.barrierId)
if not barrierRes:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(barrierRes.rewardId)
if not rewardRes:
return 0, errcode.EC_NORES
fightobj = Game.fight_mgr.createFight(constant.FIGHT_TYPE_192)
rs = fightobj.init_by_barrId(self.player, barrierRes.id)
if not rs:
return 0, errcode.EC_INIT_BARR_FAIL
buff=self.player.fuben.getXlysBuff()
fightobj.enhanceRedTeamPer(buff)
respBag = {}
fightLog = fightobj.doFight()
fightResult = fightLog["result"].get("win", 0)
if fightResult:
dReward = rewardRes.doReward()
respBag = self.player.bag.add(dReward, constant.ITEM_ADD_XLYS_REWARD, wLog=True)
self.player.fuben.setXlysMaxLevelId(levelId)
self.player.rank.uploadRank(constant.RANK_TYPE_XLYS, {"levelId": levelId})
else:
self.player.safe_pub(msg_define.MSG_XIANSHITUISONGLIBAO_XLYS_F)
# 抛事件
self.player.safe_pub(msg_define.MSG_PASS_XLYS)
dRole = {}
dRole["roleBase"] = self.player.base.to_init_data()
dRole["roleAttr"] = self.player.attr.to_update_data()
dUpdate = self.player.packRespBag(respBag)
dUpdate["role"] = dRole
resp = {
"allUpdate": dUpdate,
"fightLog": fightLog,
"levelId": levelId,
}
return 1, resp
# 挑战(ttslChallenge)
# 请求
# 关卡id(id,int)
# 返回
# 主动推送刷新(allUpdate,json)
# 游戏模型-货币
# 游戏模型-角色背包
# 游戏模型-角色属性
# 游戏模型-角色基础-战力
# 战报(fightLog, json)
# 关卡id(id,int)
def rc_ttslChallenge(self, levelId):
todayMaxlevelId = self.player.fuben.getTtslTodayMaxLevelId()
if levelId != todayMaxlevelId + 1:
return 0, errcode.EC_TTSL_LEVEL_ERROR
res = Game.res_mgr.res_ttsl.get(levelId, None)
if not res:
return 0, errcode.EC_NORES
barrierRes = Game.res_mgr.res_barrier.get(res.barrierId)
if not barrierRes:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(barrierRes.rewardId)
if not rewardRes:
return 0, errcode.EC_NORES
fightobj = Game.fight_mgr.createFight(constant.FIGHT_TYPE_193)
rs = fightobj.init_by_barrId(self.player, barrierRes.id)
if not rs:
return 0, errcode.EC_INIT_BARR_FAIL
respBag = {}
fightLog = fightobj.doFight()
fightResult = fightLog["result"].get("win", 0)
if fightResult:
dReward = rewardRes.doReward()
respBag = self.player.bag.add(dReward, constant.ITEM_ADD_TTSL_REWARD, wLog=True)
self.player.fuben.setTtslTodayMaxLevelId(levelId)
maxLevelId = self.player.fuben.getTtslMaxLevelId()
if levelId > maxLevelId:
self.player.fuben.setTtslMaxLevelId(levelId)
self.player.rank.uploadRank(constant.RANK_TYPE_TTSL, {"levelId": levelId})
else:
self.player.safe_pub(msg_define.MSG_XIANSHITUISONGLIBAO_TTSL_F)
self.player.safe_pub(msg_define.MSG_PASS_TTSL)
dRole = {}
dRole["roleBase"] = self.player.base.to_init_data()
dRole["roleAttr"] = self.player.attr.to_update_data()
dUpdate = self.player.packRespBag(respBag)
dUpdate["role"] = dRole
resp = {
"allUpdate": dUpdate,
"fightLog": fightLog,
"levelId": levelId,
}
return 1, resp
# 一键挑战(ttslOneKeyChallenge)
# 请求
# 返回
# 主动推送刷新(allUpdate,json)
# 游戏模型-货币
# 游戏模型-角色背包
# 游戏模型-角色属性
# 游戏模型-角色基础-战力
def rc_ttslOneKeyChallenge(self):
maxLevelId = self.player.fuben.getTtslMaxLevelId()
todayMaxlevelId = self.player.fuben.getTtslTodayMaxLevelId()
reward = {}
for levelId in range(todayMaxlevelId+1, maxLevelId+1):
res = Game.res_mgr.res_ttsl.get(levelId, None)
if not res:
return 0, errcode.EC_NORES
barrierRes = Game.res_mgr.res_barrier.get(res.barrierId)
if not barrierRes:
return 0, errcode.EC_NORES
rewardRes = Game.res_mgr.res_reward.get(barrierRes.rewardId)
if not rewardRes:
return 0, errcode.EC_NORES
resReward = rewardRes.doReward()
for k, v in resReward.items():
if k in reward:
reward[k] = reward[k] + v
else:
reward[k] = v
self.player.safe_pub(msg_define.MSG_PASS_TTSL)
self.player.fuben.setTtslTodayMaxLevelId(maxLevelId)
respBag = self.player.bag.add(reward, constant.ITEM_ADD_TTSL_REWARD, wLog=True)
dRole = {}
dRole["roleBase"] = self.player.base.to_init_data()
dRole["roleAttr"] = self.player.attr.to_update_data()
dUpdate = self.player.packRespBag(respBag)
dUpdate["role"] = dRole
resp = {
"allUpdate": dUpdate,
}
return 1, resp
# 领取关卡宝箱(ttslGetLevelReward)
# 请求
# 关卡id(levelId,int)
# 返回
# 主动推送刷新(allUpdate,json)
# 游戏模型-货币
# 游戏模型-角色背包
# 游戏模型-角色属性
# 游戏模型-角色基础-战力
def rc_ttslGetLevelReward(self, levelId):
maxLevelId = self.player.fuben.getTtslMaxLevelId()
if levelId > maxLevelId:
return 0, errcode.EC_TTSL_LEVEL_ERROR
res = Game.res_mgr.res_ttsl.get(levelId, None)
if not res:
return 0, errcode.EC_NORES
if not res.firstReward:
return 0, errcode.EC_TTSL_LEVEL_ERROR
status = self.player.fuben.getTtslRewardStatus(levelId)
if status:
return 0, errcode.EC_TTSL_LEVEL_REWARD_ALREADY_OPEN
self.player.fuben.markTtslRewardStatus(levelId)
respBag = self.player.bag.add(res.firstReward, constant.ITEM_ADD_TTSL_REWARD, wLog=True)
dRole = {}
dRole["roleBase"] = self.player.base.to_init_data()
dRole["roleAttr"] = self.player.attr.to_update_data()
dUpdate = self.player.packRespBag(respBag)
dUpdate["role"] = dRole
resp = {
"allUpdate": dUpdate,
"levelId": levelId,
}
return 1, resp
class NiudanMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
def rc_niudanRoll(self, resid, ten, useFree=False):
print("===rc_niudanRoll===", resid, ten, useFree)
res = Game.res_mgr.res_niudanSystem.get(resid)
if not res:
print("111111111111111", resid)
return 0, errcode.EC_NORES
resxx = getattr(Game.res_mgr, "res_niudan" + res.mod)
if not resxx:
print("111111111111111", res.mod)
return 0, errcode.EC_NORES
serverInfo = self.player.base.GetServerInfo()
#普通池
resAct1 = Game.res_mgr.res_activity.get(res.ptActID)
if not resAct1:
print("3333333333333", res.ptActID)
return 0, errcode.EC_NORES
if not resAct1.isOpen(serverInfo):
return 0, errcode.EC_NOT_OPEN
funcID1 = resAct1.getCycleFuncID(serverInfo)
if not funcID1:
return 0, errcode.EC_NOT_OPEN
#精英池
resAct2 = Game.res_mgr.res_activity.get(res.jyActID)
if not resAct2:
print("4444444444444", res.jyActID)
return 0, errcode.EC_NORES
if not resAct2.isOpen(serverInfo):
return 0, errcode.EC_NOT_OPEN
funcID2 = resAct2.getCycleFuncID(serverInfo)
if not funcID2:
return 0, errcode.EC_NOT_OPEN
#系统活动
resActX = Game.res_mgr.res_activity.get(res.sysActID)
if not resActX.isOpen(serverInfo):
return 0, errcode.EC_NOT_OPEN
funcIDX = resActX.getCycleFuncID(serverInfo)
if not funcIDX:
return 0, errcode.EC_NOT_OPEN
modres = {}
#系统活动res
modres = resxx.get(funcIDX)
if not modres:
print("55555555555", funcIDX)
return 0, errcode.EC_NORES
times = 1
cost = {}
reward = {}
rn = {}
onenum = 0
if ten:
if not res.costTen or not res.Ten:
print("666666666666")
return 0, errcode.EC_NORES
times = res.Ten
cost = res.costTen
else:
cost = res.cost
times = 1
rn = self.player.niudan.getRollOneNum()
onenum = rn.get(resid, 0)
if useFree:
if onenum < res.costFree:
cost = {}
else:
return 0, errcode.EC_FREE_EXHAUSTED
rxAll = self.player.niudan.getRollNum()
rxAllNum = rxAll.get(resid, 0)
for k, v in res.reward.items():
reward[k] = v * times
modactnum = self.player.niudan.getCycleBaodi(res.sysActID)
modactreward = self.player.niudan.getCycleReward(res.sysActID)
for timesn in range(times):
pool = []
# if ten and not timesn and res.abpool:
# for v in Game.res_mgr.res_niudanPool.values():
# if not v.scope[1]:
# v.scope[1]=constant.MAX_SAFE_INTEGER
# if v.cycleFuncID==funcID and v.scope[0]<=rxAllNum<=v.scope[1]:
# value = (v.rewardten, v.WeightTen)
# pool.append(value)
# else:
for v in Game.res_mgr.res_niudanPool.values():
if not v.scope[1]:
v.scope[1] = constant.MAX_SAFE_INTEGER
if (v.cycleFuncID == funcID1 or v.cycleFuncID
== funcID2) and v.scope[0] <= rxAllNum <= v.scope[1]:
value = (v.reward, v.Weight)
pool.append(value)
randomReward = utility.Choice(pool)
print("===============", randomReward)
modactnum += 1
modactreward += 1
if modres.baodiNum:
if modactnum >= modres.baodiNum[res.modidx]:
modactnum = 0
randomReward = {}
randomReward[modres.reward[res.modidx][0]] = modres.reward[
res.modidx][1]
print("==!!!!!=====", randomReward)
for k, v in randomReward.items():
reward[k] = reward.get(k, 0) + v
rxAllNum += 1
rxAll[resid] = rxAllNum
respBag1 = self.player.bag.costItem(cost,
constant.ITEM_COST_NIUDAN_ROLL,
wLog=True)
if not respBag1.get("rs", 0):
if ten:
if res.costTenRep:
respBag1 = self.player.bag.costItem(
res.costTenRep,
constant.ITEM_COST_NIUDAN_ROLL,
wLog=True)
if not respBag1.get("rs", 0):
return 0, errcode.EC_COST_ERR
else:
return 0, errcode.EC_COST_ERR
else:
if res.costRep:
respBag1 = self.player.bag.costItem(
res.costRep, constant.ITEM_COST_NIUDAN_ROLL, wLog=True)
if not respBag1.get("rs", 0):
return 0, errcode.EC_COST_ERR
else:
return 0, errcode.EC_COST_ERR
respBag = self.player.bag.add(reward,
constant.ITEM_ADD_NIUDAN_ROLL,
wLog=True,
mail=True)
respBag = self.player.mergeRespBag(respBag, respBag1)
print("===rc_niudanRoll===reward=", reward)
if not ten:
onenum += 1
for xresid in res.RollOneResID:
rn[xresid] = onenum
self.player.niudan.setRollOneNum(rn)
self.player.niudan.setRollNum(rxAll)
self.player.niudan.setCycleBaodi(modactnum, res.sysActID)
self.player.niudan.setCycleReward(modactreward, res.sysActID)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["niudan"] = self.player.niudan.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_niudanXianshiReward(self, idx):
totAct = constant.ACTIVITY_XIANSHINIUDAN
serverInfo = self.player.base.GetServerInfo()
resActX = Game.res_mgr.res_activity.get(totAct)
if not resActX.isOpen(serverInfo):
return 0, errcode.EC_NOT_OPEN
funcIDX = resActX.getCycleFuncID(serverInfo)
if not funcIDX:
return 0, errcode.EC_NOT_OPEN
modres = Game.res_mgr.res_niudanXianshi.get(funcIDX)
if not modres:
return 0, errcode.EC_NORES
if not modres.needs:
return 0, errcode.EC_NOT_OPEN
if len(modres.needs) < idx + 1:
return 0, errcode.EC_NORES
x = self.player.niudan.getCycleReward(totAct)
print("=====", x, modres.needs, idx)
if x < modres.needs[idx]:
return 0, errcode.EC_NOT_ENOUGH
reward = {}
reward[modres.rewardNeeds[idx][0]] = modres.rewardNeeds[idx][1]
cn = self.player.niudan.getCycleNeeds(totAct)
if idx in cn:
return 0, errcode.EC_ALREADY_REWARD
cn.append(idx)
if len(cn) == len(modres.needs):
cn = []
x -= modres.needs[len(modres.needs) - 1]
if x < 0:
x = 0
self.player.niudan.setCycleNeeds(cn, totAct)
self.player.niudan.setCycleReward(x, totAct)
respBag = self.player.bag.add(reward,
constant.ITEM_ADD_NIUDAN_XIANSHI_REWARD,
wLog=True,
mail=True)
# 打包返回信息
dUpdate = self.player.packRespBag(respBag)
dUpdate["niudan"] = self.player.niudan.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
class YabiaoRpcMixin(object):
if 0:
from game.core import player as player_md
player = player_md.Player()
def rc_husong(self):
yabiaoHusongNum = Game.res_mgr.res_common.get("yabiaoHusongNum")
if not yabiaoHusongNum:
return 0, errcode.EC_NORES
yabiaoDoubleTime = Game.res_mgr.res_common.get("yabiaoDoubleTime")
if not yabiaoDoubleTime:
return 0, errcode.EC_NORES
if self.player.yabiao.time!=0:
return 0, errcode.EC_HUSONG_TIME_NO_ZERO
if self.player.yabiao.getYabiaoHusong()>=yabiaoHusongNum.i:
return 0, errcode.EC_HUSONG_NUM_USEUP
mul=1
currHour = gtime.current_hour()
if currHour in yabiaoDoubleTime.arrayint1:
mul=2
self.player.yabiao.husong(mul)
bhname = ""
from game.mgr.guild import get_rpc_guild
rpc_guild = get_rpc_guild(self.player.guild.GetGuildId())
if rpc_guild:
bhname = rpc_guild.getName()
days = self.player.base.GetServerOpenDay()
ares = Game.res_mgr.res_activity.get(constant.ACTIVITY_YABIAO)
startD = ares.openDayRange[0]
from game.mgr.room import get_rpc_room
rpc_room = get_rpc_room(startD<=days)
if not rpc_room:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
data={
"power":self.player.base.fa,
"quality":self.player.yabiao.quality,
"bhname":bhname,
"sex":self.player.base.GetSex(),
"portrait":self.player.myhead.getPortrait(),
"headframe":self.player.myhead.getHeadframe(),
"becatchID":self.player.yabiao.getBecatchID(),
}
import app
rrv = rpc_room.hello(1,self.player.id,config.serverNo,app.addr,self.player.name,data,self.player.yabiao.time,0)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
rrv = rpc_room.get(1,self.player.id)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
resp = {}
resp["list"] = rrv["v"]
dUpdate={}
dUpdate["jiebiao"] = self.player.yabiao.to_init_data()
resp["allUpdate"] = dUpdate
return 1, resp
def rc_getHusongData(self):
days = self.player.base.GetServerOpenDay()
ares = Game.res_mgr.res_activity.get(constant.ACTIVITY_YABIAO)
startD = ares.openDayRange[0]
from game.mgr.room import get_rpc_room
rpc_room = get_rpc_room(startD<=days)
if not rpc_room:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_room.getByServerNo(1,config.serverNo)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
resp = {}
resp["list"] = rrv["v"]
return 1, resp
def rc_getHusongUserData(self,id):
days = self.player.base.GetServerOpenDay()
ares = Game.res_mgr.res_activity.get(constant.ACTIVITY_YABIAO)
startD = ares.openDayRange[0]
from game.mgr.room import get_rpc_room
rpc_room = get_rpc_room(startD<=days)
if not rpc_room:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_room.getOneByServerNo(1,config.serverNo,id)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
# print("1111111111",config.serverNo,id,rrv)
data = rrv["v"]
if len(data)==0:
return 0, errcode.EC_HUSONG_NOFOUNDONE
resp = {}
resp["data"] = data[0]
return 1, resp
def rc_fastComplete(self):
yabiaoFinish = Game.res_mgr.res_common.get("yabiaoFinish")
if not yabiaoFinish:
return 0, errcode.EC_NORES
t = time.time()
if self.player.yabiao.time<t:
return 0, errcode.EC_FASTCOMPLETE_TIME_BAD
days = self.player.base.GetServerOpenDay()
ares = Game.res_mgr.res_activity.get(constant.ACTIVITY_YABIAO)
startD = ares.openDayRange[0]
from game.mgr.room import get_rpc_room
rpc_room = get_rpc_room(startD<=days)
if not rpc_room:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
respBag = self.player.bag.costItem(yabiaoFinish.arrayint2, constant.ITEM_COST_FASTCOMPLETE, wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_COST_ERR
rrv=rpc_room.bye(1,self.player.id)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
self.player.yabiao.setTimeFinish()
dUpdate = self.player.packRespBag(respBag)
dUpdate["jiebiao"] = self.player.yabiao.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_getHusongRewardUI(self):
resp={}
dUpdate = {}
dUpdate["jiebiao"] = self.player.yabiao.to_init_data()
resp["allUpdate"] = dUpdate
return 1,resp
def rc_getHusongReward(self):
yabiaoJiebiaoLimit = Game.res_mgr.res_common.get("yabiaoJiebiaoLimit")
if not yabiaoJiebiaoLimit:
return 0, errcode.EC_NORES
# yabiaoDoubleTime = Game.res_mgr.res_common.get("yabiaoDoubleTime")
# if not yabiaoDoubleTime:
# return 0, errcode.EC_NORES
res = Game.res_mgr.res_yabiao.get(self.player.yabiao.quality)
if not res:
return 0, errcode.EC_NORES
if self.player.yabiao.time==0:
return 0, errcode.EC_HUSONGREWARD_NOSTART
t = time.time()
if self.player.yabiao.time>t:
return 0, errcode.EC_HUSONGREWARD_TIMENOABLE
# mul=1
# currHour = gtime.current_hour()
# if currHour in yabiaoDoubleTime.arrayint1:
# mul=2
mul = self.player.yabiao.mul
reward = {}
for kk, vv in res.reward.items():
reward[kk]=vv*mul
bid = self.player.yabiao.getBecatchID()
bidlen=len(bid)
if bidlen>yabiaoJiebiaoLimit.i:
bidlen=yabiaoJiebiaoLimit.i
if 5!=self.player.yabiao.quality:
for _ in range(bidlen):
for kk, vv in res.rob.items():
reward[kk]-=vv
self.player.yabiao.finishYabiao()
# # 意外绑元奖励
# DaySurpriseRewardNumRes = Game.res_mgr.res_common.get("DaySurpriseRewardNum") # 每日意外绑元获得
# iDayRewardNum = self.player.cycleDay.Query("DaySurpriseRewardNum", 0)
# if iDayRewardNum < DaySurpriseRewardNumRes.i:
# DaySurpriseRes = Game.res_mgr.res_daySurprise.get(constant.DAY_SURPRISE_REWARD_3)
# if DaySurpriseRes and random.randint(1, 10000) <= DaySurpriseRes.odds:
# for iNo, iNum in DaySurpriseRes.reward.items():
# if reward.get(iNo):
# reward[iNo] += iNum
# else:
# reward[iNo] = iNum
# # 发送世界聊天
# for addr, logic in Game.rpc_logic_game:
# if logic:
# logic.sendSystemTemplateMSG(DaySurpriseRes.chatId, [self.player.name])
respBag = self.player.bag.add(reward, constant.ITEM_ADD_HUSONGREWARD, wLog=True)
resp={}
dUpdate = self.player.packRespBag(respBag)
dUpdate["jiebiao"] = self.player.yabiao.to_init_data()
resp["allUpdate"] = dUpdate
return 1,resp
def rc_robHusongCar(self,id):
yabiaoJiebiaoLimit = Game.res_mgr.res_common.get("yabiaoJiebiaoLimit")
if not yabiaoJiebiaoLimit:
return 0, errcode.EC_NORES
yabiaoJiebiaoNum = Game.res_mgr.res_common.get("yabiaoJiebiaoNum")
if not yabiaoJiebiaoNum:
return 0, errcode.EC_NORES
yabiaoDoubleTime = Game.res_mgr.res_common.get("yabiaoDoubleTime")
if not yabiaoDoubleTime:
return 0, errcode.EC_NORES
if self.player.yabiao.getYabiaoRob()>=yabiaoJiebiaoNum.i:
return 0, errcode.EC_ROBHUSONG_USEUP
days = self.player.base.GetServerOpenDay()
ares = Game.res_mgr.res_activity.get(constant.ACTIVITY_YABIAO)
startD = ares.openDayRange[0]
from game.mgr.room import get_rpc_room
rpc_room = get_rpc_room(startD<=days)
if not rpc_room:
return 0, errcode.EC_GETD_RPC_ROOM_FAIL
rrv = rpc_room.getOneByServerNo(1,config.serverNo,id)
if not rrv:
return 0, errcode.EC_CALL_RPC_ROOM_FAIL
data = rrv["v"]
if len(data)==0:
return 0, errcode.EC_HUSONG_NOFOUNDONE
res = Game.res_mgr.res_yabiao.get(data[0]["data"]["quality"])
if not res:
return 0, errcode.EC_NORES
if yabiaoJiebiaoLimit.i<=len(data[0]["data"]["becatchID"]):
return 0, errcode.EC_ROBHUSONG_LIMIT
if self.player.id in data[0]["data"]["becatchID"]:
return 0, errcode.EC_ROBHUSONG_ALREADY
from game.mgr.logicgame import LogicGame
proxy = get_proxy_by_addr(data[0]["addr"], LogicGame._rpc_name_)
if not proxy:
return 0, errcode.EC_GETD_LOGIC_PROXY_ERR
fdata = self.player.GetFightData()
bhname = ""
from game.mgr.guild import get_rpc_guild
rpc_guild = get_rpc_guild(self.player.guild.GetGuildId())
if rpc_guild:
bhname = rpc_guild.getName()
import app
historydata={"addr":app.addr,"id":self.player.id,"endtime":0,"name":self.player.name,"data":{"quality":0,"power":self.player.base.fa,"bhname":bhname,"sex":self.player.base.GetSex()}}
resp = proxy.robHusongCar(self.player.id,data[0],fdata,historydata)
if not resp:
return 0, errcode.EC_CALL_LOGIC_PROXY_ERR
self.player.yabiao.addYabiaoRob()
respBag = {}
fightResult = resp["fightLog"]["result"].get("win", 0)
if fightResult:
self.player.yabiao.addHistory(3,data[0])
mul=1
currHour = gtime.current_hour()
if currHour in yabiaoDoubleTime.arrayint1:
mul=2
reward = {}
for kk, vv in res.rob.items():
reward[kk]=vv*mul
respBag = self.player.bag.add(reward, constant.ITEM_ADD_ROBREWARD, wLog=True)
else:
self.player.yabiao.addHistory(2,data[0])
dUpdate = self.player.packRespBag(respBag)
dUpdate["jiebiao"] = self.player.yabiao.to_init_data()
resp["allUpdate"] = dUpdate
return 1, resp
def rc_flashHusongCar(self,type):
yabiaoFlash = Game.res_mgr.res_common.get("yabiaoFlash")
if not yabiaoFlash:
return 0, errcode.EC_NORES
yabiaoFlashMax = Game.res_mgr.res_common.get("yabiaoFlashMax")
if not yabiaoFlashMax:
return 0, errcode.EC_NORES
yabiaoFlashMaxPriority = Game.res_mgr.res_common.get("yabiaoFlashMaxPriority")
if not yabiaoFlashMaxPriority:
return 0, errcode.EC_NORES
if self.player.yabiao.time!=0:
return 0, errcode.EC_FLASHCAR_TIMENOABLE
cost=yabiaoFlash.arrayint2
if type:
cost = yabiaoFlashMax.arrayint2
if type:
respBag = self.player.bag.costItem(yabiaoFlashMaxPriority.arrayint2, constant.ITEM_COST_FALSHCAR, wLog=True)
if not respBag.get("rs", 0):
respBag1 = self.player.bag.costItem(cost, constant.ITEM_COST_FALSHCAR, wLog=True)
if not respBag1.get("rs", 0):
return 0, errcode.EC_COST_ERR
else:
respBag = self.player.mergeRespBag(respBag, respBag1)
else:
respBag = self.player.bag.costItem(cost, constant.ITEM_COST_FALSHCAR, wLog=True)
if not respBag.get("rs", 0):
return 0, errcode.EC_COST_ERR
if type:
self.player.yabiao.flashCarMax()
else:
self.player.yabiao.flashCar()
dUpdate = self.player.packRespBag(respBag)
dUpdate["jiebiao"] = self.player.yabiao.to_init_data()
resp = {
"allUpdate": dUpdate,
}
return 1, resp
def rc_getHusongHistroy(self):
resp={}
resp["list"]=self.player.yabiao.getHistory()
return 1, resp
def rc_revengeHusongCar(self,id):
yabiaoDoubleTime = Game.res_mgr.res_common.get("yabiaoDoubleTime")
if not yabiaoDoubleTime:
return 0, errcode.EC_NORES
if str(id) not in self.player.yabiao.history:
return 0, errcode.EC_REVENGEHUSONG_NOIN
if self.player.yabiao.history[str(id)]["type"]!=0:
return 0, errcode.EC_REVENGEHUSONG_NOTYPE
res = Game.res_mgr.res_yabiao.get(self.player.yabiao.history[str(id)]["data"]["data"]["quality"])
if not res:
return 0, errcode.EC_NORES
from game.mgr.logicgame import LogicGame
proxy = get_proxy_by_addr(self.player.yabiao.history[str(id)]["data"]["addr"], LogicGame._rpc_name_)
if not proxy:
return 0, errcode.EC_GETD_LOGIC_PROXY_ERR
fdata = self.player.GetFightData()
bhname = ""
from game.mgr.guild import get_rpc_guild
rpc_guild = get_rpc_guild(self.player.guild.GetGuildId())
if rpc_guild:
bhname = rpc_guild.getName()
historydata={"id":self.player.id,"endtime":0,"name":self.player.name,"data":{"quality":self.player.yabiao.history[str(id)]["data"]["data"]["quality"],"power":self.player.base.fa,"bhname":bhname,"sex":self.player.base.GetSex()}}
resp = proxy.revengeHusongCar(self.player.id,{"id":self.player.yabiao.history[str(id)]["data"]["id"]},fdata,historydata)
if not resp:
return 0, errcode.EC_CALL_LOGIC_PROXY_ERR
self.player.yabiao.modfiyHistoryFinish(id)
respBag = {}
fightResult = resp["fightLog"]["result"].get("win", 0)
if fightResult:
mul=1
currHour = gtime.current_hour()
if currHour in yabiaoDoubleTime.arrayint1:
mul=2
reward = {}
for kk, vv in res.rob.items():
reward[kk]=vv*mul
respBag = self.player.bag.add(reward, constant.ITEM_ADD_REVREWARD, wLog=True)
dUpdate = self.player.packRespBag(respBag)
dUpdate["jiebiao"] = self.player.yabiao.to_init_data()
resp["allUpdate"] = dUpdate
return 1, resp
