def user_back(self, msgtype, body):
room_obj = g_gameManager.get_room(self.player.room_id)
rsp_user_offline = rainbow_pb.UserOffline()
rsp_user_offline.entityID = self.player.entityID
rsp_user_offline.offline = False
msg = success_msg(msgid.ROOM_USER_OFFLINE, rsp_user_offline)
for role in room_obj.roles:
if not role['offline']:
g_playerManager.sendto(role['entityID'], msg)
role = room_obj.get_role(self.player.entityID)
role.offline = False
rsp = rainbow_pb.JoinRoomResponse()
rsp.room_id = room_obj.room_id
rsp.master_id = room_obj.master_entity_id
rsp.master_server_index = room_obj.master_server_index
rsp.game_id = room_obj.game_id
rsp.game_settings = room_obj.game_settings
rsp.play_count = room_obj.play_count
rsp.min_player_count = room_obj.game_config['min_player_count']
rsp.max_player_count = room_obj.game_config['max_player_count']
for role in room_obj.roles:
rsp.users.add(**role)
return success_msg(msgtype, '')
def user_out(self, msgtype, body):
req = rainbow_pb.KickOutRequest()
req.ParseFromString(body)
room_obj = g_gameManager.get_room(self.player.room_id)
if room_obj.master_entity_id != self.player.entityID:
return fail_msg(msgtype,
msgTips.FAIL_MSG_ROOM_KICK_OUT_PERMISSION_DENY)
rsp = rainbow_pb.KickOutResponse()
rsp.kick_out_id = req.kick_out_id
msg = success_msg(msgtype, rsp)
for role in room_obj.roles:
if role['entityID'] == 0:
continue
p = g_entityManager.get_player(role['entityID'])
if p:
# 如果就是这个玩家被踢的话，清空一下数据
if p.entityID == req.kick_out_id:
p.room_id = 0
p.save()
p.sync()
# 发送踢人的消息
if role['entityID'] != self.player.entityID:
g_playerManager.sendto(role['entityID'], msg)
# 把这个位置空出来
if role['entityID'] == req.kick_out_id:
role['entityID'] = 0
role['username'] = ''
return msg
def user_out(self, msgtype, body):
req = rainbow_pb.KickOutRequest()
req.ParseFromString(body)
room_obj = g_roomManager.get_room(self.player.room_id)
if not room_obj:
return fail_msg(msgtype, msgTips.FAIL_MSG_ROOM_NOT_EXIST)
if room_obj.master_entity_id != self.player.entityID:
return fail_msg(msgtype, msgTips.FAIL_MSG_ROOM_KICK_OUT_PERMISSION_DENY)
rsp_user_kick_out = rainbow_pb.UserKickOut()
rsp_user_kick_out.kick_out_id = req.kick_out_id
msg = success_msg(msgid.ROOM_USER_BEEN_KICK_OUT, rsp_user_kick_out)
for role in room_obj.roles:
if role.entityID == 0:
continue
p = g_entityManager.get_player(role.entityID)
if p:
if p.entityID == req.kick_out_id:
p.room_id = 0
p.pos_index = 0
p.save()
g_playerManager.sendto(role.entityID, msg)
if role.entityID == req.kick_out_id:
role.entityID = 0
role.username = ''
return success_msg(msgtype, '')
def broadcast_red_message(info):
rsp = poem_pb.RedInfo(**info)
if not info:
return
g_redManager.cache_red_message(info)
msg = success_msg(msgid.DAILY_RED_INFO, rsp)
for k, p in g_entityManager.players.items():
g_playerManager.sendto(k, msg)
def multi_sync_property(entities, masterID=None):
for entity in entities:
entity.pop_sync_dirty()
if masterID:
assert entity.masterID == masterID, 'entity not in master'
else:
masterID = entity.masterID
if masterID:
msg = multi_sync_property_msg(entities, None)
g_playerManager.sendto(masterID, msg)
def sync_lineups(player):
rsp = Lineups()
for type, _lineup in player.lineups.items():
lineup = rsp.lineups.add(line=_lineup, type=type)
if type == LineupType.ATK:
for index, petID in enumerate(_lineup):
if petID:
for info in get_equipeds_infos(player.entityID, petID,
index):
lineup.equipeds.add(**info)
g_playerManager.sendto(player.entityID, success_msg(LINEUP_LINEUPS, rsp))
def sync_mats(role, all=False):
if all:
mats = role.mats.keys()
else:
mats = pop_mats_dirty(role)
if not mats and not all:
return
rsp = Mats()
for matID in mats:
count = role.mats.get(matID, 0)
rsp.mats.add(matID=matID, count=count)
g_playerManager.sendto(role.entityID, success_msg(msgid.SYNC_MATS, rsp))
def sync_gems(role, all=False):
if all:
gems = role.gems.keys()
else:
gems = pop_gems_dirty(role)
if not gems and not all:
return
rsp = poem_pb.Gems()
for gemID in gems:
count = role.gems.get(gemID, 0)
rsp.gems.add(gemID=gemID, count=count)
g_playerManager.sendto(role.entityID, success_msg(msgid.SYNC_GEMS, rsp))
def sync_player_property(player, all=False, syncSence=False, syncfields=set()):
'sync player dirty fields'
if all:
fields = None
player.pop_sync_dirty()
elif syncfields:
fields = player.remove_sync_dirty(syncfields)
else:
fields = player.pop_sync_dirty(syncSence)
if not fields:
#logger.error("Called sync_property, but nothing to sync!")
return
msg = sync_property_msg(player, fields, isme=True)
g_playerManager.sendto(player.entityID, msg)
def user_leave(self, msgtype, body):
room_obj = g_gameManager.get_room(self.player.room_id)
role = room_obj.get_role(self.player.entityID)
role['offline'] = True
rsp_user_offline = rainbow_pb.UserOffline()
rsp_user_offline.entityID = self.player.entityID
rsp_user_offline.offline = True
msg = success_msg(msgid.ROOM_USER_OFFLINE, rsp_user_offline)
for role in room_obj.roles:
if not role['offline']:
g_playerManager.sendto(role['entityID'], msg)
return success_msg(msgtype, '')
def sync_scene_infos(player, type=FbType.Normal):
fbInfos = get_config(FbInfoConfig)
fbs, nexts = get_fb_list(player, type)
rsp = SceneInfos()
today_ts = int(time.mktime(datedate.today().timetuple()))
for f in fbs: # 过滤引导关卡
count = get_today_remain_count(player, f, today=today_ts)
rsp.fbs.add(**get_fb_info(player, f, today=today_ts))
for next in nexts:
count = get_today_remain_count(player, next, today=today_ts)
info = fbInfos[next]
rsp.fbs.add(fbID=next, count=count, isNew=True, openlv=info.openlv)
for s in get_scene_list(player, fbs + nexts):
rsp.scenes.add(**get_scene_info(player, s))
rsp.type = type
logger.debug(rsp)
g_playerManager.sendto(player.entityID, success_msg(SCENE_INFOS, rsp))
def send_red_message(self,
p,
message,
red_count=0,
cd=10,
red_drop=0,
to_self=False,
type=RedType.Normal,
module=RedModuleType.Daily,
**kwargs):
if not message.strip(" "):
return
t = str(float(time.time()))
data = {
"message": message,
"type": type,
"order": t,
"to_self": to_self,
"module": module,
"drop": red_drop,
}
if isinstance(p, int):
entityID = p
else:
entityID = p.entityID
data.update({
"name": p.name,
"prototypeID": p.prototypeID,
"borderID": p.borderID,
})
data.update(**kwargs)
pb = poem_pb.RedInfo(**data)
if type == RedType.Red:
del data["to_self"]
self.send_red(p, red_count, data)
else:
if to_self:
msg = success_msg(msgid.DAILY_RED_INFO, pb)
if g_playerManager.has_player(entityID):
g_playerManager.sendto(entityID, msg)
else:
proxy.send_self_red_message(entityID, data)
else:
data["cd"] = cd
proxy.broadcast_red_message(data)
def game_reconn(self, msgtype, body):
room_obj = g_gameManager.get_room(self.player.room_id)
room_obj.player_reconn(self.player)
offline_rsp = rainbow_pb.UserOffline()
offline_rsp.entityID = self.player.entityID
offline_rsp.offline = False
for role_info in RoomRoleSitDownIterator(room_obj):
if role_info['entityID'] == self.player.entityID:
continue
g_playerManager.sendto(
role_info['entityID'],
success_msg(msgid.ROOM_USER_OFFLINE, offline_rsp))
return success_msg(
msgtype,
room_obj.pack_game_data(rainbow_pb.GameDataMahjong.Reconn,
self.player.entityID))
def send_horn(message, cd=10, **kwargs):
t = str(float(time.time()))
data = {
"message": message,
"type": RedType.Horn,
"order": t,
"to_self": False,
"module": RedModuleType.System,
"cd": cd,
}
data.update(**kwargs)
data["cd"] = cd
g_redManager.cache_red_message(data)
rsp = poem_pb.RedInfo(**data)
print rsp
msg = success_msg(msgid.BROADCAST_HORN, rsp)
for k, p in g_entityManager.players.items():
g_playerManager.sendto(k, msg)
def apply_for_dismiss(self, msgtype, body):
room_obj = g_gameManager.get_room(self.player.room_id)
rsp = rainbow_pb.DismissRoomResult()
# 如果只有自己一个人的话，那就直接解散吧
if room_obj.get_roles_count() == 1:
g_gameManager.dismiss_room(self.player)
rsp.result = 2
return success_msg(msgtype, rsp)
# 如果已经有人申请了，你再申请的话，就默认同意了
if room_obj.apply_entityID != 0:
role = room_obj.get_role(self.player.entityID)
role['dismiss_agree'] = True
else:
room_obj.apply_entityID = self.player.entityID
rsp.apply_id = self.player.entityID
for role in room_obj.roles:
if role['entityID'] == self.player.entityID:
role['dismiss_agree'] = True
else:
role['dismiss_agree'] = False
# 统计一下同意的玩家数量和等待的玩家数量
rsp.agree_num = 0
rsp.waiting_num = 0
rsp.result = 1
for role in room_obj.roles:
if role['entityID'] != 0:
if role['dismiss_agree']:
rsp.agree_num += 1
else:
rsp.waiting_num += 1
msg = success_msg(msgtype, rsp_dismiss)
for role in room_obj.roles:
if role['entityID'] != 0 and not role[
'offline'] and role['entityID'] != self.player.entityID:
g_playerManager.sendto(role['entityID'], msg)
return msg
def sync_pet_property(pet, all=False):
'sync pet dirty fields'
from entity.manager import g_entityManager
master = g_entityManager.get_player(pet.masterID)
if pet.entityID not in master.pets:
logger.debug('pet not in master')
return
if all:
fields = None
pet.pop_sync_dirty()
else:
fields = pet.pop_sync_dirty()
if not fields:
logger.error("Called sync_property, but nothing to sync!")
return
msg = sync_property_msg(pet, fields)
g_playerManager.sendto(master.entityID, msg)
def set_exp(role, exp):
'''增加经验，如果可以升级，设置等级'''
# 试用账户有升级上限
if isinstance(
role,
Player) and role.lock_level > 0 and role.level >= role.lock_level:
from player.manager import g_playerManager
from yy.message.header import fail_msg
g_playerManager.sendto(
role.entityID,
fail_msg(
0,
reason=
'该帐号为体验帐号，只能在注册时使用的设备上登录！体验帐号等级上限为%s级，使用正常帐号登录可体验完整的游戏内容！再次感谢您的配合！'
% role.lock_level))
return False
role.exp += exp
rs = levelup(role)
if rs:
if isinstance(role, Player):
from task.manager import on_levelup, on_login
on_levelup(role)
on_login(role)
from pvp.rob import on_mine_change, check_rob
on_mine_change(role)
check_rob(role)
from entity.manager import check_level_packs
check_level_packs(role)
from player.model import PlayerLevelRanking
PlayerLevelRanking.update_score(role.entityID, role.level)
from friend.manager import recommendp
recommendp(role)
from campaign.manager import reset_online_packs
reset_online_packs(role)
from explore.ambition import reload_ambition
reload_ambition(role)
return rs
def send_friend_message(friendID, content, senderID, **extra):
now = time.time()
message = {
"time": now,
"content": content,
"senderID": senderID,
}
message.update(extra)
p = g_entityManager.get_player(friendID)
listen_to = FRIEND_LISTENERS.get(friendID, 0)
if listen_to == senderID:
rsp = poem_pb.FriendMessages()
rsp.messages.add(**message)
rsp.senderID = senderID
msg = success_msg(
msgid.LISTEN_FRIEND, rsp)
g_playerManager.sendto(friendID, msg)
return
messages = p.friend_messages.get(senderID, [])
messages.append(message)
p.friend_messages[senderID] = messages
p.save()
p.sync()
return True
if not room_obj or not room_obj:has_player(self.player.entityID):
self.player.room_id = 0
self.player.pos_index = 0
self.player.save()
return fail_msg(msgtype, msgTips.FAIL_MSG_ROOM_NOT_EXIST)
role = room_obj.get_role(self.player.entityID)
role.offline = True
rsp_user_offline = rainbow_pb.UserOffline()
rsp_user_offline.entityID = self.player.entityID
rsp_user_offline.offline = True
msg = success_msg(msgid.ROOM_USER_LEAVE, rsp_user_offline)
for role in room_obj.roles:
if not role.offline:
g_playerManager.sendto(role.entityID, msg)
return success_msg(msgtype, '')
@rpcmethod(msgid.ROOM_APPLY_FOR_DISMISS)
def apply_for_dismiss(self, msgtype, body):
room_obj = g_roomManager.get_room(self.player.room_id)
if not room_obj or not room_obj:has_player(self.player.entityID):
self.player.room_id = 0
self.player.pos_index = 0
self.player.save()
return fail_msg(msgtype, msgTips.FAIL_MSG_ROOM_NOT_EXIST)
if room_obj.get_roles_count() == 1:
rsp_result = rainbow_pb.DissmissRoomResult()
rsp_result.dismiss = True
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 sdk_pay_start(self, msgtype, body):
assert settings.PAY, "充值关闭"
req = poem_pb.SDKStartPayRequest()
req.ParseFromString(body)
p = self.player
logger.debug("request: {}".format(req))
allows = (
poem_pb.SDK_YY,
poem_pb.SDK_YY_IOS,
)
configs = get_config(RechargeConfig)
sdktype = username2type(p.username)
label = username2label(p.username)
sdkconfigs = get_config(RechargeBySdktypeConfig).get(sdktype, [])
labconfigs = get_config(RechargeByLabelConfig).get(label, [])
ids = {e.id for e in sdkconfigs} & {e.id for e in labconfigs}
if not ids:
return fail_msg(msgtype, msgTips.SUCCESS_MSG_PAY_FAIL)
configs = {configs[c].goodsid: configs[c] for c in ids}
goods = configs.get(req.goodsid)
if not goods:
return fail_msg(msgtype, msgTips.SUCCESS_MSG_PAY_FAIL)
if goods.type == RechargeType.MonthlyCard30:
if p.monthly_card_30:
msg = fail_msg(msgid.SDK_PAY_START, reason='已经购买过月卡了。')
g_playerManager.sendto(p.entityID, msg)
return
elif goods.type == RechargeType.LimitedPacks:
now = int(time.time())
info = get_limited_packs_time(now)
if not info:
return fail_msg(msgtype, msgTips.SUCCESS_MSG_PAY_FAIL)
if p.limited_packs_used_count >= info.count:
return fail_msg(msgtype, msgTips.SUCCESS_MSG_PAY_FAIL)
elif goods.type == RechargeType.TimeLimitedPacks:
now = int(time.time())
info = get_timelimited_packs_time(now)
if not info:
return fail_msg(msgtype, msgTips.SUCCESS_MSG_PAY_FAIL)
if p.timelimited_packs_last_time >= info.start and\
p.timelimited_packs_last_time < info.end:
return fail_msg(msgtype, msgTips.SUCCESS_MSG_PAY_FAIL)
elif goods.type in (RechargeType.TriggerPacks1,
RechargeType.TriggerPacks2):
if p.trigger_packs_buy_count >= 1:
return fail_msg(msgtype, reason="已经购买过了。")
from config.configs import LevelupConfig
info = get_config(LevelupConfig).get(p.level)
if not info:
return fail_msg(msgtype, msgTips.SUCCESS_MSG_PAY_FAIL)
if goods.type == RechargeType.TriggerPacks2:
if p.level < info.triggerPacks2:
return fail_msg(msgtype, msgTips.SUCCESS_MSG_PAY_FAIL)
elif goods.type == RechargeType.TriggerPacks1:
if p.level < info.triggerPacks1:
return fail_msg(msgtype, msgTips.SUCCESS_MSG_PAY_FAIL)
# NOTE 支付回调问题 不让重复买
p.trigger_packs_buy_count += 1
p.save()
p.sync()
# 测试模式充值
if req.sdkType in allows and req.goodsid is not None and getattr(
settings, 'TEST_PAY', False):
sid = ''
rs = give_goods(p, goods)
rsp = poem_pb.PayResult(success=True,
roleID=p.entityID,
userID=0,
payID=sid,
goods=0,
count=rs["gold"],
data="")
g_playerManager.sendto(
p.entityID,
success_msg(msgtype,
poem_pb.SDKStartPayResponse(serialNo=sid)))
g_playerManager.sendto(p.entityID,
success_msg(msgid.SDK_PAY_RESULT, rsp))
return
else:
# 唯一且包含时间戳信息
sid = str(objectid.ObjectId())
from sdk.payment import gen_payment
from session.utils import sdk_username
sdkorderid = sdk_username(req.sdkType, sid)
# 记录支付订单号
result = gen_payment(sdkorderid, p.entityID, req.sdkType,
req.goodsid, goods.amount)
if not result:
return fail_msg(msgid.SDK_PAY_START,
msgTips.FAIL_MSG_SDK_START_PAY_FAILED)
self.orderindex += 1
logger.info("orderid `%s`", sid)
return success_msg(msgtype, poem_pb.SDKStartPayResponse(serialNo=sid))
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 do_send():
gevent.sleep(delay)
g_playerManager.sendto(
player.entityID, success_msg(msgid.SDK_PAY_RESULT,
rsp))
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 sync_city_dungeon_current_info(entityID, current_info):
p = g_entityManager.get_player(entityID)
if p:
rsp = poem_pb.CityDungeonCurrentInfo(**current_info)
msg = success_msg(msgid.CITY_DUNGEON_CURRENT_INFO, rsp)
g_playerManager.sendto(entityID, msg)
def user_dismiss_response(self, msgtype, body):
room_obj = g_gameManager.get_room(self.player.room_id)
rsp = rainbow_pb.DismissRoomResult()
# 没有人申请解散房间，这个可能是玩家长时间没有回应导致的
# 这个时候，房间可能已经因为超时之类的，已经自动解散了
if room_obj.apply_entityID == 0:
rsp.result = 0
return success_msg(msgtype, rsp)
req = rainbow_pb.AgreeDismiss()
req.ParseFromString(body)
# 不同意的话，就解散失败
if not req.is_agree:
rsp.result = 3
msg = success_msg(msgtype, rsp)
room_obj.apply_entityID = 0
for role in room_obj.roles:
if role['entityID'] != 0:
# 清理掉玩家对解散包间的回应标识
role['dismiss_agree'] = False
# 通知玩家，解散房间失败
if not role['offline'] and role[
'entityID'] != self.player.entityID:
g_playerManager.sendto(role['entityID'], msg)
return msg
# 同意的话，就检查是否所有玩家都做出了回应
is_all_agree = True
for role in room_obj.roles:
# 先把自己的回应标记一下
if role['entityID'] == self.player.entityID:
role['dismiss_agree'] = True
# 如果有玩家还没有回应，就需要继续等待
if role['entityID'] != 0 and not role['dismiss_agree']:
is_all_agree = False
# 如果所有玩家都同意了，就解散吧
if is_all_agree:
rsp.result = 2
msg = success_msg(msgtype, rsp)
for role in room_obj.roles:
if role['entityID'] != 0 and not role['offline'] and role[
'entityID'] != self.player.entityID:
g_playerManager.sendto(role['entityID'], msg)
g_gameManager.dismiss_room(self.player)
return msg
# 统计一下同意的玩家数量和等待的玩家数量
rsp.agree_num = 0
rsp.waiting_num = 0
rsp.result = 1
for role in room_obj.roles:
if role['entityID'] != 0:
if role['dismiss_agree']:
rsp.agree_num += 1
else:
rsp.waiting_num += 1
msg = success_msg(msgtype, rsp)
for role in room_obj.roles:
if role['entityID'] != 0 and not role[
'offline'] and role['entityID'] != self.player.entityID:
g_playerManager.sendto(role['entityID'], msg)
return msg
def notify_gve_entity(entityID, message):
g_playerManager.sendto(entityID, message)
class RoomService(RpcService):
@rpcmethod(msgid.ROOM_CREATE)
def create_room(self, msgtype, body):
req = rainbow_pb.CreateRoomRequest()
req.ParseFromString(body)
if self.player.room_id != 0:
room_obj = g_roomManager.get_room(self.player.room_id):
if room_obj and room_obj.has_player(self.player.entityID):
return fail_msg(msgtype, msgTips.FAIL_MSG_ROOM_CREATE_HAS_ROOM)
room_obj = g_roomManager.create_room(self.player, req.game_id, req.game_settings)
self.player.room_id = room_obj.room_id
self.player.pos_index = 0
self.player.save()
self.player.sync()
rsp = rainbow_pb.JoinRoomResponse()
rsp.room_id = room_obj.id
rsp.master_id = room_obj.master_entity_id
rsp.server_index = 0
for role in room_obj.roles:
rsp.users.add(**role)
return success_msg(msgtype, rsp)
@rpcmethod(msgid.ROOM_USER_JOIN)
def join_room(self, msgtype, body):
req = rainbow_pb.JoinRoomRequest()
req.ParseFromString(body)
room_obj = g_roomManager.get_room(req.room_id)
if not room_obj:
return fail_msg(msgtype, msgTips.FAIL_MSG_ROOM_NOT_EXIST)
if room_obj.max_count <= len(room_obj.roles):
return fail_msg(msgtype, msgTips.FAIL_MSG_ROOM_LIMIT_EXCEED)
#
rsp_user_info = rainbow_pb.UserInfo()
rsp_user_info.entityID = self.player.entityID
rsp_user_info.username = self.player.username
rsp_user_info.sex = self.player.sex
rsp_user_info.offline = False
g_playerManager.broadcast(room_obj.roles, success_msg(msgid.ROOM_USER_IN, rsp_user_info))
#
pos_index = -1
for index, role in enumerate(room_obj.roles):
if role.entityID == 0:
role.entityID = self.player.entityID
role.username = self.player.username
role.sex = self.player.sex
role.offline = False
pos_index = index
if pos_index == -1:
pos_index = len(room_obj.roles)
room_obj.roles.append({
'entityID': self.player.entityID,
'username': self.player.username,
'sex': self.player.sex,
'offline': False,
})
self.player.room_id = req.room_id
self.player.pos_index = pos_index
self.player.save()
self.player.sync()
rsp = rainbow_pb.JoinRoomResponse()
rsp.room_id = room_obj.id
rsp.master_id = room_obj.master_entity_id
rsp.server_index = self.player.pos_index
for role in room_obj.roles:
rsp.users.add(**role)
return success_msg(msgtype, rsp)
@rpcmethod(msgid.ROOM_USER_KICK_OUT)
def user_out(self, msgtype, body):
req = rainbow_pb.KickOutRequest()
req.ParseFromString(body)
room_obj = g_roomManager.get_room(self.player.room_id)
if not room_obj:
return fail_msg(msgtype, msgTips.FAIL_MSG_ROOM_NOT_EXIST)
if room_obj.master_entity_id != self.player.entityID:
return fail_msg(msgtype, msgTips.FAIL_MSG_ROOM_KICK_OUT_PERMISSION_DENY)
rsp_user_kick_out = rainbow_pb.UserKickOut()
rsp_user_kick_out.kick_out_id = req.kick_out_id
msg = success_msg(msgid.ROOM_USER_BEEN_KICK_OUT, rsp_user_kick_out)
for role in room_obj.roles:
if role.entityID == 0:
continue
p = g_entityManager.get_player(role.entityID)
if p:
if p.entityID == req.kick_out_id:
p.room_id = 0
p.pos_index = 0
p.save()
g_playerManager.sendto(role.entityID, msg)
if role.entityID == req.kick_out_id:
role.entityID = 0
role.username = ''
return success_msg(msgtype, '')
@rpcmethod(msgid.ROOM_USER_BACK)
def user_back(self, msgtype, body):
room_obj = g_roomManager.get_room(self.player.room_id)
if not room_obj or not room_obj:has_player(self.player.entityID):
self.player.room_id = 0
self.player.pos_index = 0
self.player.save()
return fail_msg(msgtype, msgTips.FAIL_MSG_ROOM_NOT_EXIST)
rsp_user_offline = rainbow_pb.UserOffline()
rsp_user_offline.entityID = self.player.entityID
rsp_user_offline.offline = False
msg = success_msg(msgid.ROOM_USER_BACK, rsp_user_offline)
for role in room_obj.roles:
if not role.offline:
g_playerManager.sendto(role.entityID, msg)
role = room_obj.get_role(self.player.entityID)
role.offline = False
rsp = rainbow_pb.JoinRoomResponse()
rsp.room_id = room_obj.id
rsp.master_id = room_obj.master_entity_id
rsp.server_index = self.player.pos_index
for role in room_obj.roles:
rsp.users.add(**role)
return success_msg(msgtype, '')
def join_room(self, msgtype, body):
req = rainbow_pb.JoinRoomRequest()
req.ParseFromString(body)
room_obj = g_gameManager.get_room(req.room_id)
if not room_obj:
return fail_msg(msgtype, msgTips.FAIL_MSG_ROOM_NOT_EXIST)
if room_obj.max_count <= len(room_obj.roles):
return fail_msg(msgtype, msgTips.FAIL_MSG_ROOM_LIMIT_EXCEED)
# 自动找个位置坐下
pos_index = -1
for index, role in enumerate(room_obj.roles):
if role['entityID'] == 0:
role['entityID'] = self.player.entityID
role['username'] = self.player.username
role['sex'] = self.player.sex
role['offline'] = False
role['is_ready'] = False
role['pos_index'] = index
pos_index = index
if pos_index == -1:
pos_index = len(room_obj.roles)
room_obj.roles.append({
'entityID': self.player.entityID,
'username': self.player.username,
'sex': self.player.sex,
'offline': False,
'is_ready': False,
'pos_index': pos_index,
})
# 通知房间中的其他玩家，有人进来了
rsp_user_info = rainbow_pb.RoomUserInfo()
rsp_user_info.entityID = self.player.entityID
rsp_user_info.username = self.player.username
rsp_user_info.sex = self.player.sex
rsp_user_info.offline = False
rsp_user_info.pos_index = pos_index
msg = success_msg(msgid.ROOM_USER_IN, rsp_user_info)
for role in room_obj.roles:
if role['entityID'] != 0 and not role[
'offline'] and role['entityID'] != self.player.entityID:
g_playerManager.sendto(role['entityID'], msg)
#
self.player.room_id = req.room_id
self.player.save()
self.player.sync()
rsp = rainbow_pb.JoinRoomResponse()
rsp.room_id = room_obj.room_id
rsp.master_id = room_obj.master_entity_id
rsp.master_server_index = room_obj.master_server_index
rsp.game_id = room_obj.game_id
rsp.game_settings = room_obj.game_settings
rsp.play_count = room_obj.play_count
rsp.min_player_count = room_obj.game_config['min_player_count']
rsp.max_player_count = room_obj.game_config['max_player_count']
for index, role in enumerate(room_obj.roles):
if role['entityID'] != 0:
rsp.users.add(**role)
return success_msg(msgtype, rsp)
def do_sync(self, sendto, rsp):
g_playerManager.sendto(sendto, rsp)
