async def websocket_handler(self, websocket, path):
logger.debug("websocket_handler: {}, {}".format(
websocket.remote_address, path))
while True:
try:
data = await asyncio.wait_for(
websocket.recv(), timeout=GlobalObject().ws_timeout)
logger.debug('websocketserver received {!r}'.format(data))
# await websocket.send("hello")
while data: # 解决TCP粘包问题
data = await websocket.process_data(data, websocket)
except asyncio.TimeoutError:
logger.info("{} connection timeout!".format(
websocket.remote_address))
await websocket.close()
except ConnectionClosed as e:
logger.info("{} connection lose ({}, {})".format(
websocket.remote_address, e.code, e.reason))
return 0
except DataException as e:
logger.info("data decrypt error!")
await websocket.close()
return 0
async def schedule(self):
# 定时rpc断线重连
while True:
await asyncio.sleep(3)
# logger.info("start new schedule task~")
# print("schedule:", RpcConnectionManager().type_dict, RpcConnectionManager().conns)
for node_type, name_lst in RpcConnectionManager().type_dict.items(
):
for name in name_lst:
if name not in RpcConnectionManager().conns.keys()\
or ConnectionStatus.ESTABLISHED != RpcConnectionManager().conns[name]["status"]:
host = RpcConnectionManager().conns[name]["host"]
port = RpcConnectionManager().conns[name]["port"]
try:
logger.debug("try to reconnect:{}".format(
[name, host, port]))
await self.loop.create_connection(RpcPushProtocol,
host=host,
port=port)
logger.info("success connect to {}:{}".format(
host, port))
except ConnectionRefusedError as e:
logger.error(
"schedule try connect to {}:{} failed!")
def execute(self, type_list=[SettleType.HU]):
"""
执行结算
:param params: {settletype:[], settletype2:[,...], ...}
:return:
"""
logger.debug(u"执行结算: %s", str(type_list))
for i in range(self.game_data.max_player_num):
self.players[i].hand_card.handle_hand_card_for_settle_show()
# 联合手牌,用于计算胡牌番型
self.game_data.players[i].hand_card.union_hand_card()
for t in type_list:
if SettleType.GANG == t:
self.settle_gang()
elif SettleType.GEN_ZHUANG == t:
self.settle_gen_zhuang()
elif SettleType.HU == t:
self.settle_hu()
elif SettleType.DRAW == t:
self.settle_draw()
# 返回结算数据
notify_settle_data(self.desk_id, self.game_data.settle_data)
def execute(self, seat_id, card_num=1, is_last=False):
"""
执行摸牌
:param seat_id:
:param card_num:
:param is_last:
:return:
"""
logger.debug(u"摸牌: %s", str([seat_id, card_num, is_last]))
print("### sid=%s draw_card len=%s hand-card =%s ," %
(seat_id, len(self.players[seat_id].hand_card.hand_card_vals),
self.players[seat_id].hand_card.hand_card_vals))
for step in self.game_config.draw_card_step:
for name, cfg in step.items():
ret = self.step_handlers.get(name)(seat_id=seat_id,
card_num=card_num,
is_last=is_last,
config_params=cfg)
if not ret:
logger.error("step:%s", step)
return
elif ret != 1:
return 0
return 1
def param_check(self, **kwargs): # 参数验证
act_params = kwargs.get("act_params")
if 1 != len(act_params):
# 同时只允许有一个玩家发生点杠操作
logger.debug(u"act_diangang_error:%s", str(act_params))
return
seat_id = list(act_params.keys())[0]
params = act_params[seat_id]
card_val = self.game_data.last_chu_card_val
if not card_val or -1 == self.game_data.last_chu_card_seat_id:
logger.error("dian_gang params error: %s", str([seat_id, params]))
return
hand_card = self.players[seat_id].hand_card
if 3 != hand_card.hand_card_info[Card.cal_card_type(card_val)][Card.cal_card_digit(card_val)]:
logger.error("dian_gang params error: %s", str([seat_id, params]))
return
self.seat_id = seat_id
self.hand_card = self.game_data.players[seat_id].hand_card
return 1
def execute(self, act_params={}):
"""
执行点炮胡牌
:param act_params:
:return:
"""
logger.debug(u"点炮胡牌: %s", str(act_params))
for seat_id, params in act_params.items():
for step in self.game_config.player_act_step.get(Act.DIAN_HU):
for name, cfg in step.items():
ret = self.step_handlers.get(name)(seat_id=seat_id,
params=params,
config_params=cfg)
if not ret:
logger.error("step:%s", step)
return
if not self.game_config.has_tong_pao:
# 如果不能通炮胡，则只取第一个胡牌的玩家
break
self.settle(settle_type_list=[SettleType.HU])
if self.game_config.is_hu_end:
# 当回合胡牌后结束当局游戏
self.end_game()
return 1
def param_check(self, **kwargs): # 参数验证
act_params = kwargs.get("act_params")
if 1 != len(act_params):
# 同时只允许有一个玩家发生出牌操作
logger.debug(u"act_chu_error:%s", str(act_params))
return
seat_id = list(act_params.keys())[0]
params = act_params[seat_id]
card_val = params.get("card", None)
if isinstance(card_val, list):
card_val = card_val[0]
if not card_val:
logger.debug(u"chu_card error: card_val=%s", str(card_val))
return
if 1 > self.players[seat_id].hand_card.hand_card_info[Card.cal_card_type(card_val)][Card.cal_card_digit(card_val)]:
logger.debug(u"chu_card error: not hava card %s", str([seat_id, params]))
return
self.seat_id = seat_id
self.chu_cardval = card_val
return 1
def connnection_lost(self, exc):
logger.debug('server closed connection')
RpcConnectionManager().lost_connection(self.host, self.port)
super(RpcPushProtocol, self).connection_lost(exc)
def eof_received(self):
logger.debug('rpc_push received EOF')
if self.transport and self.transport.can_write_eof():
self.transport.write_eof()
RpcConnectionManager().lost_connection(self.host, self.port)
def data_received(self, data):
logger.debug('rpc_push received response {}'.format(data))
super().data_received(data)
async def send_message(self, command_id, message, session_id, to=None):
logger.debug("rpc push:{}".format([message, type(message)]))
data = self.pack(message, command_id, session_id, to)
logger.debug("rpc_push send_message:{}".format([data, type(data)]))
self.transport.write(data)
def store_connection(self, host, port, connect, status=ConnectionStatus.LOSE):
logger.debug("store_connection:{}".format([host, port, connect]))
self.conns[RpcConnectionManager.gen_node_name(host, port)] = {
"status": status, "conn": connect, "host": host, "port": port}
def execute(self, call_func_type=CallbackFuncType.NOTHING, call_params={}):
if call_func_type not in self.handler.keys():
logger.debug(u"CallbackManager error: %s",
str([call_func_type, call_params]))
return
return self.handler.get(call_func_type)(call_params)
async def send_message(self, result, command_id):
data = self.pack(result, command_id)
logger.debug("send_message:{}".format([data, type(self), self]))
await self.send(data)
def connection_lost(self, error):
if error:
logger.error('ERROR: {}'.format(error))
else:
logger.debug('closing')
super().connection_lost(error)
def eof_received(self):
logger.debug('received EOF')
if self.transport.can_write_eof():
self.transport.write_eof()
def data_received(self, data):
logger.debug('rpcserver received {!r}'.format(data))
super().data_received(data)
def connection_made(self, transport):
self.transport = transport
address = transport.get_extra_info('peername')
logger.debug('connection accepted {}'.format(address))
