def wakuangFight(self, name, redFight, blueList, sredhp, sid):
from game.mgr.player import get_rpc_player
blueFight = []
sbluehp = {}
for pid in blueList:
other = get_rpc_player(pid)
if other:
blueFight.append(
other.GetFightData(constant.BATTLE_ARRAY_TYPE_NORMAL))
sbluehp[pid] = other.wakuangHpGet()
# print '!!!!!!!!!!BBB',redFight,blueList,blueFight
fightobj = Game.fight_mgr.createFight(constant.FIGHT_TYPE_220)
fightobj.init_players_by_data(redFight, blueFight)
allTeamHp = {}
if not fightobj.teamIsAllDead(sredhp):
# print '===============red is not all dead!'
allTeamHp[constant.FIGHT_TEAM_RED] = sredhp
if not fightobj.teamIsAllDead(sbluehp):
# print '===============blue is not all dead!'
allTeamHp[constant.FIGHT_TEAM_BLUE] = sbluehp
fightobj.FixFighterHP(allTeamHp)
fightobj.SetRounds(30)
fightLog = fightobj.doFight(1)
fightResult = fightLog["result"].get("win", 0)
redhp = fightLog["resultInfo"][constant.FIGHT_TEAM_RED]
bluehp = fightLog["resultInfo"][constant.FIGHT_TEAM_BLUE]
if fightobj.teamIsAllDead(redhp):
redhp = {}
if fightobj.teamIsAllDead(bluehp):
bluehp = {}
# 打包返回信息
resp = {
"fightLog": fightLog,
}
for pid in blueList:
other = get_rpc_player(pid)
if other:
other.wakuangHpSet(bluehp.get(pid, {}))
if fightResult:
resp["attack"] = 0
other.wakuangFightLog(resp)
else:
other.wakuangFightBack(name, sid)
resp["redhp"] = redhp
# from corelib.data import json_dumps
# Game.glog.log2File("wakuangFight", "%s" % json_dumps(fightLog))
return resp
def beKill(self, atkInfo, isTimeout=1):
self.rid = 0 # 占领者id(rid, int)
self.sex = 0 # 占领者性别(sex, int)
self.name = "" # 占领者名称(name, string)
self.fa = 0 # 占领者战力(fa, int)
self.portrait = 0 # 占领者头像
self.headframe = 0 # 占领者头像框
self.time = 0 # 占领结束时间戳(time, int)
self.status = 3
if isTimeout: #占坑到时间击杀
pid = atkInfo.get("pid", 0)
# 给击杀者发放奖励
from game.mgr.player import get_rpc_player
killer = get_rpc_player(pid, offline=False)
if killer:
killer.sendYwBossKillReward(self.id, _no_result=True)
# 调用所有逻辑服 通知玩家boss被击杀
for addr, logic in Game.rpc_logic_game:
if logic:
logic.YwBossBeKill(self.id, _no_result=True)
self.markDirty()
if self.occupier_timer:
self.occupier_timer.kill(block=False)
self.occupier_timer = None
def kfbossFight(self, robid, data, fdata, historydata):
from game.mgr.player import get_rpc_player
proxy = get_rpc_player(data["id"])
if not proxy:
return
return proxy.kfbossFight(robid, data, fdata, historydata)
def jiujiyishouFightPush(self, id, jiujiyishouId, fbId, fightLog):
from game.mgr.player import get_rpc_player
proxy = get_rpc_player(id)
if not proxy:
return
proxy.jiujiyishouFightPush(jiujiyishouId, fbId, fightLog)
def revengeHusongCar(self, robid, data, fdata, historydata):
from game.mgr.player import get_rpc_player
proxy = get_rpc_player(data["id"])
if not proxy:
return
return proxy.revengeHusongCar(robid, data, fdata, historydata)
def diaoyuRank(self, index, data):
reward = {}
res = Game.res_mgr.res_diaoyurank.get(index + 1, None)
if not res:
res = Game.res_mgr.res_common.get("diaoyuRankReward")
reward = res.arrayint2
else:
reward = res.reward
mailRes = Game.res_mgr.res_mail.get(constant.MAIL_ID_DIAOYU_REWARD,
None)
content = mailRes.content % str(index + 1)
Game.rpc_mail_mgr.sendPersonMail(int(data["id"]),
mailRes.title,
content,
reward,
push=False)
from game.mgr.player import get_rpc_player
proxy = get_rpc_player(data["id"])
if not proxy:
return
proxy.diaoyuCleanScore()
def diaoyuRob(self, robid, data, fdata, historydata):
from game.mgr.player import get_rpc_player
proxy = get_rpc_player(data["id"])
if not proxy:
return
return proxy.diaoyuRob(robid, data, fdata, historydata)
def groupPKLevelReward(self, data):
from game.mgr.player import get_rpc_player
for rid, one in data.items():
player = get_rpc_player(rid)
if not player:
continue
player.groupPKLevelReward(one)
def jiujiyishouResp(self, id):
from game.mgr.player import get_rpc_player
proxy = get_rpc_player(id)
if not proxy:
return
proxy.jiujiyishouResp()
def to_detail_info(self):
#玩家离线清除
if self.rid:
from game.mgr.player import get_rpc_player
player = get_rpc_player(self.rid, offline=False)
if not player:
if self.occupier_timer:
self.occupier_timer.kill(block=False)
self.occupier_timer = None
self.rid = 0 # 占领者id(rid, int)
self.sex = 0 # 占领者性别(sex, int)
self.name = "" # 占领者名称(name, string)
self.fa = 0 # 占领者战力(fa, int)
self.portrait = 0 # 占领者头像
self.headframe = 0 # 占领者头像框
self.time = 0 # 占领结束时间戳(time, int)
resp = {}
resp["id"] = self.id
resp["curHp"] = self.curHp
resp["maxHp"] = self.maxHp
resp["rid"] = self.rid
resp["sex"] = self.sex
resp["name"] = self.name
resp["time"] = self.time
resp["status"] = self.status
resp["portrait"] = self.portrait
resp["headframe"] = self.headframe
return resp
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
def jiujiyishouIn(self, id, jiujiyishouId, ppid, addr):
from game.mgr.player import get_rpc_player
proxy = get_rpc_player(id)
if not proxy:
return
return proxy.jiujiyishouIn(jiujiyishouId, ppid, addr)
def levelContestRankReward(self, data):
resAct = Game.res_mgr.res_activity.get(constant.ACTIVITY_LEVEL_CONTEST)
serverInfo = Game.rpc_server_info.GetServerInfo()
if not resAct.isOpen(serverInfo):
return
onlines = Game.player_mgr.players.keys()
# 发放上榜玩家
from game.mgr.player import get_rpc_player
# data {段位:{rid:名次}
for level, rankDict in data.items():
resDict = None
mailId = None
if level == constant.LEVEL_CONTEST_LV_1:
resDict = Game.res_mgr.res_levelContestRankReward1
mailId = constant.MAIL_ID_LEVEL_CONTEST_RANK_1
elif level == constant.LEVEL_CONTEST_LV_2:
resDict = Game.res_mgr.res_levelContestRankReward2
mailId = constant.MAIL_ID_LEVEL_CONTEST_RANK_2
elif level == constant.LEVEL_CONTEST_LV_3:
resDict = Game.res_mgr.res_levelContestRankReward3
mailId = constant.MAIL_ID_LEVEL_CONTEST_RANK_3
elif level == constant.LEVEL_CONTEST_LV_4:
resDict = Game.res_mgr.res_levelContestRankReward4
mailId = constant.MAIL_ID_LEVEL_CONTEST_RANK_4
elif level == constant.LEVEL_CONTEST_LV_5:
resDict = Game.res_mgr.res_levelContestRankReward5
mailId = constant.MAIL_ID_LEVEL_CONTEST_RANK_5
mailRes = Game.res_mgr.res_mail.get(mailId, None)
if not resDict or not mailRes:
continue
for rid, rank in rankDict.items():
if rid in onlines:
onlines.remove(rid)
rewardRes = None
for res in resDict.itervalues():
if res.min <= rank <= res.max:
rewardRes = res
break
if rewardRes:
content = mailRes.content % str(rank)
Game.rpc_mail_mgr.sendPersonMail(rid,
mailRes.title,
content,
rewardRes.rankReward,
push=False)
player = get_rpc_player(rid)
if player:
player.setLevelContestRankRewardFlag()
Game.glog.log2File("levelContestReward",
"%s|%s" % (config.serverNo, data))
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
def wakuangGetHpInt(self, pids):
from game.mgr.player import get_rpc_player
hp = []
for pid in pids:
other = get_rpc_player(pid)
if other:
v = other.wakuangGetHpInt()
hp.append(v)
return hp
def GET(self):
data = web.input(_method='GET')
uid, cid, rmb, test = int(data.get('uid', "0")), int(data.get('cid', "0")), int(data.get('rmb', "0")), int(data.get('test', '0'))
print(uid, cid, rmb, test)
player = get_rpc_player(uid)
if not player:
return constant.CHARGE_INSIDE_ERR_NOTFOUND_PLAYER
return ujson.dumps({"result":player.charge2player(cid,rmb, test)})
def enterGuild(self, type, playerInfo):
guildlvRes = Game.res_mgr.res_guildlv.get(self.level)
if not guildlvRes:
return 0, errcode.EC_NORES
if len(self.members) >= guildlvRes.peoplenum:
return 0, errcode.EC_GUILD_MEMBER_MAX
pid = playerInfo.get("rid", 0)
applyDict = self.GetApplyDict()
if type == 1:
if pid in applyDict:
return 0, errcode.EC_GUILD_HAS_APPLY
# 如果有设置 自动入帮战力，自动入帮
fa = playerInfo.get("fa", 0)
if self.autoEnter and fa >= self.autoFa:
self.addMember(playerInfo)
from game.mgr.player import get_rpc_player
rpc_player = get_rpc_player(pid)
rpc_player.sendEnterGuild(self.id, _no_result=1)
else:
applyDict[pid] = playerInfo
self.SetApplyDict(applyDict)
self.markDirty()
# 推送给帮会管理
guildInfo = {"red": 1}
from game.mgr.player import get_rpc_player
for member in self.members.values():
if member.GetJob(
) != constant.GUILD_MEMBER_TYPE_3 and member.time == 0:
rpc_player = get_rpc_player(member.pid, offline=False)
if rpc_player:
rpc_player.sendGuildRed(guildInfo, _no_result=1)
else:
if pid not in applyDict:
return 0, errcode.EC_GUILD_NOT_APPLY
applyDict.pop(pid)
self.SetApplyDict(applyDict)
self.markDirty()
return 1, None
def respGuild(self, myId, pid, type):
member = self.members.get(myId)
if not member:
return 0, errcode.EC_NO_GUILD
if member.GetJob() == constant.GUILD_MEMBER_TYPE_3:
return 0, errcode.EC_GUILD_OPER_LIMIT
applyDict = self.GetApplyDict()
if pid not in applyDict:
return 0, errcode.EC_GUILD_NOT_APPLY
playerInfo = applyDict.pop(pid)
self.SetApplyDict(applyDict)
if type == 1:
guildlvRes = Game.res_mgr.res_guildlv.get(self.level)
if not guildlvRes:
return 0, errcode.EC_NORES
#人数满员
if len(self.members) >= guildlvRes.peoplenum:
return 0, errcode.EC_GUILD_MEMBER_MAX
#已经加入公会
from game.mgr.player import get_rpc_player
rpc_player = get_rpc_player(pid)
if rpc_player.isInGuild():
return 0, errcode.EC_GUILD_HAS_JOIN
self.addMember(playerInfo)
rpc_player.sendEnterGuild(self.id, _no_result=1)
# 推送给帮会管理
guildInfo = {"red": 1 if len(self.GetApplyDict()) else 0}
for member in self.members.values():
if member.GetJob(
) != constant.GUILD_MEMBER_TYPE_3 and member.time == 0:
rpc_player = get_rpc_player(member.pid, offline=False)
if rpc_player:
rpc_player.sendGuildRed(guildInfo, _no_result=1)
self.markDirty()
return 1, len(self.members)
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
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
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, {}
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
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
def guildSx(self, pid, sxId):
member = self.members.get(pid)
if not member:
return 0, errcode.EC_NO_GUILD
guildlvRes = Game.res_mgr.res_guildlv.get(self.level)
if not guildlvRes:
return 0, errcode.EC_NORES
sxRes = Game.res_mgr.res_guildSx.get(sxId)
if not sxRes:
return 0, errcode.EC_NORES
iSxNum = self.GetSXNum()
if iSxNum >= guildlvRes.guildSxNum:
return 0, errcode.EC_GUILD_SX_MAX_NUM
#增加上香次数
iSxNum += 1
self.SetSXNum(iSxNum)
#增加香火值
iProgress = self.GetSXProgress()
iProgress += sxRes.addNum
if iProgress > guildlvRes.sxMaxNum:
iProgress = guildlvRes.sxMaxNum
self.SetSXProgress(iProgress)
#增加帮会资金
self.addExp(sxRes.addExp)
#上香日志
logs = self.GetSXLogs()
now = int(time.time())
logs.append({"time": now, "name": member.name, "id": sxId})
self.SetSXLogs(logs)
self.markDirty()
#同步所有人香火值
from game.mgr.player import get_rpc_player
guildInfo = {
"sxBar": iProgress,
"sxNum": iSxNum,
}
for pid, member in self.members.items():
if member.time:
continue
rpc_player = get_rpc_player(pid)
if rpc_player:
rpc_player.sendGuildSxPush(guildInfo, _no_result=1)
return 1, (iProgress, iSxNum)
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 gongchengNotiyGuild(self, guildid, cityid, atk):
nowtime = time.time()
rpc_guild = get_rpc_guild(guildid)
if not rpc_guild:
return
from game.mgr.player import get_rpc_player
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(cityid, atk, nowtime)
def POST(self):
dataJson = web.data()
data = ujson.loads(dataJson)
pid = int(data.get("pid", "0"))
action = data.get("action", 0) # 1 封号 2解封号 3禁言 3解禁言
print(pid, action)
if pid:
player = get_rpc_player(pid)
if not player:
return ujson.dumps({"result": constant.CHARGE_INSIDE_ERR_NOTFOUND_PLAYER})
if action == 1:
player.block()
elif action == 2:
player.unBlock()
elif action == 3:
player.shutup()
elif action == 4:
player.unShutup()
return ujson.dumps({"result": constant.SYNCSERVER_CODE_1})
def new(self, title, content, attachment, addTime, show=False, push=True):
self.maxMid += 1
mail = Mail(self.maxMid,
title,
content,
attachment,
addTime,
show=show)
self.inbox[self.maxMid] = mail
if len(self.inbox) > constant.MAX_MAIL:
self.inbox.popitem(last=False)
if push:
from game.mgr.player import get_rpc_player
player = get_rpc_player(self.pid, offline=True)
if player:
player.sendMail(mail.getBriefInfo())
Game.glog.log2File(
"newMail", "%s|%s|%s|%s|%s|%s" %
(self.pid, self.maxMid, title, content, attachment, addTime))
self.markDirty()
self.markActive()
def event_half_hours(self):
falist = self.getRankList(constant.RANK_TYPE_FA)
atk3 = 0
icount = 0
for one in falist:
if 3 == icount:
break
icount += 1
pid = one.get("id", 0)
# atk3+=v["fight"]
proxy = get_rpc_player(pid)
if not proxy:
continue
atk3 += proxy.getAtk()
if atk3 < 30000:
atk3 = 30000
if icount == 0:
icount = 1
atk = int(atk3 / icount)
spawn(self.SetAtk, atk)
def saveLevelContestFightLog(self, rid, saveLog):
from game.mgr.player import get_rpc_player
player = get_rpc_player(rid)
if not player:
return
player.saveLevelContestFightLog(saveLog)
