def sendFreeChipTodoTask(userid, gameId, cache = False, direct = True):
""" 推送 免费金币 added by nick.kai.lee
Args:
userid: 玩家userid
cache: action命名是否是缓存形式,默认不缓存
direct: 是否直接发送,False则return dict
"""
if not TYPlayer.isHuman(userid):
return False, None
ftlog.debug('sendFreeChipTodoTask:', userid)
from majiang2.entity.todotasks_builder.todotasks_builder import MahjongTodoTaskBuilder
task = MahjongTodoTaskBuilder.dict_free_chip(userid, cache)
if not task:
return False, None
ftlog.debug('sendFreeChipTodoTask:', task)
if False == direct:
return True, task
mo = MsgPack()
mo.setCmd('majiang_todotasks')
mo.setResult('gameId', gameId)
mo.setResult('userId', userid)
mo.setResult('tasks', [task])
router.sendToUser(mo, userid)
return True, None
def sendBuyDiamondTodoTask(userId, gameId, clientId, pay_order):
""" 幸运大抽奖，钻石购买
@param pay_order 挑选商品模板
"""
if not TYPlayer.isHuman(userId):
return
product, _ = hallstore.findProductByPayOrder(gameId, userId, clientId,
pay_order)
if not product:
ftlog.error('userId =', userId, 'clientId =', clientId, 'pay_order =',
pay_order, 'can not find suitable product!')
return
try:
product = product.clone()
except:
product = strutil.cloneData(product)
desc = u'您的钻石不够哦~\n现在' + unicode(product.price) + u'元立得' + unicode(
product.priceDiamond) + u'钻石！'
product.content.desc = str(product.priceDiamond) + '钻石'
client_ver = sessiondata.getClientIdVer(userId)
if client_ver < 3.74: # 客户端bug，小于3.74的版本转换一下
product.priceDiamond = product.price
todotasks = TodoTaskOrderShow.makeByProduct(desc, '', product)
TodoTaskHelper.sendTodoTask(gameId, userId, todotasks)
def sendMasterGiftTodoTask(userId, gameId, clientId, pic, pay_order, roomId):
""" 推送高手礼包弹窗
@param pay_order 挑选商品模板
"""
if not TYPlayer.isHuman(userId):
return
product, _ = hallstore.findProductByPayOrder(gameId, userId, clientId,
pay_order)
if not product:
ftlog.error('userId =', userId, 'clientId =', clientId, 'pay_order =',
pay_order, 'can not find suitable product!')
return
todotask = TodoTaskPayOrder(product)
task = {
'action': 'cache_wnd_gaoshou',
'params': {
'pic': pic,
'tasks': [todotask.toDict()]
}
}
mo = MsgPack()
mo.setCmd('majiang_todotasks')
mo.setResult('gameId', gameId)
mo.setResult('userId', userId)
mo.setResult('tasks', [task])
router.sendToUser(mo, userId)
def sendTodoTaskInviteFriends(userId, gameId, invite_uids, play_mode, roomId,
tableId, info_str, purl):
""" 邀请好友来牌桌
@param name 发送邀请的用户名
@param invite_uids 被邀请的玩家uid列表
@param table 牌桌对象
"""
ftlog.debug('userId =', userId, 'roomId =', roomId, 'tableId =', tableId,
'invite_uids =', invite_uids, 'info_str =', info_str)
if not TYPlayer.isHuman(userId):
ftlog.debug('robot is not supported!')
return
for uid in invite_uids:
last_gameId = onlinedata.getLastGameId(uid)
if last_gameId == gameId: # 如果玩家在麻将里
sendFriendInviteTodotask(uid, userId, gameId, play_mode, roomId,
tableId, info_str, purl)
elif last_gameId == 9999: # 如果玩家在大厅主界面
sendFriendInviteEnterGameTodotask(uid, gameId, play_mode, roomId,
tableId, info_str)
else: # 在其它游戏里，直接忽略
ftlog.debug('last_gameId is not 7 or 9999', 'last_gameId =',
last_gameId)
return
from majiang2.entity import util
util.sendPrivateMessage(uid, info_str)
def sendMarketEstimateTodoTask(userid,
gameId,
url,
des,
cache=False,
direct=True):
""" 推送麻将五星好评Cache
发送五星好评的数据,客户端缓存,什么时候激活五星好评由客户端实现
@param des 五星好评内容
"""
if not TYPlayer.isHuman(userid):
return False, None
ftlog.debug('sendMarketEstimateTodoTask:', userid, url, des, cache, direct)
from majiang2.entity.todotasks_builder.todotasks_builder import MahjongTodoTaskBuilder
task = MahjongTodoTaskBuilder.dict_market_estimate(userid, url, des, cache)
if not task:
return False, None
if True == direct:
mo = MsgPack()
mo.setCmd('majiang_todotasks')
mo.setResult('gameId', gameId)
mo.setResult('userId', userid)
mo.setResult('tasks', [task])
router.sendToUser(mo, userid)
return True, None
else:
return True, task
def sendFreeChipTodoTask(userid, gameId, cache=False, direct=True):
""" 推送 免费金币 added by nick.kai.lee
Args:
userid: 玩家userid
cache: action命名是否是缓存形式,默认不缓存
direct: 是否直接发送,False则return dict
"""
if not TYPlayer.isHuman(userid):
return False, None
ftlog.debug('sendFreeChipTodoTask:', userid)
from majiang2.entity.todotasks_builder.todotasks_builder import MahjongTodoTaskBuilder
task = MahjongTodoTaskBuilder.dict_free_chip(userid, cache)
if not task:
return False, None
ftlog.debug('sendFreeChipTodoTask:', task)
if False == direct:
return True, task
mo = MsgPack()
mo.setCmd('majiang_todotasks')
mo.setResult('gameId', gameId)
mo.setResult('userId', userid)
mo.setResult('tasks', [task])
router.sendToUser(mo, userid)
return True, None
def doCallDizhuTimeOut(self, player):
'''
叫地主超时
'''
ftlog.debug('doCallDizhuTimeOut...')
if not player or self.table.status.state != DizhuState.TABLE_STATE_CALLING:
ftlog.warn('ERROR !!, doCallDizhuTimeOut table.status=',
self.table.status, player)
return
assert (self.table.status.callGrade < 3)
if TYPlayer.isHuman(player.userId):
# 真实玩家超时默认不叫地主
call = 0
else:
# AI必须叫地主
if self.table.status.callGrade <= 0:
call = 1
else:
call = self.table.status.callGrade + 1
# 系统主动替玩家进行叫地主, 1分
self.doCallDizhu(player, -1, call, DizhuPlayer.TUGUAN_TYPE_TIMEOUT)
def sendMasterGiftTodoTask(userId, gameId, clientId, pic, pay_order, roomId):
""" 推送高手礼包弹窗
@param pay_order 挑选商品模板
"""
if not TYPlayer.isHuman(userId):
return
product, _ = hallstore.findProductByPayOrder(gameId, userId, clientId, pay_order)
if not product:
ftlog.error('userId =', userId, 'clientId =', clientId, 'pay_order =', pay_order,
'can not find suitable product!')
return
todotask = TodoTaskPayOrder(product)
task = {
'action': 'cache_wnd_gaoshou',
'params': {
'pic': pic,
'tasks': [todotask.toDict()]
}
}
mo = MsgPack()
mo.setCmd('majiang_todotasks')
mo.setResult('gameId', gameId)
mo.setResult('userId', userId)
mo.setResult('tasks', [task])
router.sendToUser(mo, userId)
def doSignin(self, userId, feeIndex=0):
"""
比赛报名
"""
if self.match.matchConf.discountTime:
startTime = util.getTimestampFromStr(self.match.matchConf.discountTime[0])
endTime = util.getTimestampFromStr(self.match.matchConf.discountTime[1])
if startTime <= int(time.time()) <= endTime:
feeIndex = 1
if self._logger.isDebug():
self._logger.debug("doSignin", "userId=", userId, "feeIndex=", feeIndex)
mo = MsgPack()
mo.setCmd("m_signin")
mo.setResult("gameId", self.gameId)
mo.setResult("roomId", self.roomId)
mo.setResult("userId", userId)
try:
if userId > config.ROBOT_MAX_USER_ID:
self.matchPlugin.ensureCanSignInMatch(self, userId, mo)
signer = self.match.signin(userId, feeIndex)
if signer:
mo.setResult("signin", 1)
mo.setResult("signinPlayerCount", self.match.signerCount)
if userId > config.ROBOT_MAX_USER_ID:
self.reportBiGameEvent("MATCH_SIGN_UP", userId, self.roomId, 0, 0, 0, 0, 0, [], "match_signin")
else:
raise SigninException()
router.sendToUser(mo, userId)
if TYPlayer.isHuman(userId):
self._notifyRobotSigninMatch(signer)
except MatchException, e:
self.matchPlugin.handleMatchException(self, e, userId, mo)
def sendLocalPushTodoTask(userid, gameId, hour, minute, second, direct=True):
""" 推送 本地推送push added by nick.kai.lee
向客户端推送闹钟push的注册,比如每次客户端登录时都会推送一次"本地推送的功能"
Args:
userid: 玩家userid
cache: action命名是否是缓存形式,默认不缓存
direct: 是否直接发送,False则return dict
"""
if not TYPlayer.isHuman(userid):
return False, None
ftlog.debug('sendLocalPushTodoTask:', userid)
from difang.majiang2.entity.todotasks_builder.todotasks_builder import MahjongTodoTaskBuilder
from datetime import datetime
now = datetime.now()
# alarm3个元素,days,seconds,microseconds, seconds遇到过去的时间会自动获得明天这个时间点的时间差
alarm = datetime(datetime.now().year, datetime.now().month, datetime.now().day, hour, minute, second)
# 推送内容
import random
content = random.choice([
"还记得上次在拜雀神中抽取的大奖么？机会又来了!",
"修复老年痴呆，拯救弱智儿童，途游麻将提高智商值得你拥有！",
"主人，您的任务奖励还没领取呢，去看看吧！",
"优惠降临！充值送豪礼，下班来放松玩玩吧！",
"幸运大抽奖可以免费领取金币了，快来领取吧！",
"您有一份礼包未签收，快去活动中心看看吧！",
"点我速领500金币~",
"工作一天了，让麻将小莲帮你放松放松~",
"亲，每隔10分钟1场免费定时赛，100奖券随便拿！",
"您可以领取每日奖励了，它将会很快过期，快回到途游麻将领取吧！",
"雀神爷爷说马上就要发红包了，你准备好了么？",
"您获取的奖券兑换话费了嘛？",
"大哥，您的贵宾桌我们已经为您准备好了！静候您的光临！",
"您的好友邀请您一起对战途游麻将！"
])
task = MahjongTodoTaskBuilder.dict_reg_push_alarm(userid, content, (alarm - now).seconds,
[True, False, True, False, True, False], "", {}, 3)
if not task:
return False, None
ftlog.debug('sendLocalPushTodoTask:', task)
if False == direct:
return True, task
mo = MsgPack()
mo.setCmd('majiang_todotasks')
mo.setResult('gameId', gameId)
mo.setResult('userId', userid)
mo.setResult('tasks', [task])
router.sendToUser(mo, userid)
return True, None
def sendLocalPushTodoTask(userid, gameId, hour, minute, second, direct = True):
""" 推送 本地推送push added by nick.kai.lee
向客户端推送闹钟push的注册,比如每次客户端登录时都会推送一次"本地推送的功能"
Args:
userid: 玩家userid
cache: action命名是否是缓存形式,默认不缓存
direct: 是否直接发送,False则return dict
"""
if not TYPlayer.isHuman(userid):
return False, None
ftlog.debug('sendLocalPushTodoTask:', userid)
from majiang2.entity.todotasks_builder.todotasks_builder import MahjongTodoTaskBuilder
from datetime import datetime
now = datetime.now()
#alarm3个元素,days,seconds,microseconds, seconds遇到过去的时间会自动获得明天这个时间点的时间差
alarm = datetime(datetime.now().year, datetime.now().month, datetime.now().day, hour, minute, second)
# 推送内容
import random
content = random.choice([
"还记得上次在拜雀神中抽取的大奖么？机会又来了!",
"修复老年痴呆，拯救弱智儿童，途游麻将提高智商值得你拥有！",
"主人，您的任务奖励还没领取呢，去看看吧！",
"优惠降临！充值送豪礼，下班来放松玩玩吧！",
"幸运大抽奖可以免费领取金币了，快来领取吧！",
"您有一份礼包未签收，快去活动中心看看吧！",
"点我速领500金币~",
"工作一天了，让麻将小莲帮你放松放松~",
"亲，每隔10分钟1场免费定时赛，100奖券随便拿！",
"您可以领取每日奖励了，它将会很快过期，快回到途游麻将领取吧！",
"雀神爷爷说马上就要发红包了，你准备好了么？",
"您获取的奖券兑换话费了嘛？",
"大哥，您的贵宾桌我们已经为您准备好了！静候您的光临！",
"您的好友邀请您一起对战途游麻将！"
])
task = MahjongTodoTaskBuilder.dict_reg_push_alarm(userid, content, (alarm-now).seconds, [True, False, True, False, True, False], "", {}, 3 )
if not task:
return False, None
ftlog.debug('sendLocalPushTodoTask:', task)
if False == direct:
return True, task
mo = MsgPack()
mo.setCmd('majiang_todotasks')
mo.setResult('gameId', gameId)
mo.setResult('userId', userid)
mo.setResult('tasks', [task])
router.sendToUser(mo, userid)
return True, None
def doSignin(self, userId, feeIndex=0):
"""
比赛报名，扣费
"""
if self.match.matchConf.discountTime:
startTime = util.getTimestampFromStr(
self.match.matchConf.discountTime[0])
endTime = util.getTimestampFromStr(
self.match.matchConf.discountTime[1])
if startTime <= int(time.time()) <= endTime:
feeIndex = 1
if self._logger.isDebug():
self._logger.debug("doSignin", "userId=", userId, "feeIndex=",
feeIndex, "status=", self.runStatus)
mo = MsgPack()
mo.setCmd("m_signin")
mo.setResult("gameId", self.gameId)
mo.setResult("roomId", self.roomId)
mo.setResult("userId", userId)
mo.setResult("matchType", "point")
try:
if self.runStatus != self.ROOM_STATUS_RUN:
raise MaintenanceException()
else:
playedTimes = self.matchMaster.userPlayedTimes.get(userId, 0)
maxGameTimes = self.match.matchConf.start.maxGameTimes
if playedTimes >= maxGameTimes > -1:
raise RunOutSigninChanceException()
else:
isIn, _, _, _ = util.isInFishTable(userId)
if isIn:
raise SigninException()
else:
if userId > config.ROBOT_MAX_USER_ID:
self.matchPlugin.ensureCanSignInMatch(
self, userId, mo)
signer = self.match.signin(userId, feeIndex)
if signer:
mo.setResult("signin", 1)
mo.setResult("signinPlayerCount",
self.match.signerCount)
if userId > config.ROBOT_MAX_USER_ID:
self.reportBiGameEvent("MATCH_SIGN_UP", userId,
self.roomId, 0, 0, 0, 0,
0, [], "match_signin")
else:
raise SigninException()
router.sendToUser(mo, userId)
if TYPlayer.isHuman(userId):
self._notifyRobotSigninMatch(signer)
except MatchException, e:
self.matchPlugin.handleMatchException(self, e, userId, mo)
def doSignin(self, userId, signinParams, feeIndex=0):
ftlog.debug("<<", "|userId, roomId, signinParams:", userId, self.roomId, feeIndex, signinParams, caller=self)
try:
mo = MsgPack()
mo.setCmd('m_signin')
self.matchPlugin.ensureCanSignInMatch(self, userId, mo)
player = self.match.signin(userId, signinParams, feeIndex)
if TYPlayer.isHuman(userId):
self.__notifyRobotSigninMatch(player)
self.reportBiGameEvent("MATCH_SIGN_UP", userId, self.roomId, 0, 0, 0, 0, 0, [], 'match_signin')
except MatchException, e:
self.matchPlugin.handleMatchException(self, e, userId, mo)
def doSignin(self, userId, signinParams, feeIndex=0):
if self._logger.isDebug():
self._logger.debug('TYErdayiMatchRoom.doSignin', 'userId=', userId,
'feeIndex=', feeIndex, 'signinParams=',
signinParams)
try:
mo = MsgPack()
mo.setCmd('m_signin')
self.matchPlugin.ensureCanSignInMatch(self, userId, mo)
signer = self.match.signin(userId, feeIndex)
if TYPlayer.isHuman(userId):
self._notifyRobotSigninMatch(signer)
except MatchException, e:
self.matchPlugin.handleMatchException(self, e, userId, mo)
def sendAlmsTodoTask(userid, gameId, cache=False, direct=True):
""" 推送麻将救济金Cache added by nick.kai.lee
发送麻将救济金数据,客户端是否缓存由cache决定,cache为True时不是立即激活,
什么时候激活转运礼包由客户端实现
Args:
userid: 玩家userid
cache: action命名是否是缓存形式,默认不缓存
direct: 是否直接发送,False则return dict
"""
if not TYPlayer.isHuman(userid):
return False, None
ftlog.debug('sendAlmsTodoTask:', userid, cache, direct)
from majiang2.entity.todotasks_builder.todotasks_builder import MahjongTodoTaskBuilder
from hall.entity import hallbenefits
_, userBenefits = hallbenefits.benefitsSystem.sendBenefits(gameId, userid)
benefitsStrs = []
benefitsStrs.append('送您%s金币翻本吧！' % (userBenefits.sendChip))
privilegeName = userBenefits.privilege.name if userBenefits.privilege else ''
if userBenefits.extSendChip > 0:
benefitsStrs.append('您是%s再加赠%s金币' %
(privilegeName, userBenefits.extSendChip))
benefitsStrs.append(
'（%s每天%s次，今天第%s次）' %
(privilegeName, userBenefits.totalMaxTimes, userBenefits.times))
if userBenefits.privilege and userBenefits.privilege.desc:
benefitsStrs.append('\n%s' % (userBenefits.privilege.desc))
task = MahjongTodoTaskBuilder.dict_general_box(userid,
'\n'.join(benefitsStrs),
cache)
if not task:
return False, None
# task['params']['buttons'][0]['tasks'].append({})
ftlog.debug('sendAlmsTodoTask:', task)
if False == direct:
return True, task
mo = MsgPack()
mo.setCmd('majiang_todotasks')
mo.setResult('gameId', gameId)
mo.setResult('userId', userid)
mo.setResult('tasks', [task])
router.sendToUser(mo, userid)
return True, None
def doSignin(self, userId, signinParams, feeIndex=0):
if self._logger.isDebug():
self._logger.debug('TYErdayiMatchRoom.doSignin',
'userId=', userId,
'feeIndex=', feeIndex,
'signinParams=', signinParams)
try:
mo = MsgPack()
mo.setCmd('m_signin')
self.matchPlugin.ensureCanSignInMatch(self, userId, mo)
signer = self.match.signin(userId, feeIndex)
if TYPlayer.isHuman(userId):
self._notifyRobotSigninMatch(signer)
except MatchException, e:
self.matchPlugin.handleMatchException(self, e, userId, mo)
def process_interactive_expression(cls, userId, gameId, seatId, chat_msg, target_player_uid, base_chip):
"""处理消费金币的表情"""
config = cls.get_interactive_expression_config(base_chip)
emoId = str(chat_msg.get('emoId', -1))
if emoId not in config:
ftlog.warn('chat msg illegal', chat_msg, config)
return False
info = config[emoId]
# 底分限制
chip = userchip.getChip(userId)
if chip < info['chip_limit'] + info['cost']:
ftlog.warn('insufficient', chip, info['chip_limit'], info['cost'])
return False
if TYPlayer.isHuman(userId):
from difang.majiang2.entity.util import Util
clientId = Util.getClientId(userId)
trueDelta, _ = userchip.incrChip(userId
, gameId
, -info['cost']
, 0
, "EMOTICON_CONSUME"
, chat_msg['emoId']
, clientId
)
if trueDelta != -info['cost']: # 失败
ftlog.warn('coin not enougth: ', chip, info['chip_limit'], info['cost'])
return False
bireport.gcoin('out.interactive_expression', gameId, info['cost'])
# 处理魅力值
# charm = incrCharm(userId, info['charm'])
# hallranking.rankingSystem.setUserByInputType(gameId
# , TYRankingInputTypes.CHARM
# , userId
# , charm)
# if TYPlayer.isHuman(target_player_uid):
# charm = incrCharm(target_player_uid, info['ta_charm'])
# hallranking.rankingSystem.setUserByInputType(gameId
# , TYRankingInputTypes.CHARM
# , target_player_uid
# , charm)
return True
def doSignin(self, userId, signinParams, feeIndex=0):
if self._logger.isDebug():
self._logger.debug('TYGroupMatchRoom.doSignin',
'userId=', userId,
'feeIndex=', feeIndex,
'signinParams=', signinParams)
try:
mo = MsgPack()
mo.setCmd('m_signin')
self.matchPlugin.ensureCanSignInMatch(self, userId, mo)
signer = self.match.signin(userId, signinParams, feeIndex)
if TYPlayer.isHuman(userId):
self._notifyRobotSigninMatch(signer)
self.reportBiGameEvent('MATCH_SIGN_UP', userId, self.roomId, 0, 0, 0, 0, 0, [], 'match_signin')
except MatchException, e:
self.matchPlugin.handleMatchException(self, e, userId, mo)
def doSignin(self, userId, signinParams, feeIndex=0):
if self._logger.isDebug():
self._logger.debug('TYGroupMatchRoom.doSignin', 'userId=', userId,
'feeIndex=', feeIndex, 'signinParams=',
signinParams)
try:
mo = MsgPack()
mo.setCmd('m_signin')
self.matchPlugin.ensureCanSignInMatch(self, userId, mo)
signer = self.match.signin(userId, signinParams, feeIndex)
if TYPlayer.isHuman(userId):
self._notifyRobotSigninMatch(signer)
self.reportBiGameEvent('MATCH_SIGN_UP', userId, self.roomId, 0, 0,
0, 0, 0, [], 'match_signin')
except MatchException, e:
self.matchPlugin.handleMatchException(self, e, userId, mo)
def process_interactive_expression(cls, userId, gameId, seatId, chat_msg,
target_player_uid, base_chip):
"""处理消费金币的表情"""
config = cls.get_interactive_expression_config(base_chip)
emoId = str(chat_msg.get('emoId', -1))
if emoId not in config:
ftlog.warn('chat msg illegal', chat_msg, config)
return False
info = config[emoId]
# 底分限制
chip = userchip.getChip(userId)
if chip < info['chip_limit'] + info['cost']:
ftlog.warn('insufficient', chip, info['chip_limit'], info['cost'])
return False
if TYPlayer.isHuman(userId):
from difang.majiang2.entity.util import Util
clientId = Util.getClientId(userId)
trueDelta, _ = userchip.incrChip(userId, gameId, -info['cost'], 0,
"EMOTICON_CONSUME",
chat_msg['emoId'], clientId)
if trueDelta != -info['cost']: # 失败
ftlog.warn('coin not enougth: ', chip, info['chip_limit'],
info['cost'])
return False
bireport.gcoin('out.interactive_expression', gameId, info['cost'])
# 处理魅力值
# charm = incrCharm(userId, info['charm'])
# hallranking.rankingSystem.setUserByInputType(gameId
# , TYRankingInputTypes.CHARM
# , userId
# , charm)
# if TYPlayer.isHuman(target_player_uid):
# charm = incrCharm(target_player_uid, info['ta_charm'])
# hallranking.rankingSystem.setUserByInputType(gameId
# , TYRankingInputTypes.CHARM
# , target_player_uid
# , charm)
return True
def sendChangeFortuneTodoTask(userid,
gameId,
roomid,
insert,
cache=False,
direct=True):
""" 推送麻将转运礼包Cache added by nick.kai.lee
发送转运礼包的数据,客户端是否缓存由cache决定,cache为True时不是立即激活,
什么时候激活转运礼包由客户端实现
Args:
userid: 玩家userid
roomid: 房间id
insert: 插入的task dict类型
cache: action命名是否是缓存形式,默认不缓存
direct: 是否直接发送,False则return dict
"""
if not TYPlayer.isHuman(userid):
return False, None
ftlog.debug('sendChangeFortuneTodoTask:', userid, roomid, insert, cache,
direct)
from majiang2.entity.todotasks_builder.todotasks_builder import MahjongTodoTaskBuilder
task = MahjongTodoTaskBuilder.dict_change_fortune(userid, gameId, roomid,
cache)
if not task:
return False, None
if isinstance(insert, dict):
task['params']['buttons'][1]['tasks'].append(insert)
ftlog.debug('sendChangeFortuneTodoTask:', task)
if True == direct:
mo = MsgPack()
mo.setCmd('majiang_todotasks')
mo.setResult('gameId', gameId)
mo.setResult('userId', userid)
mo.setResult('tasks', [task])
router.sendToUser(mo, userid)
return True, None
else:
return True, task
def sendAlmsTodoTask(userid, gameId, cache = False, direct = True):
""" 推送麻将救济金Cache added by nick.kai.lee
发送麻将救济金数据,客户端是否缓存由cache决定,cache为True时不是立即激活,
什么时候激活转运礼包由客户端实现
Args:
userid: 玩家userid
cache: action命名是否是缓存形式,默认不缓存
direct: 是否直接发送,False则return dict
"""
if not TYPlayer.isHuman(userid):
return False, None
ftlog.debug('sendAlmsTodoTask:', userid, cache, direct)
from majiang2.entity.todotasks_builder.todotasks_builder import MahjongTodoTaskBuilder
from hall.entity import hallbenefits
_, userBenefits = hallbenefits.benefitsSystem.sendBenefits(gameId, userid)
benefitsStrs = []
benefitsStrs.append('送您%s金币翻本吧！' % (userBenefits.sendChip))
privilegeName = userBenefits.privilege.name if userBenefits.privilege else ''
if userBenefits.extSendChip > 0:
benefitsStrs.append('您是%s再加赠%s金币' % (privilegeName, userBenefits.extSendChip))
benefitsStrs.append('（%s每天%s次，今天第%s次）' % (privilegeName, userBenefits.totalMaxTimes, userBenefits.times))
if userBenefits.privilege and userBenefits.privilege.desc:
benefitsStrs.append('\n%s' % (userBenefits.privilege.desc))
task = MahjongTodoTaskBuilder.dict_general_box(userid, '\n'.join(benefitsStrs), cache)
if not task:
return False, None
# task['params']['buttons'][0]['tasks'].append({})
ftlog.debug('sendAlmsTodoTask:', task)
if False == direct:
return True, task
mo = MsgPack()
mo.setCmd('majiang_todotasks')
mo.setResult('gameId', gameId)
mo.setResult('userId', userid)
mo.setResult('tasks', [task])
router.sendToUser(mo, userid)
return True, None
def doSignin(self, userId, signinParams, feeIndex=0):
ftlog.debug("<<",
"|userId, roomId, signinParams:",
userId,
self.roomId,
feeIndex,
signinParams,
caller=self)
try:
mo = MsgPack()
mo.setCmd('m_signin')
self.matchPlugin.ensureCanSignInMatch(self, userId, mo)
player = self.match.signin(userId, signinParams, feeIndex)
if TYPlayer.isHuman(userId):
self.__notifyRobotSigninMatch(player)
self.reportBiGameEvent("MATCH_SIGN_UP", userId, self.roomId, 0, 0,
0, 0, 0, [], 'match_signin')
except MatchException, e:
self.matchPlugin.handleMatchException(self, e, userId, mo)
def sendTodoTaskInviteFriends(userId, gameId, invite_uids, play_mode, roomId, tableId, info_str, purl):
""" 邀请好友来牌桌
@param name 发送邀请的用户名
@param invite_uids 被邀请的玩家uid列表
@param table 牌桌对象
"""
ftlog.debug('userId =', userId, 'roomId =', roomId, 'tableId =', tableId,
'invite_uids =', invite_uids, 'info_str =', info_str)
if not TYPlayer.isHuman(userId):
ftlog.debug('robot is not supported!')
return
for uid in invite_uids:
last_gameId = onlinedata.getLastGameId(uid)
if last_gameId == gameId: # 如果玩家在麻将里
sendFriendInviteTodotask(uid, userId, gameId, play_mode, roomId, tableId, info_str, purl)
elif last_gameId == 9999: # 如果玩家在大厅主界面
sendFriendInviteEnterGameTodotask(uid, gameId, play_mode, roomId, tableId, info_str)
else: # 在其它游戏里，直接忽略
ftlog.debug('last_gameId is not 7 or 9999', 'last_gameId =', last_gameId)
return
from majiang2.entity import util
util.sendPrivateMessage(uid, info_str)
def sendBuyDiamondTodoTask(userId, gameId, clientId, pay_order):
""" 幸运大抽奖，钻石购买
@param pay_order 挑选商品模板
"""
if not TYPlayer.isHuman(userId):
return
product, _ = hallstore.findProductByPayOrder(gameId, userId, clientId, pay_order)
if not product:
ftlog.error('userId =', userId, 'clientId =', clientId, 'pay_order =', pay_order,
'can not find suitable product!')
return
try:
product = product.clone()
except:
product = strutil.cloneData(product)
desc = u'您的钻石不够哦~\n现在' + unicode(product.price) +u'元立得' + unicode(product.priceDiamond) +u'钻石！'
product.content.desc = str(product.priceDiamond) + '钻石'
client_ver = sessiondata.getClientIdVer(userId)
if client_ver < 3.74: # 客户端bug，小于3.74的版本转换一下
product.priceDiamond = product.price
todotasks = TodoTaskOrderShow.makeByProduct(desc, '', product)
TodoTaskHelper.sendTodoTask(gameId, userId, todotasks)
def sendMarketEstimateTodoTask(userid, gameId, url, des, cache = False, direct = True):
""" 推送麻将五星好评Cache
发送五星好评的数据,客户端缓存,什么时候激活五星好评由客户端实现
@param des 五星好评内容
"""
if not TYPlayer.isHuman(userid):
return False, None
ftlog.debug('sendMarketEstimateTodoTask:', userid, url, des, cache, direct)
from majiang2.entity.todotasks_builder.todotasks_builder import MahjongTodoTaskBuilder
task = MahjongTodoTaskBuilder.dict_market_estimate(userid, url, des, cache)
if not task:
return False, None
if True == direct:
mo = MsgPack()
mo.setCmd('majiang_todotasks')
mo.setResult('gameId', gameId)
mo.setResult('userId', userid)
mo.setResult('tasks', [task])
router.sendToUser(mo, userid)
return True, None
else:
return True, task
def sendChangeFortuneTodoTask(userid, gameId, roomid, insert, cache = False, direct = True):
""" 推送麻将转运礼包Cache added by nick.kai.lee
发送转运礼包的数据,客户端是否缓存由cache决定,cache为True时不是立即激活,
什么时候激活转运礼包由客户端实现
Args:
userid: 玩家userid
roomid: 房间id
insert: 插入的task dict类型
cache: action命名是否是缓存形式,默认不缓存
direct: 是否直接发送,False则return dict
"""
if not TYPlayer.isHuman(userid):
return False, None
ftlog.debug('sendChangeFortuneTodoTask:', userid, roomid, insert, cache, direct)
from majiang2.entity.todotasks_builder.todotasks_builder import MahjongTodoTaskBuilder
task = MahjongTodoTaskBuilder.dict_change_fortune(userid, gameId, roomid, cache)
if not task:
return False, None
if isinstance(insert, dict):
task['params']['buttons'][1]['tasks'].append(insert)
ftlog.debug('sendChangeFortuneTodoTask:', task)
if True == direct:
mo = MsgPack()
mo.setCmd('majiang_todotasks')
mo.setResult('gameId', gameId)
mo.setResult('userId', userid)
mo.setResult('tasks', [task])
router.sendToUser(mo, userid)
return True, None
else:
return True, task
def _doTableCall(self, msg, userId, seatId, action, clientId):
"""
继承父类，处理table_call消息
单独处理自建桌的分享/解散
"""
if not self.CheckSeatId(seatId, userId):
ftlog.warn("MajiangFriendTable.doTableCall, delay msg action:", action
, ' seatId:', seatId
, ' messange:', msg)
return
if action == 'next_round':
if self.logic_table.isStart():
return
self.logic_table.sendMsgTableInfo(seatId)
beginGame = self.logic_table.playerReady(seatId, True)
self.logic_table.msgProcessor.create_table_succ_response(userId, seatId, 'ready',
1 if (userId == self.__table_owner) else 0,
self.logic_table.getBroadCastUIDs())
for player in self.logic_table.player:
if not player:
continue
if not TYPlayer.isHuman(player.userId):
beginGame = self.logic_table.playerReady(player.curSeatId, True)
if beginGame:
# 纪录上一局的日志 给GM使用
# addOneResult(tableNo, seats, deltaScore, totalScore, curRound, totalRound, gameId, roomId, tableId)
if self.logic_table.tableConfig[MFTDefine.CUR_ROUND_COUNT] > 1:
roundResult = self.logic_table.tableResult.results[-1]
deltaScore = roundResult.score
totalScore = self.logic_table.tableResult.score
curRound = self.logic_table.tableConfig[MFTDefine.CUR_ROUND_COUNT] - 1
totalRound = self.logic_table.tableConfig[MFTDefine.ROUND_COUNT]
seats = self.logic_table.getSeats()
ftlog.debug('MajiangFriendTable.doTableCall nextRound stat tableNo', self.ftId, 'seats', seats,
'deltaScore:',
deltaScore, 'totalScore:', totalScore, 'gameId:', self.gameId, 'roomId:', self.roomId,
'tableId', self.tableId)
hall_friend_table.addOneResult(self.ftId, seats, deltaScore, totalScore, curRound, totalRound,
self.gameId, self.roomId, self.tableId)
else:
ftlog.debug('MajiangFriendTable.doTableCall nextRound stat log error')
else:
ftlog.debug('MajiangFriendTable.doTableCall nextRound stat log error not begin')
elif action == 'ready':
# 返回房主建房成功消息，准备状态
# 玩家准备结束 游戏正式开始
beginGame = self.logic_table.playerReady(seatId, True)
self.logic_table.msgProcessor.create_table_succ_response(userId, seatId, 'ready',
1 if (userId == self.__table_owner) else 0,
self.logic_table.getBroadCastUIDs())
if beginGame and self.logic_table.tableConfig[MFTDefine.CUR_ROUND_COUNT] > 0:
# 纪录开局日志 gameBegin(tableNo, seats, gameId, roomId, tableId)
seats = self.logic_table.getSeats()
ftlog.debug('MajiangFriendTable._doTableCall log game begin tableNo:', self.__ftId, 'seats:', seats,
'gameId:', self.gameId, 'roomId:', self.roomId, 'tableId', self.tableId)
hall_friend_table.gameBegin(self.__ftId, seats, self.gameId, self.gameId, self.tableId)
else:
ftlog.debug('MajiangFriendTable._doTableCall log game begin not ready cur round:',
self.logic_table.tableConfig[MFTDefine.CUR_ROUND_COUNT])
elif action == 'create_table_user_leave':
if (self.logic_table.tableConfig[MFTDefine.CUR_ROUND_COUNT] > 0):
util.sendPopTipMsg(userId, "游戏已开始，不能解散")
return
# 房主解散，由前端主动发送，存在隐患，后续修改。房主建房后，掉线，房主的房间状态将不对，TODO
if userId == self.__table_owner:
ftlog.debug('MajiangFriendTable.create_table_user_leave owner leave...')
# 解散时，给大家提示
for player in self.logic_table.player:
if not player:
continue
# 通知
util.sendPopTipMsg(player.userId, "房主解散房间")
# 归还剩余房卡道具
ftlog.debug('MajiangFriendTable.doTableCall leftCardCount:',
self.logic_table.tableConfig[MFTDefine.LEFT_CARD_COUNT]
, ' tableOwner:', self.__table_owner)
if self.logic_table.tableConfig[MFTDefine.LEFT_CARD_COUNT] > 0:
itemId = self.room.roomConf.get('create_item', None)
if itemId:
user_remote.resumeItemFromTable(self.__table_owner
, self.gameId
, itemId
, self.logic_table.tableConfig[MFTDefine.LEFT_CARD_COUNT]
, self.roomId
, self.tableId)
# 解散牌桌
self.clearTable(True)
else:
ftlog.debug('MajiangFriendTable.create_table_user_leave player leave...')
util.sendPopTipMsg(userId, "您已退出房间")
self.kickOffUser(userId, seatId, True)
elif action == 'create_table_dissolution':
if self.logic_table.tableConfig[MFTDefine.CUR_ROUND_COUNT] == 0:
ftlog.debug(
'MajiangFriendTable._doTableCall create_table_dissolution game not start, can not dissolved...')
return
# 投票解散牌桌
if self.voteHost != MTDefine.INVALID_SEAT:
ftlog.debug('MajiangFriendTable._doTableCall create_table_dissolution ', self.voteHost,
' already dissolved...')
return
self.__vote_host = seatId
self.__vote_info[seatId] = {'userId': userId, 'seatId': seatId, 'vote': self.DISSOLVE_AGREE}
self.__vote_time_out = self.getTableConfig('dissolve_vote_time_out', 60)
ftlog.debug('MajiangFriendTable.create_table_dissolution voteInfo:', self.voteInfo)
# 广播解散投票消息
self.logic_table.msgProcessor.create_table_dissolve_vote(userId
, seatId
, self.maxSeatN
, self.get_leave_vote_info()
, self.get_leave_vote_info_detail()
, self.logic_table.player[seatId].name
, self.__vote_time_out
, self.logic_table.getBroadCastUIDs())
elif action == 'user_leave_vote':
ftlog.debug('MajiangFriendTable._doTableCall voteInfo:', self.voteInfo)
if self.voteHost == MTDefine.INVALID_SEAT:
ftlog.debug(
'MajiangFriendTable._doTableCall user_leave_vote, voteHost is invalid, no need process this message...')
return
vote = msg.getParam('vote', 0)
self.__vote_info[seatId] = {'userId': userId, 'seatId': seatId, 'vote': vote}
self.logic_table.msgProcessor.create_table_dissolve_vote(userId
, seatId
, self.maxSeatN
, self.get_leave_vote_info()
, self.get_leave_vote_info_detail()
, self.logic_table.player[self.voteHost].name
, self.__vote_time_out
, self.logic_table.getBroadCastUIDs())
# 计算投票结果
self.dissolveDecision()
elif action == 'create_friend_invite': # 微信邀请todotask下发
contentStr = ','.join(self.__params_desc)
util.sendTableInviteShareTodoTask(userId
, self.gameId
, self.ftId
, self.playMode
, self.logic_table.tableConfig[MFTDefine.CARD_COUNT]
, contentStr)
elif action == 'friend_table_ready_time_out':
# 准备超时，回收牌桌
self.clearTable(True)
else:
super(MajiangFriendTable, self)._doTableCall(msg, userId, seatId, action, clientId)
def _doNext(self, isFirst):
ftlog.debug('_doNext-->isFirst=', isFirst,
'self.table.status.nowOper=', self.table.status.nowOper)
# 查找下一个出牌的玩家座位ID
if isFirst == 0:
# 非第一次出牌, 查找
nsid = self._findNextPlayerSeatId()
else:
# 第一次, 出牌, 固定为地主出牌
self.table.status.nowOper = self.table.status.diZhu
nsid = self.table.status.nowOper
if nsid <= 0:
ftlog.warn('doNext can not found next player...')
return
ftlog.debug('_doNext-->isFirst=', isFirst, 'nsid=', nsid)
# 出牌的简单的crc校验码处理
self.table.status.cardCrc += 1
self.table.status.nowOper = nsid
# 出牌计时器处理
tuoGuanType = DizhuPlayer.TUGUAN_TYPE_USERACT
autocard = 0
seat = self.table.seats[nsid - 1]
opTime = self.table.runConfig.optimeFirst if isFirst else self.table.runConfig.optime
opTime -= self.opTimePunishMatch(seat)
if (seat.isRobot == 1) and TYPlayer.isHuman(seat.userId):
# 如果是托管状态, 那么最短时间超时, 由超时处理中,处理是否出牌
tuoGuanType = DizhuPlayer.TUGUAN_TYPE_ALREADY_TUOGUAN
latetime = self.table.runConfig.optimeAlreadyTuoGuan
ftlog.debug('autocard 1...')
autocard = 1
else:
# 正常出牌超时控制
tuoGuanType = DizhuPlayer.TUGUAN_TYPE_TIMEOUT
latetime = opTime
# 只剩一张牌时，自动出牌
if len(seat.cards) == 1:
tuoGuanType = DizhuPlayer.TUGUAN_TYPE_SYS_FAST_CARD
latetime = self.table.runConfig.optimeOnlyOneCard
ftlog.debug('autocard 2...')
autocard = 1
# 如果上家出的是火箭, 那么自动不出牌
if nsid in self._doubleKingNoCard:
tuoGuanType = DizhuPlayer.TUGUAN_TYPE_SYS_FAST_CARD
latetime = self.table.runConfig.optimeDoubleKing
ftlog.debug('autocard 3...')
autocard = 1
del self._doubleKingNoCard[nsid]
params = {
'tuoGuanType': tuoGuanType,
'seatId': nsid,
'userId': seat.userId,
'ccrc': self.table.status.cardCrc
}
ftlog.debug('params:', params, ' latetime:', latetime, ' autocard:',
autocard)
if autocard or (not TYPlayer.isRobot(seat.userId)):
# 真实玩家启动出牌超时计时器
self.table.tableTimer.setup(latetime, 'CL_TIMEUP', params)
# 牌局记录器处理
self.table.gameRound.next(nsid - 1, 0, opTime)
if autocard:
# 自动出牌, 不发送next消息
return
# 发送下一个出牌的消息至客户端
self.sender.sendChuPaiNextRes(nsid, opTime)
def doSitDown(self, userId, seatId, msg, clientId):
"""
用户坐到某个桌子上，逻辑处理：如果是非重连用户，将用户坐下的消息广播给
其它已经坐下的用户，然后将当前的桌子信息发送给新来用户
继承自table类
这是的seatId为游戏的座位号
返回值：
1）是否做下
2）是否断线重连
"""
ftlog.debug('>>MajiangQuickTable.doSitDown seatId =', seatId, ', userId = ', userId, ' tableId:', self.tableId)
if (seatId != -1) and (userId != self.seats[seatId][TYSeat.INDEX_SEATE_USERID]):
onlinedata.removeOnlineLoc(userId, self.roomId, self.tableId)
ftlog.warn('reconnecting user id is not matched', 'seats =', self.seats, ' tableId:', self.tableId)
return False
frameSeatId = self.findIdleSeat(userId)
ftlog.debug('MajiangQuickTable.doSitDown userId:', userId, ' findSeatId:', frameSeatId)
sitRe = True
if 0 == frameSeatId:
ftlog.debug('MajiangQuickTable.doSitDown now seats:', self.seats)
sendPopTipMsg(userId, '对不起,该房间已满员')
self.logic_table.msgProcessor.quick_start_err(userId)
sitRe = False
elif 0 > frameSeatId:
# 补发tableInfo
seatId = self.getSeatIdByUserId(userId)
if seatId < 0:
onlinedata.removeOnlineLoc(userId, self.roomId, self.tableId)
else:
self.sendMsgTableInfo(msg, userId, seatId, True)
elif frameSeatId > 0:
isReady = self.getTableConfig(MTDefine.READY_AFTER_SIT, 0)
gameSeatId = self.changeFrameSeatToMJSeatId(frameSeatId)
# 设置座位的状态
self.seats[gameSeatId][TYSeat.INDEX_SEATE_USERID] = userId
# 快速桌用户坐下就是准备状态
self.seats[gameSeatId][
TYSeat.INDEX_SEATE_STATE] = TYSeat.SEAT_STATE_READY if isReady else TYSeat.SEAT_STATE_WAIT
# 添加玩家
tPlayer = TYPlayer(self, gameSeatId)
self.players[gameSeatId] = tPlayer
ftlog.debug('MajiangQuickTable.doSitDown user:'******' seat in:', gameSeatId
, ' now seats:', self.seats
, ' now playersNum:', self.playersNum)
# 向牌桌添加用户：联网/机器人
if TYPlayer.isHuman(userId):
locResult = onlinedata.addOnlineLoc(userId, self.roomId, self.tableId, frameSeatId)
ftlog.info('MajiangQuickTable.doSitDown, add online loc userId:', userId
, ' roomId:', self.roomId
, ' tableId:', self.tableId
, ' frameSeatId:', frameSeatId
, ' locResult:', locResult)
_name, _purl, _sex, _coin = userdata.getAttrs(userId, ['name', 'purl', 'sex', 'coin'])
player = MPlayer(_name, _sex, userId, 0, _purl, _coin, clientId)
# 快速桌 默认坐下就是准备状态 默认非托管状态
self.logic_table.addPlayer(player, gameSeatId, isReady, False)
# 发送location消息
self.logic_table.msgProcessor.send_location_message(gameSeatId, userId)
else:
from difang.majiang2.resource import resource
robot = resource.getRobotByUserId(userId)
if robot:
player = MPlayer(robot['name'], robot['sex'], userId, 0, robot['purl'], robot['coin'])
# 机器人默认准备 默认托管状态
self.logic_table.addPlayer(player, gameSeatId, True, True)
# 座位号调整，框架返回时进行了加1的操作，调整还原
self.room.updateTableScore(self.getTableScore(), self.tableId)
self.sendMsgTableInfo(msg, userId, self.getSeatIdByUserId(userId), False)
if self.playersNum != self.maxSeatN:
# 一次召唤一个机器人
self.setTimerOfDispatchRobot()
uids = self.logic_table.getBroadCastUIDs()
self.logic_table.msgProcessor.sendTableEvent(self.playersNum, userId, gameSeatId, uids)
else:
# 人满了，启动定时器
self.setTimerHandleAutoDecideAction()
return sitRe
def _doMatchQuickStart(self):
'''
牌桌开始
初始化牌桌玩家
如果是机器人，根据需求初始化机器人信息
'''
robots = [1, 2]
tableInfo = self._match_table_info
userInfos = tableInfo['users']
userIds = []
userSeatList = []
for i, userInfo in enumerate(userInfos):
if userInfo['type'] == 'robot':
userInfo['userId'] = robots.pop()
this_seat = self.seats[i]
userIds.append(userInfo['userId'])
this_seat.userId = userInfo['userId']
this_seat.state = TYSeat.SEAT_STATE_WAIT
this_seat.call123 = -1
userSeatList.append((userInfo['userId'], i + 1))
# 初始化用户数据
from dizhu.wx_resource import wx_resource
wx_resource.initRobotSetting()
robotCount = wx_resource.getRobotCount()
robotRange = range(0, robotCount)
robots = random.sample(robotRange, 3)
for x in xrange(len(self.players)):
self.players[x].initUser(0, 1, robots[x])
for userId, seatId in userSeatList:
if TYPlayer.isRobot(userId):
continue
onlinedata.addOnlineLoc(userId, self.roomId, self.tableId, seatId)
if ftlog.is_debug():
ftlog.debug("|locList:",
onlinedata.getOnlineLocList(userId),
caller=self)
# 做一个延迟
delayConf = dizhuconf.getPublic().get('matchAnimationDelay', '')
inter = delayConf.get('waitToNextMatch', 3)
FTTasklet.getCurrentFTTasklet().sleepNb(inter)
for x in xrange(len(self.seats)):
this_seat = self.seats[x]
if TYPlayer.isHuman(this_seat.userId):
mq = MsgPack()
mq.setCmd('quick_start')
mq.setResult('userId', this_seat.userId)
mq.setResult('gameId', self.gameId)
mq.setResult('roomId', self.roomId)
mq.setResult('tableId', self.tableId)
mq.setResult('seatId', x + 1)
mq.setResult('isOK', True)
# 发送用户的quick_start
router.sendToUser(mq, this_seat.userId)
# 发送table_info
self.gamePlay.sender.sendTableInfoResAll()
delay = self._playAnimation(userInfos)
if delay > 0:
FTTasklet.getCurrentFTTasklet().sleepNb(delay)
for x in xrange(len(self.players)):
self.gamePlay.doReady(self.players[x], False)
self._sendRanks(userInfos)
def _doTableCall(self, msg, userId, seatId, action, clientId):
"""
继承父类，处理table_call消息
单独处理自建桌的分享/解散
"""
if not self.CheckSeatId(seatId, userId):
ftlog.warn("MajiangFriendTable.doTableCall, delay msg action:",
action, ' seatId:', seatId, ' messange:', msg)
return
if action == 'next_round':
if self.logic_table.isStart():
return
self.logic_table.sendMsgTableInfo(seatId)
beginGame = self.logic_table.playerReady(seatId, True)
self.logic_table.msgProcessor.create_table_succ_response(
userId, seatId, 'ready', 1 if
(userId == self.__table_owner) else 0,
self.logic_table.getBroadCastUIDs())
for player in self.logic_table.player:
if not player:
continue
if not TYPlayer.isHuman(player.userId):
beginGame = self.logic_table.playerReady(
player.curSeatId, True)
if beginGame:
# 纪录上一局的日志 给GM使用
# addOneResult(tableNo, seats, deltaScore, totalScore, curRound, totalRound, gameId, roomId, tableId)
if self.logic_table.tableConfig[MFTDefine.CUR_ROUND_COUNT] > 1:
roundResult = self.logic_table.tableResult.results[-1]
deltaScore = roundResult.score
totalScore = self.logic_table.tableResult.score
curRound = self.logic_table.tableConfig[
MFTDefine.CUR_ROUND_COUNT] - 1
totalRound = self.logic_table.tableConfig[
MFTDefine.ROUND_COUNT]
seats = self.logic_table.getSeats()
ftlog.debug(
'MajiangFriendTable.doTableCall nextRound stat tableNo',
self.ftId, 'seats', seats, 'deltaScore:', deltaScore,
'totalScore:', totalScore, 'gameId:', self.gameId,
'roomId:', self.roomId, 'tableId', self.tableId)
hall_friend_table.addOneResult(self.ftId, seats,
deltaScore, totalScore,
curRound, totalRound,
self.gameId, self.roomId,
self.tableId)
else:
ftlog.debug(
'MajiangFriendTable.doTableCall nextRound stat log error'
)
else:
ftlog.debug(
'MajiangFriendTable.doTableCall nextRound stat log error not begin'
)
elif action == 'ready':
# 返回房主建房成功消息，准备状态
# 玩家准备结束 游戏正式开始
beginGame = self.logic_table.playerReady(seatId, True)
self.logic_table.msgProcessor.create_table_succ_response(
userId, seatId, 'ready', 1 if
(userId == self.__table_owner) else 0,
self.logic_table.getBroadCastUIDs())
if beginGame and self.logic_table.tableConfig[
MFTDefine.CUR_ROUND_COUNT] > 0:
# 纪录开局日志 gameBegin(tableNo, seats, gameId, roomId, tableId)
seats = self.logic_table.getSeats()
ftlog.debug(
'MajiangFriendTable._doTableCall log game begin tableNo:',
self.__ftId, 'seats:', seats, 'gameId:', self.gameId,
'roomId:', self.roomId, 'tableId', self.tableId)
hall_friend_table.gameBegin(self.__ftId, seats, self.gameId,
self.gameId, self.tableId)
else:
ftlog.debug(
'MajiangFriendTable._doTableCall log game begin not ready cur round:',
self.logic_table.tableConfig[MFTDefine.CUR_ROUND_COUNT])
elif action == 'create_table_user_leave':
if (self.logic_table.tableConfig[MFTDefine.CUR_ROUND_COUNT] > 0):
util.sendPopTipMsg(userId, "游戏已开始，不能解散")
return
# 房主解散，由前端主动发送，存在隐患，后续修改。房主建房后，掉线，房主的房间状态将不对，TODO
if userId == self.__table_owner:
ftlog.debug(
'MajiangFriendTable.create_table_user_leave owner leave...'
)
# 解散时，给大家提示
for player in self.logic_table.player:
if not player:
continue
# 通知
util.sendPopTipMsg(player.userId, "房主解散房间")
# 归还剩余房卡道具
ftlog.debug(
'MajiangFriendTable.doTableCall leftCardCount:',
self.logic_table.tableConfig[MFTDefine.LEFT_CARD_COUNT],
' tableOwner:', self.__table_owner)
if self.logic_table.tableConfig[MFTDefine.LEFT_CARD_COUNT] > 0:
itemId = self.room.roomConf.get('create_item', None)
if itemId:
user_remote.resumeItemFromTable(
self.__table_owner, self.gameId, itemId,
self.logic_table.tableConfig[
MFTDefine.LEFT_CARD_COUNT], self.roomId,
self.tableId)
# 解散牌桌
self.clearTable(True)
else:
ftlog.debug(
'MajiangFriendTable.create_table_user_leave player leave...'
)
util.sendPopTipMsg(userId, "您已退出房间")
self.kickOffUser(userId, seatId, True)
elif action == 'create_table_dissolution':
if self.logic_table.tableConfig[MFTDefine.CUR_ROUND_COUNT] == 0:
ftlog.debug(
'MajiangFriendTable._doTableCall create_table_dissolution game not start, can not dissolved...'
)
return
# 投票解散牌桌
if self.voteHost != MTDefine.INVALID_SEAT:
ftlog.debug(
'MajiangFriendTable._doTableCall create_table_dissolution ',
self.voteHost, ' already dissolved...')
return
self.__vote_host = seatId
self.__vote_info[seatId] = {
'userId': userId,
'seatId': seatId,
'vote': self.DISSOLVE_AGREE
}
self.__vote_time_out = self.getTableConfig(
'dissolve_vote_time_out', 60)
ftlog.debug(
'MajiangFriendTable.create_table_dissolution voteInfo:',
self.voteInfo)
# 广播解散投票消息
self.logic_table.msgProcessor.create_table_dissolve_vote(
userId, seatId, self.maxSeatN, self.get_leave_vote_info(),
self.get_leave_vote_info_detail(),
self.logic_table.player[seatId].name, self.__vote_time_out,
self.logic_table.getBroadCastUIDs())
elif action == 'user_leave_vote':
ftlog.debug('MajiangFriendTable._doTableCall voteInfo:',
self.voteInfo)
if self.voteHost == MTDefine.INVALID_SEAT:
ftlog.debug(
'MajiangFriendTable._doTableCall user_leave_vote, voteHost is invalid, no need process this message...'
)
return
vote = msg.getParam('vote', 0)
self.__vote_info[seatId] = {
'userId': userId,
'seatId': seatId,
'vote': vote
}
self.logic_table.msgProcessor.create_table_dissolve_vote(
userId, seatId, self.maxSeatN, self.get_leave_vote_info(),
self.get_leave_vote_info_detail(),
self.logic_table.player[self.voteHost].name,
self.__vote_time_out, self.logic_table.getBroadCastUIDs())
# 计算投票结果
self.dissolveDecision()
elif action == 'create_friend_invite': # 微信邀请todotask下发
contentStr = ','.join(self.__params_desc)
util.sendTableInviteShareTodoTask(
userId, self.gameId, self.ftId, self.playMode,
self.logic_table.tableConfig[MFTDefine.CARD_COUNT], contentStr)
elif action == 'friend_table_ready_time_out':
# 准备超时，回收牌桌
self.clearTable(True)
else:
super(MajiangFriendTable,
self)._doTableCall(msg, userId, seatId, action, clientId)
