def giftkey(self, msgtype, body):
from protocol.poem_pb import Giftkey, GiftkeyResponse
from config.configs import get_config, GiftkeyConfig
from reward.manager import open_reward, build_reward_msg, RewardType
from giftkey import use_key, InvalidGiftkeyError, ExceedUseCountError, ExceedDeallineError
player = self.player
req = Giftkey()
req.ParseFromString(body)
try:
giftID = use_key(player, req.key)
except InvalidGiftkeyError:
return fail_msg(msgtype, reason='无效的兑换码')
except ExceedUseCountError:
return fail_msg(msgtype, reason='已经达到最大兑换次数了')
except ExceedDeallineError:
return fail_msg(msgtype, reason='已经超过有效期了')
gift = get_config(GiftkeyConfig)[giftID]
reward = open_reward(RewardType.Giftkey, gift)
result = reward.apply(player)
player.save()
player.sync()
rsp = GiftkeyResponse()
build_reward_msg(rsp, result)
gm_logger.info(
{'giftkey': {
'entityID': player.entityID,
'giftkey': req.key
}})
return success_msg(msgtype, rsp)
def clean_faction(entityID):
p = g_entityManager.get_player(entityID)
if not p:
p = Player.simple_load(entityID, ['factionID', 'applyFactions'])
if p.factionID:
faction = Faction.simple_load(p.factionID, ['memberset'])
if faction:
safe_remove(faction.memberset, p.entityID)
faction.save()
p.last_factionID = p.factionID
gm_logger.info({
'faction': {
'entityID': p.entityID,
'type': 'quit_faction',
'factionID': p.factionID,
}
})
p.factionID = 0
p.fp = 0
p.faction_name = ''
p.faction_level = 0
p.faction_is_leader = False
p.applyFactions.clear()
# p.applyFactionTime = 0
p.save()
if g_entityManager.get_player(entityID):
p.sync()
def create_user(request):
req = poem_pb.RegisterRequest()
req.ParseFromString(request.body)
clientIP = request.env.get('REMOTE_ADDR', '')
username = req.username
password = req.password
# 大小包处理
try:
if UsernameIndexing.exists(username):
raise RegisterError(_YYTEXT(u'该帐号已被注册，请重新输入'))
user = register(username, password, get_device_id(req.deviceInfo))
except RegisterError as e:
raise ApplicationError(0, e.message)
info = unpack_login_info(req.deviceInfo,
userID=user.userID,
username=user.username,
featureCode=req.featureCode,
clientIP=clientIP)
info.update({
'userID': user.userID,
'username': user.username,
'type': 'register'
})
gm_logger.info({'sessionaccess': info})
account_register.info(**info)
return poem_pb.RegisterResponse(username=user.username)
def rpccall(self, key, *args, **kwargs):
player = self.player
if player:
gm_logger.info({
'behavior': {
'entityID': player.entityID,
'msgid': clean_msgtype(key),
}
})
return super(BaseService, self).rpccall(key, *args, **kwargs)
def faction_create(self, msgtype, body):
p = self.player
# 判断是否可以创建公会
if p.factionID:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FACTION_ALREADY_HAD_FACTION)
# if is_applied(p):
# return fail_msg(
# msgtype, msgTips.FAIL_MSG_FACTION_ALREADY_APPLYED)
req = poem_pb.AlterNameFaction()
req.ParseFromString(body)
name, err = validate_name(req.name)
if err:
return fail_msg(msgtype, err)
try:
FactionnameIndexing.register(0, name) # 占位
except DuplicateIndexException:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FACTION_DUPLICATE_FACTION_NAME)
try:
now = int(time.time())
faction = Faction.create(name=name,
createtime=now,
leaderID=p.entityID)
except EntityExistsException:
FactionnameIndexing.unregister(name)
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_CREATE_FAIL)
try:
apply_reward(p, {},
cost={'gold': 500},
type=RewardType.CreateFaction)
except AttrNotEnoughError:
FactionnameIndexing.unregister(name)
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_NOT_ENOUGH_GOLD)
FactionnameIndexing.pool.execute('HSET', FactionnameIndexing.key, name,
faction.entityID) # 更新
faction.save()
gm_logger.info({
'faction': {
'entityID': p.entityID,
'type': 'create_faction',
'factionName': faction.name,
'factionLevel': 1,
'factionID': faction.factionID,
}
})
join_faction(p.entityID, faction.factionID)
p.faction_is_leader = True
p.save()
p.sync()
recommend(faction.factionID) # 加入推荐列表
FactionRankRanking.update_score(faction.factionID, 1)
rsp = poem_pb.FactionInfo(**get_faction_info(faction.factionID))
return success_msg(msgtype, rsp)
def join_faction(entityID, factionID):
faction = Faction.simple_load(factionID, [
"level", "name", "memberset", "inviteset", "applyset",
"strengthen_hp_level", "strengthen_at_level", "strengthen_ct_level",
"strengthen_df_level"
])
# recommend
level = FactionRankRanking.get_score(factionID) or 1
limit = get_config(FactionLimitConfig)[level].limit
if limit - len(faction.memberset) <= 1:
unrecommend(factionID)
clean_faction(entityID)
p = g_entityManager.get_player(entityID)
if not p:
p = Player.simple_load(entityID, [
'inviteFactionSet',
'factionID',
'last_factionID',
'strengthen_at_level',
'strengthen_hp_level',
'strengthen_ct_level',
'strengthen_df_level',
])
p.factionID = faction.factionID
p.faction_name = faction.name
p.faction_level = level
now = int(time.time())
p.joinFactionTime = now
# FIXME
for fid in p.inviteFactionSet:
f = Faction.simple_load(fid, ['inviteset'])
safe_remove(f.inviteset, p.entityID)
f.save()
p.inviteFactionSet.clear()
if p.factionID != p.last_factionID:
p.totalfp = 0
p.todayfp_donate = 0
p.todayfp_task = 0
p.todayfp_sp = 0
faction.memberset.add(p.entityID)
safe_remove(faction.applyset, p.entityID)
safe_remove(faction.inviteset, p.entityID)
if g_entityManager.get_player(entityID):
p.load_faction()
p.sync()
p.save()
faction.save()
gm_logger.info({
'faction': {
'entityID': p.entityID,
'type': 'join_faction',
'factionID': faction.factionID,
}
})
def create_role(self, msgtype, body):
limited, message = self.access_limited()
if limited:
return fail_msg(msgtype, reason=message)
req = poem_pb.CreateRoleRequest()
req.ParseFromString(body)
modelID = req.iconID
user = User.load(self.userID)
roleID = user.roles.get(settings.REGION['ID'])
if roleID:
return fail_msg(msgtype, msgTips.FAIL_MSG_ALREADY_CREATEROLE)
name, error = validate_name(req.name)
if error:
return fail_msg(msgtype, error)
# 名字去重复
try:
PlayernameIndexing.register(0, name) # 占位
player = Player.create(name=name, modelID=modelID, sex=req.sex, level=1, career=req.school)
player.save()
PlayernameIndexing.pool.execute('HSET', PlayernameIndexing.key, name, player.entityID) # 更新
except DuplicateIndexException:
return fail_msg(msgtype, reason=_YYTEXT('该名称已存在'))
except EntityExistsException: # 已经存在的entityID, 一般由于自增ID被清零，但entityID数据还存在
return fail_msg(msgtype, reason=_YYTEXT('该名称已存在'))
if not player or not player.entityID:
PlayernameIndexing.unregister(name)
return fail_msg(msgtype, reason=_YYTEXT('该名称已存在'))
PlayerLevelRanking.update_score(player.entityID, player.level)
user.roles[settings.REGION['ID']] = player.entityID
user.save()
rsp = poem_pb.CreateRoleResponse()
rsp.roleId = player.entityID
role = rsp.roles.add()
role.name, role.level, role.resourceId, role.school, role.sex = \
player.name, player.level, player.modelID, player.career, player.sex
from common.log import gm_logger
gm_logger.info({'createrole': {'entityID': player.entityID,
'userID': self.userID,
'type': 'createrole',
'username': player.username,
'playername': player.name,
'worldID': settings.SESSION['ID'],
'createrolename': player.name,
'career': player.career,
'username_alias': user.username_alias}})
role.id = rsp.roleId
return success_msg(msgtype, rsp)
def faction_levelup(self, msgtype, body):
'''只有会长能操作'''
player = self.player
factionID = player.factionID
if not factionID:
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_HAS_NOT_FACTION)
faction = Faction.simple_load(factionID, ['leaderID'])
if player.entityID != faction.leaderID:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FACTION_PERMISSION_DENIED)
level = FactionRankRanking.get_score(factionID) or 0
configs = get_config(FactionLimitConfig)
config = configs.get((level or 1) + 1)
if not config:
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_MAX_LEVEL)
faction = Faction.load(factionID)
if faction.totalfp < config.exp:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FACTION_NOT_ENOUGH_TOTALFP)
faction.incr('totalfp', -config.exp)
faction.save()
if not level:
incr = 2
else:
incr = 1
rs = FactionRankRanking.incr_score(factionID, incr)
limit1 = get_config(FactionLimitConfig)[level or 1]
limit2 = get_config(FactionLimitConfig).get((level or 1) + 1)
if limit2 and limit2.limit > limit1.limit:
recommend(factionID)
player.save()
player.sync()
notify_change(factionID)
gm_logger.info({
'faction': {
'entityID': player.entityID,
'type': 'levelup_faction',
'factionLevel': rs,
'factionID': faction.factionID,
}
})
return success_msg(msgtype, '')
def save_guide(player, guide_type):
# 保存新手引导进度
if not guide_type:
return
if guide_type in player.guide_types:
return
from common.log import gm_logger
from scene.constants import FbType
fbinfo = get_config(FbInfoByTypeConfig).get(FbType.Normal, [])
maxfb = max(set(player.fbscores) & set(e.ID for e in fbinfo) or [0])
gm_logger.info({"guide": {
"entityID": player.entityID,
"type": "guide_%s" % guide_type,
"userID": player.userID,
"username": player.username,
"data": {"fbID": maxfb},
}})
player.guide_types.add(guide_type)
player.set_dirty('guide_types')
player.save()
def throne_member(factionID, entityID):
player = g_entityManager.get_player(entityID)
faction = Faction.simple_load(factionID, ['entityID', 'memberset'])
if player.factionID == factionID:
if int(time.time()) - player.joinFactionTime <= THRONEFACTIONCD:
return msgTips.FAIL_MSG_FACTION_CAN_NOT_THRONE_TO_NEWER
faction.leaderID = player.entityID
faction.save()
player.faction_is_leader = True
player.save()
player.sync()
gm_logger.info({
'faction': {
'entityID': player.entityID,
'type': 'throne_faction',
'factionID': faction.factionID,
}
})
return SUCCESS
return msgTips.FAIL_MSG_FACTION_IS_NOT_IN_FACTION
def faction_alter_name(self, msgtype, body):
p = self.player
factionID = self.player.factionID
if not factionID:
return fail_msg(msgtype, msgTips.FAIL_MSG_FACTION_HAS_NOT_FACTION)
faction = Faction.simple_load(factionID, ['leaderID', 'name'])
if self.player.entityID != faction.leaderID:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FACTION_PERMISSION_DENIED)
req = poem_pb.AlterNameFaction()
req.ParseFromString(body)
cost = get_cons_value("FactionAlterNameGold")
if p.gold < cost:
return fail_msg(msgtype, reason="钻石不足")
name, err = validate_name(req.name)
if err:
return fail_msg(msgtype, err)
try:
FactionnameIndexing.register(factionID, req.name)
except DuplicateIndexException:
return fail_msg(msgtype,
msgTips.FAIL_MSG_FACTION_DUPLICATE_FACTION_NAME)
FactionnameIndexing.unregister(faction.name)
apply_reward(p, {},
cost={"gold": cost},
type=RewardType.FactionAlterName)
faction.name = req.name
p.save()
p.sync()
faction.save()
notify_change(factionID)
gm_logger.info({
'faction': {
'entityID': p.entityID,
'type': 'altername_faction',
'factionName': faction.name,
'factionID': faction.factionID,
}
})
return success_msg(msgtype, '')
def cleanup(player):
if not player:
return
PlayerOnlineIndexing.unregister(player.entityID)
player.save_on_quit()
logger.info('player quit %d', player.entityID)
g_entityManager.unload_player(player.entityID)
g_playerManager.close_player(player.entityID)
logger.info('clean up %d', player.entityID)
if player.lastlogin and player.lastlogout:
onlinetimes = (player.lastlogout - player.lastlogin).total_seconds()
else:
onlinetimes = 0
gm_logger.info({
'access': {
'entityID': player.entityID,
'type': 'logout',
'userID': player.userID,
'username': player.username,
'onlinetimes': onlinetimes,
'username_alias': player.username_alias,
'channel': player.channel
}
})
def itunes_iap_validation_handle(self, msgtype, req):
from itunesiap import Request, set_verification_mode
from itunesiap.exceptions import InvalidReceipt, ItunesServerNotAvailable
from session.utils import sdk_username
from sdk.payment import end_payment, get_payment, gen_payment
player = self.player
try:
# set_verification_mode('sandbox')
request = Request(req.receipt)
with request.verification_mode('review'):
receipt = request.verify()
logger.info(receipt)
configs = get_config(RechargeConfig)
goods = filter(
lambda item: item.goodsid == receipt.product_id and item.
sdktype == poem_pb.SDK_APP_IOS, configs.values())
if len(goods) != 1:
logger.error('Invalid goodsid: {},{}'.format(
player.entityID, receipt.product_id))
return False
goods = goods[0]
logger.debug(goods)
sdkorderid = sdk_username(poem_pb.SDK_APP_IOS,
receipt.transaction_id)
payment = get_payment(sdkorderid)
if not payment:
result = gen_payment(sdkorderid, player.entityID,
poem_pb.SDK_APP_IOS, receipt.product_id)
payment = get_payment(sdkorderid)
if payment.get('status', None) != 'SUCCESS':
if not end_payment(sdkorderid):
logger.error('insert callback pay record failed %s' %
sdkorderid)
return False
payment = get_payment(sdkorderid)
logger.debug(payment)
data = {
"clientVersion": "",
"amount": goods.amount,
"orderNO": sdkorderid,
"_level": "",
"_username": "",
"_userID": 0,
"_entityID": player.entityID,
"result": 1
}
username = player.username
userID = player.userID
idfa = player.idfa
appid = player.appid
rs = pay_handler(player.entityID,
username,
payment["goodsid"],
amount=int(goods.amount))
if not rs:
return False
logger.debug(rs)
get_gold = rs["get_gold"]
username = rs["username"]
level = rs["level"]
rsp = poem_pb.PayResult(success=True,
roleID=player.entityID,
userID=0,
payID=receipt.transaction_id,
goods=0,
count=get_gold,
data=req.receipt)
g_playerManager.sendto(player.entityID,
success_msg(msgid.SDK_PAY_RESULT, rsp))
data.update(_username=username, _level=level)
data.update(_gold=get_gold)
role_credit(**data)
gm_logger.info({
'pay': {
'transaction_id': receipt.transaction_id,
'userID': userID,
'entityID': player.entityID,
'channel': player.channel,
'amount': goods.amount,
'gold': get_gold,
'idfa': idfa,
'appid': appid,
'username': username
},
'payID': sdkorderid
})
if payment.get('status', None) == 'SUCCESS':
response = poem_pb.iTunesStoreReceiptResponse()
response.transaction_id = receipt.transaction_id
response.successed = True
g_playerManager.sendto(player.entityID,
success_msg(msgtype, response))
except InvalidReceipt:
logger.warning('invalid receipt')
def enter(self, msgtype, body):
req = poem_pb.EnterRequest()
req.ParseFromString(body)
entityID = req.entityID
# 不允许重新登录
if g_playerManager.has_player(entityID):
if g_playerManager.peers[entityID].key == self.peer.key:
return
# 给已登录的发送重复登录消息
g_playerManager.sendto(entityID,
fail_msg(msgtype, msgTips.FAIL_MSG_KICKED))
g_playerManager.kick_player(entityID)
clientVersion = req.clientVersion
featureCode = req.featureCode
clientIP, _ = self.peer._sock.getpeername() or ('', '')
self.player = player = g_entityManager.load_player(
self.userID, entityID, clientVersion, featureCode, clientIP)
if not player:
self.peer.sender(fail_msg(msgtype, msgTips.FAIL_MSG_LOAD_PLAYER))
self.peer.close()
return
PlayerOnlineIndexing.update(settings.WORLD["ID"], player.entityID)
player.clientVersion = clientVersion
player.featureCode = featureCode
player.clientIP = clientIP
player.appid = req.deviceInfo.appid
player.UDID = req.deviceInfo.UDID
player.idfa = req.deviceInfo.idfa
player.IMEI = req.deviceInfo.IMEI
player.MAC = req.deviceInfo.MAC
player.save()
g_playerManager.register(player.entityID, self.peer)
player.sync(all=True)
# 发送公告
notice_rsp = get_notice_rsp()
g_playerManager.sendto(player.entityID,
success_msg(msgid.NOTICE, notice_rsp))
sync_scene_infos(player)
rsp = poem_pb.EnterResponse()
rsp.ENABLE_GIFTKEY = settings.ENABLE_GIFTKEY # cdkey
rsp.REV = settings.REV
rsp.time = int(time.time())
self.peer.sender(success_msg(msgtype, rsp))
gm_logger.info({
'access': {
'entityID': player.entityID,
'type': 'login',
'userID': player.userID,
'username': player.username,
'onlines': g_playerManager.count(),
'username_alias': player.username_alias,
'channel': player.channel
}
})
from common.log import role_login
role_login(player=player)
def _set_plan(player, task, today, value=1, replace=False):
realID = task.ID
configs = get_config(TaskConfig)
info = task
taskID = info.sameID
task = player.tasks.get(taskID, {})
if not info:
return
logger.debug('set taskID {} value {}'.format(taskID, value))
if not replace:
if task.get('when'):
when = datedate.fromtimestamp(task['when'])
plan = task.get('plan', 0)
prev = configs.get(info.prev)
if prev:
init = prev.goal
else:
init = 0
if info.type in (TaskType.Daily, TaskType.Faction,
TaskType.Trigger):
if when != today:
task['plan'] = init + value
else:
if not plan:
task['plan'] = init + value
else:
task['plan'] += value
elif info.type == TaskType.Sign:
if (when.year, when.month) != (today.year, today.month):
task['plan'] = init + value
else:
if not plan:
task['plan'] = init + value
else:
task['plan'] += value
else:
if not plan:
task['plan'] = init + value
else:
task['plan'] += value
else:
task['plan'] = value
else:
task['plan'] = value
task['when'] = int(time.time())
logger.debug("{} {}".format(taskID, task))
isdone = task['plan'] >= info.goal
if isdone:
info = configs[realID]
player.taskrewards.add(realID)
if info.type == TaskType.Faction:
player.faction_taskID = 0
player.faction_task_done = True
elif info.type == TaskType.Trigger:
pass
from common.log import gm_logger
t = {TaskType.Normal: "主线"}
info = configs[realID]
gm_logger.info({
'task': {
'entityID': player.entityID,
'userID': player.userID,
'username': player.username,
'data': {
'taskID': realID
},
'type': t.get(info.type, "支线"),
}
})
player.tasks[taskID] = task
return isdone
def sdk_pay(entityID,
orderid,
amount,
rechargegold,
sdata,
sdktype,
goods,
delay=0):
from session.utils import sdk_username
from sdk.payment import end_payment, get_payment
GOOD_GOLD = 0
if orderid:
sdkorderid = sdk_username(sdktype, orderid)
payment = get_payment(sdkorderid)
if len(payment) == 0:
logger.error('orderid {} not exists.'.format(orderid))
return False
# 如果交易完成直接返回成功
if payment.get('status', None) == 'SUCCESS':
return True
if not end_payment(sdkorderid):
logger.error('insert callback pay record failed %s' % sdkorderid)
return False
goodsid = payment["goodsid"]
elif sdktype == poem_pb.SDK_YYB:
sdkorderid = sdk_username(sdktype, '')
ids = get_config(RechargeBySdktypeConfig).get(sdktype, [])
configs = [get_config(RechargeConfig)[e.id] for e in ids]
goodsid = max(configs, key=lambda o: o.amount).goodsid
else:
logger.error('orderid {} is empty.'.format(orderid))
return False
amount = amount / 10.0
gold = rechargegold
if goods == GOOD_GOLD:
data = {
"clientVersion": "",
"amount": gold,
"orderNO": sdkorderid,
"_level": "",
"_username": "",
"_userID": 0,
"_entityID": entityID,
"result": 1
}
player = g_entityManager.get_player(entityID)
if player:
username = player.username
userID = player.userID
playername = player.name
channel = player.channel
else:
p = Player.simple_load(entityID,
["username", "userID", "name", "channel"])
username = p.username
userID = p.userID
playername = p.name
channel = p.channel
rs = pay_handler(entityID, username, goodsid, amount=amount)
if not rs:
return False
get_gold = rs["get_gold"]
username = rs["username"]
level = rs["level"]
if player:
rsp = poem_pb.PayResult(success=True,
roleID=entityID,
userID=userID,
payID=orderid,
goods=0,
count=get_gold,
data=sdata)
if delay == 0:
g_playerManager.sendto(player.entityID,
success_msg(msgid.SDK_PAY_RESULT, rsp))
else:
def do_send():
gevent.sleep(delay)
g_playerManager.sendto(
player.entityID, success_msg(msgid.SDK_PAY_RESULT,
rsp))
gevent.spawn(do_send)
data.update(_username=username, _level=level)
data.update(_gold=get_gold)
role_credit(**data)
gm_logger.info({
'pay': {
'entityID': entityID,
'amount': amount,
'userID': userID,
'playername': playername,
'channel': channel,
'gold': get_gold,
'username': username,
'transaction_id': orderid
},
'payID': sdkorderid
})
return True
logger.error('unknown goods %d', goods)
return False
def apply_reward(role,
reward,
cost=None,
type=RewardType.Undefined,
force=True,
extra=None):
# reward like {'gold':10, 'exp':10, 'petList':[[30000001, 1]]}
# force 不检查限制
reward = dict(reward or {})
reward_ = dict(reward or {})
petList = reward.pop('petList', [])
matList = reward.pop('matList', [])
patList = reward.pop('petPatchList', []) # FIXME
equipList = reward.pop('equipList', [])
gemList = reward.pop('gemList', [])
specPacks = reward.pop('specPacks', [])
p_in_specPacks = 0
e_in_specPacks = 0
from config.configs import get_config
packs = get_config(SpecpackConfig)
for packID, count in specPacks:
pack = packs[packID]
if pack.ref_type == RewardItemType.Equip:
e_in_specPacks += count
elif pack.ref_type == RewardItemType.Pet:
p_in_specPacks += count
if not force:
if petList:
if not check_add_pets(role, len(petList) + p_in_specPacks):
raise PetExceedError
if matList:
if not check_add_mats(role, len(matList)):
raise MatExceedError
if equipList:
if not check_add_equips(role, len(equipList) + e_in_specPacks):
raise EquipExceedError
if gemList:
if not check_add_gems(role, len(gemList)):
raise GemExceedError
if cost:
_cost(role, cost, type)
if reward_:
add_pets(role, petList, extra=extra)
add_mats(role, matList)
add_pats(role, patList) # FIXME 已经不再使用
add_attr(role, reward)
add_equips(role, equipList, extra=extra)
add_specpacks(role, specPacks)
add_gems(role, gemList)
# {{{
from common.log import gm_logger
if isinstance(role, Player):
player = role
else:
from entity.manager import g_entityManager
player = g_entityManager.get_player(role.masterID)
gm_logger.info({
'gain': {
'entityID': player.entityID,
'data': reward_,
'type': type
}
})
from common.log import role_debit
for prototypeID, amount in petList:
role_debit(player=player,
debitType=role_debit.Gain,
itemType=type,
argID=prototypeID,
argAmount=amount)
for prototypeID, amount in equipList:
role_debit(player=player,
debitType=role_debit.Gain,
itemType=type,
argID=prototypeID,
argAmount=amount)
for matID, amount in matList:
role_debit(player=player,
debitType=role_debit.Gain,
itemType=type,
argID=matID,
argAmount=amount)
for gemID, amount in gemList:
role_debit(player=player,
debitType=role_debit.Gain,
itemType=type,
argID=gemID,
argAmount=amount)
for attr, amount in reward.items():
if not check_attr(attr) or amount == 0:
continue
role_debit(
player=player,
debitType=role_debit.Gain,
itemType=type,
currency=RewardItemTypeDict[attr],
amount=amount,
balance=getattr(player, attr, 0),
)
# }}}
role.save()
return reward_
def cost(role, cost, type):
cost_ = dict(cost)
matList = cost.pop('matList', [])
petList = cost.pop('petList', [])
patList = cost.pop('petPatchList', [])
equipList = cost.pop('equipList', [])
gemList = cost.pop('gemList', [])
# CHECK
check_cost_mats(role, matList)
check_cost_pets(role, petList)
check_cost_equips(role, equipList)
check_cost_gems(role, gemList)
check_cost_attr(role, cost)
cost_mats(role, matList)
cost_pets(role, petList)
cost_equips(role, equipList)
cost_gems(role, gemList)
if not cost_pats(role, patList):
raise PatNotEnoughError
# {{{cost log
from common.log import gm_logger
if isinstance(role, Player):
player = role
else:
from entity.manager import g_entityManager
player = g_entityManager.get_player(role.masterID)
gm_logger.info(
{'cost': {
'entityID': player.entityID,
'data': cost_,
'type': type
}})
# }}}
cost_attr(role, cost)
# {{{
from common.log import role_debit
for prototypeID, amount in petList:
role_debit(player=player,
debitType=role_debit.Cost,
itemType=type,
argID=prototypeID,
argAmount=amount)
for matID, amount in matList:
role_debit(player=player,
debitType=role_debit.Cost,
itemType=type,
argID=matID,
argAmount=amount)
for patchid, amount in patList:
role_debit(player=player,
debitType=role_debit.Cost,
itemType=type,
argID=-patchid,
argAmount=amount)
for prototypeID, amount in equipList:
role_debit(player=player,
debitType=role_debit.Cost,
itemType=type,
argID=prototypeID,
argAmount=amount)
for prototypeID, amount in gemList:
role_debit(player=player,
debitType=role_debit.Cost,
itemType=type,
argID=prototypeID,
argAmount=amount)
for attr, amount in cost.items():
if not check_attr(attr) or amount == 0:
continue
role_debit(
player=player,
debitType=role_debit.Cost,
itemType=type,
currency=RewardItemTypeDict[attr],
amount=amount,
balance=getattr(player, attr, 0),
)
# }}}
return cost_
def common_login(request,
raw_username,
req,
auto_register=False,
check_password=True):
# 检查版本
try:
clientversion = int(getattr(req.deviceInfo, 'clientVersion', 1))
except ValueError:
clientversion = 1
if get_device_id(req.deviceInfo) in g_block_devices:
raise ApplicationError(0, u"该设备已被禁止登录 如有疑问请联系客服")
if get_g_version() and clientversion and get_g_version() > clientversion:
raise ApplicationError(msgTips.FAIL_MSG_LOGIN_OLDVERSION,
settings.CLIENTOLDVERSION_NOTICE)
username = raw_username
# 检查白名单
if username not in g_whitelist:
raise ApplicationError(0, get_loginlimitmsg())
# 查找用户
userID = UsernameIndexing.get_pk(username)
if userID:
user = User.get(userID)
user.load_containers()
# 检查设备锁定
if user.lock_device and get_device_id(
req.deviceInfo) != user.lock_device:
raise ApplicationError(0, u'该帐号为试玩帐号，只能在注册时的使用的设备上登录！')
else:
user = None
clientIP = request.env.get('REMOTE_ADDR', '')
password = getattr(req, 'password', '') or "dummy"
if not user and auto_register:
# register
try:
user = register(raw_username, password,
get_device_id(req.deviceInfo))
except RegisterError as e:
raise ApplicationError(0, e.message)
# 创建成功
userID = user.userID
info = unpack_login_info(req.deviceInfo,
userID=userID,
username=user.username,
featureCode=req.featureCode,
clientIP=clientIP)
info.update({
'userID': userID,
'username': user.username,
'type': 'register'
})
gm_logger.info({'sessionaccess': info})
account_register.info(**info)
if not user:
raise ApplicationError(msgTips.FAIL_MSG_LOGIN_WRONG_ACCOUNT)
# 检查密码
userID = user.userID
if check_password:
hashed = user.password
if not utils.check_password(password, hashed):
raise ApplicationError(msgTips.FAIL_MSG_INVALID_PASSWORD)
# 检查封停
now = int(time.time())
if user.blocktime and user.blocktime > now:
raise ApplicationError(0, u"该账号已被禁止登录 如有疑问请联系客服")
if user.imsi in g_block_devices:
raise ApplicationError(0, u"该账号已被禁止登录 如有疑问请联系客服")
do_login(request, userID)
user.lastserver = req.regionID
user.save()
# log
info = unpack_login_info(req.deviceInfo,
userID=userID,
username=user.username,
featureCode=req.featureCode,
clientIP=clientIP)
info.update({'userID': userID, 'username': user.username, 'type': 'login'})
gm_logger.info({'sessionaccess': info})
account_login.info(**info)
# 响应
entityIDs = user.roles.get(req.regionID, [])
return poem_pb.HTTPLoginResponse(
userID=userID,
sdk_username=user.username,
world=encode_world(
route(req.regionID, entityIDs[0] if entityIDs else None)),
verify_code=request.sid,
)