def new_room(self, name):
if name in self._rooms.keys():
util.print_core('Room already exists')
return 0
else:
util.print_core('Making a new room')
self._rooms[name] = Room(name)
return 1
def leave(self, person_name):
if self._status == 'waiting' and person_name in self._players.keys():
del self._players[person_name]
util.print_core(f'{person_name} has left {self._name}')
return 1
elif self._status == 'started' and person_name in self._players.keys():
util.print_core(
f'The game has already started but {person_name} has left {self._name}')
return 1
else:
return 0
async def send_message(self, msg):
try:
if isinstance(msg, str):
await self._ws.send(msg)
elif isinstance(msg, list):
for m in msg:
await self._ws.send(m)
else:
await self._ws.send(json.dumps(msg))
except:
util.print_core('Could not send!')
async def start_game(self):
if self._status == 'started':
util.print_core(f'The game in {self._name} has already started!')
await self.tell_room({
'type': 'Info', 'status': f'The game in room {self._name} has already started'
})
return
util.print_core(f'The game in {self._name} is starting!')
await self.tell_room({
'type': 'Info', 'status': f'The game in room {self._name} has begun'
})
async def consume(self, q: asyncio.Queue):
while True:
msg, ws = await self._q.get()
if isinstance(msg, dict):
await self.update_and_send_response(msg, ws)
elif isinstance(msg, list):
for m in msg:
await self.update_and_send_response(m, ws)
else:
util.print_core('Unknown message datatype')
async def client_handler(self, websocket, path):
self._connected_users.add(websocket)
print('-' * 60)
util.print_core('A client has connected!')
print('-' * 60)
try:
async for _ in websocket:
message = await websocket.recv()
d = json.loads(message)
await self._q.put((d, websocket))
except Exception:
traceback.print_exc()
util.print_core('Client unexpectedly disconnected!')
async def join_room(self, room_name):
if room_name in self._rooms:
util.print_core(f'{self._player_name} is already in {room_name}')
return 0
else:
self._rooms.add(room_name)
await self.send_message({
'type': 'CurrentRoom',
'data': {
'name': room_name
}
})
util.print_core(f'{self._player_name} has joined {room_name}')
return 1
async def join(self, player: Player):
person_name = player._player_name
if self._status != 'waiting' and person_name not in self._players.keys():
util.print_core(
f'{person_name} could not join {self._name} (already started)')
return 0
elif self._status != 'waiting' and person_name in self._players.keys():
util.print_core(
f'{person_name} is rejoining in {self._name} (started)')
await player.send_message({
'type': 'RoomPlayersUpdate',
'data': {
'room': self._name,
'players': list(self._players.keys())
}
})
await player.send_message({
'type': 'GameStart',
'data': {
}
})
return 1
else:
self._players[person_name] = player
util.print_core(f'{person_name} has joined {self._name}')
await self.tell_room({
'type': 'RoomPlayersUpdate',
'data': {
'room': self._name,
'players': list(self._players.keys())
}
})
return 1
async def new_player(self, player_name, password, ws):
if player_name in self._players.keys():
util.print_core('Player already exists - attempting login')
if self._players[player_name]._password == password:
self._players[player_name].update_ws(ws)
await self._players[player_name].send_message({
'type': 'PlayerDetails',
'data': player_name
})
util.print_core('Login success!')
return 1
else:
return 0
else:
util.print_core(f'Creating player: {player_name}')
self._players[player_name] = Player(player_name, password, ws)
await self._players[player_name].send_message(
{
'type': 'PlayerDetails',
'data': player_name
}
)
util.print_core('New player creation success!')
return 1
async def tell_room(self, msg):
for _, player in self._players.items():
try:
await player.send_message(json.dumps(msg))
except:
util.print_core('Could not send!')
def leave_room(self, room_name):
if room_name in self._rooms:
self._rooms.remove(room_name)
util.print_core(f'{self._player_name} has left {room_name}')
return 1
return 0
async def run(self, port='8887', host='localhost'):
util.print_core(f'Starting server on port {port}')
await websockets.server.serve(self.client_handler, host, port)
consumer = asyncio.create_task(self.consume(self._q))
await asyncio.gather(consumer)
def __init__(self):
util.print_core('Initialising...')
self._connected_users = set()
self._lobby = Lobby() # Lobby of the rooms
self._q = asyncio.Queue()