130 lines
4.1 KiB
Python
130 lines
4.1 KiB
Python
import asyncio
|
|
from os import stat
|
|
import websockets
|
|
import json
|
|
import queue # refer to https://docs.python.org/3/library/queue.html for multi-threading
|
|
from typing import Dict
|
|
from threading import Thread
|
|
|
|
class MultiplayerService():
|
|
_thread = None
|
|
_receive_piece_queue = queue.Queue()
|
|
_send_piece_queue = queue.Queue()
|
|
_current_game_id = None
|
|
|
|
@classmethod
|
|
def init(cls) -> None:
|
|
thread = Thread(target=asyncio.get_event_loop().run_until_complete,\
|
|
args=(_NetworkConnectionService.init(),))
|
|
thread.start()
|
|
|
|
@classmethod
|
|
def enter_game(cls, game_id: str) -> None:
|
|
cls._current_game_id = game_id
|
|
_NetworkConnectionService._join_game = True
|
|
pass
|
|
|
|
@classmethod
|
|
def send_piece(cls, piece: "PieceDto") -> None:
|
|
cls._send_piece_queue.put(piece)
|
|
|
|
@classmethod
|
|
def try_receive_piece(cls) -> "PieceDto":
|
|
return cls._receive_piece_queue.get() if not cls._receive_piece_queue.empty() else None
|
|
|
|
@classmethod
|
|
def quit(cls) -> None:
|
|
_NetworkConnectionService.close_connection()
|
|
|
|
class _NetworkConnectionService():
|
|
_URI = "ws://localhost:5001" # TODO get from config file
|
|
_websocket = None
|
|
_is_closed = False
|
|
_join_game = False
|
|
|
|
@classmethod
|
|
async def init(cls) -> None:
|
|
await cls._connect_to_server()
|
|
await cls._run_network_loop()
|
|
|
|
@classmethod
|
|
def close_connection(cls) -> None:
|
|
cls._is_closed = True
|
|
|
|
@classmethod
|
|
async def _run_network_loop(cls) -> None:
|
|
while True:
|
|
await asyncio.sleep(16e-3) # TODO add clock tick instead
|
|
|
|
await cls._try_enter_game()
|
|
await cls._try_send_piece()
|
|
# await cls._try_receive_message()
|
|
|
|
# if conection is closed, exit loop
|
|
if cls._is_closed:
|
|
await cls._websocket.close()
|
|
break
|
|
|
|
@classmethod
|
|
async def _try_enter_game(cls) -> None:
|
|
if not cls._join_game:
|
|
return
|
|
|
|
json_message = json.dumps({"action": "enter_game", "gameId": MultiplayerService._current_game_id})
|
|
await cls._websocket.send(json_message)
|
|
|
|
json_response = await cls._websocket.recv()
|
|
print(json_response)
|
|
|
|
cls._join_game = False
|
|
|
|
@classmethod
|
|
async def _try_send_piece(cls) -> None:
|
|
# if no messages to proccess, return
|
|
if MultiplayerService._send_piece_queue.empty():
|
|
return
|
|
|
|
# get next piece to send and send to server
|
|
piece = MultiplayerService._send_piece_queue.get()
|
|
|
|
# construct json message
|
|
message = {}
|
|
message["action"] = "send_piece"
|
|
message["gameId"] = MultiplayerService._current_game_id
|
|
message["piece"] = piece.__dict__()
|
|
|
|
await cls._websocket.send(json.dumps(message))
|
|
|
|
@classmethod
|
|
async def _try_receive_message(cls) -> None:
|
|
try:
|
|
async for message in cls._websocket:
|
|
data = json.loads(message)
|
|
print(data)
|
|
# if message type is receive_piece, put it in the receive queue
|
|
if data["type"] == "receive_piece":
|
|
# convert Dict to PieceDto
|
|
MultiplayerService._receive_piece_queue.put(PieceDto.create(data["piece"]))
|
|
finally:
|
|
pass # TODO handle connection closed exception
|
|
|
|
@classmethod
|
|
async def _connect_to_server(cls) -> None:
|
|
print("Connecting to server...") # TODO replace with logging
|
|
cls._websocket = await websockets.connect(cls._URI, ping_interval=None)
|
|
# ping_interval=None is important, otherwise the server will disconnect us
|
|
# https://stackoverflow.com/a/58993145/11512104
|
|
print("Connected to server...") # TODO replace with logging
|
|
|
|
# DTOs
|
|
|
|
class PieceDto():
|
|
def __init__(self, x: int, y: int, type_: str) -> None:
|
|
self.x = x
|
|
self.y = y
|
|
self.type = type_
|
|
pass
|
|
|
|
@staticmethod
|
|
def create(data: Dict) -> "PieceDto":
|
|
return PieceDto(data["x"], data["y"], data["type"]) |