ptg-web 0.1.0__py3-none-any.whl

ptg_web-0.1.0.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: ptg-web
+Version: 0.1.0
+Author: Daniel Pérez Rodríguez
+Requires-Python: >=3.12
+Requires-Dist: ptg>=0.1.15
+Requires-Dist: flask
+Requires-Dist: flask-socketio
+Requires-Dist: eventlet
+Requires-Dist: pyyaml
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"

ptg_web-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+server/app.py,sha256=G3_dDdgtEEAK4jgb_qJzTeXBwmvJgjTDA9sPiViwWio,19002
+server/bot.py,sha256=z5LXLJKMOxJXKDAJxl62vNiNrDGMWrzhAUT6Xuvp60o,3817
+server/game_manager.py,sha256=poFp7goHZUNzbX8B7rcg9Q6GTIjd8mSF_UgZlC6rPp0,3944
+server/room.py,sha256=AjgKuCwKRFVv608Z2pRcQQfO0zclmMcvvue4HUFqPGI,2927
+server/set_loader.py,sha256=YH1a8r4zRN8Q-W1QWobBwy_zo2HIVt17WYW8I_hi7ZI,5419
+server/state_builder.py,sha256=hGNaQ59EXqPn4mQCk2jE5jaOHpwjAGa-WA91KFkOz7E,5121
+server/static/game.js,sha256=uo1R1nImqK9-yqoV0PxY8evdrTMln5zoFb5JzwSQOx4,19573
+server/static/style.css,sha256=zG7KngHdYfvpcv_aKpnVyoExf7jfVgMt52jU1ukARjA,20826
+server/templates/index.html,sha256=dOiUacbjHbXnyHfGHdxS57ei1prr221pE4VJyZ1BYqs,20619
+ptg_web-0.1.0.dist-info/METADATA,sha256=PqrAlU0J3re8LjJ2GXiPbUN4V8RUALfYFtmmTtHFMls,290
+ptg_web-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+ptg_web-0.1.0.dist-info/entry_points.txt,sha256=2Am4bXsYuICvjAHWRi2AMCdsTH8gJHrATac7o0-Mzzg,44
+ptg_web-0.1.0.dist-info/top_level.txt,sha256=StKOSmRhvWS5IPcvhsDRbtxUTEofJgYFGOu5AAJdSWo,7
+ptg_web-0.1.0.dist-info/RECORD,,

ptg_web-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ptg_web-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ptg-web = server.app:main

ptg_web-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+server

server/app.py

@@ -0,0 +1,580 @@
+import os
+import eventlet
+
+eventlet.monkey_patch()
+
+import logging
+import sys
+import uuid
+from pathlib import Path
+
+import yaml
+
+from flask import Flask, render_template, request, jsonify
+from flask_socketio import SocketIO, emit
+
+from ptg.api import (
+    PlayCardAction, DeclareAttackAction, DeclareDefenseAction,
+    ActivateAbilityAction, load_cards_from_dir, build_catalog,
+    PhaseType,
+)
+
+import ptg.effects  # noqa: F401 — ensure package is importable
+
+import importlib
+import pkgutil
+
+
+def _import_all_effects():
+    """Dynamically import all effect modules so they self-register."""
+    path = ptg.effects.__path__
+    prefix = ptg.effects.__name__ + "."
+    for _, modname, is_pkg in pkgutil.iter_modules(path, prefix):
+        if is_pkg:
+            continue
+        if modname.endswith((".base", ".registry")):
+            continue
+        importlib.import_module(modname)
+
+
+_import_all_effects()
+
+from .game_manager import GameManager
+from .bot import bot_play_main, bot_declare_attacks, bot_declare_defense
+from .set_loader import SetLoader
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    stream=sys.stdout,
+)
+logger = logging.getLogger(__name__)
+
+# ── Config ──
+
+CONFIG_PATH = Path(__file__).resolve().parent.parent / "config.yaml"
+_config = {}
+if CONFIG_PATH.is_file():
+    with open(CONFIG_PATH) as f:
+        _config = yaml.safe_load(f) or {}
+
+HOST = os.environ.get("PTG_HOST", _config.get("host", "0.0.0.0"))
+PORT = int(os.environ.get("PTG_PORT", _config.get("port", 5000)))
+SETS_DIR = Path(os.environ.get(
+    "PTG_SETS_DIR",
+    _config.get("sets_dir", str(Path(__file__).resolve().parent.parent / "sets"))
+))
+
+# Fallback: look for sets/ alongside the server package or at project root
+if not SETS_DIR.is_dir():
+    alt = Path(__file__).resolve().parent / "sets"
+    if alt.is_dir():
+        SETS_DIR = alt
+
+if not SETS_DIR.is_dir() or not any(
+    (d / "manifest.yaml").is_file() for d in SETS_DIR.iterdir() if d.is_dir()
+):
+    logger.error("No sets found in %s. Create a sets/ directory with at least one set.", SETS_DIR)
+    sys.exit(1)
+
+set_loader = SetLoader(SETS_DIR)
+logger.info("Loaded %d set(s) from %s", len(set_loader.list_sets()), SETS_DIR)
+
+app = Flask(__name__, template_folder="templates", static_folder="static")
+app.config["SECRET_KEY"] = "ptg-secret-key"
+
+socketio = SocketIO(app, async_mode="eventlet", cors_allowed_origins="*")
+
+game_manager = GameManager(set_loader=set_loader)
+
+
+def _card_dict(cd):
+    return {
+        "card_id": cd.card_id,
+        "name": cd.name,
+        "type": cd.type.value,
+        "mana": {t.value: a for t, a in cd.mana.items()},
+        "defense": cd.defense,
+        "attack": cd.attack,
+        "description": cd.description,
+        "abilities": [
+            {"name": a.name, "description": a.description, "ability_type": a.ability_type.value}
+            for a in (cd.abilities or [])
+        ],
+    }
+
+
+@app.route("/")
+def index():
+    return render_template("index.html")
+
+
+@app.route("/api/sets")
+def api_sets():
+    return jsonify(set_loader.list_sets())
+
+
+@app.route("/api/sets/<set_id>/catalog")
+def api_set_catalog(set_id):
+    try:
+        catalog = set_loader.get_catalog(set_id)
+        return jsonify([_card_dict(cd) for cd in catalog.values()])
+    except (ValueError, FileNotFoundError) as e:
+        return jsonify({"error": str(e)}), 404
+
+
+@app.route("/api/sets/<set_id>/decks")
+def api_set_decks(set_id):
+    try:
+        return jsonify(set_loader.list_decks(set_id))
+    except ValueError as e:
+        return jsonify({"error": str(e)}), 404
+
+
+def _ensure_player_id() -> str:
+    sid = request.sid
+    for pid, rsid in list(game_manager._player_sids.items()):
+        if rsid == sid:
+            return pid
+    pid = str(uuid.uuid4())
+    game_manager._player_sids[pid] = sid
+    return pid
+
+
+def _resolve_player(room) -> tuple[str, str] | None:
+    session_id = _ensure_player_id()
+    player_uuid = room.player_uuid_for(session_id)
+    if player_uuid is None:
+        return None
+    return (session_id, player_uuid)
+
+
+def _broadcast_state(room):
+    for session_id in [sid for sid in [room.host_id, room.guest_id] if sid]:
+        sid = game_manager.get_sid(session_id)
+        if sid:
+            player_uuid = room.player_uuid_for(session_id)
+            if player_uuid is None:
+                continue
+            view = game_manager.state_view(room, player_uuid)
+            socketio.emit("state", view, to=sid)
+    _maybe_schedule_bot(room)
+
+    _log_graveyards(room)
+
+
+def _log_graveyards(room):
+    game = room.game
+    if game is None or game.state is None:
+        return
+    g = game.state.graveyards
+    pids = list(g.keys())
+    if len(pids) >= 2:
+        logger.info(
+            "GRAVEYARDS: P0=%d cards, P1=%d cards  (P0=%s, P1=%s)",
+            len(g.get(pids[0], [])), len(g.get(pids[1], [])),
+            pids[0][:8], pids[1][:8],
+        )
+
+
+_SCHEDULABLE_PHASES = {
+    PhaseType.MAIN, PhaseType.ATTACK, PhaseType.DEFENSE,
+    PhaseType.MAIN_POSTCOMBAT,
+}
+
+
+def _bot_should_act(room) -> bool:
+    if not room.bot_game or room.game is None:
+        return False
+    bot_player = room.game.players[1]
+    active = room.game.active_player
+    cp = room.game.current_phase
+
+    if cp not in _SCHEDULABLE_PHASES:
+        return False
+
+    if cp in (PhaseType.MAIN, PhaseType.ATTACK, PhaseType.MAIN_POSTCOMBAT):
+        return bot_player == active
+    elif cp == PhaseType.DEFENSE:
+        return bot_player != active
+    return False
+
+
+def _maybe_schedule_bot(room):
+    if room._bot_acting:
+        return
+    if not _bot_should_act(room):
+        return
+
+    room._bot_acting = True
+    socketio.start_background_task(_run_bot_turn, room)
+
+
+def _auto_resolve_bot_triggers(room):
+    """Auto-resolve any pending triggers the bot triggered."""
+    game = room.game
+    if game is None or game.state is None:
+        return
+    triggers = game.state.pending_triggers
+    if not triggers:
+        return
+    for i in reversed(range(len(triggers))):
+        t = triggers[i]
+        if t.source_player_id != room.bot_id:
+            continue
+        from ptg.effects.base import PlayerEffect
+        if isinstance(t.effect, PlayerEffect):
+            target = room.game.opponent.uuid
+        else:
+            opp_bf = game.state.battlefield.get(room.game.opponent.uuid, [])
+            target = next((cid for cid in opp_bf if game.state.all_cards[cid].is_alive), None)
+            if target is None:
+                target = next((cid for cid in game.state.battlefield.get(room.bot_id, [])
+                              if cid != t.source_card_id and game.state.all_cards[cid].is_alive), None)
+        if target is not None:
+            try:
+                game.resolve_pending_trigger(i, target)
+            except Exception as e:
+                logger.debug("Bot trigger resolution error: %s", e)
+
+
+def _run_bot_turn(room):
+    try:
+        import eventlet as ev
+
+        game = room.game
+        bot_id = room.bot_id
+        cp = game.current_phase
+
+        if cp in (PhaseType.MAIN, PhaseType.MAIN_POSTCOMBAT):
+            ev.sleep(1.0)
+            card_ids = bot_play_main(game.state, bot_id)
+            for cid in card_ids:
+                try:
+                    game.apply_action(PlayCardAction(), player_id=bot_id, card_id=cid)
+                    logger.info("Bot played card %s", cid)
+                    _auto_resolve_bot_triggers(room)
+                    _broadcast_state(room)
+                    ev.sleep(0.7)
+                except Exception as e:
+                    logger.debug("Bot play_card failed: %s", e)
+
+        if game.current_phase == PhaseType.ATTACK:
+            ev.sleep(0.8)
+            attackers = bot_declare_attacks(game.state, bot_id)
+            for aid in attackers:
+                try:
+                    game.apply_action(DeclareAttackAction(), player_id=bot_id, attacker_id=aid)
+                    logger.info("Bot declared attack: %s", aid)
+                    _broadcast_state(room)
+                    ev.sleep(0.5)
+                except Exception as e:
+                    logger.debug("Bot declare_attack failed: %s", e)
+
+        if game.current_phase == PhaseType.DEFENSE:
+            ev.sleep(0.8)
+            assignments = bot_declare_defense(game.state, bot_id)
+            for blocker_id, combat_idx in assignments:
+                try:
+                    game.apply_action(DeclareDefenseAction(), player_id=bot_id,
+                                      blocker_id=blocker_id, combat_index=combat_idx)
+                    logger.info("Bot declared defense: %s -> idx %d", blocker_id, combat_idx)
+                    _broadcast_state(room)
+                    ev.sleep(0.5)
+                except Exception as e:
+                    logger.debug("Bot declare_defense failed: %s", e)
+
+        room._bot_acting = False
+        game.advance_phase()
+        if game.current_phase == PhaseType.DRAW:
+            game.advance_phase()
+
+        winner = game.check_victory()
+        if winner:
+            _broadcast_state(room)
+            return
+
+        _broadcast_state(room)
+
+    except Exception as e:
+        logger.error("Bot turn error: %s", e)
+        room._bot_acting = False
+
+
+@socketio.on("connect")
+def handle_connect():
+    pid = _ensure_player_id()
+    logger.info("Client connected: sid=%s pid=%s", request.sid, pid)
+    emit("connected", {"player_id": pid})
+
+
+@socketio.on("disconnect")
+def handle_disconnect():
+    sid = request.sid
+    pid = None
+    for p, rsid in list(game_manager._player_sids.items()):
+        if rsid == sid:
+            pid = p
+            break
+    if pid is None:
+        return
+    logger.info("Client disconnected: sid=%s pid=%s", sid, pid)
+    room = game_manager.remove_player(pid)
+    if room and room.guest_id:
+        opp_sid = game_manager.get_sid(room.guest_id)
+        if opp_sid:
+            socketio.emit("opponent_left", {}, to=opp_sid)
+
+
+@socketio.on("create_game")
+def handle_create_game(data=None):
+    pid = _ensure_player_id()
+    set_id = (data or {}).get("set_id", "default")
+    code = game_manager.create_room(pid, set_id=set_id)
+    emit("room_created", {"room": code})
+    logger.info("Room created: %s by %s (set=%s)", code, pid, set_id)
+
+
+@socketio.on("create_bot_game")
+def handle_create_bot_game(data=None):
+    pid = _ensure_player_id()
+    set_id = (data or {}).get("set_id", "default")
+    code = game_manager.create_bot_game(pid, set_id=set_id)
+    emit("game_start", {
+        "opponent_name": "Bot",
+        "phase": "deck_select",
+        "set_id": set_id,
+    })
+    logger.info("Bot game created: %s by %s (set=%s)", code, pid, set_id)
+
+
+@socketio.on("join_game")
+def handle_join_game(data):
+    pid = _ensure_player_id()
+    code = data.get("room", "").upper()
+    room = game_manager.join_room(code, pid)
+    if room is None:
+        emit("error", {"message": "Room not found or full."})
+        return
+
+    host_sid = game_manager.get_sid(room.host_id)
+    if host_sid:
+        socketio.emit("game_start", {
+            "opponent_name": "Player 2",
+            "phase": "deck_select",
+            "set_id": room.set_id,
+        }, to=host_sid)
+
+    emit("game_start", {
+        "opponent_name": "Player 1",
+        "phase": "deck_select",
+        "set_id": room.set_id,
+    })
+    logger.info("Game started in room %s", code)
+
+
+@socketio.on("select_deck")
+def handle_select_deck(data):
+    session_id = _ensure_player_id()
+    room = game_manager.get_room_for_player(session_id)
+    if room is None:
+        emit("error", {"message": "Not in a room."})
+        return
+
+    deck_name = data.get("deck_name")
+    cards = data.get("cards", {})
+    selected_set = data.get("set_id")
+    if selected_set:
+        room.set_id = selected_set
+
+    if deck_name:
+        try:
+            catalog = set_loader.get_catalog(room.set_id)
+            spec = set_loader.get_deck_spec(room.set_id, deck_name)
+        except (ValueError, FileNotFoundError) as e:
+            emit("error", {"message": str(e)})
+            return
+    else:
+        spec = cards
+
+    ok = game_manager.set_deck(session_id, spec)
+    if not ok:
+        emit("error", {"message": "Failed to set deck."})
+        return
+
+    total = sum(spec.values())
+    logger.info("Player %s selected deck: %d cards%s",
+                session_id, total, f" (pre-built: {deck_name})" if deck_name else "")
+
+    if room.both_decks_ready():
+        room.start_game()
+        room.game.advance_phase()
+        _broadcast_state(room)
+        logger.info("Game started in room %s", room.code)
+
+
+@socketio.on("action")
+def handle_action(data):
+    session_id = _ensure_player_id()
+    room = game_manager.get_room_for_player(session_id)
+    if room is None or room.game is None:
+        emit("error", {"message": "Not in an active game."})
+        return
+
+    resolved = _resolve_player(room)
+    if resolved is None:
+        emit("error", {"message": "Not in a game."})
+        return
+    _, player_uuid = resolved
+
+    action_type = data.get("action")
+    game = room.game
+    cp = game.current_phase
+
+    logger.info("Action: %s by %s in phase %s", action_type, player_uuid, cp.value if cp else "none")
+
+    try:
+        if action_type == "next_phase":
+            if cp not in (PhaseType.MAIN, PhaseType.MAIN_POSTCOMBAT,
+                          PhaseType.ATTACK, PhaseType.DEFENSE, PhaseType.COMBAT):
+                emit("error", {"message": f"Cannot advance from {cp.value}."})
+                return
+            if cp in (PhaseType.DEFENSE, PhaseType.COMBAT):
+                if player_uuid not in [p.uuid for p in game.players]:
+                    emit("error", {"message": "Not in this game."})
+                    return
+            else:
+                if player_uuid != game.active_player.uuid:
+                    emit("error", {"message": "Not your turn."})
+                    return
+
+            if cp == PhaseType.ATTACK:
+                attacker_ids = data.get("attacker_ids", [])
+                for aid in attacker_ids:
+                    try:
+                        game.apply_action(DeclareAttackAction(),
+                                          player_id=player_uuid, attacker_id=aid)
+                    except ValueError:
+                        pass
+
+            if cp == PhaseType.DEFENSE:
+                blocker_ids = data.get("blocker_ids", [])
+                for i, bid in enumerate(blocker_ids):
+                    pending = game.state.pending_combats
+                    if not pending:
+                        break
+                    combat_idx = i % len(pending)
+                    try:
+                        game.apply_action(DeclareDefenseAction(),
+                                          player_id=player_uuid,
+                                          blocker_id=bid, combat_index=combat_idx)
+                    except ValueError:
+                        pass
+
+            game.advance_phase()
+            if game.current_phase == PhaseType.DRAW:
+                game.advance_phase()
+
+            if game.check_victory():
+                _broadcast_state(room)
+                return
+
+            _broadcast_state(room)
+            return
+
+        elif action_type == "play_card":
+            if not _can_play(cp, player_uuid, game):
+                emit("error", {"message": "Cannot play cards right now."})
+                return
+            card_id = data.get("card_id")
+            action_obj = PlayCardAction()
+            game.apply_action(action_obj, player_id=player_uuid, card_id=card_id)
+            logger.info("Played card %s by %s", card_id, player_uuid)
+
+            _broadcast_state(room)
+            return
+
+        elif action_type == "declare_attack":
+            if cp != PhaseType.ATTACK:
+                emit("error", {"message": "Can only attack during attack phase."})
+                return
+            if player_uuid != game.active_player.uuid:
+                emit("error", {"message": "Not your turn."})
+                return
+            attacker_id = data.get("attacker_id")
+            action_obj = DeclareAttackAction()
+            game.apply_action(action_obj, player_id=player_uuid, attacker_id=attacker_id)
+            logger.info("Declared attack: %s by %s", attacker_id, player_uuid)
+            _broadcast_state(room)
+            return
+
+        elif action_type == "declare_defense":
+            if cp != PhaseType.DEFENSE:
+                emit("error", {"message": "Can only defend during defense phase."})
+                return
+            if player_uuid == game.active_player.uuid:
+                emit("error", {"message": "Only the defender can declare defense."})
+                return
+            blocker_id = data.get("blocker_id")
+            combat_index = data.get("combat_index", 0)
+            action_obj = DeclareDefenseAction()
+            game.apply_action(action_obj, player_id=player_uuid,
+                              blocker_id=blocker_id, combat_index=combat_index)
+            logger.info("Declared defense: %s blocking combat %d by %s",
+                        blocker_id, combat_index, player_uuid)
+            _broadcast_state(room)
+            return
+
+        elif action_type == "activate_ability":
+            if not _can_play(cp, player_uuid, game):
+                emit("error", {"message": "Cannot activate abilities right now."})
+                return
+            card_id = data.get("card_id")
+            ability_index = data.get("ability_index", 0)
+            target_id = data.get("target_id")
+            action_obj = ActivateAbilityAction()
+            kwargs = dict(player_id=player_uuid, card_id=card_id, ability_index=ability_index)
+            if target_id:
+                kwargs["target_id"] = target_id
+            game.apply_action(action_obj, **kwargs)
+            logger.info("Activated ability %d on %s by %s", ability_index, card_id, player_uuid)
+
+            _broadcast_state(room)
+            return
+
+        elif action_type == "resolve_trigger":
+            trigger_index = data.get("trigger_index", 0)
+            target_id = data.get("target_id")
+            if not target_id:
+                emit("error", {"message": "No target selected."})
+                return
+            try:
+                game.resolve_pending_trigger(trigger_index, target_id)
+            except (IndexError, ValueError) as e:
+                emit("error", {"message": str(e)})
+                return
+            _broadcast_state(room)
+            return
+
+        else:
+            emit("error", {"message": f"Unknown action: {action_type}"})
+            return
+
+    except Exception as e:
+        logger.warning("Action error: %s", e)
+        emit("error", {"message": str(e)})
+
+
+def _can_play(cp: PhaseType, player_uuid: str, game) -> bool:
+    if cp not in (PhaseType.MAIN, PhaseType.MAIN_POSTCOMBAT):
+        return False
+    return player_uuid == game.active_player.uuid
+
+
+def main():
+    import eventlet.wsgi
+    eventlet.wsgi.server(eventlet.listen((HOST, PORT)), app)
+
+
+if __name__ == "__main__":
+    main()