Пример #1
0
    def _match_update(self) -> GameUpdate:
        """
        Genera un game_update con información sobre la partida para cada
        jugador.
        """

        update = GameUpdate(self._game)
        for current_user in self.users:
            data = {"players": []}
            for user in self.users:
                # Información genérica del resto de usuarios
                user_data = {
                    "name": user.name,
                    "picture": user.picture,
                }

                # Para el mismo usuario que recibe el mensaje, se envía también
                # su tablero.
                if user == current_user:
                    user_data["board"] = user.board

                data["players"].append(user_data)

            update.add(current_user.name, data)

        return update
Пример #2
0
    def test_repeated(self):
        """
        Comprueba el caso especial en el que los datos son los mismos para todos
        los usuarios para hacer un broadcast.
        """

        game = self.get_game()
        game.start()

        update = GameUpdate(game)
        self.assertTrue(update.is_repeated)

        update.repeat({"thing": "abc"})
        self.assertEqual(update.as_dict(), {
            "test_1": {
                "thing": "abc"
            },
            "test_2": {
                "thing": "abc"
            }
        })
        self.assertTrue(update.is_repeated)

        update.add("test_1", {"foo": "bar"})
        self.assertFalse(update.is_repeated)

        self.assertRaises(ValueError, lambda: update.get_any())
Пример #3
0
    def broadcast_update(self, caller: Optional[str],
                         update: GameUpdate) -> None:
        """
        Envía un mismo game_update a todos los participantes de la partida.
        """

        self.send_chat_update(caller, update)
        socket.emit("game_update", update.get_any(), room=self.code)
Пример #4
0
    def send_update(self, caller: Optional[str], update: GameUpdate) -> None:
        """
        Envía un game_update a cada uno de los participantes de la partida.
        """

        self.send_chat_update(caller, update)
        for user in self.users:
            status = update.get(user.name)
            if status == {}:
                continue

            socket.emit("game_update", status, room=user.sid)
Пример #5
0
    def send_chat_update(self, caller: Optional[str],
                         update: GameUpdate) -> None:
        """
        Envía un mensaje de chat con el resumen de un turno.
        """

        if caller is None:
            return

        msg = update.fmt_msg(caller)
        if msg is None:
            return

        socket.emit("chat", {"msg": msg, "owner": "[GATOVID]"}, room=self.code)
Пример #6
0
    def check_rejoin(self, user: User) -> (bool, Optional[GameUpdate]):
        """
        Para comprobar si un usuario se puede volver a unir a la partida.
        """

        if isinstance(self, PublicMatch):
            return False, None

        if not self.is_started():
            return False, None

        if user not in self.users:
            return False, None

        update = GameUpdate(self._game)
        update.merge_with(self._game.full_update())
        update.merge_with(self._match_update())
        return True, update.get(user.name)
Пример #7
0
    def test_full(self):
        """
        Comprueba que un GameUpdate es lo esperado tras una secuencia de
        operaciones.
        """

        game = self.get_game()
        game.start()

        update = GameUpdate(game)
        self.assertEqual(update.as_dict(), {"test_1": {}, "test_2": {}})

        update.repeat({"hand": 1234})
        self.assertEqual(update.as_dict(), {
            "test_1": {
                "hand": 1234
            },
            "test_2": {
                "hand": 1234
            }
        })

        update.add_for_each(lambda p: {"thing": p.name})
        self.assertEqual(
            update.as_dict(),
            {
                "test_1": {
                    "hand": 1234,
                    "thing": "test_1"
                },
                "test_2": {
                    "hand": 1234,
                    "thing": "test_2"
                },
            },
        )

        update.add("test_1", {"list": ["foo", "bar"]})
        self.assertEqual(
            update.as_dict(),
            {
                "test_1": {
                    "hand": 1234,
                    "thing": "test_1",
                    "list": ["foo", "bar"]
                },
                "test_2": {
                    "hand": 1234,
                    "thing": "test_2"
                },
            },
        )

        update_test_1 = update.get("test_1")
        self.assertEqual(
            update_test_1,
            {
                "hand": 1234,
                "thing": "test_1",
                "list": ["foo", "bar"]
            },
        )

        new_update = GameUpdate(game)
        new_update.repeat({"from_new": 1.4})
        update.merge_with(new_update)
        self.assertEqual(
            update.as_dict(),
            {
                "test_1": {
                    "hand": 1234,
                    "thing": "test_1",
                    "list": ["foo", "bar"],
                    "from_new": 1.4,
                },
                "test_2": {
                    "hand": 1234,
                    "thing": "test_2",
                    "from_new": 1.4
                },
            },
        )
Пример #8
0
    def test_recursive_merge(self):
        """
        Comprueba que los mergeos de datos son recursivos y no únicamente del
        primer nivel.
        """

        game = self.get_game()
        game.start()

        update = GameUpdate(game)
        update.repeat({"bodies": {"marcuspkz": 1234}})
        update.repeat({"bodies": {"zebra": 444}})
        update.repeat({"bodies": {"becario": {"a": 1, "b": 2}}})
        update.repeat({"bodies": {"becario": {"a": 2, "c": 3}}})
        update.add("test_1", {"bodies": 1})
        update.add("test_2", {"hand": 1234.1234})
        self.assertEqual(
            update.as_dict(),
            {
                "test_1": {
                    "bodies": 1
                },
                "test_2": {
                    "bodies": {
                        "marcuspkz": 1234,
                        "zebra": 444,
                        "becario": {
                            "a": 2,
                            "b": 2,
                            "c": 3
                        },
                    },
                    "hand": 1234.1234,
                },
            },
        )