class PlayerWaitBag(object):
""" 待收取物品列表 """
TYPE_TO_LOG = {
WAITBAG_TYPE_HITFATE: ITEM_FETCH_HITFATE,
WAITBAG_TYPE_TIMEBOX: ITEM_FETCH_TIMEBOX,
WAITBAG_TYPE_EMAIL: ITEM_FETCH_EMAIL,
}
VALID_TYPES = (tuple, list, set)
def __init__(self, player):
if 0:
from game.player.player import Player
self.player = Player()
self.items = {}
self.types = {}
self.player = player
def uninit(self):
self.player = None
self.items = {}
self.types = {}
def add(self, witem):
wid = witem.data.id
self.items[wid] = witem
ids = self.types.setdefault(witem.data.type, [])
ids.append(wid)
def delete(self, wid):
if not self.items.has_key(wid):
return
witem = self.items.pop(wid)
wtype = witem.data.type
ids = self.types[wtype]
ids.remove(wid)
if not ids:
self.types.pop(wtype)
witem.delete(self.player._game.rpc_store)
def deletes(self, type):
witems = self.types.get(type)
if not witems:
return
del_wids = []
for id in witems[:]:
self.delete(id)
del_wids.append(id)
return del_wids
def load(self):
""" 加载数据 """
store = self.player._game.rpc_store
querys = dict(pid=self.player.data.id)
waits = store.query_loads(TN_P_WAIT, querys)
for w in waits:
item = WaitItem(adict=w)
self.add(item)
def load_item(self, wid):
""" 动态加载待收物品 """
if wid in self.items:
return
data = self.player._game.rpc_store.load(TN_P_WAIT, wid)
if data:
item = WaitItem(adict=data)
self.add(item)
return item
def save(self):
store = self.player._game.rpc_store
for key in self.items.keys():
if key not in self.items:
continue
w = self.items[key]
w.save(store)
def clear(self):
store = self.player._game.rpc_store
for w in self.items.itervalues():
w.delete(store)
self.items.clear()
self.types.clear()
def copy_from(self, wait_bag):
items = {}
self.clear()
for i in wait_bag.items.itervalues():
ni = WaitItem(adict=i.data.to_dict())
ni.data.id = None
ni.data.pid = self.player.data.id
ni.save(self.player._game.rpc_store)
items[i.data.id] = ni.data.id
self.load()
return items
def to_dict(self):
return [i.to_dict() for i in self.items.itervalues()]
def get_log_type(self, wtype):
try:
return self.TYPE_TO_LOG[wtype]
except:
return 100 + wtype
def fetch(self, wtype, id=None, pack_msg=True, delete=True,
log_type=None):
""" 收取物品 """
if id is not None:
ids = [id]
else:
ids = self.types.get(wtype, None)
if not ids:
return False, errcode.EC_VALUE
ids = ids[:]
witems = [self.items[i] for i in ids if i in self.items]
if not witems:
return False, errcode.EC_NOFOUND
items = []
bag = self.player.bag
rid = 0
for witem in witems:
if not isinstance(witem.items, self.VALID_TYPES):
continue
items.extend(witem.items)
if witem.data.rid:
rid = witem.data.rid
#是否可添加
if not bag.can_add_items(items):
return False, errcode.EC_BAG_FULL
if log_type is None:
log_type = self.get_log_type(wtype)
#添加背包
bag_items = bag.add_items(items, log_type=log_type, rid=rid)
#删除
for item in witems:
if delete:
self.delete(item.data.id)
#时光盒数据特殊处理
if wtype == WAITBAG_TYPE_TIMEBOX:
ptbox_attr = self.player.play_attr.get(PLAYER_ATTR_TBOX)
if ptbox_attr[PT_CH]:
ptbox_attr[PT_CH] = 0
ptbox_attr[PT_WAITS] = []
if pack_msg:
return True, bag_items.pack_msg(del_wids=ids)
return True, bag_items
def _handle_type_data(self, type):
""" 处理特殊类型凌晨刷新的数据(主动发给客户端) """
#猎命
if type == WAITBAG_TYPE_HITFATE:
hfate = getattr(self.player.runtimes, PLAYER_ATTR_HITFATE)
if hfate.handle_pass_day(fetch=True):
resp_f = 'enterHitFate'
rs, data = hfate.enter()
if rs:
self.player.send_msg(resp_f, 1, data=data)
#时光盒
elif type == WAITBAG_TYPE_TIMEBOX:
ptbox = getattr(self.player.runtimes, TN_P_TBOX)
ch = ptbox.handle_pass_day(fetch=True)
if ch:
resp_f = 'tBoxEnter'
rs, data = ptbox.enter(ch)
if rs:
pack = pack_msg(resp_f, 1, data={'tbox':data.to_dict()})
else:
pack = pack_msg(resp_f, 0, data=data)
self.player.send_msg(pack)
def add_waitItem(self, aType, aItems):
""" 添加待收物品 """
if not isinstance(aItems, self.VALID_TYPES):
raise ValueError('add_waitItem:aItems mush list type')
oWaitItem = WaitItem.new(self.player.data.id, aType, aItems)
oWaitItem.save(self.player._game.rpc_store, forced=True)
self.add(oWaitItem)
return oWaitItem
class GMPlayer(object):
""" 对玩家的gm命令类 """
def __init__(self, gm, player):
self.player = player
self.gm = gm
self._raw_return = 0
if 0:
from game.player.player import Player
self.player = Player()
self.gm = GameMaster()
@contextmanager
def raw_return_context(self):
self._raw_return = 1
try:
yield
finally:
self._raw_return = 0
def info(self):
self.gm.log(player_info(self.player))
self.gm.log('*' * 10)
def clear_player(self, all=True, dels=tuple()):
self.player.clear(all=all, dels=dels)
self.gm.log(u'清理玩家数据成功')
def clear_bag(self):
self.player.bag.clear()
self.gm.log(u'清除玩家背包')
def clear_ally_tbox_team(self):
"""重置同盟组队炼妖"""
data = dict(bids=[], t=0, cr=0)
self.player.set_ally_tbox_data(data)
self.gm.log(u'重置同盟组队炼妖')
def copy(self, pid):
""" 完全复制玩家数据 """
if self.player.copy_player(pid):
self.gm.log(u'拷贝成功')
else:
self.gm.log(u'拷贝失败')
def clear_part_data(self, *args):
""" 部分指定删除 """
self.player.clear(all=False, dels=args[0])
self.gm.log(u'清理玩家部分数据成功')
def add_money(self, coin1, coin2=0, coin3=0, is_set=False, vip=False):
""" 增加金钱(coin1, coin2=0, coin3=0) """
data = self.player.data
self.player.add_coin(aCoin1=coin1,
aCoin2=coin2,
aCoin3=coin3,
is_set=is_set,
vip=vip,
log_type=COIN_ADD_GM)
self.gm.log(u'增加银币成功，角色当前(银币,元宝,绑元宝)数：(%s, %s, %s)', data.coin1,
data.coin2, data.coin3)
self.player.pack_msg_data(coin=1, send=1)
def tbox_change_data(self, chapter, tbids):
""" 修改时光盒数据 """
log.debug('chpteer--%s %s', chapter, tbids)
chapter_id = chapter + 1
self.player._game.tbox_mgr.init_player_tbox(self.player)
oPTbox = getattr(self.player.runtimes, TN_P_TBOX)
rs = oPTbox.gm_change_data(chapter_id, tbids)
if not rs:
self.gm.log(u'数据填入错误')
return
self.gm.log(u'时光盒数据更改成功')
def add_exp(self, exp):
""" 增加经验 """
self.player.add_exp(exp)
self.gm.log(u'增加经验成功:lv=%s, exp=%s', self.player.data.level,
self.player.data.exp)
self.player.pack_msg_data(exp=1, send=1)
def add_train(self, train):
""" 增加练历 """
self.player.add_train(train, log_type=TRAIN_GM)
self.gm.log(u'增加练历成功:%s', self.player.data.train)
self.player.pack_msg_data(train=1, send=1)
def add_re(self, num, chapter=0):
""" 刷新次数 1:时光盒，"""
self.player._game.tbox_mgr.init_player_tbox(self.player)
oPTbox = getattr(self.player.runtimes, TN_P_TBOX)
chapter += 1
for o in oPTbox.p_tboxs.itervalues():
if chapter == 1:
o.data.re1 = num
o.data.re2 = num
o.modify()
if chapter == o.data.chapter:
o.data.re1 = num
o.data.re2 = num
o.modify()
self.gm.log(u'时光盒刷新次数更新完成')
def awar_kill_monster(self):
""" 狩龙战 批量杀死地图上的所有npc """
rs, data = self.player._game.rpc_awar_mgr.gm_kill_monsters(
self.player.data.id)
if rs:
self.gm.log(u'成功杀完该地图上的npc')
else:
self.gm.log(u'秒杀失败，请检查是否进入战场')
def rest_daylucky(self, mnum, lucky_role=True):
""" 改变抽奖次数上线并重置抽奖 """
self.player._game.day_lucky_mgr.init_player_dayluck(self.player)
player_daylucky = getattr(self.player.runtimes, TN_P_DAYLUCKY)
player_daylucky.day_lucky.data.d['mdraw'] = mnum - 1
player_daylucky.day_lucky.data.d['ctime'] = int(time.time()) - 86400
if lucky_role:
player_daylucky.day_lucky.data.d['rids'] = []
player_daylucky.enter()
self.gm.log(u'抽奖修改成功！')
def add_bf_boxes(self, num):
""" 添加兵符任务 剩余箱子数目 """
self.player._game.bftask_mgr.init_player_bftask(self.player)
player_bftask = getattr(self.player.runtimes, PLAYER_ATTR_BFTASK)
max_boxes = self.player._game.bftask_mgr.bf_boxes(self.player.data.vip)
if num > max_boxes: num = max_boxes
player_bftask.bfTaskData.bs = num
self.gm.log(u'兵符任务剩余宝箱数目')
def add_fete_num(self, num, type=1):
""" 祭天次数增加 """
self.player._game.fete_mgr.init_player_fete(self.player)
player_fete = getattr(self.player.runtimes, PLAYER_ATTR_FETE)
if type == 1:
player_fete.feteData.n1 = 10 - 1 * num
else:
player_fete.feteData.n2 = 10 - 1 * num
self.gm.log(u'祭天次数更新完成')
def add_fate_num(self, num, type=1):
""" 猎命次数增加 """
self.player._game.hfate_mgr.init_player_hitfate(self.player)
player_hfate = getattr(self.player.runtimes, PLAYER_ATTR_HITFATE)
if type == 1:
if num > 50: num = 50
player_hfate.hitFateData.n1 = 50 - num
else:
if num > 20: num = 20
player_hfate.hitFateData.n2 = 20 - num
self.gm.log(u'猎命次数更新完成')
def del_tbox_news(self):
""" 清除时光盒所有战报 """
self.player._game.rpc_tboxnews_mgr.clear()
self.gm.log(u'清楚时光盒所有战报')
def del_deep(self):
""" 清除深渊 """
self.player._game.deep_mgr.clear(self.player)
self.gm.log(u'清除深渊数据')
def deep_jump(self, level):
""" 直接调整到深渊指定层 """
from game.mgr.deep import ET_NORMAL
self.player._game.deep_mgr.enter(self.player,
ET_NORMAL,
level=int(level))
self.gm.log(u'跳转成功')
def deep_buff(self, count):
""" 增加多少层buff """
deep = self.player._game.deep_mgr.init_player(self.player)
deep.add_buff(self.player._game.deep_mgr, floors=count)
self.gm.log(u'增加buff成功')
def set_player_attr(self, key, value):
""" 设置用户属性:cli_introstep """
self.player.play_attr.client_set(key, value)
self.gm.log(u'设置用户属性成功')
def add_wait_item(self, wtype, items):
""" 添加待收物品(wtype, items) items=列表对象 """
witem = self.player.wait_bag.add_waitItem(wtype, items)
self.gm.log(u'add_wait_item:%s', witem.to_dict())
def add_fate(self, fid, level=1, can_trade=False):
"""添加命格 """
item_mgr = self.player._game.item_mgr
fate = item_mgr.new_fate(fid, is_trade=can_trade)
fate.data.level = level
res_fate_level = self.player._game.res_mgr.fate_level_by_keys.get(
(fid, level))
if res_fate_level:
fate.data.exp = res_fate_level.exp
if self.player.bag.add_fate(fate) is None:
self.gm.log(u'命格(%d)添加失败', fid)
else:
self.gm.log(u'命格(%d)添加成功', fid)
self.player.pack_msg_data(fates=[fate], send=1)
return fate
def roleup_add_num(self, num):
""" 添加升段次数 """
self.player.roles.gm_add_num(num)
self.gm.log(u'升段次数更改成功')
def reset_gem_mine(self):
"""重置珠宝开采"""
self.player._game.gem_mgr.reset_mine(self.player)
self.gm.log(u'重置珠宝开采成功')
def add_gem(self, gid, level=1, is_trade=0):
"""添加珠宝"""
item_mgr = self.player._game.item_mgr
gem = item_mgr.new_gem(gid, level, is_trade=is_trade)
if gem is None:
self.gm.log(u'等级(%s)珠宝(%d)添加失败', level, gid)
if self.player.bag.add_gem(gem) is None:
self.gm.log(u'等级(%s)珠宝(%d)添加失败', level, gid)
self.gm.log(u'添加等级(%s)珠宝(%d)成功', level, gid)
return gem
def add_equip(self, eid, level=1, can_trade=False, forced=1):
""" 添加命格 """
item_mgr = self.player._game.item_mgr
equip = item_mgr.new_equip(eid, is_trade=can_trade)
equip.data.level = level
rs_equip = self.player.bag.add_equip(equip, forced)
if rs_equip is None:
self.gm.log(u'装备(%d)添加失败，背包已满', eid)
else:
self.gm.log(u'装备(%d)添加成功', eid)
self.player.pack_msg_data(equips=[rs_equip], send=1)
return equip
def wear_equip(self, rid, eid, is_base=1, send=1):
""" 穿戴装备(rid, id) """
equip = None
if is_base:
equips = self.player.bag.get_equips_by_eid(eid)
#no used
for e in equips:
if not e.data.used:
equip = e
break
else:
equip = self.player.bag.get_equip(eid)
role = self.player.roles.get_role_by_rid(rid)
if not (equip and role):
self.gm.log(u'装备(%d, %d)穿戴失败', rid, eid)
return
equip, res_equip = self.player.bag.get_equip_ex(equip.data.id)
rs, data = role.wear_equip(self.player, equip, res_equip)
if not rs:
self.gm.log(u'装备(%d, %d)穿戴失败', rid, eid)
else:
if send:
_, msg = data
self.player.send_msg(msg)
self.gm.log(u'装备(%d, %d)穿戴成功', rid, eid)
def add_item(self, aIid, aCount, can_trade=False):
"""添加物品 id_count = {id:count}"""
rs, c = self.player.bag.can_add_item(aIid, aCount, can_trade=can_trade)
if not rs:
self.gm.log(u'物品(%d, %d)添加失败', aIid, aCount)
return
res_item = self.player._game.item_mgr.get_res_item(aIid)
items = self.player.bag.add_item(aIid, aCount, can_trade=can_trade)
self.player.pack_msg_data(items=items, send=1)
self.gm.log(u'物品(%s, %d)添加成功', res_item.name, aCount)
def vip_level(self, level):
""" 改变vip等级 """
self.player.vip.vip = level
self.gm.log(u'vip等级改变到(%d)', level)
def vip_reward(self, rid):
"""设置gm命令的vip奖励"""
t_dics = self.player._game.rpc_vip_mgr.get_goods()
keys = [dic['rid'] for dic in t_dics]
rid = int(rid)
if rid not in keys:
keys.sort()
self.gm.log(u'设置失败, 目前的vip奖励ID可以是(%s)', keys)
return
coin = self.player._game.rpc_vip_mgr.get_good_coin(rid)
self.player.pay_back(rid, None, coin)
self.gm.log(u'vip奖励购买成功奖励ID是(%d)', rid)
def use_item(self, id):
""" 使用物品 """
rs, data = self.player.use_item(id)
if not rs:
self.gm.log(u'使用物品失败:%s', data)
return
self.player.send_update_msg(data)
self.gm.log(u'使用物品成功:%s', data)
def use_item_ex(self, iid):
""" 使用特定物品 """
ids, res_item = self.player.bag.get_item_ids_ex(iid)
if ids is None:
self.gm.log(u'物品不存在')
return
rs, data = self.player.use_item(ids[0])
if not rs:
self.gm.log(u'使用物品失败:%s', data)
return
self.player.send_update_msg(data)
self.gm.log(u'使用物品成功:%s', data)
def show_bag(self):
""" 显示背包物品列表 """
log = self.gm.log
log(u'玩家(%s)背包物品列表:', self.player.data.name)
def _logs(items, name):
for k, item in items.iteritems():
log(u' id:%s %s:%s', k, name, item.to_dict())
_logs(self.player.bag.items, u'物品')
_logs(self.player.bag.equips, u'装备')
_logs(self.player.bag.fates, u'命格')
_logs(self.player.bag.cars, u'坐骑')
def show_wait_bag(self):
""" 显示待收取物品列表 """
log = self.gm.log
log(u'玩家(%s)待收取物品列表:', self.player.data.name)
for k, witem in self.player.wait_bag.items.iteritems():
log(u' id:%d %s', k, witem.to_dict())
def update_bag(self, type_name, id, **kw):
""" 更新背包数据(type_name[items,equips,fates,cars], id, **kw) """
items = getattr(self.player.bag, type_name)
item = items.get(id)
item.update(kw)
self.gm.log(u'背包数据(%s)更新成功: %s', id, item.to_dict())
def add_arena_count(self, c):
"""增加竞技场次数"""
pid = self.player.data.id
self.player._game.rpc_arena_mgr.gm_add_count(pid=pid, c=c)
self.gm.log(u'玩家(%s)增加竞技场(%s)挑战次数', pid, c)
def change_arena_rank(self, rank):
""" 改变改玩家在竞技场的排名 """
pid = self.player.data.id
vip = self.player.data.vip
game = self.player._game
rid = game.rpc_arena_mgr.gm_get_rid_byrank(rank)
if not rid:
self.gm.log(u'调整失败！等级超出')
return
#保存战报
fp = '0'
fp_id = game.rpc_report_mgr.save(REPORT_TYPE_ARENA, [rid, pid], fp)
self.player._game.rpc_arena_mgr.gm_change_rank(pid, rid, fp_id, vip)
rplayer = game.rpc_player_mgr.get_rpc_player(pid)
if rplayer:
r_resp = 'arenaRivalEnd'
r_data = dict(rid=pid, isOK=1, fp_id=fp_id)
msg = pack_msg(r_resp, 1, data=r_data)
rplayer.send_msg(msg)
self.gm.log(u'调整成功！')
def add_role(self, rid, active=True):
""" 添加配将(rid, active=True) """
role, err = self.player.roles.invite(rid, gm=True)
if not role:
self.gm.log(u'增加配将(%s)失败:%s', rid, err)
return
if active and self.player.roles.can_come_back():
role.come_back()
self.gm.log(u'增加配将(%s)成功:%s', rid, role.to_dict())
def show_roles(self):
""" 显示配将信息 """
sleep(3)
log = self.gm.log
log(u'玩家(%s)配将列表:', self.player.data.name)
for k, role in self.player.roles.roles.iteritems():
log(u' id:%s %s', k, role.to_dict())
def show_play_data(self):
""" 显示角色信息 """
log = self.gm.log
log(u'玩家(%s)信息:', self.player.data)
def update_role(self, id, **kw):
""" 更新配将数据(id, **kw) """
role = self.player.roles.get_role(id)
role.update(kw)
self.gm.log(u'配将(%s)数据更新成功: %s', id, role.to_dict())
def del_player(self, pid):
""" 通过修发player表中的uid隐藏角色 """
self.player.data.uid = -self.player.data.uid
self.gm.log(u'删除角色成功')
def del_role(self, rid):
""" 删除玩家角色 """
rs, data = self.player.roles.del_role(rid, send_msg=1)
if not rs:
self.gm.log(u'删除配将失败')
else:
self.gm.log(u'删除配将成功')
def get_role(self, rid):
return self.player.roles.get_role_by_rid(rid)
def role_come_back(self, id):
""" 配将归队(id) """
role = self.player.roles.get_role(id)
role.come_back()
self.gm.log(u'增加配将(%s)归队成功!', id)
def position_study(self, pid):
""" 学习阵型 """
if self.player.positions.study(pid, forced=True):
self.gm.log(u'学习阵型成功')
def get_position(self, pid):
return self.player.positions.get_active()
def position_upgrade(self, id, level=None):
""" 升级阵型(level=None)可以通过level指定直接升级到特定等级 """
if self.player.positions.upgrade(id, level=level, forced=True):
self.gm.log(u'升级阵型成功')
def position_place(self, pid, rid, pos):
""" 布置某角色到某阵型位置 """
self.player.positions.place(pid, rid, pos)
def scene_enter(self, mapId):
""" 进入地图 """
if self.player.scene_enter(mapId):
self.gm.log(u'进入地图成功')
def upgrade(self, level, pub=True):
""" 升级到某级 """
self.player.upgrade(level, pub=pub)
def accept_tasks(self, utype=None, id_or_level=None):
if utype is None:
utype = TUL_LEVEL
id_or_level = self.player.data.level
self.player.task.accept_tasks(utype, id_or_level)
def task_clear_ids(self, ids):
ids = [int(item) for item in str(ids).split(',')]
self.player.task.clear_tids(ids)
self.gm.log(u'清理已完成任务列表成功')
def task_complete(self, tid):
task = self.player.task.get_task_by_tid(tid)
if task:
self.player.task.task_complete(task.data.id)
self.gm.log(u'完成任务成功')
def add_task(self, tid):
task = self.player.task.add_task(tid, forced=True, send_msg=True)
self.gm.log(u'添加任务成功:%s', task.to_dict())
def turn_task(self, tid, auto=1):
""" 转到特定任务
如果tid比当前完成的任务id小,会清理已完成任务列表内容
auto: 是否自动完成tid之前的所有任务id?
"""
self.player.task.turn_to(tid, auto_complete=auto)
def show_tasks(self):
""" 显示玩家任务信息 """
log = self.gm.log
log(u'玩家(%s)任务列表:', self.player.data.name)
for id, task in self.player.task.tids.iteritems():
log(u' id:%d %s', id, task.to_dict())
def reward(self, rid):
""" 直接获取奖励(rid) """
r = self.player._game.reward_mgr.get(rid)
if not r:
self.gm.log(u'获取奖励(%d)失败', rid)
return
sitems = r.reward(params=self.player.reward_params())
bag_items = self.player.bag.add_items(sitems, log_type=ITEM_ADD_GM)
bag_items.pack_msg(send=1)
self.gm.log(u'获取奖励列表:%s', sitems)
def kick(self):
""" 踢下线 """
self.player.user.logout()
self.gm.log(u'踢下线成功')
def attr_set(self, key, value):
self.player.play_attr.set(key, value)
def attr_get(self, key):
value = self.player.play_attr.get(key)
self.gm.log(u'%s', value)
def add_car(self, cid):
""" 添加坐骑 """
self.player.bag.add_car(cid)
self.gm.log(u'添加坐骑成功')
def car_do(self, cid):
""" 操作坐骑,骑或下马 """
if cid is 0:
self.player.car_do(cid)
self.gm.log(u'操作坐骑成功')
else:
car = self.player.bag.has_car(cid)
if car:
self.player.car_do(car.data.id)
self.gm.log(u'操作坐骑成功')
else:
self.gm.log(u'操作坐骑失败')
def set_allyboss_start(self, delay_time=300):
""" 开启同盟boss战，并清楚玩家该星期已参加boss战时间的属性 """
game = self.player._game
aid = game.rpc_ally_mgr.get_aid_by_pid(self.player.data.id)
if not aid:
self.gm.log(u'该玩家无同盟')
return
if game.rpc_boss_mgr.set_ally_start(aid, delay_time):
self.gm.log(u'同盟boss战开启成功')
else:
self.gm.log(u'同盟boss开启失败')
def fihgt_allyboss_clear(self):
""" 清楚该周已参加同盟boss的状态 """
tObjDict = self.player.play_attr.get(PLAYER_ATTR_BOSS)
tObjDict['jt'] = 0
self.player.play_attr.update_attr({PLAYER_ATTR_BOSS: tObjDict})
self.gm.log(u'成功更新状态')
def kill_boss(self, type=0):
""" 秒杀boss type=0 世界 type!=0 同盟 """
game = self.player._game
p_data = self.player.data
hurts = 999999999
if type:
aid = game.rpc_ally_mgr.get_aid_by_pid(p_data.id)
if not aid:
self.gm.log(u'该玩家无同盟')
return
game.rpc_boss_mgr.kill_boss(p_data.id, p_data.name, hurts, aid)
else:
game.rpc_boss_mgr.kill_boss(p_data.id, p_data.name, hurts)
self.gm.log(u'成功秒杀')
def one_hurt_boss(self, num):
""" 单次击杀世界boss """
game = self.player._game
p_data = self.player.data
game.rpc_boss_mgr.kill_boss(p_data.id, p_data.name, num)
self.gm.log(u'成功击杀怪物 %d 血', num)
def reset_shop(self):
""" 刷新神秘商店的物品 """
player_shop = self.player._game.shop_mgr.init_player_shop(self.player)
player_shop.gm_reset_items()
self.gm.log(u'成功重置')
def next_sign(self):
p_sign = self.player._game.day_sign_mgr.init_player(self.player)
p_sign.data.t = 0
p_sign.save(self.player._game.rpc_store, forced=True)
self.gm.log(u'成功重置')
def set_sign_day(self, day):
p_sign = self.player._game.day_sign_mgr.init_player(self.player)
p_sign.data.t = 0
p_sign.data.finish = min(15, int(day))
p_sign.save(self.player._game.rpc_store, forced=True)
if int(day) > 15:
return self.gm.log(u'成功重置, 设置的天数大于15 被设置为15')
self.gm.log(u'成功重置')
def bftask_clear(self):
""" 清楚玩家身上已接的兵符任务 """
tasks = self.player.task.tasks
for task in tasks.values():
tid = task.data.tid
res_task = self.player._game.res_mgr.tasks.get(tid)
if res_task is None or res_task.type != 3:
continue
self.player.task.del_task(task)
p_bftask = self.player._game.bftask_mgr.init_player_bftask(self.player)
p_bftask.bfTaskData.tids = []
p_bftask.bfTaskData.ss = []
p_bftask.bfTaskData.qs = []
p_bftask.bfTaskData.exps = []
p_bftask.bfTaskData.btid = 0
self.gm.log(u"清楚成功")
class PlayerWaitBag(object):
""" 待收取物品列表 """
TYPE_TO_LOG = {
WAITBAG_TYPE_HITFATE: ITEM_FETCH_HITFATE,
WAITBAG_TYPE_TIMEBOX: ITEM_FETCH_TIMEBOX,
WAITBAG_TYPE_EMAIL: ITEM_FETCH_EMAIL,
}
VALID_TYPES = (tuple, list, set)
def __init__(self, player):
if 0:
from game.player.player import Player
self.player = Player()
self.items = {}
self.types = {}
self.player = player
def uninit(self):
self.player = None
self.items = {}
self.types = {}
def add(self, witem):
wid = witem.data.id
self.items[wid] = witem
ids = self.types.setdefault(witem.data.type, [])
ids.append(wid)
def delete(self, wid):
if not self.items.has_key(wid):
return
witem = self.items.pop(wid)
wtype = witem.data.type
ids = self.types[wtype]
ids.remove(wid)
if not ids:
self.types.pop(wtype)
witem.delete(self.player._game.rpc_store)
def deletes(self, type):
witems = self.types.get(type)
if not witems:
return
del_wids = []
for id in witems[:]:
self.delete(id)
del_wids.append(id)
return del_wids
def load(self):
""" 加载数据 """
store = self.player._game.rpc_store
querys = dict(pid=self.player.data.id)
waits = store.query_loads(TN_P_WAIT, querys)
for w in waits:
item = WaitItem(adict=w)
self.add(item)
def load_item(self, wid):
""" 动态加载待收物品 """
if wid in self.items:
return
data = self.player._game.rpc_store.load(TN_P_WAIT, wid)
if data:
item = WaitItem(adict=data)
self.add(item)
return item
def save(self):
store = self.player._game.rpc_store
for key in self.items.keys():
if key not in self.items:
continue
w = self.items[key]
w.save(store)
def clear(self):
store = self.player._game.rpc_store
for w in self.items.itervalues():
w.delete(store)
self.items.clear()
self.types.clear()
def copy_from(self, wait_bag):
items = {}
self.clear()
for i in wait_bag.items.itervalues():
ni = WaitItem(adict=i.data.to_dict())
ni.data.id = None
ni.data.pid = self.player.data.id
ni.save(self.player._game.rpc_store)
items[i.data.id] = ni.data.id
self.load()
return items
def to_dict(self):
return [i.to_dict() for i in self.items.itervalues()]
def get_log_type(self, wtype):
try:
return self.TYPE_TO_LOG[wtype]
except:
return 100 + wtype
def fetch(self, wtype, id=None, pack_msg=True, delete=True, log_type=None):
""" 收取物品 """
if id is not None:
ids = [id]
else:
ids = self.types.get(wtype, None)
if not ids:
return False, errcode.EC_VALUE
ids = ids[:]
witems = [self.items[i] for i in ids if i in self.items]
if not witems:
return False, errcode.EC_NOFOUND
items = []
bag = self.player.bag
rid = 0
for witem in witems:
if not isinstance(witem.items, self.VALID_TYPES):
continue
items.extend(witem.items)
if witem.data.rid:
rid = witem.data.rid
#是否可添加
if not bag.can_add_items(items):
return False, errcode.EC_BAG_FULL
if log_type is None:
log_type = self.get_log_type(wtype)
#添加背包
bag_items = bag.add_items(items, log_type=log_type, rid=rid)
#删除
for item in witems:
if delete:
self.delete(item.data.id)
#时光盒数据特殊处理
if wtype == WAITBAG_TYPE_TIMEBOX:
ptbox_attr = self.player.play_attr.get(PLAYER_ATTR_TBOX)
if ptbox_attr[PT_CH]:
ptbox_attr[PT_CH] = 0
ptbox_attr[PT_WAITS] = []
if pack_msg:
return True, bag_items.pack_msg(del_wids=ids)
return True, bag_items
def _handle_type_data(self, type):
""" 处理特殊类型凌晨刷新的数据(主动发给客户端) """
#猎命
if type == WAITBAG_TYPE_HITFATE:
hfate = getattr(self.player.runtimes, PLAYER_ATTR_HITFATE)
if hfate.handle_pass_day(fetch=True):
resp_f = 'enterHitFate'
rs, data = hfate.enter()
if rs:
self.player.send_msg(resp_f, 1, data=data)
#时光盒
elif type == WAITBAG_TYPE_TIMEBOX:
ptbox = getattr(self.player.runtimes, TN_P_TBOX)
ch = ptbox.handle_pass_day(fetch=True)
if ch:
resp_f = 'tBoxEnter'
rs, data = ptbox.enter(ch)
if rs:
pack = pack_msg(resp_f, 1, data={'tbox': data.to_dict()})
else:
pack = pack_msg(resp_f, 0, data=data)
self.player.send_msg(pack)
def add_waitItem(self, aType, aItems):
""" 添加待收物品 """
if not isinstance(aItems, self.VALID_TYPES):
raise ValueError('add_waitItem:aItems mush list type')
oWaitItem = WaitItem.new(self.player.data.id, aType, aItems)
oWaitItem.save(self.player._game.rpc_store, forced=True)
self.add(oWaitItem)
return oWaitItem
class PlayerVip(object):
""" 玩家vip类 """
def __init__(self, player):
self.player = player
if 0:
from .player import Player
self.player = Player()
def uninit(self):
self.player = None
def _set_vip(self, value):
self.player.data.vip = value
self.update()
def _get_vip(self):
return self.player.data.vip
vip = property(_get_vip, _set_vip)
def load(self):
""" 初始化vip相关数据 """
#背包格子数
self.update()
def _send_reward(self, vip_lev):
""" 发送vip奖励 """
p = self.player
if self.vip > vip_lev:
log.info('player(%s) cur vip:%s, upgrade vip:%s', p.data.name, self.vip, vip_lev)
return
rw_mail = Game.res_mgr.reward_mails.get(RW_MAIL_VIP)
pid = p.data.id
for vip in xrange(self.vip + 1, vip_lev + 1):
try:
cont_dict = dict(vip=vip)
content = rw_mail.content % cont_dict
rid = get_vip_rid(vip)
t_rw = p._game.reward_mgr.get(rid)
if not t_rw:
log.info('vip reward_item is %s, please check data', t_rw)
continue
items = t_rw.reward(params=p.reward_params())
log.info('player(%s) vip_lv:%s send:%s', p.data.name, vip, items)
Game.mail_mgr.send_mails(pid, MAIL_REWARD, rw_mail.title,
RW_MAIL_VIP, items, param=content, rid=rid)
except:
log.log_except("the vip send_mail is error the vip level is:%s", vip)
def _init_vip_level(self):
""" 根据累计重置元宝数,确定vip等级
只升级,不降级,方便实现送vip等级等人为调整功能
"""
lv = self.player._game.vip_mgr.get_vip_level(self.player.data.vipCoin)
if lv > self.player.data.vip:
self.player.log_normal(PL_VIP_UPGRADE, lv=lv)
log.info('player(%s)vip level up:%s', self.player.data.name, lv)
self._send_reward(int(lv))
self.vip = lv
self.player.pub_vip_level()
def update(self):
p = self.player
game = p._game
mgr = game.vip_mgr
vip = self.vip
def first_charge(self, bag_item):
"""发送首冲奖励"""
rw_mail = Game.res_mgr.reward_mails.get(RW_MAIL_FIRST_CHARGE)
content = RW_MAIL_FIRST_CHARGE
pid = self.player.data.id
log.info("first_charge mailType:%s, pid:%s, items:%s", content, pid, bag_item)
if not bag_item:
return
Game.mail_mgr.send_mails(pid, MAIL_REWARD, rw_mail.title, content,
bag_item, param=rw_mail.content)
def pay_back(self, bag_items):
""" 支付回调,获取奖励 """
#_last = self.player.data.vipCoin
#调整vip
self.player.data.vipCoin += bag_items.coin2
#log.info("pay_back_vipCoin last:%s, now:%s", _last, self.player.data.vipCoin)
self._init_vip_level()
#支付奖励,马上保存
self.player.save(full=1)
#通知前端
resp_f = 'goodsGive'
data = dict(player=self.player.to_dict(),
data=bag_items.pack_msg(),
vipData=self.player.vip_attr.to_dict())
self.player.send_msg(pack_msg(resp_f, 1, data=data))
def copy_from(self, p_vip):
"""拷贝玩家数据"""
self.vip = p_vip.vip
