001code-html--cocos/scratch-gui/static/js/pyodideWorker.js

// pyodideWorker.js

importScripts("../pyodide/pyodide.js");
usecdn = true
// 确定 indexURL 的值
let indexURL;
if (usecdn) {
    indexURL = 'https://oss.eanic.cn/001_code_python_res_20241213/pyodide/';
} else {
    indexURL = "../pyodide/";
}

// 初始化 Pyodide
let pyodideReadyPromise = loadPyodide({
    indexURL: indexURL
});

// 定义一个 Map 来存储所有的 pending 请求
let pendingRequests = new Map();
let requestIdCounter = 0;

pyodideReadyPromise.then(() => {
    self.postMessage({ type: "finish", message: "Pyodide 加载完成" });
});

// 定义一个 JavaScript 函数，用于接收来自 Python 的调用

self.unitydata = {};

function sleep(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
}

// 定义发送 setTag 的函数
function send_setTag(line) {
    self.postMessage({ type: "setTag", line: line });
}

// #-------------------角色相关----------------------#
// #playerMove(step)，移动角色，参数step为整数
// #playerJump() 向右前跳跃
// #turnLeft(times) 向左转动角色，参数times为整数代表次数
// #turnRight(times) 向右转动角色，参数times为整数代表次数
// #player_position() 获取角色坐标，x y代表 x y坐标，坐标为整数
// #-------------------载具相关----------------------#
// #vehicleMove(step)，移动载具，参数step为整数
// #turnVehicleLeft(times) 向左转动载具，参数times为整数代表次数
// #turnVehicleRight(times) 向右转动载具，参数times为整数代表次数
// #vehicle_position() 获取坐标，x y代表 x y坐标，坐标为整数
// #-----------------------------------------------#

async function playerMove(value) {
    const requestId = ++requestIdCounter;
    return new Promise((resolve, reject) => {
        pendingRequests.set(requestId, { resolve, reject });
        self.postMessage({ type: "playerMove", step: value, requestId: requestId });
    });
}

async function playerJump() {
    const requestId = ++requestIdCounter;
    return new Promise((resolve, reject) => {
        pendingRequests.set(requestId, { resolve, reject });
        self.postMessage({ type: "playerJump", requestId: requestId });
    });
}

async function turnLeft(value) {
    const requestId = ++requestIdCounter;
    return new Promise((resolve, reject) => {
        pendingRequests.set(requestId, { resolve, reject });
        self.postMessage({ type: "turnLeft", step: value, requestId: requestId });
    });
}

async function turnRight(value) {
    const requestId = ++requestIdCounter;
    return new Promise((resolve, reject) => {
        pendingRequests.set(requestId, { resolve, reject });
        self.postMessage({ type: "turnRight", step: value, requestId: requestId });
    });
}

async function cmdPrint(text) {
    const requestId = ++requestIdCounter;
    return new Promise((resolve, reject) => {
        pendingRequests.set(requestId, { resolve, reject });
        self.postMessage({ type: "cmdPrint", text: text, requestId: requestId });
    });
}

async function vehicleMove(value) {
    const requestId = ++requestIdCounter;
    return new Promise((resolve, reject) => {
        pendingRequests.set(requestId, { resolve, reject });
        self.postMessage({ type: "vehicleMove", step: value, requestId: requestId });
    });
}

async function turnVehicleLeft(value) {
    const requestId = ++requestIdCounter;
    return new Promise((resolve, reject) => {
        pendingRequests.set(requestId, { resolve, reject });
        self.postMessage({ type: "turnVehicleLeft", step: value, requestId: requestId });
    });
}

async function turnVehicleRight(value) {
    const requestId = ++requestIdCounter;
    return new Promise((resolve, reject) => {
        pendingRequests.set(requestId, { resolve, reject });
        self.postMessage({ type: "turnVehicleRight", step: value, requestId: requestId });
    });
}

async function scriptRunOver() {
    const requestId = ++requestIdCounter;
    return new Promise((resolve, reject) => {
        pendingRequests.set(requestId, { resolve, reject });
        self.postMessage({ type: "scriptRunOver", requestId: requestId });
    });
}


self.onmessage = async (event) => {
    const { type, code, unity_data, requestId} = event.data;
    if (type === "response") {
        self.unitydata = unity_data
        console.log("get new response", self.unitydata.externalDatas[0].position)
        const pending = pendingRequests.get(requestId);
        if (pending) {
            pending.resolve();
            pendingRequests.delete(requestId);
            console.log('收到回调',requestId)
        }
    } else if (type === "runPython") {
        try {
            let pyodide = await pyodideReadyPromise;
            await pyodide.registerJsModule("send_setTag", send_setTag);
            await pyodide.registerJsModule("playerMove", playerMove);
            await pyodide.registerJsModule("playerJump", playerJump);
            await pyodide.registerJsModule("turnLeft", turnLeft);
            await pyodide.registerJsModule("turnRight", turnRight);
            await pyodide.registerJsModule("cmdPrint", cmdPrint);
            await pyodide.registerJsModule("vehicleMove", vehicleMove);
            await pyodide.registerJsModule("turnVehicleLeft", turnVehicleLeft);
            await pyodide.registerJsModule("turnVehicleRight", turnVehicleRight);
            await pyodide.registerJsModule("scriptRunOver", scriptRunOver);

            console.log(code)
            let result = await pyodide.runPythonAsync(code);
            
            // 发送执行完成的消息
            self.postMessage({ type: "executionComplete" });
            console.log("Python 执行完成",window.isPythonRun);
            self.postMessage({ type: "result", result });
        } catch (error) {
            self.postMessage({ type: "error", error: error.message });
            // 发生错误时也要发送执行完成的消息
            self.postMessage({ type: "executionComplete" });
        }
    }
};