def online_add_sitexp(self):
""" 上线添加打坐经验 """
if self.online_rs is not None or self.player is None:
return
#离线前是否处于打坐状态
logout_time = self.sit_data.get(SIT_LOGOUT_TIME)
can_site_time, finish_site_time = self._get_time_exp(logout_time)
data ={}
if can_site_time > 0:
data = {'canSitTime':can_site_time}
#如打坐时间未超过上线 则继续打坐
if self.sit_data[SIT_START_TIME]:
start = self.sit_data[SIT_START_TIME]
else:
start = logout_time
self.sit_data[SIT_START_TIME] = start
tAddCnt = finish_site_time / self.fetch_exppre_time
self.online_rs = data
self._clear_logout_time()
if not tAddCnt:
return data
tAddExp = self._handle_exp(tAddCnt)
if tAddExp:
#添加经验
vip = self.player.data.vip
res_rate = self.vip_addexp(vip)
tAddExps = tAddExp + tAddExp * res_rate / 100
log.debug('player-sit-exp pid = %s, tAddExps = %s', self.player.data.id, tAddExps)
self.player.add_exp(tAddExps)
self.sit_data[SIT_EXP] += tAddExps
return data
def _loop(self, aFinishSitTime=0):
""" 按规定时间每一段时间获得一段经验
aFinishSitTime 为零时表示开始打坐
不为零 表示已打坐的时间
"""
tPerTime = self.fetch_exppre_time
is_online = aFinishSitTime
while self.is_sit:
aFinishSitTime += tPerTime
if aFinishSitTime > self.fetch_time_max:
self.stop_sit()
break
if is_online:
#上线打坐时算出第一次到达60s剩余的描述
sleep(tPerTime - aFinishSitTime % tPerTime)
is_online = False
else:
sleep(tPerTime)
#在线每两分钟的广播
self._sit_time += 60
if self._sit_time / 60 % 2 == 0:
self.player.pub(MSG_SIT_PER, 2)
#服务端检测位置是否发生变化
if self.start_sit_pos and self.start_sit_pos != self.player.data.pos:
log.debug('start_sit_pos = %s, change_pos = %s', self.start_sit_pos, self.player.data.pos)
self.stop_sit()
break
self.add_sit_exp()
def load(self):
""" 加载数据 """
v = self.player.play_attr.get(PLAYER_ATTR_SIT)
log.debug('player-login-exp1 pid = %s, exp = %s', self.player.data.id, self.player.data.exp)
if not v:
v = self.make_sit_data()
self.player.play_attr.set(PLAYER_ATTR_SIT, v)
self.sit_data = v
self._save_logout_time()
tResLevelExp = self._get_res_exp(self.player.data.level)
#vip提速
self.vip_addexp = self.fetch_res(SIT_ADD_EXP, SIT_ADD_EXP_V)
if not tResLevelExp or not tResLevelExp.siteExp:
return
#提前更新玩家状态
self._update_player_state()
#判断离线之前是否处于打坐状态，并且做处理
#延迟5秒 是因为此模块会抛出消息如果先执行别的模块获得不到消息
def _delay():
try:
self.online_add_sitexp()
except:
log.log_except()
if not self.player.no_game:
spawn_later(5, _delay)
def load(self):
self.d_quality = self._game.setting_mgr.setdefault(GEM_SANDING_QUALITY, GEM_SANDING_QUALITY_V)
self.d_level = self._game.setting_mgr.setdefault(GEM_SANDING_LEVEL, GEM_SANDING_LEVEL_V)
self.d_type = self._game.setting_mgr.setdefault(GEM_SANDING_TYPE, GEM_SANDING_TYPE_V)
self.d_rate = self._game.setting_mgr.setdefault(GEM_UPGRADE_RATE, GEM_UPGRADE_RATE_V)
self.max_level = int(self._game.setting_mgr.setdefault(GEM_MAX_LEVEL, GEM_MAX_LEVEL_V))
self.max_free = int(self._game.setting_mgr.setdefault(GEM_MINE_FREE_NUM, GEM_MINE_FREE_NUM_V))
self.max_coin = int(self._game.setting_mgr.setdefault(GEM_MINE_COIN3_NUM, GEM_MINE_COIN3_NUM_V))
self.mime_cost = self._game.setting_mgr.setdefault(GEM_MINE_COIN3_COST, GEM_MINE_COIN3_COST_V)
self.mine_reward = eval(self._game.setting_mgr.setdefault(GEM_MINE_REWARD, GEM_MINE_REWARD_V))
self.mine_reward_coin_num = int(self._game.setting_mgr.setdefault(GEM_MINE_REWARD_COIN_NUM,
GEM_MINE_REWARD_COIN_NUM_V))
self.mine_vip_level = int(self._game.setting_mgr.setdefault(GEM_MINE_VIP_LEVEL, GEM_MINE_VIP_LEVEL_V))
self.d_quality = str2dict3(self.d_quality)
self.d_quality = self.decode_data(self.d_quality)
self.d_level = str2dict3(self.d_level)
self.d_level = self.decode_data(self.d_level)
self.d_type = str2dict3(self.d_type)
self.d_type = self.decode_data(self.d_type)
self.d_rate = str2dict3(self.d_rate)
self.d_rate = self.decode_data(self.d_rate)
for gem in self._game.res_mgr.gem.itervalues():
k = (gem.type, gem.quality)
self.d_gid[k] = gem.id
log.debug('GemMgr inited')
def get_random_name(self, sex=None):
""" 根据性别取名 """
male = 1
if not hasattr(self, '_names_'):
#[<姓区间>, <男名区间>, <女名区间>]
self._names_ = [[0, 0], [0, 0], [0, 0]]
keys = self.names.keys()
keys.sort()
for k in keys:
n = self.names[k]
if n.t == 1:
rg = self._names_[0]
elif n.sex == male:
rg = self._names_[1]
else:
rg = self._names_[2]
if rg[0] == 0 or k < rg[0]:
rg[0] = k
if rg[1] == 0 or k > rg[1]:
rg[1] = k
log.debug('names range:%s', self._names_)
if sex is None:
sex = random.choice([1, 2])
xr = self._names_[0]
xi = random.randint(xr[0], xr[1])
mr = self._names_[1] if sex == male else self._names_[2]
mi = random.randint(mr[0], mr[1])
return '%s%s' % (self.names[xi].n, self.names[mi].n)
def _handle_bf_bestbox(self, rs_items):
""" 兵符任务宝箱开启获得极品装备广播 """
for rs_item in rs_items:
if rs_item[IKEY_TYPE] == IT_ITEM_STR and \
rs_item[IKEY_ID] in DIFF_TITEM_IDS:
continue
game = self.player._game
res_horn = game.res_mgr.hornmsgs.get(HORN_TYPE_BFBOX)
iid = rs_item[IKEY_ID]
type = ''
log.debug('errr------------ %s', rs_item)
item_type = rs_item[IKEY_TYPE]
if item_type == IT_EQUIP_STR:
res_eq = game.res_mgr.equips.get(iid)
res = game.res_mgr.equip_sets.get(res_eq.sid)
name = res_eq.name
elif item_type == IT_FATE_STR:
type = language.HORN_BFBOX_FATE
res = game.res_mgr.fates.get(iid)
name = res.name
elif item_type == IT_GEM_STR:
res = game.res_mgr.gem.get(iid)
name = res.name
else:
res = game.res_mgr.items.get(iid)
name = res.name
color = '#' + game.item_mgr.get_color(res.quality)
pc = self.get_player_color(self.player)
arg = dict(name=self.player.data.name, pcolor=pc, iname=name, color=color)
part_msg = res_horn.msg % arg
msg = "%s%s" % (part_msg, type)
game.rpc_horn_mgr.send(msg)
def complete(self, player_task, old_exp, old_level):
""" 兵符任务完成处理 """
self.completed = True
#记录
player_task.player.log_task(self.data.tid, self.data.id)
super(BFTask, self).complete(player_task, old_exp, old_level)
player = player_task.player
player_bftask = player._game.bftask_mgr.init_player_bftask(player)
bfTaskData = player_bftask.bfTaskData
if BFTASK_ALREADY_ACCEPT not in bfTaskData.ss:
log.debug('pid=%d bfTaskData= (%s, %s) tid=%d ttid=%d', player.data.id, bfTaskData.ss, bfTaskData.tids, self.data.id, self.data.tid)
return
index = bfTaskData.ss.index(BFTASK_ALREADY_ACCEPT)
q = bfTaskData.qs[index]
tExp = int(player_bftask.fetch_bf_exp[q])
bfTaskData.exp += tExp
bfTaskData.ss[index] = BFTASK_TYPE_FINISH
bfTaskData.btid = 0
if player.data.level > old_level:
tExpLevel = player._game.res_mgr.exps_by_level.get(old_level+1)
addExp = tExpLevel.exp - old_exp + player.data.exp
else:
addExp = player.data.exp - old_exp
bfTaskData.exps[index] = addExp
player.pub(MSG_TASK_FINISH, TT_OFFER)
player.task.p_attr_task[TASK_BFTASK_FINISH] += 1
def rc_dayLuckDraw(self, index):
""" 每日抽奖进行抽奖 """
log.debug('rc_dayluckDarw == %s' % index)
resp_f = 'dayLuckDraw'
rs, data = self.player._game.day_lucky_mgr.day_luck_draw(self.player, index)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def player_logout(self, pid):
""" 玩家退出监听 """
self.exit_room(pid)
rs, is_win = self.room_mgr.player_logout(pid)
log.debug('is--win %s, rs %s pid %s', pid, rs, is_win)
if rs and is_win:
self.win_pids.append(pid)
self.clear_player_data(pid)
def _on_client_accept(self, sock, addr):
""" 处理玩家登陆请求 """
log.debug(u'client发起连接(%s)', addr)
_rpc = ClientRpc(sock, addr, self)
_rpc.call_link_rpc = True
_rpc.start()
sleep(120)
_rpc.stop()#该链接只用于登录接口,之后断开
def test_app_store():
from webapi import app_store
apple_urls = "['sandbox.itunes.apple.com', None, '/verifyReceipt']"
#apple_urls = ['buy.itunes.apple.com', 443, '/verifyReceipt']
store = app_store.AppStore(apple_urls)
s = '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'
rs = store.pay(s, 'com.vqw.zdzltw.c60')
log.debug('app_store:%s', rs)
assert rs[0]
def add_player(self, player):
""" 玩家进入游戏 """
pid = player.data.id
rs = Game.rpc_player_mgr.add(self.key, pid, player.data.name, player.data.rid, player.data.uid)
if not rs:
return False
self.players[pid] = player
log.debug('sub_player_mgr.add_player:%s', pid)
return True
def _thread(pool):
while pool.started:
task = pool.getTask()
try:
task()
except:
#TODO 添加到log
log.debug("多线程战报写入错误")
pass
def del_player(self, player):
""" 玩家退出 """
pid = player.data.id
if pid not in self.players:
return
log.debug('sub_player_mgr.del_player:%s', pid)
assert self.players[pid] == player, 'player != p'
self.players.pop(pid)
Game.rpc_player_mgr.delete(self.key, pid, player.data.uid)
self.safe_pub(MSG_LOGOUT, player)
def pub_floor(self, player, floor):
""" 抛出当前到达的最高层事件 """
#进入大厅不用广播
if not floor:
return
log.debug('enter----floor-------%s', floor)
pid = player.data.id
floor_max = self._enter_floor_max.get(pid)
if not floor_max or floor_max < floor:
self._enter_floor_max[pid] = floor
Game.rpc_horn_mgr.safe_pub(MSG_DEEP_FLOOR, pid, floor)
def _check_rid_fate(self, rid, fate1, fate2):
""" 检测玩家是否穿此命格 """
role = self.roles.get(rid)
used = 0
for key, fid in role.iter_fates():
if fid == fate1.data.id or fid == fate2.data.id:
used += 1
if used and used == fate1.data.used + fate2.data.used:
return True, None
log.debug('check-rid-fate rid %s, fate1 %s, fate2 %s', rid, fate1.data.id, fate2.data.id)
return False, errcode.EC_ROLE_WEARED
def init(self):
log.debug('------stop-----')
self.room_mgr = RoomMgr()
#开战后守龙战 {pid:守龙战1...}
#self.sky_wars = {}
#开战后降世战 {pid:降世战1...}
#self.world_wars = {}
#降世战组的保存 {组id:组的对象}
self.groups = {}
#保存已获胜的玩家
self.win_pids= []
def _check(self, boss, check_data, hurt, pid):
""" 伤害值检测 """
p_level, join_nums, m_atk = check_data
boss_def = boss.get_boss_def()
hurt1 = m_atk * (1 - boss_def * math.sqrt(p_level*10)
/(boss_def * p_level + p_level * p_level * 180))
check_hurt = join_nums * 5 * hurt1 * 3
if check_hurt < hurt:
log.debug('world_boss_finish - pid %d check_hurt %s, hurt %s, check-data %s', pid, check_hurt, hurt, check_data)
return False
return True
def auto_choose_node(self):
""" 时间到自动选择路线 """
n = 0
while not self.is_choose:
sleep(1)
n += 1
if n > self.fetch_choose_time :
log.debug('time out !! %s, %s, %s', self.room.pids, self.is_choose, n)
war_node = self.group.auto_choose(self.war_node)
self.choose_node(war_node, NODE_TYPE_MONSTER)
break
def _process(self, data):
msgs = self._unpacker.unpack(data)
if DEBUG_PACK: log.debug('read data:%s, msgs=%s', len(data), msgs)
for m in msgs:
tag = m.pop('_tag')
full_name = m['f']
func = self._get_handle(full_name)
if func:
corelib.spawn(self._call_func, func, tag, m)
else:
self.send(self.pack_msg(full_name, 0, err=1, tag=tag))
def _test_boss(name):
print 'name --- %s', name
player = enter(name, host, port)
player.valid_gm()
log.debug(u'玩家(%s)进入', name)
while 1:
player.chat.chat_send(1, u'(%s)世界测试', player.name)
sleep(2)
player.chat.chat_send(2, u'(%s)世界测试', player.name)
sleep(2)
player.chat.chat_send(2, u'(%s)世界测试', player.name)
sleep(2)
def rc_goodsBuy(self, t, gid):
""" 购买商品 """
log.debug('[rc_goodsBuy](%s)(%s, %s)', self.player.data.id, t, gid)
resp_f = 'goodsBuy'
rs, data = self.player._game.rpc_vip_mgr.buy_goods(
t, gid, self.player.data.uid, self.player.data.id)
if not rs:
return pack_msg(resp_f, 0, err=data)
gorder, price, good_id = data
return pack_msg(resp_f,
1,
data=dict(gorder=gorder, price=price, gid=good_id))
def _notice_data(self, l_sec):
""" 广播数据 包括世界boss剩余血量和排名 """
#log.debug('(%s)WorldBoss_notice_data %s', self.data.blid, l_sec)
hp_resp_f = 'bossHp'
rank_resp_f = 'bossRank'
hp_time = self.fetch_hp_time
c = self.fetch_rank_time / hp_time
sleep(l_sec)
tmp = 0
self.is_start = is_win =True
while not self.gm_stoped:
sleep(hp_time)
msg = pack_msg(hp_resp_f, 1, data={'hp':self.boss_hp, 'mhp':self.max_hp})
Game.rpc_player_mgr.player_send_msg(self.enter_pids, msg)
#log.debug('world hp enter_pids %s %s', self.boss_hp, self.enter_pids)
if self.boss_hp <= 0:
break
if self.boss_start + self.fetch_world_boss_times < time.time():
is_win = False
break
tmp += 1
if tmp != c:
continue
tmp = 0
rs, data = self._get_rank()
#log.debug('world_rank %s', data)
if not rs:
continue
msg = pack_msg(rank_resp_f, 1, data=data)
Game.rpc_player_mgr.player_send_msg(self.enter_pids, msg)
self.boss_mgr.w_start_boss = None
log.debug('is_win------- %s, gm %s, join-player %s', is_win, self.gm_stoped, len(self.pid_hurts))
if self.gm_stoped:
is_win = False
#if is_win:
#更改为不管怪物是否死都发奖励
try:
#发放奖励
self._reward()
#vip不参加也发奖励
self._reward_vip()
except:
log.log_except()
#写入log 记录伤害
self._log_info()
#清楚数据
self._clear_data()
#记录数据
self.save_data(is_win)
if self.boss_mgr.gm_wboss:
self.boss_mgr.gm_wboss = False
self.boss_mgr.gm_start = False
self.gm_stoped = False
def time_start(self):
""" 根据当前时间和配置表数据对应开启活动 """
now_sec = common.current_time() - common.zero_day_time()
for res_config in self.res_warstart_configs.itervalues():
notice_time = res_config.stime - res_config.ntime
if notice_time <= now_sec < res_config.etime:
self.warstart_config = res_config
l_sec = now_sec - res_config.stime
spawn(self._notice, l_sec)
log.debug('start----- %s, %s', res_config.stime, res_config.type)
return True
return False
def handle_score(self, num, type):
""" 获取分数 """
res_awar_scores = Game.res_mgr.awar_world_score_bykeys.get(type)
l = res_awar_scores.keys()
l.sort()
index = bisect.bisect_left(l, num)
if index >= len(l):
log.debug('res-err-----------type %s,index %s, l-%s',type, index, l)
return 0
key = l[index]
res_awar_score = res_awar_scores[key]
return res_awar_score.score
def auto_choose_node(self):
""" 时间到自动选择路线 """
n = 0
while not self.is_choose:
sleep(1)
n += 1
if n > self.fetch_choose_time:
log.debug('time out !! %s, %s, %s', self.room.pids,
self.is_choose, n)
war_node = self.group.auto_choose(self.war_node)
self.choose_node(war_node, NODE_TYPE_MONSTER)
break
def loop_connon(self):
""" 处理打炮 """
if not self.connon2data or self.war_mgr.war_data.war_end:
return
log.debug('loop_connon----------- %s', self.connon2data)
now = common.current_time()
hurt_pids = []
for index, (pid, use_time) in self.connon2data.items():
if now < use_time + self.ctime:
continue
hurt_pids.append(pid)
self.connon2data.pop(index)
return hurt_pids
def rc_awarGetBox(self):
""" 获取宝箱 """
resp_f = 'awarGetBox'
pid = self.player.data.id
log.debug('rc_awarGetBox --pid %s', pid)
rs, data, war_type = self.player._game.rpc_awar_mgr.get_box(pid)
log.debug('rc_awarGetBox -- %s', data)
if rs is False:
return pack_msg(resp_f, 0, err=data)
rs, data = self.reward(data, war_type=war_type)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def gm_kill_monsters(self, pid):
""" 秒杀制定玩家该战场出现的怪物 """
if not self.war_data.show_npcids:
return False, None
log.debug('gm---kill pid-%s, npcids-%s', pid, self.war_data.show_npcids)
kill_npcids = self.war_data.show_npcids[:]
for npcid in kill_npcids:
log.debug('npcid---- %s', npcid)
if npcid == self.war_data.b_npcid:
continue
self.war_monster_start(pid, npcid)
self.war_monster_end(pid, npcid, 1, 0)
return True, None
def send_msg(self, resp_f, data, remove_pid=0, send_pids=None):
""" 主动发给客户端的数据 """
msg = pack_msg(resp_f, 1, data=data)
if not send_pids:
if self.war_data:
send_pids = self.war_data.war_pids[:]
else:
send_pids = self.room.pids[:]
if remove_pid and remove_pid in send_pids:
send_pids.remove(remove_pid)
if send_pids:
log.debug('broad-- pids-%s, resp_f-%s, data- %s', send_pids, resp_f, msg)
Game.rpc_player_mgr.player_send_msg(send_pids, msg)
def time_start(self):
""" 根据当前时间和配置表数据对应开启活动 """
now_sec = common.current_time() - common.zero_day_time()
for res_config in self.res_warstart_configs.itervalues():
notice_time = res_config.stime - res_config.ntime
if notice_time <= now_sec < res_config.etime:
self.warstart_config = res_config
l_sec = now_sec - res_config.stime
spawn(self._notice, l_sec)
log.debug('start----- %s, %s', res_config.stime,
res_config.type)
return True
return False
def handle_score(self, num, type):
""" 获取分数 """
res_awar_scores = Game.res_mgr.awar_world_score_bykeys.get(type)
l = res_awar_scores.keys()
l.sort()
index = bisect.bisect_left(l, num)
if index >= len(l):
log.debug('res-err-----------type %s,index %s, l-%s', type, index,
l)
return 0
key = l[index]
res_awar_score = res_awar_scores[key]
return res_awar_score.score
def rc_awarSkyInvite(self, msg):
""" 守龙战邀请同盟加入战斗 """
from game.mgr.chat import CT_ALLY
resp_f = 'awarSkyInvite'
pid = self.player.data.id
log.debug('rc_awarSkyInvite --pid %s, %s', pid, msg)
aid = self.player._game.rpc_ally_mgr.get_aid_by_pid(pid)
if not aid:
pack_msg(resp_f, 0, err=errcode.EC_PLAYER_NO)
msg = PlayerAllyHandler.WAR_SKY_HEAD + msg
rs, data = self.player._game.chat_mgr.chat_send(
self.player, CT_ALLY, msg)
return pack_msg(resp_f, 1)
def loop_connon(self):
""" 处理打炮 """
if not self.connon2data or self.war_mgr.war_data.war_end:
return
log.debug('loop_connon----------- %s', self.connon2data)
now = common.current_time()
hurt_pids = []
for index, (pid, use_time) in self.connon2data.items():
if now < use_time + self.ctime:
continue
hurt_pids.append(pid)
self.connon2data.pop(index)
return hurt_pids
def _check(self, boss, check_data, hurt, pid):
""" 伤害值检测 """
p_level, join_nums, m_atk = check_data
boss_def = boss.get_boss_def()
hurt1 = m_atk * (1 - boss_def * math.sqrt(p_level * 10) /
(boss_def * p_level + p_level * p_level * 180))
check_hurt = join_nums * 5 * hurt1 * 3
if check_hurt < hurt:
log.debug(
'world_boss_finish - pid %d check_hurt %s, hurt %s, check-data %s',
pid, check_hurt, hurt, check_data)
return False
return True
def one_finish(self, pid, name, hurt):
""" 单场boss战结束 """
if self.boss_hp <= 0:
return False, EC_BOSS_FINISH
now = int(time.time())
#防范短时间内多次提交
finish_time = self.finish_time.get(pid)
if finish_time and now - finish_time < self.fetch_boss_safetimes:
return False, EC_BOSS_CD
max_hp = self._get_max_hp()
rhurt = hurt / float(max_hp) * 100
if rhurt >= 5:
log.debug('world--boss---(pid, one_hurt) = (%d, %d)', pid, hurt)
old_boss_hp = self.boss_hp
self.finish_time[pid] = now
self.pid_hurt[pid] = hurt
if self.pid_hurts.has_key(pid):
self.pid_hurts[pid] += hurt
else:
self.pid_hurts.setdefault(pid, hurt)
#排名
self._handle_rank(pid, name)
rs, data = self._get_rank()
#扣血要在排名数据后
self.boss_hp -= hurt
#boss剩余血量的广播
if not self.aid:
self.handle_horn(HORN_TYPE_WORLDBOSSHP,
pid=pid,
pname=name,
old_boss_hp=old_boss_hp)
else:
self.handle_horn(HORN_TYPE_ALLYBOSSHP,
pid=pid,
pname=name,
old_boss_hp=old_boss_hp,
aid=self.aid)
if self.boss_hp <= 0:
self.boss_hp = 0
#世界boss最后一击广播
if not self.aid:
self.handle_horn(HORN_TYPE_WORLDBOSSEND, pid=pid, pname=name)
else:
self.handle_horn(HORN_TYPE_ALLYBOSSEND,
pid=pid,
pname=name,
aid=self.aid)
if self.pid_hurts.has_key(pid):
data.update({'hurt': self.pid_hurts[pid]})
#Game.rpc_boss_mgr.world_boss_cdend(pid)
return True, data
def login(self, user):
""" 登录 """
log.debug('player(%s-%s) login, sns(%s)', self.data.id, self.data.name,
user.sns_type)
self.logon_time = int(time.time())
self.log_normal(PL_LOGIN, u=self.data.uid, ip=self._rpc.addr[0])
self.user = user
self.save_time = int(time.time())
self.load()
if self.is_guide:
self._init_guide()
self.logined = True
self.init()
self.safe_pub(MSG_LOGON)
def rc_awarCopyStart(self, ancid):
""" 击杀影分身开始 """
resp_f = 'awarCopyStart'
pid = self.player.data.id
log.debug('rc_awarCopyStart --pid %s', pid)
rs, data = self.player._game.rpc_awar_mgr.war_copy_start(pid, ancid)
if rs is False:
return pack_msg(resp_f, 0, err=data)
rpid, pbuff = data
rs, info = self.player._game.player_mgr.look(rpid)
if not rs:
return pack_msg(resp_f, 0, err=info)
info.update(dict(pbuff=pbuff))
return pack_msg(resp_f, 1, data=info)
def send_msg(self, resp_f, data, remove_pid=0, send_pids=None):
""" 主动发给客户端的数据 """
msg = pack_msg(resp_f, 1, data=data)
if not send_pids:
if self.war_data:
send_pids = self.war_data.war_pids[:]
else:
send_pids = self.room.pids[:]
if remove_pid and remove_pid in send_pids:
send_pids.remove(remove_pid)
if send_pids:
log.debug('broad-- pids-%s, resp_f-%s, data- %s', send_pids,
resp_f, msg)
Game.rpc_player_mgr.player_send_msg(send_pids, msg)
def rc_loginSNS(self, t, sid, session, UDID, DT,
MAC='', DEV='', VER='', **kw):
""" 平台登录接口 """
resp_f = 'loginSNS'
if not self.area_legal():
return pack_msg(resp_f, 0, err=errcode.EC_LOGIN_AREA_ERR)
if not self.is_debug_time():
return pack_msg(resp_f, 0, err=errcode.EC_LOGIN_DEBUG_TIME)
log.debug(u'平台(%s)用户登录请求:%s, %s, %s, %s, %s, %s, %s, %s',
t, sid, session, UDID, DT, MAC, DEV, VER, kw)
if self.count >= self.max_players:
return pack_msg(resp_f, 0, err=errcode.EC_TEAM_ROLE_FULL)
if not sid and t not in SNS_LOGINS:#游客登录
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
#u = Game.rpc_store.query_loads(TN_USER, dict(UDID=UDID, name=''))
else:
rs, data = self.sns_client.login(t, sid, session)
if not rs:
return pack_msg(resp_f, 0, err=data)
if data:#login返回sid
sid = data
u = UserData.user_by_sns(t, sid)
if not u:
#不存在自动增加
u = self._new_user(t, sid, '', UDID, DT, MAC, DEV, VER)
else:
u = u[0]
u = User(adict=u)
#如果mac地址不同,记录
if u.data.UDID != UDID or u.data.DT != DT or \
u.data.DEV != DEV or \
u.data.MAC != MAC or u.data.VER != VER:
def _log_mac():
if 1: #强制保存更新信息, not u.data.MAC:
u.data.UDID = UDID
u.data.DT = DT
u.data.MAC = MAC
u.data.DEV = DEV
u.data.VER = VER
u.save(Game.rpc_store)
else:
self.glog(PM_MAC, u=u.data.id,
UDID=UDID, MAC=MAC, DEV=DEV, VER=VER)
spawn(_log_mac)
params = self._get_login_params(sid, u.data.id, t)
log.debug(u'loginSNS finish:%s', params)
return pack_msg(resp_f, 1, data=params)
def kill_boss(self, pid, name, hurts, aid=0):
""" 秒杀boss aid=0 世界 aid!=0同盟"""
if aid:
boss_id = self.a_bosses.get(aid)
a_boss = self.bosses.get(boss_id)
if not a_boss:
return False
a_boss.one_finish(pid, name, hurts, is_cd=False)
return True
if not self.w_start_boss:
return True
rs = self.w_start_boss.one_finish(pid, name, hurts, is_cd=False)
log.debug('kill_boss=rs----- %s', rs)
return True
def gm_kill_monsters(self, pid):
""" 秒杀制定玩家该战场出现的怪物 """
if not self.war_data.show_npcids:
return False, None
log.debug('gm---kill pid-%s, npcids-%s', pid,
self.war_data.show_npcids)
kill_npcids = self.war_data.show_npcids[:]
for npcid in kill_npcids:
log.debug('npcid---- %s', npcid)
if npcid == self.war_data.b_npcid:
continue
self.war_monster_start(pid, npcid)
self.war_monster_end(pid, npcid, 1, 0)
return True, None
def _test_one(name):
tasks.append(name)
try:
p = enter(name, host, port)
log.debug(u'玩家(%s)进入', name)
p.valid_gm()
while 1:
_test(name, p, TESTS[:], func_times)
#close(p.user)
except KeyboardInterrupt:
wait_event.set()
except:
log.log_except()
finally:
tasks.remove(name)
def get_scene_key(self, player, map):
""" 获取场景key,如:
同盟地图, key=ally_id
"""
t = map.type
if t in MAP_ALLYS:#返回同盟id
key = SCENE_ALLY + str(player.ally_id)
return key
if t in MAP_ALLY_WAR:
room_key = self._game.rpc_awar_mgr.get_roomkey_by_pid(player.data.id)
log.debug('room_key %s, pid %s', room_key, player.data.id)
if room_key:
return "%s%d%s" % (SCENE_ALLY, player.ally_id, room_key)
print 'player--------',player.ally_id
return "%s%s" % (SCENE_ALLY, player.ally_id)
def start_apns(self, pem_data, pem_path, sandbox, **sslargs):
""" start apns """
import apns
if self.apns_started:
return
import zlib, base64
pem_data = zlib.decompress(base64.b64decode(pem_data))
self.apns_pem = fn = join(pem_path, 'apns.pem')
log.debug(self.apns_pem)
with open(fn, 'wb') as f:
f.write(pem_data)
self.apns = apns.NotificationService(sandbox=sandbox,
certfile=fn, **sslargs)
self.apns.start()
def _handle_request(self, tag, procId, params):
""" 消息处理 """
# log.debug("_handle_request(%s):tag(%d):procId(%d):%s", self.player_id, tag, procId, params)
fname = params[FIELD_FUNC]
func = getattr(self.export, '%s%s' % (self.PRE, fname), None)
if func is None:
print("======找不到协议=====",fname)
self._handle_exception(procId, fname, EC_NOFOUND)
return
st=time.time()
try:
kw = params[FIELD_DATA]
with self:
if kw is not None: rs = func(**kw)
else: rs = func()
if rs is None:
log.debug("_handle_resp(%s):tag(%d):procId(%d): ok(%s) data(%s)", self.player_id, tag, procId, 1, rs)
return
ok, data = rs
# log.debug("_handle_resp(%s):tag(%d):procId(%d): ok(%s) data(%s)", self.player_id, tag, procId, ok, data)
if not ok:
self._handle_exception(procId, fname, data)
else:
if data is None:
data = '[]'
self.resp(procId, fname, RES_OK, data, 0)
except GreenletExit:
log.error("[Processer(%s-%s)] stoped. _handle_msg:func(%s)", self.pid, self.player_id, fname)
except:
log.log_except("_handle_msg:func(%s) %s", fname, params)
self._handle_exception(procId, fname, EC_VALUE)
et=time.time()
us=et-st
if fname not in STATISTICS:
STATISTICS[fname]={"max":us,"avg":us,"num":1,"tot":us,"n":fname}
else:
max=STATISTICS[fname]["max"]
if us>max:
max=us
STATISTICS[fname]["num"]+=1
STATISTICS[fname]["max"]=max
STATISTICS[fname]["avg"]=int((STATISTICS[fname]["avg"]+us)/2)
STATISTICS[fname]["tot"]=STATISTICS[fname]["num"]*STATISTICS[fname]["avg"]
def start_apns(self, pem_data, pem_path, sandbox, **sslargs):
""" start apns """
import apns
if self.apns_started:
return
import zlib, base64
pem_data = zlib.decompress(base64.b64decode(pem_data))
self.apns_pem = fn = join(pem_path, 'apns.pem')
log.debug(self.apns_pem)
with open(fn, 'wb') as f:
f.write(pem_data)
self.apns = apns.NotificationService(sandbox=sandbox,
certfile=fn,
**sslargs)
self.apns.start()
def new(cls, mgr, aid):
_, (hard, cfire, ctime,
gtime) = Game.rpc_ally_mgr.get_boat_init_params(aid)
#gtime, ctime, cfire, hard = 60, 10, 40, 30000
#cfire = 500000
#ctime = 4
log.debug('--------- %s, %s, %s, %s', gtime, ctime, cfire, hard)
o = cls()
o.war_mgr = mgr
o.cannon = mgr.fetch_mcannon
o.gtime = gtime
o.ctime = ctime
o.cfire = cfire
o.hard = hard
o.mhard = hard
return o
def get_scene_key(self, player, map):
""" 获取场景key,如:
同盟地图, key=ally_id
"""
t = map.type
if t in MAP_ALLYS: #返回同盟id
key = SCENE_ALLY + str(player.ally_id)
return key
if t in MAP_ALLY_WAR:
room_key = self._game.rpc_awar_mgr.get_roomkey_by_pid(
player.data.id)
log.debug('room_key %s, pid %s', room_key, player.data.id)
if room_key:
return "%s%d%s" % (SCENE_ALLY, player.ally_id, room_key)
print 'player--------', player.ally_id
return "%s%s" % (SCENE_ALLY, player.ally_id)
def _remove_logic(self, app, app_exist=True):
pid, game = self.logics.pop(app, None)
log.debug('remove_logic:%s, %s', pid, game)
#self.mgr.apps.pop(app, None)
#反注册
try:
if game:
Game.unreg_other_game(game.get_addr())
except:
log.log_except()
if app_exist:
game.stop()
app.stop()
app.get_service().stop()
spawn(self.mgr._del_game, app)
spawn_later(5, self.mgr._del_subgame, pid, app)
def rc_awarMosterEnd(self, ancid, isWin, hurts=0):
""" 击杀怪物结束 """
resp_f = 'awarMosterEnd'
pid = self.player.data.id
log.debug('rc_awarMosterEnd --pid %s, ancid %s, iswin %s', pid, ancid,
isWin)
rs, data = self.player._game.rpc_awar_mgr.war_monster_end(
pid, ancid, isWin, hurts)
log.debug('rc_awarMosterEnd -- %s', data)
if not rs:
return pack_msg(resp_f, 0, err=data)
if data is None:
return pack_msg(resp_f, 1)
rs, data = self.reward(data)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def new_logic(self):
""" 新建游戏逻辑进程 """
log.info(u'新建游戏逻辑进程')
mgr = self.mgr
app, pid = mgr._new_subgame(self._get_key())
name = mgr._app_register(app, new_logic_game)[0]
game = app.get_proxy(name)
self.mgr.init_subgame(app)
game.init()
game.start()
self.logics[app] = pid, game
#注册
Game.reg_other_game(game, pid)
log.debug('new_logic:%s, %s', pid, game)
app.sub_close(self._on_close)
spawn_later(1, self.mgr._new_game, app, game, pid)
return app
def loop_data_cbe(self, cbe_rank):
""" 战斗力排名数据载入 """
while 1:
cbe_fields = [CONST_PID, CONST_CBE]
cbe_sort_by = [(CONST_CBE, DESCENDING)]
cbe_list = cbe_rank.query(TN_P_ATTR, cbe_fields, limit=TIMES_NUMS,
sort_by=cbe_sort_by, rpc=CONST_RPC_STORE)
player_fields = [CONST_NAME, CONST_LEVEL, CONST_RID]
cbe_rank.queryByList(cbe_list, CONST_PID, TN_PLAYER, player_fields,
rpc=CONST_RPC_STORE)
del_key_list = [CONST_ID]
cbe_rank.getRet(cbe_list, CONST_PID, del_key_list, type=RANK_CBE)
sleep(0.1)
if not cbe_rank.is_next:
self.player_cbe_data = cbe_rank.data
log.debug("rank--load--data--cbe")
break
def hard_broad(self, book_data=None, boss_data=None):
""" 广播天舟耐久度 """
if self.war_mgr.war_data.war_end:
return
resp_f = 'awarHardB'
data = dict(hard=self.hard)
if book_data:
data.update(dict(type=HARD_TYPE_BOOK, mhard=self.mhard))
if boss_data:
boss_hurts = boss_data
desc = self.war_mgr.fetch_boat_desc % dict(hurt=boss_hurts)
#desc = 'boss 袭击了天舟 天舟失去了 %d 耐久度' % boss_hurts
data.update(dict(desc=desc, type=HARD_TYPE_BOSS))
self.war_mgr.send_msg(resp_f, data)
if self.hard <= 0:
log.debug('self.hard %s', self.hard)
self.war_mgr.war_result_borad(ALLY_WAR_FAIL_HARD)
def save_data(self, is_win):
""" boss数据的保存 """
#log.debug('boss--end--is_win %s', is_win)
self.data.c += 1
if not is_win:
self.save(Game.rpc_store, forced=True)
return
self.data.deads += 1
res_boss_level = Game.res_mgr.boss_level.get(self.data.blid)
key = (res_boss_level.mid, res_boss_level.level + 1)
res_boss_level_up = Game.res_mgr.boss_level_by_midlevel.get(key)
log.debug('kill-time %s', common.current_time() - self.boss_start)
if common.current_time() - self.boss_start < self.fetch_bosskill_time or\
self.data.deads >= res_boss_level_up.deads:
self.data.blid = res_boss_level_up.id
self.data.deads = 0
self.save(Game.rpc_store, forced=True)
def start(self, init=False):
if not self.stoped:
return
init_setting()
if not self.is_start: #开启自动启动线程
if self._auto_start_task is None:
self._auto_start_task = spawn_later(0, self._auto_start)
return
log.debug(u'arena_mgr start!')
spawn(self.lood_save)
Game.setting_mgr.sub(MSG_RES_RELOAD, self.reload)
if init:
self.init()
else:
self.load()
self.arena_reward()
Game.chat_mgr.sys_send(language.ARENA_START)
self.stoped = False
def logout(self):
""" 登出 """
log.debug('player(%s-%s) logout', self.data.id, self.data.name)
self._handler.close_handler()
self.log_normal(PL_LOGOUT)
try:
self._logout()
except:
log.log_except(u'player(%s) logout error', self.data.name)
logout_time = int(time.time())
self.data.tTotal += logout_time - self.logon_time
self.data.tLogin = self.logon_time
self.data.tLogout = int(time.time())
self.save()
self._runtimes_exec('logout', lambda obj: obj.logout(self))
self.logined = False
self.user.player_logout()
self.uninit()
def gm_start_activity(self, war_type, time=300):
""" gm开启活动 """
if time > 300:
time = 300
self.stop_activity()
now_sec = common.current_time() - common.zero_day_time()
for res_warstart in self.res_warstart_configs.itervalues():
if war_type == res_warstart.type:
self.warstart_config = copy.copy(res_warstart)
self.warstart_config.etime = now_sec + 60 * 60
start_time = now_sec + time
self.warstart_config.stime = start_time
log.debug('gm-start----- %s, %s', start_time,
res_warstart.type)
break
l_sec = self.warstart_config.stime - now_sec
if l_sec <= self.warstart_config.ntime:
spawn(self._notice, l_sec)
def iter_servers(self, sids=None):
self._init_servers()
if sids is None:
sids = self.servers.keys()
for sid in sids:
if sid not in self.servers:
continue
s = self.servers.get(sid)
host, port = s.host, s.port
log.debug('iter_servers, host:%s, port:%s', host, port)
rpc_client = with_timeout(3,
grpc.get_proxy_by_addr, (host, port - 1),
'rpc_client',
timeout_value=None)
if not rpc_client:
continue
#缓存代理类,保持连接一段时间
self.rpc_caches.set(sid, rpc_client)
yield sid, rpc_client
