def kg(player):
dice_1 = random.randint(1, 6)
dice_2 = random.randint(1, 6)
proto = game_pb2.KGResponse()
proto.player = player.uuid
proto.dice.dice1 = dice_1
proto.dice.dice2 = dice_2
log = {
"dice_1": dice_1,
"dice_2": dice_2,
"player": player.seat,
"card": [],
}
i = 0
while i < 2:
i += 1
try:
card = player.table.cards_on_desk.pop()
if not player.table.cards_on_desk:
player.table.haidi_card = card
except IndexError:
card = player.table.haidi_card
body = proto.cards.add()
body.card = card
log["card"].append(card)
for i in player.table.player_dict.values():
send(KG, proto, i.session)
player.table.logger.info(log)
player.table.cards_kg = log["card"]
player.cards_discard.extend(log["card"])
def enter(self, owner):
super(DealerChooseState, self).enter(owner)
# 初始化阵营
owner.init_camp()
if owner.dealer_seat == owner.spy_chair:
proto = game_pb2.PokerDealerChooseInitResponse()
proto.dealer_seat = owner.dealer_seat
for e_player in owner.player_dict.values():
proto.flag = -1
if e_player.seat == owner.dealer_seat:
# 只给地主返回是否拿了狗腿8，其他玩家返回-1
# proto.flag = 1 if owner.dealer_seat == owner.spy_chair else -1
proto.flag = 1
send(POKER_DEALER_CHOOSE_INIT, proto, e_player.session)
else:
from rules.player_rules.manager import PlayerRulesManager
for player in owner.player_dict.values():
PlayerRulesManager().condition(player, PLAYER_RULE_CHOOSE)
# 计时器控制时间，中间的所有请求都可以接收，这个时间是控制死必须延迟这个时间
# 2018.5.17取消计时器
# owner.choose_begin_time = time.time()
# owner.temp_timer = IOLoop().instance().add_timeout(owner.choose_begin_time + choose_delay, self.after_delay,
# owner)
owner.dumps()
def enter(self, owner):
super(HaiDiState, self).enter(owner)
# TableRulesManager().condition(owner, TABLE_RULE_END)
owner.haidi_pre_seat = owner.active_seat
owner.reset_proto(HAIDI)
# 按顺序发牌
for i in range(owner.chairs):
active_player = owner.seat_dict[owner.active_seat]
owner.active_seat = active_player.next_seat
player = owner.seat_dict[owner.active_seat]
proto = game_pb2.QH_HaiDiResponse()
proto.cards_rest_num = 0
card = owner.cards_on_desk.pop()
player.draw_card = card
player.cards_ready_hand = is_ready_hand(player)
player.cards_in_hand.append(card)
# player.proto.p = copy(proto)
proto.card.card = card
send(HAIDI, proto, player.session)
player.dumps()
cards_rest_num = len(owner.cards_on_desk)
owner.replay["procedure"].append(
{"draw": [player.seat, card, cards_rest_num]})
for player in owner.player_dict.values():
from rules.player_rules.manager import PlayerRulesManager
PlayerRulesManager().condition(player, PLAYER_RULE_MOON)
if not owner.player_prompts:
# 没有提示
owner.machine.trigger(EndState())
def show_step2(self, owner):
if owner.temp_timer:
IOLoop().instance().remove_timeout(owner.temp_timer)
owner.temp_timer = None
last_show_player = owner.seat_dict[owner.show_card_seat]
# 超时未进行选择默认不明牌,取消计时器之后这段代码怕是不会走了
if not last_show_player.has_chosen_ming:
proto_req = game_pb2.PokerShowCardRequest()
proto_req.flag = 2
from logic.player_action import show_card
show_card(last_show_player, proto_req)
# 发给前端明牌结果
proto_show_res = game_pb2.PokerShowCardResponse()
proto_show_res.seat = owner.show_card_seat
if last_show_player.show_card == 1:
# 明牌发现狗腿直接暴露
if owner.spy_card in last_show_player.cards_in_hand and last_show_player.seat != owner.dealer_seat:
owner.notify_goutui()
for card in last_show_player.cards_in_hand:
show_card = proto_show_res.show_cards.add()
# 如果明牌就返回真实牌型,否则返回空字符串
show_card.card = card if last_show_player.show_card == 1 else ""
for e_player in owner.player_dict.values():
send(POKER_SHOW_CARDS_RESULT, proto_show_res, e_player.session)
# 接下来就是各种骚操作看好了！
from rules.player_rules.manager import PlayerRulesManager
from rules.define import PLAYER_RULE_SHOWCARD
PlayerRulesManager().condition(last_show_player, PLAYER_RULE_SHOWCARD)
def enter(self, owner):
super(DiscardState, self).enter(owner)
# 防止前端未发 pass
proto = game_pb2.CockDiscardNotifyResponse()
proto.player = owner.uuid
send(NOTIFY_DISCARD, proto, owner.session)
owner.dumps()
def enter(self, room_id, player_id, info, session):
#print "player {0} enter room {1}, session {2}".format(player_id, room_id, session.uuid)
table = self.room_dict.get(room_id)
#if not table:
#self.create(room_id,'asdfasdfsaf', player_id,
#'{"game_type":163,"max_rounds":6,"play_type":100,"has_zhong":0,"app_id":47,"has_niao":0,"chips":null,"options":604005382,"ren_shu":4,"qiang_gang":0,"bao_gang":0,"hu_pai":1,"create_type":2,"aa":0}')
#table = self.room_dict.get(room_id)
if not table:
# 给前端返回房间不存在的错误
proto = game_pb2.EnterRoomResponse()
proto.code = 5001
send(ENTER_ROOM, proto, session)
print("room {0} not exist, player {1} enter failed".format(room_id, player_id))
return
if table.room_id != room_id:
self.room_dict[table.room_id] = table
del self.room_dict[room_id]
proto = game_pb2.EnterRoomResponse()
proto.code = 5001
send(ENTER_ROOM, proto, session)
table.logger.fatal("room id map error: proto {0} actually {1}".format(room_id, table.room_id))
return
player = table.player_dict.get(player_id)
if player:
# 服务重启后player没有session
if player.session:
player.table.logger.info("player {0} cancel old session {1}".format(player_id, player.session.uuid))
# SessionMgr().cancel(player.session)
player.session.close()
SessionMgr().register(player, session)
player.table.logger.info("player {0} register new session {1}".format(player_id, player.session.uuid))
player.reconnect()
player.online_status(True)
else:
table.enter_room(player_id, info, session)
def exit_room(self):
if self.table.state == 'InitState':
if self.table.conf.is_aa():
#if self.table.cur_round <= 1:
if self.table.total_round <= 1:
if self.uuid == self.table.owner:
self.dismiss_room()
else:
self.table.request.aa_refund(self.uuid, 0)
self.table.request.exit_room(self.uuid)
proto = game_pb2.ExitRoomResponse()
proto.player = self.uuid
proto.code = 1
for player in self.table.player_dict.values():
send(EXIT_ROOM, proto, player.session)
self.table.logger.info("player {0} exit room".format(self.uuid))
self.delete()
try:
self.session.close()
except Exception:
pass
del self.table.seat_dict[self.seat]
del self.table.player_dict[self.uuid]
self.table.dumps()
self.table = None
else:
self.table.logger.info("player {0} exit room failed".format(
self.uuid))
def show_card_dealer(player, proto):
""" 地主二次明牌
"""
step = proto.step
s1, s2 = divmod(step, 10)
if s1 and s1 != 3:
return
for k, v in player.table.player_dict.iteritems():
if k == player.uuid:
continue
proto = game_pb2.ShowCardResponse()
proto.code = 0
proto.player = k
proto.step = step
if step != 0:
for c in player.cards_in_hand:
card = proto.cards.add()
card.card = c
send(SHOWCARD, proto, v.session)
player.show_card = step
multiple = player.table.conf.show_card_config['double'].get(step, 1)
if multiple > player.table.max_show_multiple:
player.table.max_show_multiple = multiple
# 刷新面板分
for i in player.table.player_dict.values():
score_proto = game_pb2.PokerScoreResponse()
score_proto.multiple = i.table.get_multiple(i)
send(POKER_SCORE, score_proto, i.session)
player.table.replay["procedure"].append({"show_card": [player.seat]})
from rules.player_rules.manager import PlayerRulesManager
PlayerRulesManager().condition(player, PLAYER_RULE_SHOWCARD_DEALER)
player.dumps()
def ready_hand(self, isTing=False):
if self.isTing:
return
if not isTing:
return
cards = is_ready_hand(self)
# cards,键：牌，值：（分，[类型])
self.cards_ready_hand = cards
if not cards:
return
# 删除win_card_group不胡的牌
for temp_keys in self.win_card_group.keys():
if temp_keys not in self.cards_ready_hand.keys():
self.win_card_group.pop(temp_keys)
proto = game_pb2.ReadyHandResponse()
for i in cards:
flag = True
if flag:
c = proto.card.add()
c.card = i
if isTing:
proto.ting_tag = 1
send(READY_HAND, proto, self.session)
self.table.logger.info("player {0} ready hand cards {1}".format(
self.seat, cards))
def calculate_reward_points(self):
# 配置文件不带喜
if not self.conf.reward_type:
return
# 得分出问题
points = self.get_reward_points(self.active_card,
self.active_card_type)
if points <= 0:
return
plus_player = self.seat_dict[self.active_seat]
plus_player.reward_counts += points / self.conf.base_score
for player in self.player_dict.values():
if player.seat == self.active_seat:
continue
player.reward_points -= points
plus_player.reward_points += points
for e_player in self.player_dict.values():
reward_proto = game_pb2.PokerRewardPointsResponse()
reward_proto.plus_points = 4 * points
reward_proto.reduce_points = points
reward_proto.seat = self.active_seat
send(POKER_REWARD, reward_proto, e_player.session)
if self.active_seat not in self.reward_info.keys():
self.reward_info[self.active_seat] = []
self.reward_info[self.active_seat].append([self.active_card, points])
self.replay["procedure"].append(
{"reward": [plus_player.uuid, 4 * points]})
def vote(self, proto):
if self.vote_timer:
IOLoop().instance().remove_timeout(self.vote_timer)
self.dumps()
self.vote_state = proto.flag
self.table.logger.info("player {0} vote {1}".format(self.uuid, self.vote_state))
self.vote_timer = None
proto_back = game_pb2.PlayerVoteResponse()
proto_back.player = self.uuid
proto_back.flag = proto.flag
for k, v in self.table.player_dict.items():
send(VOTE, proto_back, v.session)
if proto.flag:
for player in self.table.player_dict.values():
if not player.vote_state:
return # 给除了提出投票的人发
self.table.dismiss_room()
else:
# 只要有一人拒绝则不能解散房间1
self.table.dismiss_state = False
self.table.dismiss_sponsor = None
self.table.dismiss_time = 0
for player in self.table.player_dict.values():
player.vote_state = None
if player.vote_timer:
IOLoop.instance().remove_timeout(player.vote_timer)
player.vote_timer = None
def enter(self, owner):
super(DrawConcealedKongState, self).enter(owner)
#print "cards_kong_concealed", owner.action_ref_cards, owner.cards_in_hand
for card in owner.action_ref_cards:
owner.cards_in_hand.remove(card)
owner.cards_kong_concealed.extend(owner.action_ref_cards)
owner.cards_group.extend(owner.action_ref_cards)
owner.table.active_seat = owner.seat
proto = game_pb2.ActionResponse()
for card in owner.action_ref_cards:
cards = proto.card.add()
cards.card = card
proto.active_type = PLAYER_ACTION_TYPE_KONG_CONCEALED
proto.player = owner.uuid
proto.trigger_seat = owner.seat
proto.active_card.card = 0
for player in owner.table.player_dict.values():
send(ACTION, proto, player.session)
owner.table.logger.info("player {0} kong {1}".format(owner.seat, owner.action_ref_cards))
# 修改杠上开花
owner.last_gang_card = owner.table.active_card
owner.add_gang_num(0, 0, 1, 0)
owner.table.discard_seat = -1
# owner.table.check_bao_change()
from rules.player_rules.manager import PlayerRulesManager
from rules.define import PLAYER_RULE_TING_KONG
owner.table.reset_proto(PROMPT)
PlayerRulesManager().condition(owner,PLAYER_RULE_TING_KONG)
def enter(self, owner):
super(DiscardExposedKongKGState, self).enter(owner)
for card in owner.action_ref_cards:
owner.cards_in_hand.remove(card)
active_card = owner.action_op_card
action_cards = [active_card] * 4
owner.cards_kong_exposed.extend(action_cards)
owner.cards_group.extend(action_cards)
owner.add_gang_num(1, 0, 0, 0)
trigger_seat = owner.table.active_seat
trigger_player = owner.table.seat_dict[trigger_seat]
calculate_final_score(trigger_player, owner,
owner.get_fang_gang_score())
trigger_player.add_gang_num(0, 0, 0, 1)
trigger_player.cards_discard.remove(active_card)
trigger_player.machine.trigger(WaitState())
owner.table.active_seat = owner.seat
proto = game_pb2.ActionCSResponse()
for card in owner.action_ref_cards:
cards = proto.ref_card.add()
cards.card = card
proto.active_card.card = active_card
proto.trigger_seat = trigger_seat
proto.active_type = PLAYER_ACTION_TYPE_KONG_EXPOSED_KG
proto.player = owner.uuid
for player in owner.table.player_dict.values():
send(ACTION_CS, proto, player.session)
owner.table.logger.info("player {0} kong {1}".format(
owner.seat, active_card))
owner.table.discard_seat = -1
def enter(self, owner):
super(DrawConcealedKongKGState, self).enter(owner)
#print self.name, owner.action_ref_cards, owner.cards_in_hand
for card in owner.action_ref_cards:
owner.cards_in_hand.remove(card)
owner.cards_kong_concealed.extend(owner.action_ref_cards)
owner.cards_group.extend(owner.action_ref_cards)
owner.table.active_seat = owner.seat
owner.add_gang_num(0, 0, 1, 0)
proto = game_pb2.ActionCSResponse()
for card in owner.action_ref_cards:
cards = proto.ref_card.add()
cards.card = card
proto.active_type = PLAYER_ACTION_TYPE_KONG_CONCEALED_KG
proto.player = owner.uuid
proto.trigger_seat = owner.seat
proto.active_card.card = 0
for player in owner.table.player_dict.values():
send(ACTION_CS, proto, player.session)
if player == owner:
continue
else:
calculate_final_score(player, owner, SCORE_AN_GANG)
owner.table.logger.info("player {0} kong {1}".format(
owner.seat, owner.action_ref_cards))
owner.table.discard_seat = -1
def notify_goutui(self):
self.baolu = True
proto = game_pb2.PokerExposeResponse()
proto.seat = self.spy_chair
self.replay["procedure"].append({"notify_goutui": self.spy_chair})
for player in self.player_dict.values():
send(POKER_EXPOSE, proto, player.session)
def enter(self, owner):
super(SettleForRoomState, self).enter(owner)
# 广播大结算数据并解散房间
owner.et = time.time()
proto = game_pb2.SettleForRoomResponse()
proto.end_time = time.strftime('%Y-%m-%d %X', time.localtime())
proto.room_id = owner.room_id
dismiss_flag = 0 if owner.dismiss_state else 1
if owner.dismiss_flag == 2:
dismiss_flag = 2
proto.flag = dismiss_flag
log = {
"flag": proto.flag,
"uuid": owner.room_uuid,
"owner": owner.owner,
"max_rounds": owner.conf.max_rounds,
"st": owner.st,
"et": owner.et,
"room_id": owner.room_id,
"player_data": []
}
scores = []
for p in owner.player_dict.values():
scores.append(p.total)
top_score = max(scores)
for p in owner.player_dict.values():
i = proto.player_data.add()
i.player = p.uuid
i.seat = p.seat
i.total_score = p.total
i.top_score = top_score
i.win_total_cnt = p.win_total_cnt
i.win_draw_cnt = p.win_draw_cnt
i.win_discard_cnt = p.win_discard_cnt
i.pao_cnt = p.pao_cnt
i.is_owner = 1 if p.uuid == owner.owner else 0
i.kong_total_cnt = p.kong_total
i.total_chong_bao = p.total_chong_bao
log["player_data"].append({
"player": p.uuid,
"seat": p.seat,
"total": p.total,
"top_score": top_score,
"win_total_cnt": p.win_total_cnt,
"win_draw_cnt": p.win_draw_cnt,
"win_discard_cnt": p.win_discard_cnt,
"pao_cnt": p.pao_cnt,
"is_owner": i.is_owner,
"kong_total_cnt": i.kong_total_cnt,
"total_chong_bao": i.total_chong_bao,
})
owner.logger.info(log)
owner.dumps()
for p in owner.player_dict.values():
send(SETTLEMENT_FOR_ROOM, proto, p.session)
owner.request.settle_for_room(log)
# owner.bao_card = 0
# owner.bao_card_idx = 0
owner.dismiss_flag = 1
def is_show_card_state(self, session):
if self.state != 'ShowCardState':
proto = game_pb2.ShowCardResponse()
proto.code = 2
proto.player = self.uuid
send(SHOWCARD, proto, session)
return False
return True
def broadcast_all(self, message):
""" 系统广播
"""
proto = game_pb2.CommonNotify()
proto.messageId = 4
proto.sdata = message
for player in self.player_dict.values():
send(NOTIFY_MSG, proto, player.session)
def dismiss_room(self, vote=True):
# 如果是投票解散房间则进入大结算，否则直接推送房主解散命令
def _dismiss():
# 弹出大结算
from state.table_state.settle_for_room import SettleForRoomState
self.machine.trigger(SettleForRoomState())
self.request.load_minus()
if vote and self.state != "InitState":
# 房间内游戏中投票解散
_dismiss()
else:
# 0-没开始解散 1-投票 2-外部解散或者游戏进行中房主解散
vote_flag = 2
if vote:
# 房间内投票
vote_flag = 1
else:
if self.state == "InitState":
# 房主在游戏未开始时解散
vote_flag = 0
if vote_flag == 2:
# 到这说明游戏在进行中房主解散
# 在游戏内部已经做了限制不会走到这里
# 在游戏外部如果游戏进行中不让解散
# 这里直接返回吧
# self.dismiss_flag = 2
# _dismiss()
return
else:
# 游戏未开始时和游戏外房主解散直接返回0,2。
# 0代表外开始时解散，2代表外部解散或者游戏进行中房主解散
# 直接返回一个flag就完事了
proto = game_pb2.DismissRoomResponse()
proto.code = 1
proto.flag = vote_flag
for k, v in self.player_dict.items():
send(DISMISS_ROOM, proto, v.session)
# 这个位置没－1导致房间数量一直上升
if vote_flag == 1:
self.request.load_minus()
self.logger.info("room {0} dismiss".format(self.room_id))
from logic.table_manager import TableMgr
self.request.dismiss_room(self)
TableMgr().dismiss(self.room_id)
for player in self.player_dict.values():
try:
player.session.close()
except Exception:
pass
player.delete()
self.delete()
def execute(self, owner, event, proto=None):
super(DiscardState, self).execute(owner, event, proto)
if event == "discard":
discard(owner, proto)
else:
owner.table.logger.warn("player {0} event {1} not register".format(
owner.seat, event))
proto_re = game_pb2.CommonNotify()
proto_re.messageId = PLAYER_MSG_RECONNECT
send(NOTIFY_MSG, proto_re, owner.session)
def enter(self, owner):
super(ReadyState, self).enter(owner)
# 广播其他玩家
for k, v in owner.table.player_dict.items():
proto = game_pb2.ReadyResponse()
proto.player = owner.uuid
proto.cur_round = owner.table.cur_round
send(READY, proto, v.session)
owner.table.is_all_ready()
owner.dumps()
def online_status(self, status):
self.is_online = status
proto = game_pb2.OnlineStatusResponse()
proto.player = self.uuid
proto.status = self.is_online
self.table.logger.info("player {0} toggle online status {1}".format(self.seat, status))
for i in self.table.player_dict.values():
if i.uuid == self.uuid:
continue
send(ONLINE_STATUS, proto, i.session)
def send_rob_init(self, owner):
if owner.temp_timer:
IOLoop().instance().remove_timeout(owner.temp_timer)
owner.temp_timer = None
for k, v in owner.player_dict.items():
proto = game_pb2.RobLandLordInitResponse()
proto.uuid = owner.seat_dict[owner.rob_seat].uuid
proto.play_type = owner.conf.play_type
send(ROB_DEALER_INIT, proto, v.session)
owner.dumps()
def enter(self, owner):
super(DoubleState, self).enter(owner)
proto = game_pb2.PokerDoubleInitResponse()
for k, v in owner.seat_dict.iteritems():
if k != owner.dealer_seat:
proto.double_list.append(k)
for k, v in owner.seat_dict.iteritems():
send(POKER_DOUBLE_INIT, proto, v.session)
owner.dumps()
def speaker(string, session):
player = SessionMgr().player(session)
proto = game_pb2.SpeakerRequest()
proto.ParseFromString(string)
proto_back = game_pb2.SpeakerResponse()
proto_back.player = player.uuid
proto_back.content = proto.content
for i in player.table.player_dict.values():
send(SPEAKER, proto_back, i.session)
def execute(self, owner, event, proto=None):
super(PromptDrawState, self).execute(owner, event, proto)
from logic.player_action import action, discard
if event == "action":
action(owner, proto)
elif event == "discard" and owner.table.state != 'HaiDiState':
discard(owner, proto)
else:
owner.table.logger.warn("player {0} event {1} not register".format(owner.seat, event))
proto_re = game_pb2.CommonNotify()
proto_re.messageId = PLAYER_MSG_RECONNECT
send(NOTIFY_MSG, proto_re, owner.session)
def send_prompts(self):
proto = game_pb2.PromptResponse()
for k, v in self.action_dict.items():
prompt = proto.prompt.add()
prompt.action_id = k
prompt.prompt = v["prompt"]
prompt.op_card.card = v["op_card"]
for c in v["ref_cards"]:
ref_card = prompt.ref_card.add()
ref_card.card = c
send(PROMPT, proto, self.session)
self.table.logger.info(self.action_dict)
def enter(self, owner):
super(SettleForRoomState, self).enter(owner)
# 广播大结算数据并解散房间
if owner.temp_timer:
IOLoop().instance().remove_timeout(owner.temp_timer)
owner.temp_timer = None
owner.et = time.time()
proto = game_pb2.PokerSettleForRoomResponse()
proto.end_time = time.strftime('%Y-%m-%d %X', time.localtime())
proto.room_id = owner.room_id
dismiss_flag = 0 if owner.dismiss_state else 1
if owner.dismiss_flag == 2:
dismiss_flag = 0
proto.flag = dismiss_flag
log = {
"flag": proto.flag,
"uuid": owner.room_uuid,
"owner": owner.owner,
"max_rounds": owner.conf.max_rounds,
"st": owner.st,
"et": owner.et,
"room_id": owner.room_id,
"player_data": []
}
scores = []
for p in owner.player_dict.values():
scores.append(p.total)
top_score = max(scores)
for p in owner.player_dict.values():
i = proto.player_data.add()
i.player = p.uuid
i.seat = p.seat
i.total_score = p.total
i.top_score = top_score
i.is_owner = 1 if p.uuid == owner.owner else 0
i.reward_score = p.reward_total
i.base_score = p.base_total
log["player_data"].append({
"player": p.uuid,
"seat": p.seat,
"total": p.total,
"top_score": top_score,
"reward_score": p.reward_total,
"is_owner": i.is_owner,
"base_score": p.base_total,
})
owner.logger.info(log)
owner.dumps()
for p in owner.player_dict.values():
send(POKER_SETTLEMENT_FOR_ROOM, proto, p.session)
owner.request.settle_for_room(log)
owner.dismiss_flag = 1
def enter(self, owner):
super(SettleForRoomState, self).enter(owner)
# 广播大结算数据并解散房间
if owner.temp_timer:
IOLoop().instance().remove_timeout(owner.temp_timer)
owner.temp_timer = None
owner.et = time.time()
proto = game_pb2.CockSettleForRoomResponse()
proto.end_time = time.strftime('%Y-%m-%d %X', time.localtime())
proto.room_id = owner.room_id
proto.round = owner.cur_round - 1
proto.score_mul = owner.conf.base_score
proto.aa = 0 if owner.conf.aa is not True else 1
dismiss_flag = 0 if owner.dismiss_state else 1
if owner.dismiss_flag == 2:
dismiss_flag = 0
proto.flag = dismiss_flag
configs = json.dumps({"play_type": owner.conf.play_type, "reward_type": owner.conf.reward_type,
"base_score": owner.conf.base_score})
log = {"flag": proto.flag, "uuid": owner.room_uuid, "owner": owner.owner, "max_rounds": owner.conf.max_rounds,
"st": owner.st, "et": owner.et, "room_id": owner.room_id, "config": configs, "player_data": []}
# scores = []
# for p in owner.player_dict.values():
# scores.append(p.total)
# top_score = max(scores)
index = 0
for p in sorted(owner.player_dict.values(), key=lambda x: x.total, reverse=True):
i = proto.player_data.add()
i.player = p.uuid
i.seat = p.seat
i.total_score = p.total
i.index = index
index += 1
i.is_owner = 1 if p.uuid == owner.owner else 0
# i.reward_score = p.reward_total
# i.base_score = p.base_total
log["player_data"].append({
"player": p.uuid,
"seat": p.seat,
"total": p.total,
"top_score": 0,
"reward_score": 0,
"is_owner": i.is_owner,
"base_score": 0,
})
owner.logger.info(log)
owner.dumps()
for p in owner.player_dict.values():
send(POKER_SETTLEMENT_FOR_ROOM, proto, p.session)
owner.request.settle_for_room(log)
owner.dismiss_flag = 1
def dealer_choose(player, proto):
if player.seat == player.table.dealer_seat and player.seat == player.table.spy_chair:
choose_code = proto.choose_code
if choose_code not in [1, 2]:
player.table.logger.fatal(
"choose_code : {0} wrong".format(choose_code))
else:
player.table.land_lord_chairs = []
player.table.farmer_chairs = []
player.table.land_lord_chairs.append(player.seat)
if choose_code == 1:
# 一打四
player.table.spy_chair = -1
elif choose_code == 2:
# 叫狗腿
# 换狗腿牌
result = player.table.change_spy_card()
if result:
# 换狗腿座位
player.table.change_spy_chair()
# 地主阵营
player.table.land_lord_chairs.append(
player.table.spy_chair)
else:
player.table.logger.fatal("Change spy_card Wrong")
# 要是实在是找不到狗腿牌就直接判定为一打四
player.table.spy_chair = -1
if player.table.spy_chair == -1:
player.table.replay["procedure"].append({"dealer_choose": 1})
else:
player.table.replay["procedure"].append({"dealer_choose": 2})
for e_player in player.table.player_dict.values():
if e_player.seat not in player.table.land_lord_chairs:
# 农民阵营
player.table.farmer_chairs.append(e_player.seat)
# 发送选择结果
if player.table.spy_card != "8G":
proto_res = game_pb2.PokerDealerChooseResponse()
proto_res.choose_code = 2
proto_res.spy_card = player.table.spy_card
player.table.replay["procedure"].append(
{"change_goutui": player.table.spy_card})
for e_player in player.table.player_dict.values():
send(POKER_DEALER_CHOOSE, proto_res, e_player.session)
from rules.player_rules.manager import PlayerRulesManager
for player in player.table.player_dict.values():
PlayerRulesManager().condition(player, PLAYER_RULE_CHOOSE)
