worker.js

importScripts("https://cdn.jsdelivr.net/pyodide/v0.25.0/full/pyodide.js");

let pyodide;

async function init() {
    try {
        pyodide = await loadPyodide();
        await pyodide.loadPackage("numpy");
        
        // Fetch python source files from the current directory and write to Pyodide Virtual FS
        const files = ["state.py", "Alpha_Beta.py", "MCTS.py", "random_agent.py"];
        for (let f of files) {
            let res = await fetch(`${f}`);
            if (!res.ok) {
                console.warn(`Could not fetch ${f}`);
                continue;
            }
            let code = await res.text();
            pyodide.FS.writeFile(f, code);
        }

        // Set up a python wrapper to manage state and interface with JS
        pyodide.runPython(`
import numpy as np
from state import State_2, UltimateTTT_Move
import Alpha_Beta
import MCTS
import random_agent

agents = {
    'Alpha_Beta': Alpha_Beta,
    'MCTS': MCTS,
    'random_agent': random_agent
}

game_state = State_2()

def init_game():
    global game_state
    game_state = State_2()
    
    # Reset Alpha_Beta globals just in case
    Alpha_Beta.numMoves = 0
    Alpha_Beta.transposition_table.clear()
    
    return get_state_json()

def play_move(board_idx, x, y, value):
    global game_state
    _ = game_state.get_valid_moves
    move = UltimateTTT_Move(board_idx, x, y, value)
    if game_state.is_valid_move(move):
        game_state.act_move(move)
        _ = game_state.get_valid_moves
        return get_state_json()
    return None

def ai_move(agent_name, remain_time):
    global game_state
    try:
        agent = agents.get(agent_name, random_agent)
        move = agent.select_move(game_state, remain_time)
        if move:
            game_state.act_move(move)
            _ = game_state.get_valid_moves
        return get_state_json()
    except Exception as e:
        import traceback
        return '{"error": ' + json.dumps(traceback.format_exc()) + '}'

import json

def get_state_json():
    global game_state
    return json.dumps({
        "global_cells": game_state.global_cells.tolist(),
        "blocks": [b.tolist() for b in game_state.blocks],
        "player_to_move": int(game_state.player_to_move),
        "previous_move": {
            "index_local_board": int(game_state.previous_move.index_local_board),
            "x": int(game_state.previous_move.x),
            "y": int(game_state.previous_move.y),
            "value": int(game_state.previous_move.value)
        } if game_state.previous_move else None,
        "game_over": bool(game_state.game_over),
        "free_move": bool(game_state.free_move)
    })
        `);

        postMessage({ type: 'READY' });
    } catch (err) {
        console.error(err);
        postMessage({ type: 'ERROR', payload: err.toString() });
    }
}

init();

onmessage = async (e) => {
    const { type, payload } = e.data;
    try {
        if (type === 'INIT') {
            const res = pyodide.runPython(`init_game()`);
            postMessage({ type: 'INIT_STATE', payload: JSON.parse(res) });
        } else if (type === 'PLAY') {
            const { board_idx, x, y, value } = payload;
            const res = pyodide.runPython(`play_move(${board_idx}, ${x}, ${y}, ${value})`);
            if (res) {
                postMessage({ type: 'STATE', payload: JSON.parse(res) });
            } else {
                postMessage({ type: 'INVALID_MOVE' });
            }
        } else if (type === 'AI_MOVE') {
            const { agent_name, remain_time } = payload;
            const res = pyodide.runPython(`ai_move('${agent_name}', ${remain_time})`);
            const parsedRes = JSON.parse(res);
            if (parsedRes.error) {
                postMessage({ type: 'ERROR', payload: parsedRes.error });
            } else {
                postMessage({ type: 'STATE', payload: parsedRes });
            }
        }
    } catch(err) {
        postMessage({ type: 'ERROR', payload: err.toString() });
    }
}