def uninit(self):
self.player = None
self.rpc = None
if 0:
from game.player import player as player_md
self.player = player_md.Player()
self.rpc = ClientRpc()
def init_app(self):
""" 初始化 """
global aes_encrypt
from game import aes_encrypt as game_aes_encrypt, ClientRpc
from game.store.define import GF_CLIENTRPC_AESKEY
client_rpc_aes_key = model.logon_store.get_config(GF_CLIENTRPC_AESKEY)
ClientRpc.aes_init(client_rpc_aes_key, pack=1)
aes_encrypt = game_aes_encrypt
def __init__(self, player):
if 0:
from game.player import player as player_md
self.player = player_md.Player()
self.rpc = ClientRpc()
self.player = player
self.active = True
self.rpc = None
self._lock = RLock()
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 _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 connect(self, host, port):
self.rpc = ClientRpc.rpc_client(host, port, self)
self.rpc.raw_call_func()
self.rpc.start()
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import os
from gevent.event import AsyncResult
from corelib import log
from game import ClientRpc, pack_msg, AbsExport
sys_encoding = os.environ['sys_encoding']
if os.environ.get('CYGWIN', ''):
sys_encoding = 'utf-8'
import config
AES = 1
if AES:
ClientRpc.aes_init(config.client_rpc_aes_key, unpack=1)
class Client(AbsExport):
def __init__(self):
self.rpc = None
self.listeners = []
self.waits = {}
def add_listener(self, listener):
if listener in self.listeners:
return
self.listeners.append(listener)
def del_listener(self, listener):
if listener not in self.listeners:
def connect(self, host, port):
self.rpc = ClientRpc.rpc_client(host, port, self)
self.rpc.raw_call_func()
self.rpc.start()
#!/usr/bin/env python
# -*- coding:utf-8 -*-
import os
from gevent.event import AsyncResult
from corelib import log
from game import ClientRpc, pack_msg, AbsExport
sys_encoding = os.environ['sys_encoding']
if os.environ.get('CYGWIN', ''):
sys_encoding = 'utf-8'
import config
AES = 1
if AES:
ClientRpc.aes_init(config.client_rpc_aes_key, unpack=1)
class Client(AbsExport):
def __init__(self):
self.rpc = None
self.listeners = []
self.waits = {}
def add_listener(self, listener):
if listener in self.listeners:
return
self.listeners.append(listener)
def del_listener(self, listener):
if listener not in self.listeners:
return
def __init__(self):
Player._wrefs[id(self)] = self
self.data = PlayerData()
self._game = Game.instance
if self._game is None:
self._game = Game
Player.no_game = True
self.user = None
self._rpc = None
self._disable_send = 0
self._proxy = None
self.logined = False
self.save_time = 0
self._save_lock = RLock()
#保存其它的运行期对象 player保存时,调用对象方法: obj.save(store)
self.runtimes = CustomObject()
#保存角色退出时需要调用清理方法的对象
self.logout_objs = set([])
#场景
self.rpc_scene = None
#物品列表
self.bag = Bag(self)
#待收取物品列表
self.wait_bag = PlayerWaitBag(self)
#配将
self.roles = PlayerRoles(self)
#任务信息
self.task = PlayerTask(self)
#玩家属性
self.play_attr = PlayerAttr(self)
#玩家阵型
self.positions = PlayerPositions(self)
#玩家打坐
self.sit = PlayerSit(self)
#玩家地图信息
self.maps = PlayerMap(self)
#邮件
self.mail = PlayerMail(self)
#buff
self.buffs = PlayerBuff(self)
#vip
self.vip = PlayerVip(self)
#大喇叭
self.hron = PlayHornMgr(self)
#玩家成就信息(每日成就， 永久成就)
self.achievement = PlayerAchievement(self)
#角色属性
self.property = PlayerProperty(self)
#玩家胜利战斗id(仅内存中，不存数据库,为防止作弊)
self.win_fights = IntBiteMap()
self.vip_attr = PlayerVipAttr(self)
#ally = {'aid': 同盟ID, 'n': 同盟名字}
self.ally = None
self.other_init()
if 0:
from game.scene.scene import Scene
self.user = User()
self._rpc = ClientRpc()
self._game = Game()
self.rpc_scene = Scene()
class Player(actions.PlayerActionMixin):
_wrefs = weakref.WeakValueDictionary()
Data = PlayerData
no_game = False
@classmethod
def new_player(cls, player_dict):
""" 新建玩家,初始化数据 """
p = cls()
p.data.update(player_dict)
p.save(full=False)
return p
@classmethod
def load_player(cls, pid):
""" 根据pid,加载创建player对象,必须在逻辑进程执行 """
p = cls()
if not p.data.load_from_pid(pid):
return
p.load_p()
return p
@classmethod
def del_player(cls, pid, data=None):
""" 删除玩家数据 """
if data is None:
data = Game.rpc_store.load(TN_PLAYER, pid)
if data is None:
return False
player = cls()
player.data.update(data)
player.load()
player.clear()
Game.rpc_store.delete(TN_PLAYER, player.data.id)
Game.rpc_player_mgr.del_player(pid)
return True
def __init__(self):
Player._wrefs[id(self)] = self
self.data = PlayerData()
self._game = Game.instance
if self._game is None:
self._game = Game
Player.no_game = True
self.user = None
self._rpc = None
self._disable_send = 0
self._proxy = None
self.logined = False
self.save_time = 0
self._save_lock = RLock()
#保存其它的运行期对象 player保存时,调用对象方法: obj.save(store)
self.runtimes = CustomObject()
#保存角色退出时需要调用清理方法的对象
self.logout_objs = set([])
#场景
self.rpc_scene = None
#物品列表
self.bag = Bag(self)
#待收取物品列表
self.wait_bag = PlayerWaitBag(self)
#配将
self.roles = PlayerRoles(self)
#任务信息
self.task = PlayerTask(self)
#玩家属性
self.play_attr = PlayerAttr(self)
#玩家阵型
self.positions = PlayerPositions(self)
#玩家打坐
self.sit = PlayerSit(self)
#玩家地图信息
self.maps = PlayerMap(self)
#邮件
self.mail = PlayerMail(self)
#buff
self.buffs = PlayerBuff(self)
#vip
self.vip = PlayerVip(self)
#大喇叭
self.hron = PlayHornMgr(self)
#玩家成就信息(每日成就， 永久成就)
self.achievement = PlayerAchievement(self)
#角色属性
self.property = PlayerProperty(self)
#玩家胜利战斗id(仅内存中，不存数据库,为防止作弊)
self.win_fights = IntBiteMap()
self.vip_attr = PlayerVipAttr(self)
#ally = {'aid': 同盟ID, 'n': 同盟名字}
self.ally = None
self.other_init()
if 0:
from game.scene.scene import Scene
self.user = User()
self._rpc = ClientRpc()
self._game = Game()
self.rpc_scene = Scene()
def init(self):
if not self.is_guide:
self.property.update_CBE()
def uninit(self):
""" 清理数据,防止内存泄露 """
#log.debug('player(%s)uninit', self.data.id)
def _uninit(obj):
try:
if hasattr(obj, 'uninit'):
obj.uninit()
else:
obj.player = None
obj._player = None
except:
log.log_except()
self.message_clear()
_uninit(self.bag)
del self.bag
_uninit(self.wait_bag)
del self.wait_bag
_uninit(self.roles)
del self.roles
_uninit(self.task)
del self.task
_uninit(self.play_attr)
del self.play_attr
_uninit(self.positions)
del self.positions
_uninit(self.sit)
del self.sit
_uninit(self.maps)
del self.maps
_uninit(self.mail)
del self.mail
_uninit(self.buffs)
del self.buffs
_uninit(self.vip)
del self.vip
_uninit(self.hron)
del self.hron
_uninit(self.achievement)
del self.achievement
_uninit(self.property)
del self.property
del self.win_fights
_uninit(self.vip_attr)
del self.vip_attr
self._game = None
self._runtimes_exec('', _uninit)
def _rpc_proxy_(self):
""" 返回对应的代理对象 """
if self._proxy is None:
self._proxy = self.user.mgr.get_player_proxy(self.data.id)
return self._proxy
def set_rpc(self, rpc):
self._rpc = rpc
self._handler = PlayerRpcHandler(self)
self._handler.init_by_rpc(rpc)
@property
def gm(self):
try:
return self._gm
except AttributeError:
self._gm = self._game.gm_mgr.get_gm(self)
return self._gm
@property
def is_gm(self):
return UserData.is_gm(self.data.uid)
@property
def is_close(self):
return self._rpc is None
@property
def is_guide(self):
return self.data.chapter <= 1
@contextmanager
def with_disable_msg(self):
self._disable_send = 1
try:
yield
finally:
self._disable_send = 0
def _gm_cmd(self, cmds):
if not isinstance(cmds, (tuple, list)):
cmds = [cmds]
gm = self._game.gm_mgr.get_gm(self, forced=True)
with self.with_disable_log():
with self.with_disable_msg():
data = self.data.to_dict()
for cmd in cmds:
gm.execute(cmd % data, log_except=True, log_gm=False)
return gm
def on_close(self):
""" 断线处理 """
log.info(u'player(%s) on_close', self.data.name)
if self.user:
self.user.logout()
#TODO: 断线延迟释放，允许重连等优化
def debug_kick(self):
"""测试T非测试玩家下线"""
log.info(u'pid:(%s),during_debug_time(%s)', self.data.id,
self.data.name)
self.user.logout()
def to_dict(self):
return self.data.to_dict()
def _runtimes_exec(self, name, func):
for obj in self.runtimes.__dict__.values():
if name and not hasattr(obj, name):
continue
try:
func(obj)
except:
log.log_except()
def reward_params(self):
""" 获取奖励用参数 """
return dict(level=self.data.level)
def _init_guide(self):
""" 初始化为初章数据 """
if self._game.rpc_status_mgr.get(GUIDE_PASS):
self.task.chapter_complete()
return
cmd = self._game.setting_mgr.setdefault(GUIDE_PLAYER_CMD,
GUIDE_PLAYER_CMD_V)
self._gm_cmd(cmd)
def reg_logout(self, obj):
"""注册玩家下线调用的数据清理obj"""
self.logout_objs.add(obj)
def unreg_logout(self, obj):
if obj in self.logout_objs:
self.logout_objs.remove(obj)
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 _logout(self):
self.sit.close()
for obj in self.logout_objs:
if not hasattr(obj, 'player_logout'):
continue
try:
obj.player_logout(self.data.id)
except Exception:
log.log_except()
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 leave(self):
""" 退出player """
self.logout()
def send_msg(self, msg):
""" 发送由pack_msg生成的消息 """
if self._disable_send or self._rpc is None:
return
self._rpc.send(msg)
def get_ip(self):
if self._rpc is None:
return
return self._rpc.addr[0]
def get_init_msg(self):
""" 发送玩家初始化数据 """
resp_f = 'init'
CBE = {
FN_P_ATTR_CBE: self.play_attr.CBE,
FN_P_ATTR_CBES: self.play_attr.CBES
}
d = dict(
player=self.to_dict(),
roles=self.roles.to_dict(),
ilist=self.bag.to_dict(),
iwait=self.wait_bag.to_dict(),
task=self.task.to_dict(),
position=self.positions.to_dict(),
cliAttr=self.play_attr.client_to_dict(),
map=self.maps.to_dict(),
mail=self.mail.to_dict(),
buff=self.buffs.to_dict(),
vip=self.vip_attr.to_dict(),
CBE=CBE,
#reward = self._game.reward_mgr2.reward_init_msg(self)
)
if self.ally:
d['ally'] = self.ally
return pack_msg(resp_f, 1, data=d)
def base_load(self):
""" 加载玩家数据 """
self.play_attr.load()
self.roles.load()
self.bag.load()
self.wait_bag.load()
self.task.load()
self.positions.load()
self.maps.load()
self.buffs.load()
self.mail.load()
self.vip.load()
self.hron.load()
self.achievement.load()
self.vip_attr.load()
self.ally = self._game.rpc_ally_mgr.to_dict(self.data.id)
def load(self):
""" 加载玩家数据 """
self.base_load()
self.sit.load()
def load_p(self):
""" 玩家不在线时，其他模块使用(如机器人) """
self.base_load()
def save(self, full=True):
""" 保存玩家数据, """
#未完成初章,初章的数据是特殊的保存会污染其它功能,需要调整
if self.is_guide:
self.data.level = 1
self._game.rpc_store.save(TN_PLAYER, self.to_dict())
if not full:
return
with self._save_lock:
self.save_time = int(time.time())
self.roles.save()
self.bag.save()
self.wait_bag.save()
self.task.save()
self.positions.save()
self.maps.save()
self.sit.save()
self.buffs.save()
self.mail.save()
self.achievement.save()
store = self._game.rpc_store
self._runtimes_exec('save', lambda obj: obj.save(store))
if not self.is_guide:
self.property.update_CBE()
#玩家属性应最后保存(别的模块有玩家属性点更新)
log.debug('player(%s)_attr-save', self.data.name)
self.play_attr.save()
def clear_attr_car(self):
""" 清楚玩家坐骑属性 """
self.data.car = 0
self.update_scene_info({IF_IDX_CAR: 0})
def clear(self, all=True, dels=tuple()):
""" 清理玩家所有数据 """
if dels:
all = False
if all or 'role' in dels:
self.roles.clear()
if all or 'bag' in dels:
self.bag.clear()
if all or 'wait_bag' in dels:
self.wait_bag.clear()
if all or 'task' in dels:
self.task.clear()
if all or 'positions' in dels:
self.positions.clear()
if all or 'play_attr' in dels:
self.play_attr.clear()
if all or 'maps' in dels:
self.maps.clear()
if all or 'buffs' in dels:
self.buffs.clear()
if all or 'mail' in dels:
self.mail.clear()
if all or 'deep' in dels:
self._game.deep_mgr.clear(self)
if all or 'achievement' in dels:
self.achievement.clear()
def update_state(self, state):
""" 更新状态 """
self.data.state = state
self.update_scene_info({IF_IDX_STATE: state})
def get_coin2(self, use_bind=1):
""" 获取元宝数 """
return self.data.coin2 + self.data.coin3 if use_bind else self.data.coin2
def enough_coin(self, aCoin1, aCoin2=0, use_bind=True):
""" 消耗的钱币是否够 """
return 0 <= aCoin1 <= self.data.coin1 and \
0 <= aCoin2 <= self.get_coin2(use_bind=use_bind)
def enough_coin_ex(self, aCoin1, aCoin2=0, aCoin3=0):
""" 消耗的钱币是否够 """
if aCoin2 and aCoin3:
return False
use_bind = bool(aCoin3)
yb = aCoin3 if use_bind else aCoin2
return 0 <= aCoin1 <= self.data.coin1 and\
0 <= yb <= self.get_coin2(use_bind=use_bind)
def cost_coin_ex(self, aCoin1=0, aCoin2=0, aCoin3=0, log_type=None):
""" 花费 """
if aCoin2 and aCoin3:
return False
use_bind = bool(aCoin3)
yb = aCoin3 if use_bind else aCoin2
return self.cost_coin(aCoin1=aCoin1,
aCoin2=yb,
use_bind=use_bind,
log_type=log_type)
def cost_coin(self, aCoin1=0, aCoin2=0, use_bind=True, log_type=None):
""" 花费钱币(aCoin1:银币,aCoin2:元宝, use_bind:是否使用绑定元宝 """
if not self.enough_coin(aCoin1, aCoin2=aCoin2, use_bind=use_bind):
return False
c2, c3 = 0, 0
if aCoin1:
self.data.coin1 -= aCoin1
if aCoin2:
if use_bind:
#先消耗绑定元宝再消耗元宝
if self.data.coin3 < aCoin2:
c3 = self.data.coin3
c2 = aCoin2 - c3
self.data.coin2 -= c2
self.data.coin3 = 0
else:
c3 = aCoin2
self.data.coin3 -= aCoin2
else:
c2 = aCoin2
self.data.coin2 -= aCoin2
self.safe_pub(MSG_COST_COIN3, aCoin2)
self.save(full=False)
if log_type:
self.log_coin(log_type, aCoin1, c2, c3)
return True
def add_coin(self,
aCoin1=0,
aCoin2=0,
aCoin3=0,
is_set=False,
vip=False,
log_type=None):
""" 添加钱币(银币\元宝\绑元宝) """
if is_set:
self.data.coin1 = aCoin1
self.data.coin2 = aCoin2
self.data.coin3 = aCoin3
if vip:
self.data.vipCoin = aCoin2
else:
if aCoin1:
self.data.coin1 += aCoin1
if aCoin2:
self.data.coin2 += aCoin2
if aCoin3:
self.data.coin3 += aCoin3
if vip:
self.data.vipCoin += aCoin2
if aCoin2 or aCoin3:
self.save(full=False)
if log_type:
self.log_coin(log_type, aCoin1, aCoin2, aCoin3)
return True
def is_max_level(self, level=None):
""" 是否达到最大等级 """
if level is None:
level = self.data.level
return level >= self._game.setting_mgr.setdefault(
PLAYER_LEVEL_MAX, 9999)
def add_exp(self, aExp):
""" 添加经验
返回：0 失败 1 成功 2 升级
"""
if aExp < 0:
return 0
tReturn = 1
tNewExp = self.data.exp + aExp
if self.is_max_level():
tNextExpLevel = self._game.res_mgr.exps_by_level.get(
self.data.level + 1)
if tNextExpLevel:
if tNewExp < tNextExpLevel.exp:
self.data.exp = tNewExp
else:
self.data.exp = tNextExpLevel.exp - 1
return tReturn
#进行升级级检查
tNewLevel = self.data.level
tNextLevel = self.data.level
while True:
tNextLevel += 1
tNextExpLevel = self._game.res_mgr.exps_by_level.get(tNextLevel)
if not tNextExpLevel:
return 0
if tNewExp >= tNextExpLevel.exp:
#升一级
tNewLevel += 1
tNewExp -= tNextExpLevel.exp
continue
break
if tNewLevel > self.data.level:
self.data.exp = tNewExp
self.upgrade(tNewLevel)
tReturn = 2
else:
self.data.exp = tNewExp
#self.save(full=False)
return tReturn
def upgrade(self, level, pub=True):
""" 玩家升级 """
if not self.is_guide and self.is_max_level(level - 1):
return
old_lv = self.data.level
self.data.level = level
self.log_normal(PL_UPGRADE, lv=level)
#升级主动推
if self.logined:
self.up_level()
if pub:
#跨等级升级,发送多次消息
for lv in xrange(old_lv + 1, level + 1):
self.pub(MSG_UPGRADE, lv)
def up_level(self):
""" 升级主动推给客户端 """
resp_f = 'upLevel'
self.send_msg(pack_msg(resp_f, 1, data={'player':
self.data.to_dict()}))
self.update_scene_info({IF_IDX_LEVEL: self.data.level})
def add_site_time(self, site_time):
""" 添加打坐时间经验 """
site_exp = self._game.res_mgr.get_site_exp(self.data.level)
return self.add_exp(int(site_exp * site_time))
def add_train(self, aTrain, msg=1, log_type=None):
""" 添加练历 """
if aTrain <= 0:
return
old_train = self.data.train
self.data.train += aTrain
if old_train / 1000 != self.data.train / 1000:
self.pub(MSG_TRAIN)
if msg:
self.pub(MSG_ADDTRAIN, aTrain)
if log_type:
self.log_train(log_type, aTrain)
return True
def cost_train(self, aTrain, log_type=None):
""" 消耗练历 """
if aTrain <= 0 or aTrain > self.data.train:
return
self.data.train -= aTrain
if log_type:
self.log_train(log_type, aTrain)
#self.save(full=False)
return True
def pack_msg_data(self,
coin=False,
exp=False,
train=False,
items=None,
equips=None,
fates=None,
cars=None,
roles=None,
waits=None,
buffs=None,
mails=None,
gem=None,
del_iids=None,
del_eids=None,
del_fids=None,
del_cids=None,
del_wids=None,
del_bids=None,
del_mids=None,
del_gids=None,
send=0):
""" 打包物品更新结构 """
data = self.data
rs = dict()
if coin:
rs['coin1'] = data.coin1
rs['coin2'] = data.coin2
rs['coin3'] = data.coin3
if exp:
rs['exp'] = data.exp
if train:
rs['train'] = data.train
if items:
rs['item'] = [i.to_dict() for i in items]
if equips:
rs['equip'] = [i.to_dict() for i in equips]
if fates:
rs['fate'] = [i.to_dict() for i in fates]
if gem:
rs['gem'] = [i.to_dict() for i in gem]
if cars:
rs['car'] = [i.to_dict() for i in cars]
if waits:
rs['wait'] = [i.to_dict() for i in waits]
if buffs:
rs['buff'] = [i.to_dict() for i in buffs]
if roles:
rs['role'] = [i.to_dict() for i in roles]
if mails:
rs['mail'] = [i.to_dict() for i in mails]
if del_iids:
rs['delIids'] = tuple(del_iids)
if del_eids:
rs['delEids'] = tuple(del_eids)
if del_fids:
rs['delFids'] = tuple(del_fids)
if del_cids:
rs['delCids'] = tuple(del_cids)
if del_wids:
rs['delWids'] = tuple(del_wids)
if del_bids:
rs['delBids'] = tuple(del_bids)
if del_mids:
rs['delMids'] = tuple(del_mids)
if del_gids:
rs['delGids'] = tuple(del_gids)
if send:
self.send_msg(pack_msg('update', 1, data=rs))
return rs
def send_update_msg(self, msg_data, rs=1):
if rs:
self.send_msg(pack_msg('update', rs, data=msg_data))
else:
self.send_msg(pack_msg('update', rs, err=msg_data))
def init_all_runtimes(self):
"""初始化所有动态模块"""
self._game.bftask_mgr.init_player_bftask(self)
self._game.deep_mgr.init_player(self)
self._game.fete_mgr.init_player_fete(self)
self._game.fish_mgr.init_player(self)
self._game.ctree_mgr.bind_player(self)
self._game.hfate_mgr.init_player_hitfate(self)
self._game.mining_mgr.init_player(self)
self._game.reward_mgr2.init_player(self)
self._game.shop_mgr.init_player_shop(self)
self._game.social_mgr.init_player(self)
self._game.tbox_mgr.init_player_tbox(self)
def copy_from(self, player):
pid, uid, name = self.data.id, self.data.uid, self.data.name
self.data.copy_from(player.data)
self.data.update(dict(id=pid, uid=uid, name=name))
items = self.bag.copy_from(player.bag)
self.roles.copy_from(player.roles, items)
self.play_attr.copy_from(player.play_attr)
witems = self.wait_bag.copy_from(player.wait_bag)
self.task.copy_from(player.task)
self.positions.copy_from(player.positions, player.data.posId)
self.maps.copy_from(player.maps)
self.sit.copy_from(player.sit)
self.buffs.copy_from(player.buffs)
self.mail.copy_from(player.mail, witems)
self.vip.copy_from(player.vip)
self.achievement.copy_from(player.achievement)
#拷贝动态模块
self.init_all_runtimes()
player.init_all_runtimes()
self._runtimes_exec('copy_from', lambda obj: obj.copy_from(player))
def copy_player(self, pid):
""" 完全复制玩家数据 """
p = self.load_player(pid)
if not p:
return 0
self.copy_from(p)
return 1
def look(self):
""" 返回查看,战斗用信息 """
CBE = {
FN_P_ATTR_CBE: self.play_attr.CBE,
FN_P_ATTR_CBES: self.play_attr.CBES
}
info = dict(
player=self.data.to_dict(),
roles=self.roles.to_dict(used=1),
ilist=self.bag.to_dict(used=1),
position=self.positions.to_dict(used=1),
CBE=CBE,
)
return info
def team_look(self, rids):
"""返回组队战斗用信息"""
CBE = {
FN_P_ATTR_CBE: self.play_attr.CBE,
FN_P_ATTR_CBES: self.play_attr.CBES
}
roles = self.roles.roles_to_dict(rids)
ilist = self.roles.roles_bag_to_dict(rids)
info = dict(
player=self.data.to_dict(),
roles=roles,
ilist=ilist,
CBE=CBE,
)
return info
def fight_win(self, fid):
"""主线战斗胜利"""
fid = int(fid)
if fid in self.win_fights:
return
rid = self._game.res_mgr.get_fight_rid(fid)
if not rid:
return
rw = self._game.reward_mgr.get(rid)
if rw is None:
return
items = rw.reward(params=self.reward_params())
if items is None:
return
if self.bag.can_add_items(items):
self.set_win_fight(fid)
bag_items = self.bag.add_items(items, log_type=COIN_ADD_FIGHT_WIN)
return bag_items.pack_msg(coin=True)
def set_win_fight(self, fid):
self.win_fights.insert(fid)
self.play_attr.set(PLAYER_ATTR_WIN_FIGHTS, self.win_fights.to_base64())
def load_win_fight(self):
win_fights = self.play_attr.attr.get(PLAYER_ATTR_WIN_FIGHTS)
if win_fights:
self.win_fights.from_base64(win_fights)
def get_main_role_eid(self):
"""获取主将装备（用于组队战斗显示）"""
rid = self.data.rid
role = self.roles.get_role_by_rid(rid)
return rid, role.body_equip_id
def get_ally_tbox_data(self):
return self.play_attr.get(FN_P_ATTR_ALLYTBOX, dict(bids=[], t=0, cr=0))
def set_ally_tbox_data(self, data):
self.play_attr.set(FN_P_ATTR_ALLYTBOX, data)
def gm_finish_achi(self, t, aid):
self.achievement.gm_finish(t, aid)
def start(self, mgr, sock, addr):
self.mgr = mgr
self.sock = sock
self.addr = addr
self._rpc = ClientRpc(self.sock, self.addr, self)
self._rpc.start()
class User(GameObj, AbsExport):
""" 账号 """
TABLE_NAME = TN_USER
DATA_CLS = UserData
INIT_TIMEOUT = 60
LOGON_TIMEOUT = 60 * 5 #登录、新建角色
def __init__(self, adict=None):
if 0:
from game.player.player_mgr import SubPlayerMgr
self.mgr = SubPlayerMgr()
self.player = Player()
super(User, self).__init__(adict=adict)
self.inited = 0
self._init_waiter = Event()
self.key = None
self.player = None
self.logouted = False
self.player_datas = None
self.players = {}
self.sns_type = 0
def start(self, mgr, sock, addr):
self.mgr = mgr
self.sock = sock
self.addr = addr
self._rpc = ClientRpc(self.sock, self.addr, self)
self._rpc.start()
def stoped(self):
return self._rpc is None
def stop(self):
if self._rpc:
rpc = self._rpc
self._rpc = None
rpc.stop()
def on_close(self, rpcobj):
""" 断线处理 """
self.logout()
def wait_for_init(self):
""" 等待初始化和登陆 """
self._init_waiter.wait(self.INIT_TIMEOUT)
if not self.inited >= 2:
self.stop()
## self._init_waiter.clear()
## self._init_waiter.wait(self.LOGON_TIMEOUT)
## if not self.inited == 3:
## self.stop()
def send_msg(self, msg):
""" 发送由pack_msg生成的消息 """
if self._rpc is None:
return
self._rpc.send(msg)
def logon(self):
""" 账号登录 """
uid, sns_type = self.mgr.check_logon(self.data.id, self.key)
if uid is False:
return False
adict = Game.rpc_store.load(TN_USER, uid)
self.data.update(adict)
self.mgr.add_user(self)
self.sns_type = sns_type
return True
def logout(self):
""" 退出账号 """
if self.logouted:
return
self.logouted = True
if self.player:
self.player.logout()
self.mgr.del_user(self)
self.stop()
def player_login(self, pid):
resp_f = 'enter'
player_data = PlayerData.load(pid)
player = Player()
player.data.update(player_data)
if player.data.id is None:
log.error('player(%d)player_login load error:%s', pid, player_data)
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
if player.is_forbid_login:
return pack_msg(resp_f, 0, err=errcode.EC_FORBID_LOGON)
if not self.mgr.add_player(player):
return pack_msg(resp_f, 0, err=errcode.EC_TIME_UNDUE)
self.player = player
try:
player.set_rpc(self._rpc)
player.login(self)
map_id = player.data.mapId if player.data.mapId else 1
player.scene_enter(map_id, login=True)
self.mgr.logon_player(player)
log.debug(u'(%s)玩家(%s)登陆成功', player.data.id, player.data.name)
player.send_msg(player.get_init_msg())
spawn(self.mgr.logoned_player, player)
return pack_msg(resp_f, 1)
except:
log.log_except(u'玩家(%s)登陆初始化失败', player.data.id)
self.player_logout()
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
def player_logout(self):
try:
self.player_leave()
if not self.player:
return
p = self.player
self.player = None
self.mgr.del_player(p)
except Exception:
log.log_except()
self.player = None
def player_leave(self):
if self._rpc:
self._rpc.set_export(self)
def rc_login1(self, user, key):
""" client登陆到逻辑进程
user: user id
"""
if self.inited:
return
resp_f = 'login1'
self.inited = 1
log.info(u'账号(%s)登陆', user)
self.key = key
self.data.id = user
if not self.logon():
log.error(u'账号(%s)登陆错误', user)
resp = pack_msg(resp_f, 0, err=errcode.EC_LOGIN_ERR)
else:
#resp.server_time = int(time.time())
resp = pack_msg(resp_f, 1)
self.inited = 2
spawn_later(1, self._init_waiter.set)
return resp
def rc_logout(self):
resp_f = 'logout'
self.logout()
return pack_msg(resp_f, 1)
@wrap_inited
def rc_players(self):
""" 获取角色列表 """
resp_f = 'players'
if self.player_datas is None:
self.player_datas = list(
Game.rpc_store.query_loads(TN_PLAYER, dict(uid=self.data.id)))
self.players = dict(
(v[FN_ID], i) for i, v in enumerate(self.player_datas))
return pack_msg(resp_f, 1, data=self.player_datas)
@wrap_inited
def rc_delete(self, pid):
""" 删除玩家,注意:数据未备份会永远删除掉 """
resp_f = 'delete'
if not self.player_datas:
return pack_msg(resp_f, 0)
for data in self.player_datas:
if data['id'] != pid:
continue
self.players.pop(pid, None)
self.player_datas.remove(data)
rs = Player.del_player(pid, data=data)
if rs:
return pack_msg(resp_f, 1)
else:
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
@wrap_inited
def rc_new(self, name, rid):
""" 新建player """
resp_f = 'new'
#log.debug(u'rc_new:%s', name)
#判断该账号是否超过创建角色的数目
name = name.strip()
tPlayerNum = len(
Game.rpc_store.query_loads(TN_PLAYER, dict(uid=self.data.id)))
if tPlayerNum > Game.instance.setting_mgr.setdefault(
USE_PLAYS_MAX, USE_PLAYS_MAX_V):
return pack_msg(resp_f, 0, err=errcode.EC_USER_MAX)
if not name or rid not in Game.res_mgr.roles:
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
#敏感词
if Game.rpc_ban_word_mgr.check_ban_word(name):
#if Game.setting_mgr.check_ban_word(name):
return pack_msg(resp_f, 0, err=errcode.EC_NAME_REPEAT)
#名字长度截取
player_dict = Game.rpc_player_mgr.new_player(self.data.id, name[:50],
rid)
if not player_dict:
return pack_msg(resp_f, 0, err=errcode.EC_NAME_REPEAT)
player = Player.new_player(player_dict)
log.info(u'用户(%s)新建玩家(%s):%s', self.data.name, name, player.data.id)
data = player.to_dict()
self.player_datas.append(data)
self.players[player.data.id] = len(self.player_datas) - 1
return pack_msg(resp_f, 1, data=data)
@wrap_inited
def rc_enter(self, id):
""" 进入player """
resp_f = 'enter'
if not id:
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
if id not in self.players:
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
if Game.rpc_player_mgr.pre_add(id, self.data.id):
sleep(0.01)
return self.player_login(id)
def init(self, sock, addr):
self._sock = sock
self.rpc = ClientRpc(sock, addr, self)
self.rpc.start()
_locks[self] = {}
class PlayerRpcHandler(BasePlayerRpcHander):
def __init__(self, player):
if 0:
from game.player import player as player_md
self.player = player_md.Player()
self.rpc = ClientRpc()
self.player = player
self.active = True
self.rpc = None
self._lock = RLock()
def uninit(self):
self.player = None
self.rpc = None
if 0:
from game.player import player as player_md
self.player = player_md.Player()
self.rpc = ClientRpc()
def on_close(self, rpcobj):
""" 断线处理 """
sleep(0.05) #等待其它接口完成
self.player.on_close()
_close_i = 0.05
_close_time = 10 #等待时间
_close_count = int(_close_time / _close_i)
def close_handler(self):
""" player主动调用，先关闭接口,再处理别的,注意不调用会内存泄漏 """
global _locks
try:
self.active = False
for i in xrange(self._close_count):
if not _locks[self]:
break
sleep(self._close_i)
except:
log.log_except()
finally:
_locks.pop(self, None)
def init(self, sock, addr):
self._sock = sock
self.rpc = ClientRpc(sock, addr, self)
self.rpc.start()
_locks[self] = {}
def init_by_rpc(self, rpc):
self.rpc = rpc
if rpc:
rpc.set_export(self)
_locks[self] = {}
def stop(self):
if self.rpc is not None:
self.rpc.stop()
self.rpc = None
def _pack_items(self, items, equips, fates):
return dict(
coin1=self.player.data.coin1,
coin2=self.player.data.coin2,
coin3=self.player.data.coin3,
exp=self.player.data.exp,
train=self.player.data.train,
items=[i.to_dict() for i in items],
equips=[i.to_dict() for i in equips],
fates=[i.to_dict() for i in fates],
)
def rc_gm(self, cmd):
""" 执行gm命令 """
resp_f = 'gm'
gm = self.player.gm
if gm is None:
return pack_msg(resp_f, 0, err=u'gm auth error!')
msg = gm.execute(cmd)
return pack_msg(resp_f, 1, data=dict(msg=msg))
def rc_isGm(self):
""" 判断玩家是否gm """
resp_f = 'isGm'
gm = self.player.gm is not None
return pack_msg(resp_f, 1, data=dict(gm=int(gm)))
def rc_clear_player_data(self, all=True, dels=tuple()):
""" 清空玩家数据,压力测试用,正常游戏不需要调用这个接口 """
resp_f = 'clear_player_data'
#log.warn(u'(%s) rc_clear_player_data', self.player.data.id)
try:
self.player.clear(all=all, dels=dels)
return pack_msg(resp_f, 1)
except Exception as e:
return pack_msg(resp_f, 0, err=str(e))
def rc_valid_gm(self):
""" 启动gm模块,压力测试用 """
resp_f = 'valid_gm'
if not self.player._game.rpc_player_mgr.is_overload():
return pack_msg(resp_f, 0, err='overload close')
self.player._gm = self.player._game.gm_mgr.get_gm(self.player,
forced=True)
return pack_msg(resp_f, 1)
def rc_init(self):
""" 获取初始化信息 """
resp_f = 'init'
return self.player.get_init_msg()
def rc_bindSNS(self, t, sid, session):
""" 账号绑定 """
resp_f = 'bindSNS'
rs, data = self.player._game.rpc_player_mgr.bindSNS(
self.player.data.uid, t, sid, session)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1)
def rc_logout(self):
""" 退出 """
return self.player.user.rc_logout()
@_wrap_nolock
def rc_leave(self):
""" 退出player """
resp_f = 'leave'
self.player.leave()
return pack_msg(resp_f, 1)
def rc_lookPlayer(self, pid=None, name=None):
""" 查看其它玩家信息 """
resp_f = 'lookPlayer'
if name:
querys = dict(name=name)
dics = self.player._game.rpc_store.query_loads(TN_PLAYER,
querys=querys)
if not dics:
return pack_msg(resp_f, 0, err=errcode.EC_PLAYER_EMPTY)
pid = dics[0]['id']
rs, data = self.player._game.player_mgr.look(pid)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_player(self):
""" 请求玩家信息 """
resp_f = 'player'
return pack_msg(resp_f, 1, data=self.player.to_dict())
def rc_funcsUpdate(self, funcs):
""" 更新前端用的开启功能按钮列表 """
resp_f = 'funcsUpdate'
self.player.data.funcs = funcs
if config.debug:
self.player.log_normal(PL_FUNCSUPDATE,
d=funcs,
tid=self.player.task.current_tid)
return pack_msg(resp_f, 1)
def rc_CBEUpdate(self, CBE, cbes):
""" 更新战斗力信息 """
if self.player.is_guide:
return
#CBE改用服务器计算的
#self.player.play_attr.set(FN_P_ATTR_CBE, CBE)
#self.player.play_attr.set(FN_P_ATTR_CBES, cbes)
def rc_roles(self, pid=None):
""" 请求配将信息 """
resp_f = 'roles'
if pid is None:
return pack_msg(resp_f, 1, data=self.player.roles.to_dict())
#TODO 获取其它玩家配将信息
def rc_ilist(self, pid=None):
""" 请求玩家物品信息 """
log.debug(u'===rc_ilist===')
resp_f = 'ilist'
if pid is None:
return pack_msg(resp_f, 1, data=self.player.bag.to_dict())
def rc_iwait(self):
""" 请求待收取物品列表 """
resp_f = 'iwait'
return pack_msg(resp_f, 1, data=self.player.wait_bag.to_dict())
def rc_waitFetch(self, type, id=None):
""" 收取物品 """
resp_f = 'waitFetch'
rs, data = self.player.wait_bag.fetch(type, id)
if rs:
return pack_msg(resp_f, 1, data=data)
else:
return pack_msg(resp_f, 0, err=data)
def rc_useItem(self, id):
""" 使用物品,获取东西 """
resp_f = 'useItem'
rs, data = self.player.use_item(id)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_cliAttr(self, key):
""" 获取前端属性 """
resp_f = 'cliAttr'
value = self.player.play_attr.client_get(key)
return pack_msg(resp_f, 1, data=value if value is not None else '')
#return pack_msg(resp_f, 1, data=self.player.play_attr.client_to_dict())
def rc_cliAttrSet(self, key, value):
""" 设置前端属性 """
#log.debug('rc_cliAttrSet(%s, %s)', key, value)
resp_f = 'cliAttrSet'
if not key:
return pack_msg(resp_f, 0)
self.player.play_attr.client_set(key, value)
return pack_msg(resp_f, 1)
def rc_pAttr(self, key):
""" 获取属性 """
resp_f = 'pAttr'
value = self.player.play_attr.get(key)
return pack_msg(resp_f, 1, data=value if value is not None else '')
#return pack_msg(resp_f, 1, data=self.player.play_attr.client_to_dict())
def rc_pAttrSet(self, key, value):
""" 设置属性 """
resp_f = 'pAttrSet'
if not key:
return pack_msg(resp_f, 0)
self.player.play_attr.set(key, value)
return pack_msg(resp_f, 1)
def rc_task(self, pid=None):
""" 获取玩家的任务 """
resp_f = 'task'
if pid is None:
return pack_msg(resp_f, 1, data=self.player.task.to_dict())
def rc_taskUpdate(self, id, step):
""" 更新玩家任务状态"""
resp_f = 'taskUpdate'
return pack_msg(resp_f, 1, data=self.player.task.task_update(id, step))
def rc_taskActive(self, id):
""" 激活某任务,无返回 """
resp_f = 'taskActive'
task = self.player.task.get_task(id)
if not task:
return
self.player.task.task_active(task)
def rc_taskComplete(self, id):
""" 完成任务获取奖励 """
resp_f = 'taskComplete'
rs, bag_items = self.player.task.task_complete(id)
if rs:
if bag_items:
data = bag_items.pack_msg(rwitems=True)
else:
data = None
return pack_msg(resp_f, 1, data=data)
else:
return pack_msg(resp_f, 0, err=bag_items)
def rc_chapterComplete(self):
""" 完成章节 """
resp_f = 'chapterComplete'
if self.player.task.chapter_complete():
return pack_msg(resp_f, 1)
else:
return pack_msg(resp_f, 0)
def rc_bfTaskEnter(self):
""" 进入兵符任务 """
resp_f = 'bfTaskEnter'
rs, data = self.player._game.bftask_mgr.bf_task_enter(self.player)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_bfTaskRe(self, type):
""" 兵符任务刷新 """
resp_f = 'bfTaskRe'
rs, data = self.player._game.bftask_mgr.bf_task_re(self.player, type)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_bfTaskBox(self):
""" 打开兵符宝箱 """
resp_f = 'bfTaskBox'
rs, data = self.player._game.bftask_mgr.bf_task_box(self.player)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_bfTaskGet(self, index):
""" 接兵符任务 """
resp_f = 'bfTaskGet'
rs, data = self.player._game.bftask_mgr.bf_task_get(self.player, index)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_bfTaskFinish(self):
""" 立即完成的兵符任务 """
resp_f = 'bfTaskFinish'
rs, data = self.player._game.bftask_mgr.bf_finish(self.player)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_carExchange(self, cid):
""" 坐骑兑换 """
resp_f = 'carExchange'
rs, data = self.player.car_exchange(cid)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_carDo(self, cid):
""" 坐骑的操作 """
resp_f = 'carDo'
rs, data = self.player.car_do(cid)
if rs:
return pack_msg(resp_f, 1)
return pack_msg(resp_f, 0, err=data)
def rc_mergeItem(self, desId, count, srcId):
""" 物品合成 """
res_f = 'mergeItem'
rs, data = self.player.merge_item(desId, count, srcId)
if rs:
return pack_msg(res_f, 1, data=data)
return pack_msg(res_f, 0, err=data)
def rc_wearEq(self, id, rid):
""" 穿装备
id: 装备玩家表id
rid:角色玩家表id
"""
resp_f = 'wearEq'
role = self.player.roles.get_role(rid)
equip, res_equip = self.player.bag.get_equip_ex(id)
if res_equip is None:
return pack_msg(resp_f, 0, err=errcode.EC_ITEM_NOFOUND)
res_eq_set = self.player._game.item_mgr.get_res_eq_set(res_equip.sid)
if res_eq_set.cond and res_eq_set.lv > self.player.data.level:
return pack_msg(resp_f, 0, err=errcode.EC_NOLEVEL)
if not (role and equip):
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
if equip.data.used:
return pack_msg(resp_f, 0, err=errcode.EC_ROLE_WEARED)
rs, data = role.wear_equip(self.player, equip, res_equip)
if rs:
off_equip, msg = data
return msg
return pack_msg(resp_f, 0, err=data)
def rc_tackOffEq(self, id, rid):
""" 脱装备 """
resp_f = 'tackOffEq'
role = self.player.roles.get_role(rid)
equip, res_equip = self.player.bag.get_equip_ex(id)
if not (equip and role):
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
rs, data = role.take_off_equip(self.player, res_equip.part)
if rs:
return pack_msg(resp_f, 1, data=dict(uid=id))
return pack_msg(resp_f, 0, err=data)
def rc_armUpgrade(self, rid):
""" 武器升级 """
resp_f = 'armUpgrade'
if not rid:
return pack_msg(resp_f, 0)
tRole = self.player.roles.roles.get(rid)
rs, data = self.player.arm_upgrade(tRole)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_armSkill(self, rid, sid):
""" 激活技能 """
resp_f = 'armSkill'
if not rid or not sid:
return pack_msg(resp_f, 0)
tRole = self.player.roles.roles.get(rid)
rs, data = self.player.arm_skill(tRole, sid)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_skillBack(self, rid, type):
""" 取回技能点 """
resp_f = 'skillBack'
if not rid or not type:
return pack_msg(resp_f, 0)
tRole = self.player.roles.roles.get(rid)
rs, data = self.player.skill_back(tRole, type)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_eqStr(self, eid):
""" 装备强化升级 """
resp_f = 'eqStr'
if not eid:
return pack_msg(resp_f, 0)
rs, data = self.player.equip_strong(eid)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_eqMove(self, rid, eid1, eid2):
""" 装备强化转移 """
resp_f = 'eqMove'
if not eid1 or not eid2:
return pack_msg(resp_f, 0)
tRole = self.player.roles.roles.get(rid)
rs, data = self.player.equip_move_level(tRole, eid1, eid2)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_chatSend(self, t, m, id=None, name=None):
""" 玩家发聊天信息 """
resp_f = 'chatSend'
rs, data = self.player._game.chat_mgr.chat_send(self.player,
t,
m,
pid=id,
name=name)
if rs:
return pack_msg(resp_f, 1)
return pack_msg(resp_f, 0, err=data)
def rc_wearFt(self, id, rid, place):
""" 穿命格 """
resp_f = 'wearFt'
role = self.player.roles.get_role(rid)
fate, res_fate = self.player.bag.get_fate_ex(id)
if not (place and fate and role):
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
rs, data = role.wear_fate(self.player, fate, res_fate, place)
if rs:
return pack_msg(resp_f, 1, data=dict(id=id, rid=rid))
return pack_msg(resp_f, 0, err=data)
def rc_tackOffFt(self, id, rid, place):
""" 脱命格 """
resp_f = 'tackOffFt'
role = self.player.roles.get_role(rid)
fate = self.player.bag.get_fate(id)
if not (role and fate):
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
rs, data = role.take_off_fate(self.player, fate, place)
if rs:
return pack_msg(resp_f, 1, data=dict(uid=id))
return pack_msg(resp_f, 0, err=data)
def rc_mergeFt(self, id1, id2, rid=0):
""" 命格合并 """
resp_f = 'mergeFt'
if not id1 or not id2:
return pack_msg(resp_f, 0)
rs, data = self.player.roles.merge_fate(id1, id2, rid)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_mergeAllFt(self):
""" 命格一键合成"""
resp_f = 'mergeAllFt'
rs, data = self.player.roles.merge_all_fate()
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_sellAll(self, equip=None, item=None, fate=None, gem=None):
""" 批量卖出 """
resp_f = 'sellAll'
rs, data = self.player.bag.sell_all(equip, item, fate, gem)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_invite(self, rid):
""" 招募配将 """
resp_f = 'invite'
role, data = self.player.roles.invite(rid)
if role == False:
return pack_msg(resp_f, 0, err=data)
d = role.data
data['id'] = d.id
data['rid'] = d.rid
data['role'] = [role.to_dict()]
#self.player.pub(MSG_ROLE_INVITE, d.rid, self.player)
return pack_msg(resp_f, 1, data=data)
def rc_roleLeave(self, rid):
""" 离队 """
resp_f = 'roleLeave'
role = self.player.roles.get_role(rid)
if role is None or role.is_main:
return pack_msg(resp_f, 0, err=errcode.EC_ROLE_NOFOUND)
role.leave()
return pack_msg(resp_f, 1, data=dict(rid=role.data.id))
def rc_roleReturn(self, rid):
""" 归队 """
resp_f = 'roleReturn'
role = self.player.roles.get_role(rid)
if role is None:
return pack_msg(resp_f, 0, err=errcode.EC_ROLE_NOFOUND)
if not self.player.roles.can_come_back():
return pack_msg(resp_f, 0, err=errcode.EC_NO_RIGHT)
role.come_back()
return pack_msg(resp_f, 1, data=dict(rid=role.data.id))
def rc_inviteState(self, rid):
""" 获取招募条件状态 """
#TODO: 获取招募条件状态
def rc_enterHitFate(self):
""" 进入猎命获取初始数据 """
resp_f = 'enterHitFate'
rs, data = self.player._game.hfate_mgr.enter_hit_fate(self.player)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0)
def rc_hitFate(self, type, isBatch=0):
""" 进行猎命 """
resp_f = 'hitFate'
rs, data = self.player._game.hfate_mgr.hit_fate(
self.player, type, isBatch)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_enterFete(self):
""" 进入祭天获取初始化数据 """
resp_f = 'enterFete'
data = self.player._game.fete_mgr.enter_fete(self.player)
if data:
return data
def rc_fete(self, type):
""" 进行祭天 """
resp_f = 'fete'
rs, data = self.player._game.fete_mgr.fete_ing(self.player, type)
if rs:
self.player.pub(MSG_FETE_NUM)
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_position(self):
""" 获取阵型信息 """
resp_f = 'position'
return pack_msg(resp_f, 1, data=self.player.positions.to_dict())
def rc_posStudy(self, pid):
""" 学习阵型 """
resp_f = 'posStudy'
p = self.player.positions.study(pid)
if p:
return pack_msg(resp_f,
1,
data=dict(pid=p.data.id,
coin1=self.player.data.coin1))
else:
return pack_msg(resp_f, 0)
def rc_posUpgrade(self, pid):
""" 升级阵型 """
resp_f = 'posUpgrade'
rs, err = self.player.positions.upgrade(pid)
if rs:
return pack_msg(resp_f, 1, data=dict(coin1=self.player.data.coin1))
else:
return pack_msg(resp_f, 0, err=err)
def rc_posActive(self, pid):
""" 激活阵型 """
resp_f = 'posActive'
rs = self.player.positions.active(pid)
if rs:
return pack_msg(resp_f, 1)
else:
return pack_msg(resp_f, 0)
def rc_posSet(self, **kw):
""" 设置阵型 """
resp_f = 'posSet'
id = kw['id']
rs = self.player.positions.set(id, kw)
if rs:
return pack_msg(resp_f, 1)
else:
return pack_msg(resp_f, 0)
def rc_startSit(self):
""" 开始打坐 """
resp_f = 'startSit'
rs, data = self.player.sit.start_sit()
if rs:
return pack_msg(resp_f, 1)
return pack_msg(resp_f, 0, err=data)
def rc_stopSit(self):
""" 停止打坐 """
resp_f = 'stopSit'
rs, data = self.player.sit.stop_sit()
if rs:
return pack_msg(resp_f, 1)
return pack_msg(resp_f, 0, err=data)
def rc_onlineSitExp(self):
""" 上线获取打坐信息 """
resp_f = 'onlineSitExp'
rs, data = self.player.sit.online_sit()
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_mail(self):
""" 获取邮件列表 """
resp_f = 'mail'
return pack_msg(resp_f, 1, data=self.player.mail.to_dict())
def rc_mailReceive(self, id):
""" 收取删除邮件 """
resp_f = 'mailReceive'
rs, msg = self.player.mail.receive(id)
if rs:
return pack_msg(resp_f, 1, data=msg)
else:
return pack_msg(resp_f, 0, err=msg)
def rc_fishEnter(self):
""" 进入钓鱼操作获取所有的鱼饵 """
resp_f = 'fishEnter'
rs, data = self.player._game.fish_mgr.fish_enter(self.player)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_fishUp(self, iid, num, qt=1):
""" 一次(批量)起杆获得奖励 """
resp_f = 'fishUp'
rs, data = self.player._game.fish_mgr.fish_up(self.player, iid, num,
qt)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
#def rc_fishGiveup(self, iid, t):
# """ 放弃钓鱼 """
# resp_f = "fishGiveup"
# rs, data = self.player._game.fish_mgr.fish_give_up(self.player, iid, t)
# if not rs:
# return pack_msg(resp_f, 0, err = data)
# return pack_msg(resp_f, 1, data = data)
def rc_foodEnter(self):
resp_f = 'foodEnter'
return pack_msg(resp_f,
1,
data=dict(bTime=self.player.buffs.delay_times))
def rc_foodEat(self, id, t):
""" 进食 """
resp_f = 'foodEat'
rs, err = self.player.buffs.eat(id, t)
if not rs:
return pack_msg(resp_f, 0, err=err)
return pack_msg(resp_f, 1, data=err)
def rc_buffDel(self, id):
""" buff过期，删除buff """
resp_f = 'buffDel'
buff = self.player.buffs.get_buff(id)
if not buff:
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
rs, err = self.player.buffs.del_buff(buff)
if not rs:
return pack_msg(resp_f, 0, err=err)
return pack_msg(resp_f, 1)
def rc_mineEnter(self):
resp_f = "mineEnter"
rs, data = self.player._game.mining_mgr.enter(self.player)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_mine(self, type, hit, isbatch, hit3=0, hit5=0):
""" 请求采矿 """
resp_f = "mine"
hit = dict(hit2=hit, hit3=hit3, hit5=hit5)
rs, data = self.player._game.mining_mgr.mining(self.player, type, hit,
isbatch)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_deepEnter(self, type):
""" 进入深渊 """
resp_f = 'deepEnter'
rs, data = self.player._game.deep_mgr.enter(self.player, type)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_deepBox(self):
resp_f = 'deepBox'
rs, data = self.player._game.deep_mgr.open_box(self.player)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_deepFight(self, type):
resp_f = 'deepFight'
rs, data = self.player._game.deep_mgr.fight(self.player, type)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_deepAuto(self):
""" 自动挂机 """
resp_f = 'deepAuto'
rs, data = self.player._game.deep_mgr.auto(self.player)
if not rs:
return pack_msg(resp_f, 0, err=data)
wasteTimes = int(data)
data = self.player.pack_msg_data(coin=True)
return pack_msg(resp_f, 1, data=dict(data=data, wasteTimes=wasteTimes))
def rc_shop(self, t=2):
""" 神秘商店 """
resp_f = 'shop'
rs, data = self.player._game.shop_mgr.enter(self.player, t)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_shopBuy(self, t=2, sid=0):
""" 神秘商店购买物品 """
resp_f = 'shopBuy'
rs, data = self.player._game.shop_mgr.buy(self.player, t, sid)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_dshopBuy(self, id=0, c=0):
"""可购买物品"""
resp_f = 'dshopBuy'
rs, data = self.player._game.shop_mgr.dshopBuy(self.player, id, c)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_gemShop(self):
"""珠宝商店"""
resp_f = 'gemShop'
rs, data = self.player._game.shop_mgr.gem_enter(self.player)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_resetShop(self):
""" 重置神秘商店 """
resp_f = "resetShop"
rs, data = self.player._game.shop_mgr.resetShop(self.player)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_allyEnter(self):
""" 玩家进入游戏的发送 """
resp_f = "allyEnter"
rs, data = self.player._game.rpc_ally_mgr.enter(self.player)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_fightReport(self, id):
""" 获取战报 """
resp_f = 'fightReport'
rs, data = self.player._game.rpc_report_mgr.get_url(id)
if rs:
return pack_msg(resp_f, 1, data=dict(url=data))
return pack_msg(resp_f, 0, err=data)
def rc_rankEnter(self, t, p):
""" 排行榜 """
resp_f = 'rankEnter'
pid = self.player.data.id
level = self.player.data.level
if hasattr(self.player.play_attr, 'CBE'):
p_cbe = self.player.play_attr.CBE
else:
p_cbe = 0
p_data = {'id': pid, 'level': level, 'CBE': p_cbe}
rs, data = self.player._game.rpc_rank_mgr.enter(p_data, t, p)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_speedUp(self, mul):
"""vip战斗加速mul战斗的倍数"""
resp_f = 'speedUp'
rs, data = self.player.vip_attr.speed_up(mul)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_rewardTime(self):
""" 领取登录时长的奖励 """
resp_f = 'rewardTime'
rs, data = self.player._game.reward_mgr2.reward_time(self.player)
if not rs:
return pack_msg(resp_f, 0, err=data)
#return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 1)
def rc_rewardActiveEnter(self):
""" 活动奖励面板打开 """
resp_f = 'rewardActiveEnter'
rs, data = self.player._game.reward_mgr2.active_enter(self.player)
if not rs:
return pack_msg(resp_f, 0, err=data)
#return pack_msg(resp_f, 1, data = data)
return pack_msg(resp_f, 1)
def rc_rewardActive(self, t, lv):
"""
活动奖励的领取 t = 1 充值 2 = 武器升阶 3 = 招募 4 = 激活码奖励
t=1对lv参数忽略
"""
resp_f = 'rewardActive'
rs, data = self.player._game.reward_mgr2.active_fetch(
self.player, t, lv)
if not rs:
return pack_msg(resp_f, 0, err=data)
#return pack_msg(resp_f, 1, data = data)
return pack_msg(resp_f, 1)
def rc_rewardCode(self, code):
""" 兑换码领取 """
resp_f = 'rewardCode'
rs, data = self.player._game.reward_mgr2.reward_code(self.player, code)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_goodsList(self):
""" 获取商品列表 """
resp_f = 'goodsList'
rs = self.player._game.rpc_vip_mgr.get_goods(self.player.user.sns_type)
return pack_msg(resp_f, 1, data=rs)
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 rc_goodsPay(self, gorder, pid):
""" 支付成功检查 """
resp_f = 'goodsPay'
#log.info('[rc_goodsPay](%s)(%s, %s)', self.player.data.id, gorder, pid)
rs, data = SNSClient.pay(gorder,
pid) #, self.player._game.rpc_res_store)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
# def rc_goodsPay1(self, t, gid, torder):
# resp_f = 'goodsPay1'
# log.info('[rc_goodsPay1](%s, %s)', t, torder)
# 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)
# pre_pay, gorder, price, good_id = data
# SNSClient.pay1(t, torder, pre_pay, self.player._game.rpc_res_store)
# return pack_msg(resp_f, 1, data=data)
def rc_TeamFight(self, tid):
"""组队战斗"""
resp_f = 'TeamFight'
if tid == 1000001 or tid == 1000002:
data = self.test_rc_TeamFight(tid)
else:
data = self.player._game.rpc_team_mgr.get_fight_info(tid)
if data is None:
return pack_msg(resp_f, 0, err=errcode.EC_TEAM_NOT_FIND)
return pack_msg(resp_f, 1, data=data)
def test_rc_TeamFight(self, tid):
if tid == 1000001:
pid1, rid1_1, rid1_2 = 526, 1, 21
pid2, rid2_1 = 700, 6
pid3, rid3_1 = self.player.data.id, self.player.data.rid
p1, p2 = self.player.load_player(pid1), self.player.load_player(
pid2)
info1, info2, eid1, eid2 = [], [], [], []
if p1:
info1 = p1.team_look([rid1_1, rid1_2])
_, eid1 = p1.get_main_role_eid()
if p2:
info2 = p2.team_look([rid2_1])
_, eid2 = p2.get_main_role_eid()
info3 = self.player.team_look([self.player.data.rid])
_, eid3 = self.player.get_main_role_eid()
pos = {
1: {
'pid': pid1,
'rid': rid1_1,
'eid': eid1
},
2: {
'pid': pid1,
'rid': rid1_2
},
4: {
'pid': pid2,
'rid': rid2_1,
'eid': eid2
},
7: {
'pid': pid3,
'rid': rid3_1,
'eid': eid3
},
} #阵型信息 {index : {pid:0, rid:0} }
return dict(players=[info1, info2, info3],
mb=pos,
lid=self.player.data.id)
if tid == 1000002:
pid1, rid1_1, rid1_2 = 2905, 1, 26
pid2, rid2_1, rid2_2 = 3024, 1, 33
pid3, rid3_1, rid3_2 = 2908, 1, 22
p1, p2, p3 = self.player.load_player(
pid1), self.player.load_player(pid2), self.player.load_player(
pid3)
info1, info2, info3, eid1, eid2, eid3 = [], [], [], [], [], []
if p1:
info1 = p1.team_look([rid1_1, rid1_2])
_, eid1 = p1.get_main_role_eid()
if p2:
info2 = p2.team_look([rid2_1, rid2_2])
_, eid2 = p2.get_main_role_eid()
if p3:
info3 = p3.team_look([rid3_1, rid3_2])
_, eid3 = p3.get_main_role_eid()
pos = {
1: {
'pid': pid1,
'rid': rid1_1,
'eid': eid1
},
2: {
'pid': pid1,
'rid': rid1_2
},
4: {
'pid': pid2,
'rid': rid2_1,
'eid': eid2
},
5: {
'pid': pid2,
'rid': rid2_2
},
7: {
'pid': pid3,
'rid': rid3_1,
'eid': eid3
},
8: {
'pid': pid3,
'rid': rid3_2
},
} #阵型信息 {index : {pid:0, rid:0} }
return dict(players=[info1, info2, info3],
mb=pos,
lid=self.player.data.id)
def rc_TeamDisband(self, tid):
"""解散队伍"""
resp_f = 'TeamDisband'
rs, err = self.player._game.rpc_team_mgr.disband(tid)
if not rs:
return pack_msg(resp_f, 0, err=err)
def rc_fightWin(self, fid):
"""主线战斗胜利"""
resp_f = 'fightWin'
data = self.player.fight_win(fid)
if data:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=errcode.EC_FIGHT_WIN)
def rc_achiEnter(self):
"""进入成就系统"""
resp_f = 'achiEnter'
data = self.player.achievement.to_dict()
return pack_msg(resp_f, 1, data=data)
def rc_achiUpdate(self):
"""更新成就"""
resp_f = 'achiUpdate'
data = self.player.achievement
def rc_achiReward(self, id, t):
"""领取成就奖励"""
resp_f = 'achiReward'
rs, data = self.player.achievement.get_reward(id, t)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_gemInlay(self, eid, gid, index):
"""珠宝镶嵌"""
resp_f = 'gemInlay'
rs, data = self.player._game.gem_mgr.inlay(self.player, eid, gid,
index)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_gemRemove(self, eid, index):
"""珠宝移除"""
resp_f = 'gemRemove'
rs, data = self.player._game.gem_mgr.remove(self.player, eid, index)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_gemTransform(self, feid, teid):
"""珠宝转移"""
resp_f = 'gemTransform'
rs, data = self.player._game.gem_mgr.transform(self.player, feid, teid)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_gemMineEnter(self):
"""进入珠宝开采"""
resp_f = 'gemMineEnter'
data = self.player._game.gem_mgr.enter_mine(self.player)
return pack_msg(resp_f, 1, data=data)
def rc_gemMine(self, t, n):
"""珠宝开采"""
resp_f = 'gemMine'
rs, data = self.player._game.gem_mgr.mine(self.player, t, n)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_gemSanding(self, stuff):
"""珠宝打磨"""
resp_f = 'gemSanding'
rs, data = self.player._game.gem_mgr.sanding(self.player, stuff)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_gemCalc(self, gid, stuff):
"""珠宝升级概率"""
resp_f = 'gemCalc'
rs, data = self.player._game.gem_mgr.calculate(self.player, gid, stuff)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=dict(succ=data))
def rc_gemShop(self):
"""读取珠宝商店信息"""
resp_f = 'gemShop'
rs, data = self.player._game.shop_mgr.gem_enter(self.player)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_gemUpgrade(self, gid, stuff):
"""珠宝升级"""
resp_f = 'gemUpgrade'
rs, data = self.player._game.gem_mgr.upgrade(self.player, gid, stuff)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_gemShopBuy(self, sid):
"""珠宝商店购买"""
resp_f = 'gemShopBuy'
rs, data = self.player._game.shop_mgr.gem_buy(self.player, sid)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_gemShopAdd(self):
"""珠宝商店窗口增加"""
resp_f = 'gemShopAdd'
rs, data = self.player._game.shop_mgr.gem_add(self.player)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_gemShopReset(self):
"""珠宝商店重置"""
resp_f = 'gemShopReset'
rs, data = self.player._game.shop_mgr.gem_reset(self.player)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_ctreeEnter(self):
"""
点击进入摇钱树，返回剩余次数
"""
resp_f = 'ctreeEnter'
ctree_mgr = self.player._game.ctree_mgr
rs, data = ctree_mgr.enter(self.player)
# import logging
# LG = logging.getLogger()
# LG.info(str(rs) + ' ---peng--- ' + str(data))
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_ctreeExchange(self):
"""
处理兑换过程，要用真无宝
"""
resp_f = 'ctreeExchange'
ctree_mgr = self.player._game.ctree_mgr
rs, data = ctree_mgr.exchange(self.player)
# import logging
# LG = logging.getLogger()
# LG.info(str(rs) + ' ---peng--- ' + str(data))
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1, data=data)
def rc_roleUpEnter(self):
""" 进入武将升段 """
resp_f = 'roleUpEnter'
rs, data = self.player.roles.role_up_enter()
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_roleUpDo(self, rid):
""" 武将升段 """
resp_f = 'roleUpDo'
role = self.player.roles.rid2roles.get(rid)
if not role:
return False, errcode.EC_ROLE_NOFOUND
rs, data = role.role_up_do()
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_roleUpTrain(self, rid, type):
""" 武将培养 """
resp_f = 'roleUpTrain'
rs, data = self.player.roles.role_train_do(rid, type)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_roleUpTrainOk(self, rid):
""" 武将培养保存 """
resp_f = 'roleUpTrainOk'
rs, data = self.player.roles.role_train_ok(rid)
if rs:
return pack_msg(resp_f, 1, data=data)
return pack_msg(resp_f, 0, err=data)
def rc_changeName(self, n=None):
"""
玩家改名
"""
resp_f = 'changeName'
name = n.strip()
querys = dict(name=name)
if not name:
return pack_msg(resp_f, 0, err=errcode.EC_VALUE)
_game = self.player._game
if _game.rpc_player_mgr.get_id_by_name(name):
return pack_msg(resp_f, 0, err=errcode.EC_NAME_REPEAT)
if _game.rpc_store.query_loads(TN_PLAYER, querys=querys):
return pack_msg(resp_f, 0, err=errcode.EC_NAME_REPEAT)
#敏感词
if _game.rpc_ban_word_mgr.check_ban_word(name):
#if _game.setting_mgr.check_ban_word(name):
return pack_msg(resp_f, 0, err=errcode.EC_FORBID_STRING)
name = name[:50]
log.info(u'pid(%s)原名(%s)改为(%s)', self.player.data.id,
self.player.data.name, name)
self.player.data.name = name
self.player.save(full=False)
rs, data = _game.rpc_player_mgr.change_name(self.player.data.id, name,
self.player.data.rid)
if not rs:
return pack_msg(resp_f, 0, err=data)
return pack_msg(resp_f, 1)
def __init__(self):
if 0:
from game.player import player as player_md
self.player = player_md.Player()
self.rpc = ClientRpc()
raise NotImplementedError