def callback(content):
content = content.decode()
try:
DEBUG_MSG("cards response: {}".format(content))
if content[0] != '{':
if getattr(self, 'client', None):
self.client.createRoomFailed(const.CREATE_FAILED_OTHER)
return
data = json.loads(content)
card_cost, diamond_cost = switch.calc_cost(maxOldDealNum, maxLoseScore)
if not KBEngine.globalData["GameWorld"].free_play and card_cost > data["card"] and diamond_cost > data["diamond"]:
if getattr(self, 'client', None):
self.client.createRoomFailed(const.CREATE_FAILED_NO_ENOUGH_CARDS)
return
params = {
'owner_uid': self.userId,
'game_round': 999,
'lucky_tile': 0,
"maxOldDealNum" : maxOldDealNum,
"startOldDealNum" : startOldDealNum,
"diceAddNum" : diceAddNum,
"isSameAdd" : isSameAdd,
"maxLoseScore" : maxLoseScore,
'is_agent': is_agent,
"createRoomInfoList" : createRoomInfoList
}
KBEngine.createBaseAnywhere("GameRoom", params, self.createRoomCallback)
except:
DEBUG_MSG("createRoom callback error:{}".format(content))
if getattr(self, 'self', None):
self.client.createRoomFailed(const.CREATE_FAILED_OTHER)
def callback(content):
content = content.decode()
try:
DEBUG_MSG("cards response: {}".format(content))
if content[0] != '{':
if getattr(self, 'client', None):
self.client.createRoomFailed(const.CREATE_FAILED_OTHER)
return
data = json.loads(content)
card_cost, diamond_cost = switch.calc_cost(
game_round, room_mode)
if not KBEngine.globalData[
"GameWorld"].free_play and card_cost > data[
"card"] and diamond_cost > data["diamond"]:
if getattr(self, 'client', None):
self.client.createRoomFailed(
const.CREATE_FAILED_NO_ENOUGH_CARDS)
return
params = {
'owner_uid': self.userId,
'room_mode': room_mode,
'game_round': game_round,
'insert_card': insert_card,
'deal_mode': deal_mode,
'score_mode': score_mode,
'changeSeat': changeSeat,
'best_phase': best_phase,
'is_agent': is_agent,
}
KBEngine.createBaseAnywhere("GameRoom", params,
self.createRoomCallback)
except:
DEBUG_MSG("createRoom callback error:{}".format(content))
if getattr(self, 'self', None):
self.client.createRoomFailed(const.CREATE_FAILED_OTHER)
def callback(content):
content = content.decode()
try:
DEBUG_MSG("cards response: {}".format(content))
if content[0] != '{':
if getattr(self, 'client', None):
self.client.createRoomFailed(const.CREATE_FAILED_OTHER)
return
data = json.loads(content)
card_cost, diamond_cost = switch.calc_cost(game_round, player_num, pay_mode)
if not KBEngine.globalData["GameWorld"].free_play and card_cost > data["card"] and diamond_cost > data["diamond"]:
if getattr(self, 'client', None):
self.client.createRoomFailed(const.CREATE_FAILED_NO_ENOUGH_CARDS)
return
params = {
'owner_uid': self.userId,
'player_num': player_num,
'pay_mode': pay_mode,
'win_quantity': win_quantity,
'game_round': game_round,
'king_num' : king_num,
'is_agent': is_agent,
}
KBEngine.createBaseAnywhere("GameRoom", params, self.createRoomCallback)
except:
DEBUG_MSG("createRoom callback error:{}".format(content))
if getattr(self, 'self', None):
self.client.createRoomFailed(const.CREATE_FAILED_OTHER)
def callback(content):
if content is None:
DEBUG_MSG("createRoom callback error: content is None, user id {}".format(self.userId))
self.createRoomFailed(const.CREATE_FAILED_NET_SERVER_ERROR)
return
try:
DEBUG_MSG("cards response: {}".format(content))
if content[0] != '{':
if getattr(self, 'client', None):
self.createRoomFailed(const.CREATE_FAILED_NET_SERVER_ERROR)
return
data = json.loads(content)
card_cost, diamond_cost = switch.calc_cost(game_round, {"pay_mode":pay_mode})
if not KBEngine.globalData["GameWorld"].free_play and card_cost > data["card"] and diamond_cost > data["diamond"]:
if getattr(self, 'client', None):
self.client.createRoomFailed(const.CREATE_FAILED_NO_ENOUGH_CARDS)
return
params ={
# 基本必填信息
'owner_uid' : self.userId,
'player_num' : 4,
# client 2 svr
# 'game_mode' : game_mode,
'game_round' : game_round,
'hand_prepare' : hand_prepare,
'pay_mode' : pay_mode,
'room_type' : room_type,
}
KBEngine.createBaseAnywhere("GameRoom", params, self.createRoomCallback)
except:
err, msg, stack = sys.exc_info()
DEBUG_MSG("createRoom callback error:{} , exc_info: {} ,{}".format(content, err, msg))
self.createRoomFailed(const.CREATE_FAILED_OTHER)
def createRoomCallback(self, room, err = None):
DEBUG_MSG("createRoomCallback")
if room:
room.roomID = utility.gen_room_id(room.id)
if room.is_agent == 1:
def callback(content):
try:
content = content.decode()
if content[0] != '{':
DEBUG_MSG(content)
return
room.reqEnterRoom(self, True)
self.room = room
KBEngine.globalData["GameWorld"].addRoom(room)
info = room.get_init_client_dict()
if getattr(self, 'client', None):
self.client.createRoomSucceed(info)
except:
DEBUG_MSG("agent consume callback error:{}".format(content))
card_cost, diamond_cost = switch.calc_cost(room.game_round, room.player_num, room.pay_mode)
if switch.DEBUG_BASE:
callback('{"card":99, "diamond":999}'.encode())
else:
utility.update_card_diamond(self.accountName, -card_cost, -diamond_cost ,callback, "NingBoMJ RoomID:{}".format(self.roomID)) # reason 必须为英文
else:
room.reqEnterRoom(self, True)
self.room = room
KBEngine.globalData["GameWorld"].addRoom(room)
info = room.get_init_client_dict()
if getattr(self, 'client', None):
self.client.createRoomSucceed(info)
else:
if getattr(self, 'client', None):
self.client.createRoomFailed(const.CREATE_FAILED_OTHER)
def dropRoom(self):
self.dismiss_timer = None
for i,p in enumerate(self.players_list):
if p and p.mb:
try:
p.mb.quitRoomSucceed()
except:
pass
if self.room_type == const.AGENT_ROOM and self.agent:
# 将房间从代理房间中删除
if not self.agent.isDestroyed:
self.agent.agentRoomDropped(self.roomID)
try:
# 如果是代开房, 没打完一局返还房卡
if switch.DEBUG_BASE == 0 and self.current_round < 1 and self.agent and self.pay_mode == const.AGENT_PAY_MODE:
card_cost, diamond_cost = switch.calc_cost(self.game_round, self.getCalCostNeed())
def callback(room_id, user_id, content):
try:
content = content.decode()
if content[0] != '{':
DEBUG_MSG(content)
return
except:
DEBUG_MSG("dropRoom{} AgentRoom return Failed, userID = {}. return {} back".format(room_id, user_id, (card_cost, diamond_cost)))
utility.update_card_diamond(self.agent.accountName, card_cost, diamond_cost,
Functor(callback, self.roomID, self.agent.userId), "KouDianDian drop AgentRoomID:{}".format(self.roomID)) # reason 必须为英文
except:
pass
self._reset()
def readyForDestroy(self):
INFO_MSG('iRoomManager readyForDestroy()')
self.destroyState = const.DESTROY_PROCESS_BEGIN
self.destroy_ts = utility.get_cur_timestamp()
card_req = {}
for key in list(self.rooms.keys()):
room = self.rooms[key]
if room.room_type == const.AGENT_ROOM and room.current_round < 1:
# 代开房间没开始打, 返还房卡
card_cost, diamond_cost = switch.calc_cost(
room.game_round, room.getCalCostNeed())
if room.agent:
key = room.agent.accountName
if key in card_req:
val = card_req[key]
card_req[key] = (val[0] + card_cost,
val[1] + diamond_cost)
else:
card_req[key] = (card_cost, diamond_cost)
try:
room.destroyByServer()
except:
pass
self.rooms.clear()
self.handleCardBack(card_req)
def pay2StartGame(self):
""" 开始游戏 """
DEBUG_MSG("{} game_mode:{},game_max_lose:{},game_round:{},hand_prepare:{} pay2StartGame state:{}"
.format(self.prefixLogStr, self.game_mode, self.game_max_lose, self.game_round, self.hand_prepare, self.state))
if self.timeout_timer:
self.cancel_timer(self.timeout_timer)
self.timeout_timer = None
self.state = const.ROOM_TRANSITION
# 仅仅在第1局扣房卡, 不然每局都会扣房卡
if self.current_round == 0:
self.origin_players_list = self.players_list[:]
if switch.DEBUG_BASE != 0:
self.paySuccessCbk()
return
card_cost, diamond_cost = switch.calc_cost(self.game_round, self.getCalCostNeed())
if self.pay_mode == const.NORMAL_PAY_MODE:
def pay_callback(content):
if self._check_pay_callback(content):
self.paySuccessCbk()
utility.update_card_diamond(self.origin_players_list[0].mb.accountName, -card_cost, -diamond_cost, pay_callback, "{} RoomID:{}".format(const.GAME_NAME, self.roomID))
elif self.pay_mode == const.AGENT_PAY_MODE:
# 开房的时候已经扣了房卡 续房的时候需要再扣一次，这个时候房卡不足怎么办？
if self._continue_room_flag:
def pay_callback(content):
if self._check_pay_callback(content):
self.paySuccessCbk()
utility.update_card_diamond(self.agent.accountName, -card_cost, -diamond_cost, pay_callback, "{} RoomID:{}".format(const.GAME_NAME, self.roomID)) # reason 必须为英文
elif self.pay_mode == const.CLUB_PAY_MODE:
pay_account = self.club.owner['accountName']
reason = "{} Club:{} RoomID:{}".format(const.GAME_NAME, self.club.clubId, self.roomID)
def pay_callback(content):
if self._check_pay_callback(content):
self.paySuccessCbk()
utility.update_card_diamond(pay_account, -card_cost, -diamond_cost, pay_callback, reason)
elif self.pay_mode == const.AA_PAY_MODE:
pay_accounts = [p.mb.accountName for p in self.players_list if p is not None]
if self.club:
reason = "{} Club:{} AA RoomID:{}".format(const.GAME_NAME, self.club.clubId, self.roomID)
else:
reason = "{} AA RoomID:{}".format(const.GAME_NAME, self.roomID)
def pay_callback(content):
if self._check_aa_pay_callback(content):
self.paySuccessCbk()
utility.update_card_diamond_aa(pay_accounts, -card_cost, -diamond_cost, pay_callback, reason)
else:
ERROR_MSG("pay2StartGame Error: No this PayMode:{}".format(self.pay_mode))
return
else:
self.paySuccessCbk()
def pay2StartGame(self):
""" 开始游戏 """
DEBUG_MSG("room:{},curround:{},game_mode:{},king_mode:{},game_round:{},hand_prepare:{} pay2StartGame state:{}".format(self.roomID, self.current_round,
self.game_mode, self.king_mode, self.game_round, self.hand_prepare,
self.state))
if self.timeout_timer:
self.cancel_timer(self.timeout_timer)
self.timeout_timer = None
self.state = const.ROOM_TRANSITION
# 在第2局开始扣房卡
if self.current_round == 1:
if switch.DEBUG_BASE:
self.paySuccessCbk()
return
card_cost, diamond_cost = switch.calc_cost(self.game_round, self.getCalCostNeed())
if self.pay_mode == const.NORMAL_PAY_MODE:
pay_account = self.origin_players_list[0].mb.accountName
reason = "KouDianDian RoomID:{}".format(self.roomID)
def pay_callback(content):
if self._check_pay_callback(content):
self.paySuccessCbk()
utility.update_card_diamond(pay_account, -card_cost, -diamond_cost, pay_callback, reason)
elif self.pay_mode == const.AGENT_PAY_MODE:
# 开房的时候已经扣了房卡
self.paySuccessCbk()
elif self.pay_mode == const.CLUB_PAY_MODE:
pay_account = self.club.owner['accountName']
reason = "KouDianDian Club:{} RoomID:{}".format(self.club.clubId, self.roomID)
def pay_callback(content):
if self._check_pay_callback(content):
self.paySuccessCbk()
utility.update_card_diamond(pay_account, -card_cost, -diamond_cost, pay_callback, reason)
elif self.pay_mode == const.AA_PAY_MODE:
pay_accounts = [p.mb.accountName for p in self.players_list]
if self.club:
reason = "KouDianDian Club:{} AA RoomID:{}".format(self.club.clubId, self.roomID)
else:
reason = "KouDianDian AA RoomID:{}".format(self.roomID)
def pay_callback(content):
if self._check_aa_pay_callback(content):
self.paySuccessCbk()
utility.update_card_diamond_aa(pay_accounts, -card_cost, -diamond_cost, pay_callback, reason)
else:
ERROR_MSG("pay2StartGame Error: No this PayMode:{}".format(self.pay_mode))
return
else:
self.paySuccessCbk()
def callback(content):
if content is None:
DEBUG_MSG(
"createRoom callback error: content is None, user id {}".
format(self.userId))
self.createRoomFailed(const.CREATE_FAILED_NET_SERVER_ERROR)
return
try:
DEBUG_MSG("cards response: {}".format(content))
if content[0] != '{':
self.createRoomFailed(const.CREATE_FAILED_NET_SERVER_ERROR)
return
data = json.loads(content)
card_cost, diamond_cost = switch.calc_cost(
game_round, {
"game_mode": game_mode,
"pay_mode": pay_mode,
"game_max_lose": game_max_lose
})
if not KBEngine.globalData[
"GameWorld"].free_play and card_cost > data[
"card"] and diamond_cost > data["diamond"]:
self.createRoomFailed(const.CREATE_FAILED_NO_ENOUGH_CARDS)
return
params = {
# 基本必填信息
'owner_uid': self.userId,
'king_num': 1,
'player_num': 4,
'lucky_num': 0,
# client 2 svr
'game_mode': game_mode,
'base_score': base_score if game_mode == 0 else 1,
'king_mode': play_list[0],
'begin_dealer_mul': play_list[1],
'win_mode': play_list[2],
'three_job': play_list[3],
'pong_useful': play_list[4],
'bao_tou': play_list[5],
'round_max_lose': round_max_lose if game_mode == 0 else 0,
'game_max_lose':
game_max_lose if game_mode == 1 else 999999,
'game_round': game_round if game_mode == 0 else 999999,
'hand_prepare': hand_prepare,
'pay_mode': pay_mode,
'room_type': room_type,
}
KBEngine.createBaseAnywhere("GameRoom", params,
self.createRoomCallback)
except:
err, msg, stack = sys.exc_info()
DEBUG_MSG(
"createRoom callback error:{} , exc_info: {} ,{}".format(
content, err, msg))
self.createRoomFailed(const.CREATE_FAILED_OTHER)
def callback(content):
try:
DEBUG_MSG("cards response: {}".format(content))
if content[0] != '{':
self.createRoomFailed(const.CREATE_FAILED_OTHER)
return
data = json.loads(content)
card_cost, diamond_cost = switch.calc_cost(room_op["game_round"])
can_do = False
if x42.GW.free_play:
can_do = True
if card_cost and card_cost <= data['card']:
can_do = True
if diamond_cost and diamond_cost <= data['diamond']:
can_do = True
if not can_do:
self.createRoomFailed(const.CREATE_FAILED_NO_ENOUGH_CARDS)
return
detail_op = {}
detail_op["game_mode"] = game_mode
# FIXME 测试用, 正式时候记得改回来
# detail_op["game_round"] = game_round
detail_op["game_round"] = 2
detail_op["player_num"] = player_num
detail_op["game_function"] = game_function
detail_op["game_start"] = game_start
detail_op["game_hei3"] = game_hei3
detail_op["game_deal"] = game_deal
detail_op["game_force"] = game_force
detail_op["game_cardnum"] = game_cardnum
detail_op["game_plays"] = game_plays
detail_op["game_end"] = game_end
detail_op["anticheating"] = anticheating
detail_op["is_competition"] = is_competition
detail_op["is_agent"] = is_agent
detail_op.setdefault("match_mode", belong_info["match_mode"])
detail_op.setdefault("group_id", belong_info["group_id"])
detail_op.setdefault("team_uuid", belong_info["team_uuid"])
detail_op.setdefault("sportId", belong_info["sportId"])
detail_op.setdefault("owner_uid", self.userId)
detail_op.setdefault("create_time", time.time())
DEBUG_MSG("reqCreate----GroupRoom", detail_op)
KBEngine.createBaseAnywhere("GameRoom", detail_op, self.createRoomCallback)
except:
self.createRoomFailed(const.CREATE_FAILED_OTHER)
def createRoomCallback(self, room, err=None):
DEBUG_MSG("createRoomCallback")
if room:
if room.room_type == const.AGENT_ROOM:
if room.pay_mode == const.AGENT_PAY_MODE:
def callback(content):
self.req_entering_room = False
try:
if content is None or content[0] != '{':
DEBUG_MSG(
"agent consume callback error: content is None or error, room id {} ,content: {}"
.format(room.roomId, content))
# 此处应当执行退款逻辑
room.destroySelf()
return
room.agent = self
x42.GW.addRoom(room)
self.playingRoomList.append(room.roomId)
self.getPlayingRoomInfo(True)
except:
DEBUG_MSG("agent consume callback error:{}".format(
content))
# 此处应当执行退款逻辑
room.destroySelf()
return
card_cost, diamond_cost = switch.calc_cost(
room.game_round, room.pay_mode)
if switch.DEBUG_BASE:
callback('{"card":99, "diamond":9999}')
else:
utility.update_card_diamond(
self.accountName, -card_cost, -diamond_cost,
callback, "GuiXi RoomID:{}".format(
room.roomId)) # reason 必须为英文
elif room.pay_mode == const.AA_PAY_MODE:
self.req_entering_room = False
room.agent = self
x42.GW.addRoom(room)
self.playingRoomList.append(room.roomId)
self.getPlayingRoomInfo(True)
else:
self.createRoomFailed(const.CREATE_FAILED_OTHER)
else:
room.reqEnterRoom(self, True)
else:
self.createRoomFailed(const.CREATE_FAILED_OTHER)
def callback(content):
if content is None:
DEBUG_MSG(
"createRoom callback error: content is None, user id {}".
format(self.userId))
self.createRoomFailed(const.CREATE_FAILED_NET_SERVER_ERROR)
return
try:
DEBUG_MSG("cards response: {}".format(content))
if content[0] != '{':
self.createRoomFailed(const.CREATE_FAILED_NET_SERVER_ERROR)
return
data = json.loads(content)
card_cost, diamond_cost = switch.calc_cost(
game_round, {
"round_mode": round_mode,
"pay_mode": pay_mode
})
if not KBEngine.globalData[
"GameWorld"].free_play and card_cost > data[
"card"] and diamond_cost > data["diamond"]:
self.createRoomFailed(const.CREATE_FAILED_NO_ENOUGH_CARDS)
return
params = {
'owner_uid': self.userId,
'king_num': 1,
'player_num': 4,
'game_round': game_round,
'round_mode': round_mode,
'base_score_mode': base_score_mode,
'pay_mode': pay_mode,
'game_mode': game_mode,
'king_mode': king_mode,
'max_lose': max_lose,
'score': score,
'job': job,
'discard_seconds': discard_seconds,
'hand_prepare': hand_prepare,
'room_type': room_type,
}
KBEngine.createBaseAnywhere("GameRoom", params,
self.createRoomCallback)
except:
err, msg, stack = sys.exc_info()
DEBUG_MSG(
"createRoom callback error:{} , exc_info: {} ,{}".format(
content, err, msg))
self.createRoomFailed(const.CREATE_FAILED_OTHER)
def _check_user_info(content):
if content is None:
DEBUG_MSG("room:{0},curround:{1} userId:{2} enterRoomFailed callback error: content is None".format(self.roomID, self.current_round, avt_mb.userId))
if not first:
avt_mb.enterRoomFailed(const.CREATE_FAILED_NET_SERVER_ERROR)
return False
try:
data = json.loads(content)
card_cost, diamond_cost = switch.calc_cost(self.game_round, self.getCalCostNeed())
if card_cost > data["card"]:
avt_mb.enterRoomFailed(const.ENTER_FAILED_ROOM_DIAMOND_NOT_ENOUGH)
return False
except:
err, msg, stack = sys.exc_info()
DEBUG_MSG("room:{0},curround:{1} _check_user_info callback error:{2} , exc_info: {3} ,{4}".format(self.roomID, self.current_round, content, err, msg))
avt_mb.enterRoomFailed(const.CREATE_FAILED_OTHER)
return False
return True
def createRoomCallback(self, room, err=None):
if room:
if room.is_agent == 1:
def callback(content):
if content[0] != '{':
DEBUG_MSG(content)
return
self.createRoomSucceed(room)
card_cost, diamond_cost = switch.calc_cost(room.game_round)
if switch.DEBUG_BASE:
callback('{"card":99, "diamond":999}')
else:
utility.update_card_diamond(self.accountName, -card_cost, -diamond_cost, callback,
"PaoDeKuai RoomID:{}".format(self.roomID)) # reason 必须为英文
else:
self.createRoomSucceed(room)
else:
self.createRoomFailed(const.CREATE_FAILED_OTHER)
def user_cb(content):
DEBUG_MSG("cardCheck user_cb content is {}".format(content))
if content is None:
DEBUG_MSG("cardCheck user_cb content is None")
callable(callback) and callback(False, "网络有点问题")
return
try:
data = json.loads(content)
# AA付费 自己房卡必须大于等于房间最低消耗数量, 否则不让玩家坐下游戏
card_cost, diamond_cost = switch.calc_cost(club_game_round, self.club.getCalCostNeed())
if data["card"] >= card_cost:
callable(callback) and callback(True, None)
else:
callable(callback) and callback(False, "您的房卡不足, 无法坐下游戏")
except:
import traceback
ERROR_MSG(traceback.format_exc())
callable(callback) and callback(False, "网络有点问题")
def callback(content):
content = content.decode()
try:
data = json.loads(content)
card_cost, diamond_cost = switch.calc_cost(
self.game_round, self.player_num, self.pay_mode)
if diamond_cost > data["diamond"]:
avt_mb.enterRoomFailed(
const.ENTER_FAILED_ROOM_DIAMOND_NOT_ENOUGH)
return
# 代开房
if first and self.is_agent == 1:
self.agent = PlayerProxy(avt_mb, self, -1)
self.players_dict[avt_mb.userId] = self.agent
avt_mb.enterRoomSucceed(self, -1)
return
for i, p in enumerate(self.players_list):
if p and p.mb and p.mb.userId == avt_mb.userId:
p.mb = avt_mb
avt_mb.enterRoomSucceed(self, i)
return
DEBUG_MSG("Room.reqEnterRoom: %s" % (self.roomID))
idx = self.getSit()
n_player = PlayerProxy(avt_mb, self, idx)
self.players_dict[avt_mb.userId] = n_player
self.players_list[idx] = n_player
# 确认准备
# if idx not in self.confirm_next_idx:
# self.confirm_next_idx.append(idx)
if not first:
self.broadcastEnterRoom(idx)
self.check_same_ip()
if self.isFull:
self.origin_players_list = self.players_list[:]
except:
DEBUG_MSG("enterRoomFailed callback error:{}".format(content))
def callback(content):
if content is None:
DEBUG_MSG(
"createRoom callback error: content is None, user id {}".
format(self.userId))
self.createRoomFailed(const.CREATE_FAILED_NET_SERVER_ERROR)
return
# try:
DEBUG_MSG("cards response: {}".format(content))
if content[0] != '{':
self.createRoomFailed(const.CREATE_FAILED_NET_SERVER_ERROR)
return
data = json.loads(content)
card_cost, diamond_cost = switch.calc_cost(game_round, pay_mode)
if not KBEngine.globalData[
"GameWorld"].free_play and card_cost > data[
"card"] and diamond_cost > data["diamond"]:
self.createRoomFailed(const.CREATE_FAILED_NO_ENOUGH_CARDS)
return
# @formatter:off
params = {
'owner_uid': self.userId,
'king_num': 0,
'player_num': player_num,
'game_round': game_round,
'pay_mode': pay_mode,
'game_mode': game_mode,
'max_lose': max_lose,
'lucky_num': lucky_num,
'discard_seconds': 0,
'hand_prepare': hand_prepare,
'room_type': room_type,
}
# @formatter:on
KBEngine.createEntityAnywhere("GameRoom", params,
self.createRoomCallback)
def startGame(self):
""" 开始游戏 """
DEBUG_MSG("startGame")
self.op_record = []
self.state = 1
self.current_round += 1
diceList = self.throwTheDice([self.dealer_idx])
idx, num = self.getMaxDiceIdx(diceList)
# 仅仅在第1局扣房卡, 不然每局都会扣房卡
def callback(content):
content = content.decode()
try:
if content[0] != '{':
DEBUG_MSG(content)
self.dropRoom()
return
# 第一局时房间默认房主庄家, 之后谁上盘赢了谁是, 如果臭庄, 最后摸牌的人是庄
for p in self.players_list:
p.reset()
self.current_idx = self.dealer_idx
self.initTiles()
self.deal(self.king_num)
dragon_greens_list = [p.dragon_greens for i,p in enumerate(self.players_list)]
for p in self.players_list:
if p and p.mb:
DEBUG_MSG("start game,dealer_idx:{0},tiles:{1}, kingTiles:{2}, diceList:{3},leftTileNum:{4}".format(self.dealer_idx, p.tiles, self.kingTiles, diceList, len(self.tiles)))
p.mb.startGame(self.dealer_idx, p.tiles, dragon_greens_list, self.kingTiles, diceList)
self.beginRound()
except:
DEBUG_MSG("consume failed!")
if self.current_round == 1 and self.is_agent == 0:
card_cost, diamond_cost = switch.calc_cost(self.game_round, self.player_num)
if switch.DEBUG_BASE:
callback('{"card":99, "diamond":999}'.encode())
else:
signal = 0
def payCallback(content):
nonlocal signal
try:
signal += 1
if signal == len(self.players_list):
callback(content)
except:
DEBUG_MSG("AA payCallback Failed")
if self.player_num == 3:
utility.update_card_diamond(self.players_list[0].mb.accountName, -card_cost, -diamond_cost, payCallback, "WuNingMJ RoomID:{}".format(self.roomID))
utility.update_card_diamond(self.players_list[1].mb.accountName, -card_cost, -diamond_cost, payCallback, "WuNingMJ RoomID:{}".format(self.roomID))
utility.update_card_diamond(self.players_list[2].mb.accountName, -card_cost, -diamond_cost, payCallback, "WuNingMJ RoomID:{}".format(self.roomID))
else:
utility.update_card_diamond(self.players_list[0].mb.accountName, -card_cost, -diamond_cost, payCallback, "WuNingMJ RoomID:{}".format(self.roomID))
utility.update_card_diamond(self.players_list[1].mb.accountName, -card_cost, -diamond_cost, payCallback, "WuNingMJ RoomID:{}".format(self.roomID))
utility.update_card_diamond(self.players_list[2].mb.accountName, -card_cost, -diamond_cost, payCallback, "WuNingMJ RoomID:{}".format(self.roomID))
utility.update_card_diamond(self.players_list[3].mb.accountName, -card_cost, -diamond_cost, payCallback, "WuNingMJ RoomID:{}".format(self.roomID))
return
DEBUG_MSG("start Game: Room{0} - Round{1}".format(self.roomID, str(self.current_round)+'/'+str(self.game_round)))
callback('{"card":99, "diamond":999}'.encode())
def startGame(self):
""" 开始游戏 """
self.op_record = []
self.controller_discard_list = []
self.deskPokerList = [[] for i in range(const.ROOM_PLAYER_NUMBER)]
self.state = 1
self.current_round += 1
self.key_card = 0
#扣费后开始游戏的回调
def callback(content):
content = content.decode()
# try:
if content[0] != '{':
DEBUG_MSG(content)
self.dropRoom()
return
for p in self.players_list:
p.reset()
self.initCards()
self.deal()
if self.changeSeat:
if True or self.current_round == 1 or len(
self.show_empty_list) == 2:
# 根据需求每次重新换座位
self.random_key_card()
first_key_idx, second_key_idx = self.getKeyCardSeat()
self.swap_list = self.swapSeat(first_key_idx,
second_key_idx)
self.controller_idx = self.swap_list.index(first_key_idx)
self.wait_idx = self.controller_idx
else:
self.key_card = 0
self.controller_idx = self.show_empty_list[0]
self.wait_idx = self.controller_idx
else:
if len(self.show_empty_list) > 0:
self.controller_idx = self.show_empty_list[0]
self.wait_idx = self.controller_idx
else:
self.controller_idx = 0
self.wait_idx = self.controller_idx
self.show_empty_list = []
#DEBUG_MSG
for i, p in enumerate(self.players_list):
DEBUG_MSG("player [{0}] cards: {1}".format(p.idx, p.cards))
for p in self.players_list:
if p and p.mb:
p.start()
p.mb.startGame(self.controller_idx, self.key_card, p.cards,
self.swap_list)
# except:
# DEBUG_MSG("consume failed!")
if self.current_round == 1 and self.is_agent == 0:
# 仅仅在第1局扣房卡, 不然每局都会扣房卡
card_cost, diamond_cost = switch.calc_cost(self.game_round,
self.room_mode)
if switch.DEBUG_BASE:
callback('{"card":99, "diamond":999}'.encode())
else:
utility.update_card_diamond(
self.players_list[0].mb.accountName, -card_cost,
-diamond_cost, callback,
"BaiBianShuangKou RoomID:{}".format(self.roomID))
return
DEBUG_MSG("start Game: Room{0} - Round{1}".format(
self.roomID,
str(self.current_round) + '/' + str(self.game_round)))
callback('{"card":99, "diamond":999}'.encode())
def startGame(self):
""" 开始游戏 """
DEBUG_MSG("startGame")
self.op_record = []
self.state = 1
self.current_round += 1
self.wait_give_up_list = []
self.give_up_list = []
self.polling_give_up_op = -1
for i, p in enumerate(self.players_list):
if p is not None:
p.wreaths = []
diceList = self.throwTheDice([self.dealer_idx])
idx, num = self.getMaxDiceIdx(diceList)
# 仅仅在第1局扣房卡, 不然每局都会扣房卡
def callback(content):
content = content.decode()
try:
if content[0] != '{':
DEBUG_MSG(content)
self.dropRoom()
return
# 第一局时房间默认房主庄家, 之后谁上盘赢了谁是, 如果臭庄, 最后摸牌的人是庄
for p in self.players_list:
p.reset()
self.current_idx = self.dealer_idx
#圈风
if sum([1 for state in self.player_dealer_state
if state == 1]) == self.player_num:
windIdx = (self.prevailing_wind + 1 -
const.WIND_EAST) % len(const.WINDS)
self.prevailing_wind = const.WINDS[windIdx]
self.player_dealer_state = [0, 0, 0, 0]
self.player_dealer_state[self.dealer_idx] = 1
#自风
for i, p in enumerate(self.players_list):
if p is not None:
p.wind = (self.player_num + i - self.dealer_idx
) % self.player_num + const.WIND_EAST
self.initTiles()
self.deal(self.king_num)
wreathsList = [
p.wreaths for i, p in enumerate(self.players_list)
]
playerWindList = [
p.wind for i, p in enumerate(self.players_list)
]
for p in self.players_list:
if p and p.mb:
DEBUG_MSG(
"start game,dealer_idx:{0},tiles:{1}, wreathsList:{2}, kingTiles:{3}, diceList:{4},leftTileNum:{5}"
.format(self.dealer_idx, p.tiles, wreathsList,
self.kingTiles, diceList, len(self.tiles)))
p.mb.startGame(self.dealer_idx, p.tiles, wreathsList,
self.kingTiles, self.prevailing_wind,
playerWindList, diceList)
self.beginRound()
except:
DEBUG_MSG("consume failed!")
if self.current_round == 1 and self.is_agent == 0:
card_cost, diamond_cost = switch.calc_cost(self.game_round,
self.player_num,
self.pay_mode)
if switch.DEBUG_BASE:
callback('{"card":99, "diamond":999}'.encode())
elif self.pay_mode == 1:
utility.update_card_diamond(
self.players_list[0].mb.accountName, -card_cost,
-diamond_cost, callback,
"FengHua RoomID:{}".format(self.roomID))
else:
signal = 0
def payCallback(content):
nonlocal signal
try:
signal += 1
if signal == len(self.players_list):
callback(content)
except:
DEBUG_MSG("AA payCallback Failed")
if self.player_num == 3:
utility.update_card_diamond(
self.players_list[0].mb.accountName, -card_cost,
-diamond_cost, payCallback,
"NingBoMJ RoomID:{}".format(self.roomID))
utility.update_card_diamond(
self.players_list[1].mb.accountName, -card_cost,
-diamond_cost, payCallback,
"NingBoMJ RoomID:{}".format(self.roomID))
utility.update_card_diamond(
self.players_list[2].mb.accountName, -card_cost,
-diamond_cost, payCallback,
"NingBoMJ RoomID:{}".format(self.roomID))
else:
utility.update_card_diamond(
self.players_list[0].mb.accountName, -card_cost,
-diamond_cost, payCallback,
"NingBoMJ RoomID:{}".format(self.roomID))
utility.update_card_diamond(
self.players_list[1].mb.accountName, -card_cost,
-diamond_cost, payCallback,
"NingBoMJ RoomID:{}".format(self.roomID))
utility.update_card_diamond(
self.players_list[2].mb.accountName, -card_cost,
-diamond_cost, payCallback,
"NingBoMJ RoomID:{}".format(self.roomID))
utility.update_card_diamond(
self.players_list[3].mb.accountName, -card_cost,
-diamond_cost, payCallback,
"NingBoMJ RoomID:{}".format(self.roomID))
return
DEBUG_MSG("start Game: Room{0} - Round{1}".format(
self.roomID,
str(self.current_round) + '/' + str(self.game_round)))
callback('{"card":99, "diamond":999}'.encode())
def startGame(self):
""" 开始游戏 """
self.op_record = []
self.state = 1
self.current_round += 1
self.discardKingTileIdx = -2
diceList = [[0, 0], [0, 0], [0, 0], [0, 0]]
addDealNum = 0
if self.current_round <= 1: #首次选庄
diceList = self.throwTheDice([0, 1, 2, 3])
idx, num = self.getMaxDiceIdx(diceList)
self.dealer_idx = idx
if self.diceAddNum > 0 and num >= self.diceAddNum:
addDealNum += 1
elif self.isSameAdd > 0 and diceList[idx][0] == diceList[idx][1]:
addDealNum += 1
else:
diceList = self.throwTheDice([self.dealer_idx])
idx, num = self.getMaxDiceIdx(diceList)
if self.dealer_idx != self.last_dealer_idx:
if self.diceAddNum > 0 and num >= self.diceAddNum:
addDealNum += 1
elif self.isSameAdd > 0 and diceList[idx][0] == diceList[idx][
1]:
addDealNum += 1
#老庄
self.setCurOldDealNum(addDealNum)
DEBUG_MSG(
"start game,curOldDealNum{0},dealer_idx{1},diceList{2}".format(
self.curOldDealNum, self.dealer_idx, str(diceList)))
# 仅仅在第1局扣房卡, 不然每局都会扣房卡
def callback(content):
content = content.decode()
try:
if content[0] != '{':
DEBUG_MSG(content)
self.dropRoom()
return
for p in self.players_list:
p.reset()
self.initTiles()
self.deal()
self.current_idx = self.dealer_idx
for p in self.players_list:
if p and p.mb:
p.mb.startGame(self.dealer_idx, p.tiles, self.kingTile,
diceList, self.curOldDealNum,
self.game_round, self.roomMode)
self.beginRound()
except:
DEBUG_MSG("consume failed!")
if self.current_round == 1 and self.is_agent == 0:
card_cost, diamond_cost = switch.calc_cost(self.roomMode,
self.game_round)
if switch.DEBUG_BASE:
callback('{"card":99, "diamond":999}'.encode())
else:
utility.update_card_diamond(
self.players_list[0].mb.accountName, -card_cost,
-diamond_cost, callback,
"XiaoShanMJ RoomID:{}".format(self.roomID))
return
DEBUG_MSG("start Game: Room{0} - Round{1}".format(
self.roomID,
str(self.current_round) + '/' + str(self.game_round)))
callback('{"card":99, "diamond":999}'.encode())
def pay2StartGame(self):
""" 开始游戏 """
DEBUG_MSG("room:{},curround:{},game_mode:{},base_score:{},king_mode:{},begin_dealer_mul:{},win_mode:{},three_job:{},pong_useful:{},bao_tou:{},round_max_lose:{},game_max_lose:{},game_round:{},hand_prepare:{} pay2StartGame state:{}".format(self.roomID, self.current_round,
self.game_mode, self.base_score, self.king_mode, self.begin_dealer_mul, self.win_mode, self.three_job,
self.pong_useful, self.bao_tou, self.round_max_lose, self.game_max_lose, self.game_round, self.hand_prepare,
self.state))
if self.timeout_timer:
self.cancel_timer(self.timeout_timer)
self.timeout_timer = None
self.state = const.ROOM_TRANSITION
if self.current_round == 0:
# 第一局备份原始座位
self.origin_players_list = self.players_list[:]
self.dealer_idx = 0
# 仅仅在第1局扣房卡, 不然每局都会扣房卡
if self.current_round == 0:
if switch.DEBUG_BASE:
self.paySuccessCbk()
return
card_cost, diamond_cost = switch.calc_cost(self.game_round, self.getCalCostNeed())
if self.pay_mode == const.NORMAL_PAY_MODE:
pay_account = self.origin_players_list[0].mb.accountName
reason = "FourDeckCards RoomID:{}".format(self.roomID)
def pay_callback(content):
if self._check_pay_callback(content):
self.paySuccessCbk()
utility.update_card_diamond(pay_account, -card_cost, -diamond_cost, pay_callback, reason)
elif self.pay_mode == const.CLUB_PAY_MODE:
pay_account = self.club.owner['accountName']
reason = "FourDeckCards Club:{} RoomID:{}".format(self.club.clubId, self.roomID)
def pay_callback(content):
if self._check_pay_callback(content):
self.paySuccessCbk()
utility.update_card_diamond(pay_account, -card_cost, -diamond_cost, pay_callback, reason)
elif self.pay_mode == const.AGENT_PAY_MODE:
# 开房的时候已经扣了房卡
self.paySuccessCbk()
elif self.pay_mode == const.AA_PAY_MODE:
pay_accounts = [p.mb.accountName for p in self.players_list]
if self.club:
reason = "FourDeckCards Club:{} AA RoomID:{}".format(self.club.clubId, self.roomID)
else:
reason = "FourDeckCards AA RoomID:{}".format(self.roomID)
def pay_callback(content):
if self._check_aa_pay_callback(content):
self.paySuccessCbk()
utility.update_card_diamond_aa(pay_accounts, -card_cost, -diamond_cost, pay_callback, reason)
else:
ERROR_MSG("pay2StartGame Error: No this PayMode:{}".format(self.pay_mode))
return
else:
self.paySuccessCbk()
def get_continue_list(self, callback, playing_players):
# 如果时代开房需要检查代理的房卡
# 如果时房主 需要检查房主放房卡
# 如果时AA 需要检查所有人的房卡
card_cost, diamond_cost = switch.calc_cost(self.game_round, self.getCalCostNeed())
def _check_user_info(user_id, content):
if self.club and not self.club.isMember(user_id):
DEBUG_MSG("{0} userId:{1} get_continue_list callback error: not in club {2}".format(self.prefixLogStr, user_id, self.club.clubId))
return False
if content is None:
DEBUG_MSG("{0} userId:{1} get_continue_list callback error: content is None".format(self.prefixLogStr, user_id))
return False
try:
data = json.loads(content)
if diamond_cost > data["diamond"] and card_cost > data["card"]:
return False
except:
err, msg, stack = sys.exc_info()
DEBUG_MSG("{0} _check_user_info callback error:{1} {4}, exc_info: {2} ,{3}".format(self.prefixLogStr, content, err, msg, user_id))
return False
return True
def _user_info_callback(user_id, content):
if _check_user_info(user_id, content):
callback and callback([const.ROOM_CONTINUE] * self.player_num)
else:
callback and callback([const.ROOM_END] * self.player_num)
if switch.DEBUG_BASE > 0:
if self.pay_mode == const.CLUB_PAY_MODE:
if self.club is None:
callback and callback([const.ROOM_END] * self.player_num)
return
callback and callback([random.randint(0, 1) if i % 2 == 0 and i > 0 else 1 for i in range(self.player_num)])
elif self.room_type == const.AGENT_ROOM and self.agent:
# user_id = self.agent.userId
# utility.get_user_info(self.agent.accountName, _user_info_callback)
pass
elif self.pay_mode == const.NORMAL_PAY_MODE:
utility.get_user_info(self.players_list[0].mb.accountName, Functor(_user_info_callback, self.players_list[0].mb.userId))
elif self.pay_mode == const.AA_PAY_MODE:
count = len(playing_players)
stats = 0
result = [const.ROOM_END] * self.player_num
for p in playing_players:
result[p.idx] = const.ROOM_CONTINUE
def _find_idx(user_id):
for p in playing_players:
if p.userId == user_id:
return p.idx
return -1
def _check_callback_aa(roomId, user_id, content):
nonlocal stats
nonlocal result
stats += 1
if not _check_user_info(user_id, content):
idx = _find_idx(user_id)
if idx != -1:
result[idx] = const.ROOM_END
if count == stats:
callback and callback(result)
for p in playing_players:
utility.get_user_info(p.mb.accountName, Functor(_check_callback_aa, self.roomID, p.userId))
elif self.pay_mode == const.CLUB_PAY_MODE:
if self.club is None:
callback and callback([const.ROOM_END] * self.player_num)
else:
pay_account = self.club.owner['accountName']
utility.get_user_info(pay_account, Functor(_user_info_callback, self.club.owner['userId']))
else:
ERROR_MSG("{} get_continue_list: not support {} {}".format(self.prefixLogStr, self.room_type, self.pay_mode))
callback and callback([0] * self.player_num)
