chess_rpg_backend/room/consumers.py

import json
import os
import django

from asgiref.sync import sync_to_async
from channels.generic.websocket import AsyncWebsocketConsumer

from room.services.game_logic import move_handler

os.environ.setdefault("DJANGO_SETTINGS_MODULE", "chess_backend.settings")
django.setup()

from game.models import Deck
from room.models import PlayerInQueue, Room, PlayerInRoom, GameState
from room.services.room_create import create_room


class BaseConsumer(AsyncWebsocketConsumer):
    def __init__(self, *args, **kwargs):
        super().__init__(args, kwargs)

    async def send_message(self, message_type: str, **data):
        await self.send(text_data=json.dumps({"type": message_type, **data}))


class QueueConsumer(BaseConsumer):
    def __init__(self, *args, **kwargs):
        super().__init__(args, kwargs)
        self.room_group_name = None

    async def connect(self):
        self.room_group_name = "queue"

        await self.accept()
        await self.check_origin()

        if await self.check_user_already_in_room():
            await self.send_message(
                "INFO",
                message=f"user already in room {self.scope['room_id']}",
                room=self.scope["room"],
            )
            await self.close()

        await self.channel_layer.group_add(self.room_group_name, self.channel_name)

    async def disconnect(self, close_code):
        await self.delete_user_in_queue()
        await self.channel_layer.group_discard(self.room_group_name, self.channel_name)

    # Receive message from WebSocket
    async def receive(self, text_data):
        data = None

        try:
            data = json.loads(text_data)
        except ValueError:
            await self.send_message("ERROR", message="data is not JSON serializable")

        if data:
            # TODO move to external function/class
            if "type" not in data:
                await self.send_message("ERROR", message="incorrect data typing")
            else:
                if data["type"] == "connect":
                    if "deck_id" not in data:
                        await self.send_message(
                            "ERROR", message="deck id is not provided"
                        )
                    else:
                        deck = None
                        # validate deck and check user originality
                        try:
                            deck_id = int(data["deck_id"])
                            deck = await self.check_user_deck(deck_id)
                        except ValueError:
                            await self.send_message(
                                "ERROR", message="deck id is incorrect"
                            )

                        if deck:
                            # add to que, start finding players
                            await self.queue_connector(deck)
                            await self.send_message(
                                "INFO",
                                message=f"added to queue deck with score {self.scope['score']}",
                            )
                            opponent = await self.find_user_by_score()

                            if not opponent:
                                await self.send_message(
                                    "INFO", message="no user found, awaiting in queue"
                                )
                            else:
                                # add to group and send message that opponent found to players
                                room = await create_room(
                                    deck_id_1=self.scope["deck"],
                                    player_id_1=self.scope["player"],
                                    player_score_1=self.scope["score"],
                                    deck_id_2=opponent[2],
                                    player_id_2=opponent[3],
                                    player_score_2=opponent[1],
                                )

                                await self.channel_layer.send(
                                    opponent[0],
                                    {
                                        "type": "info",
                                        "message": f"user found, with score {self.scope['score']}",
                                        "room": room,
                                    },
                                )

                                await self.send_message(
                                    "INFO",
                                    message=f"user found, with score {opponent[1]}",
                                    room=room,
                                )
                        else:
                            await self.send_message(
                                "ERROR", message="such deck doesn't exist"
                            )

    @sync_to_async
    def delete_user_in_queue(self):
        try:
            PlayerInQueue.objects.get(player_id=self.scope["player"])
        except PlayerInQueue.DoesNotExist:
            return False

    @sync_to_async
    def check_user_already_in_room(self):
        try:
            p = PlayerInRoom.objects.get(player_id=self.scope["player"])

            self.scope["room"] = p.room.slug
            self.scope["room_id"] = p.room.id

            return True
        except PlayerInRoom.DoesNotExist:
            return False

    @sync_to_async
    def find_user_by_score(self):
        s_min = self.scope["score"] * 0.95
        s_max = self.scope["score"] * 1.05
        for el in PlayerInQueue.objects.all():
            if el.player_id != self.scope["player"]:
                if s_min <= el.score <= s_max:
                    return el.channel_name, el.score, el.deck.id, el.player.id
        return False

    @sync_to_async
    def check_user_deck(self, deck_id: int):
        try:
            deck = Deck.objects.get(id=deck_id)
            if deck.player.id != self.scope["player"]:
                return False
            return deck
        except Deck.DoesNotExist:
            return False

    @sync_to_async
    def queue_connector(self, deck):
        try:
            queue = PlayerInQueue.objects.get(player_id=self.scope["player"])
            queue.score = deck.score()
            queue.channel_name = self.channel_name
            queue.save()

        except PlayerInQueue.DoesNotExist:
            queue = PlayerInQueue.objects.create(
                player_id=self.scope["player"],
                deck=deck,
                score=deck.score(),
                channel_name=self.channel_name,
            )

        self.scope["queue"] = queue.id
        self.scope["deck"] = deck.id
        self.scope["score"] = queue.score

    async def info(self, event):
        if "room" in event:
            await self.send_message(
                "INFO", message=event["message"], room=event["room"]
            )
        else:
            await self.send_message("INFO", message=event["message"])

    async def check_origin(self):
        if not self.scope["player"]:
            await self.send_message("ERROR", message="token is incorrect or expired")
            await self.close()


class RoomConsumer(BaseConsumer):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.room_group_name = None
        self.room_name = None

    async def connect(self):
        await self.accept()
        await self.check_origin()

        if not await self.connect_to_room():
            await self.close()
        else:
            message, round = await self.get_state()

            await self.send_message(
                "INFO",
                opponent_score=self.scope["opponent_score"],
                opponent_deck=self.scope["opponent_deck"],
                opponent_online=self.scope["opponent_online"],
                first=self.scope["first"],
                state=message,
                round=round,
            )
            if "opponent_channel" in self.scope and self.scope["opponent_channel"]:
                await self.channel_layer.send(
                    self.scope["opponent_channel"],
                    {
                        "type": "channel",
                        "channel": self.channel_name,
                    },
                )
                await self.channel_layer.send(
                    self.scope["opponent_channel"],
                    {"type": "connection_info", "online": True},
                )

            # Join room group
            await self.channel_layer.group_add(self.room_group_name, self.channel_name)

            # load and send board
            await self.load_board()
            await self.send_board()

    @sync_to_async
    def get_state(self):
        state = self.scope["player_in_room"].get_state()
        return state.message, state.round

    @sync_to_async
    def connect_to_room(self):
        slug = self.scope["url_route"]["kwargs"]["room_name"]

        self.room_name = slug
        self.room_group_name = f"room_{slug}"
        room = Room.objects.filter(slug=slug)

        if not room:
            return False

        self.scope["room"] = room.first()

        # check if player can be in a room
        p_ids = [x.player.id for x in room.first().players.all()]
        if self.scope["player"] not in p_ids:
            return False

        # add player info to scope
        player = PlayerInRoom.objects.get(player_id=self.scope["player"])

        self.scope["player_in_room"] = player
        self.scope["first"] = player.first
        self.scope["score"] = player.score
        self.scope["deck"] = player.deck.id
        self.scope["state"] = room.first().states.last().round

        p_ids.remove(player.player.id)
        opponent = PlayerInRoom.objects.get(player_id=p_ids[0])

        self.scope["opponent"] = opponent.player.id
        self.scope["opponent_channel"] = opponent.channel_name
        self.scope["opponent_score"] = opponent.score
        self.scope["opponent_deck"] = opponent.deck.id
        self.scope["opponent_first"] = opponent.first
        self.scope["opponent_online"] = opponent.online

        player.online = True
        player.channel_name = self.channel_name
        player.save(update_fields=["online", "channel_name"])
        return True

    async def disconnect(self, close_code):
        # Leave room group
        await self.channel_layer.group_discard(self.room_group_name, self.channel_name)
        await self.disconnect_player()

        if "opponent_channel" in self.scope and self.scope["opponent_channel"]:
            await self.channel_layer.send(
                self.scope["opponent_channel"],
                {"type": "connection_info", "online": False},
            )

    @sync_to_async
    def disconnect_player(self):
        if "player_in_room" in self.scope:
            self.scope["player_in_room"].online = False
            self.scope["player_in_room"].channel_name = None
            self.scope["player_in_room"].save(update_fields=["online", "channel_name"])

    # Receive message from WebSocket
    async def receive(self, text_data):
        data = None

        try:
            data = json.loads(text_data)
        except ValueError:
            await self.send_message("ERROR", message="data is not JSON serializable")

        if data:
            if "type" not in data:
                await self.send_message("ERROR", message="incorrect data typing")
            elif data["type"] == "start":
                if not await self.start(data):
                    await self.send_message("ERROR", message="opponent is offline")
            elif data["type"] == "move":
                if all(x in data for x in ["x", "y", "px", "py"]):
                    await self.perform_move(data)
            else:
                await self.send_message("ERROR", message="incorrect data typing")

    async def start(self, data):
        if self.scope["opponent_channel"] and self.scope["opponent_online"]:
            await self.channel_layer.send(
                self.scope["opponent_channel"],
                {
                    "type": "info",
                    "message": "opponent is ready to start",
                },
            )
            return True
        return False

    async def perform_move(self, data):
        if await move_handler(
            data["px"],
            data["py"],
            data["x"],
            data["y"],
            self.room_name,
            self.scope["player_in_room"],
        ):
            await self.send_board()
        if self.scope["opponent_channel"] and self.scope["opponent_online"]:
            await self.channel_layer.send(
                self.scope["opponent_channel"],
                {
                    "type": "move",
                    "x": data["x"],
                    "y": data["y"],
                    "px": data["px"],
                    "py": data["py"],
                },
            )
            return True
        return False

    @sync_to_async
    def load_board(self):
        # loads bord from db to scope
        room = self.scope["room"]
        board = [
            [None, None, None, None, None, None, None, None],
            [None, None, None, None, None, None, None, None],
            [None, None, None, None, None, None, None, None],
            [None, None, None, None, None, None, None, None],
            [None, None, None, None, None, None, None, None],
            [None, None, None, None, None, None, None, None],
            [None, None, None, None, None, None, None, None],
            [None, None, None, None, None, None, None, None],
        ]
        for el in room.heroes.all():
            board[el.y - 1][el.x - 1] = [el.hero.type, el.health]

        self.scope["board"] = board

    async def send_board(self):
        # sends board to client
        await self.send_message(
            "INFO",
            message=f"game's board for round {self.scope['state']}",
            board=self.scope["board"],
        )

    # info type group message handler
    async def info(self, event):
        message = event["message"]
        msg = {"type": "INFO", "message": message}

        if "opponent_score" in event:
            msg["opponent_score"] = event["opponent_score"]

        if "opponent_deck" in event:
            msg["opponent_deck"] = event["opponent_deck"]

        if "opponent_online" in event:
            msg["opponent_online"] = event["opponent_online"]

        if "first" in event:
            msg["first"] = event["first"]

        if "state" in event:
            msg["state"] = event["state"]

        if "round" in event:
            msg["round"] = event["round"]

        await self.send(text_data=json.dumps(msg))

    async def channel(self, event):
        channel = event["channel"]
        self.scope["opponent_channel"] = channel

    async def connection_info(self, event):
        status = event["online"]
        await self.send(
            text_data=json.dumps(
                {
                    "type": "INFO",
                    "message": "opponent is online"
                    if status
                    else "opponent is offline",
                }
            )
        )
        self.scope["opponent_online"] = status

    async def move(self, event):
        await self.send(
            text_data=json.dumps(
                {
                    "type": "MOVE",
                    "x": event["x"],
                    "y": event["y"],
                    "px": event["px"],
                    "py": event["py"],
                }
            )
        )

    async def check_origin(self):
        if not self.scope["player"]:
            await self.send(
                text_data=json.dumps(
                    {"type": "ERROR", "message": "token is incorrect or expired"}
                )
            )
            await self.close()