jsbeeb 1.1.1

package/src/gamepad-source.js

@@ -0,0 +1,59 @@
+import { AnalogueSource } from "./analogue-source.js";
+
+/**
+ * Gamepad implementation of AnalogueSource
+ * Maps gamepad axes to ADC channels
+ */
+export class GamepadSource extends AnalogueSource {
+    /**
+     * Create a new GamepadSource
+     * @param {Function} getGamepads - Function that returns gamepad array
+     */
+    constructor(getGamepads) {
+        super();
+        this.getGamepads = getGamepads;
+    }
+
+    /**
+     * Get analog value from gamepad for the specified channel
+     * @param {number} channel - The ADC channel (0-3)
+     * @returns {number} A value between 0 and 0xffff
+     */
+    getValue(channel) {
+        const pads = this.getGamepads();
+        if (!pads || !pads[0]) return 0x8000; // Default center value
+
+        const pad = pads[0];
+        const pad2 = pads[1];
+
+        let rawValue = 0;
+
+        switch (channel) {
+            case 0:
+                rawValue = pad.axes[0];
+                break;
+            case 1:
+                rawValue = pad.axes[1];
+                break;
+            case 2:
+                if (pad2) {
+                    rawValue = pad2.axes[0];
+                } else {
+                    rawValue = pad.axes[2];
+                }
+                break;
+            case 3:
+                if (pad2) {
+                    rawValue = pad2.axes[1];
+                } else {
+                    rawValue = pad.axes[3];
+                }
+                break;
+            default:
+                return 0x8000;
+        }
+
+        // Scale from [-1, 1] to [0, 0xffff]
+        return Math.floor(((1 - rawValue) / 2) * 0xffff);
+    }
+}

package/src/gamepads.js

@@ -0,0 +1,268 @@
+"use strict";
+import * as utils from "./utils.js";
+
+const BBC = utils.BBC;
+
+export class GamePad {
+    constructor() {
+        this.gamepad0 = null;
+
+        //this.gamepadMapping = [BBC.COLON_STAR, BBC.X, BBC.SLASH, BBC.Z,
+        //    BBC.SPACE, BBC.SPACE, BBC.SPACE, BBC.SPACE,
+        //    BBC.SPACE, BBC.SPACE, BBC.SPACE, BBC.SPACE,
+        //    BBC.SPACE, BBC.SPACE, BBC.SPACE, BBC.SPACE];
+
+        this.gamepadMapping = [];
+
+        // default: "snapper" keys
+        this.gamepadMapping[14] = BBC.Z;
+        this.gamepadMapping[15] = BBC.X;
+        this.gamepadMapping[13] = BBC.SLASH;
+        this.gamepadMapping[12] = BBC.COLON_STAR;
+
+        // often <Return> = "Fire"
+        this.gamepadMapping[0] = BBC.RETURN;
+        // "start" (often <Space> to start game)
+        this.gamepadMapping[9] = BBC.SPACE;
+
+        // Gamepad joysticks
+        this.gamepadAxisMapping = [[], [], [], []];
+    }
+
+    /*
+         this.gamepadAxisMapping[0][-1] = BBC.Z;          // left
+         this.gamepadAxisMapping[0][1] = BBC.X;          // right
+         this.gamepadAxisMapping[1][-1] = BBC.COLON_STAR; // up
+         this.gamepadAxisMapping[1][1] = BBC.SLASH;      // down
+         this.gamepadAxisMapping[2][-1] = BBC.Z;          // left
+         this.gamepadAxisMapping[2][1] = BBC.X;          // right
+         this.gamepadAxisMapping[3][-1] = BBC.COLON_STAR; // up
+         this.gamepadAxisMapping[3][1] = BBC.SLASH;      // down
+         */
+    remap(gamepadKey, bbcKey) {
+        // convert "1" into "K1"
+        if ("0123456789".indexOf(bbcKey) > 0) {
+            bbcKey = "K" + bbcKey;
+        }
+
+        const mappedBbcKey = BBC[bbcKey];
+        if (!mappedBbcKey) {
+            console.log("unknown BBC key: " + bbcKey);
+            return;
+        }
+
+        switch (gamepadKey) {
+            case "LEFT":
+                this.gamepadMapping[3] = mappedBbcKey;
+                this.gamepadAxisMapping[0][-1] = mappedBbcKey;
+                this.gamepadAxisMapping[2][-1] = mappedBbcKey;
+                break;
+            case "RIGHT":
+                this.gamepadMapping[1] = mappedBbcKey;
+                this.gamepadAxisMapping[0][1] = mappedBbcKey;
+                this.gamepadAxisMapping[2][1] = mappedBbcKey;
+                break;
+            case "UP":
+                this.gamepadMapping[0] = mappedBbcKey;
+                this.gamepadAxisMapping[1][-1] = mappedBbcKey;
+                this.gamepadAxisMapping[3][-1] = mappedBbcKey;
+                break;
+            case "DOWN":
+                this.gamepadMapping[2] = mappedBbcKey;
+                this.gamepadAxisMapping[1][1] = mappedBbcKey;
+                this.gamepadAxisMapping[3][1] = mappedBbcKey;
+                break;
+            case "FIRE":
+                for (let i = 0; i < 16; i++) {
+                    this.gamepadMapping[i] = mappedBbcKey;
+                }
+                break;
+
+            // XBox 360 Controller names
+            case "UP2":
+                this.gamepadAxisMapping[3][-1] = mappedBbcKey;
+                break;
+            case "UP1":
+                this.gamepadAxisMapping[1][-1] = mappedBbcKey;
+                break;
+            case "UP3":
+                this.gamepadMapping[0] = mappedBbcKey;
+                break;
+            case "DOWN2":
+                this.gamepadAxisMapping[3][1] = mappedBbcKey;
+                break;
+            case "DOWN1":
+                this.gamepadAxisMapping[1][1] = mappedBbcKey;
+                break;
+            case "DOWN3":
+                this.gamepadMapping[2] = mappedBbcKey;
+                break;
+            case "LEFT2":
+                this.gamepadAxisMapping[2][-1] = mappedBbcKey;
+                break;
+            case "LEFT1":
+                this.gamepadAxisMapping[0][-1] = mappedBbcKey;
+                break;
+            case "LEFT3":
+                this.gamepadMapping[3] = mappedBbcKey;
+                break;
+            case "RIGHT2":
+                this.gamepadAxisMapping[2][1] = mappedBbcKey;
+                break;
+            case "RIGHT1":
+                this.gamepadAxisMapping[0][1] = mappedBbcKey;
+                break;
+            case "RIGHT3":
+                this.gamepadMapping[1] = mappedBbcKey;
+                break;
+            case "FIRE2":
+                this.gamepadMapping[11] = mappedBbcKey;
+                break;
+            case "FIRE1":
+                this.gamepadMapping[10] = mappedBbcKey;
+                break;
+            case "A":
+                this.gamepadMapping[0] = mappedBbcKey;
+                break;
+            case "B":
+                this.gamepadMapping[1] = mappedBbcKey;
+                break;
+            case "X":
+                this.gamepadMapping[2] = mappedBbcKey;
+                break;
+            case "Y":
+                this.gamepadMapping[3] = mappedBbcKey;
+                break;
+            case "START":
+                this.gamepadMapping[9] = mappedBbcKey;
+                break;
+            case "BACK":
+                this.gamepadMapping[8] = mappedBbcKey;
+                break;
+            case "RB":
+                this.gamepadMapping[5] = mappedBbcKey;
+                break;
+            case "RT":
+                this.gamepadMapping[7] = mappedBbcKey;
+                break;
+            case "LB":
+                this.gamepadMapping[4] = mappedBbcKey;
+                break;
+            case "LT":
+                this.gamepadMapping[6] = mappedBbcKey;
+                break;
+            default:
+                console.log("unknown gamepad key: " + gamepadKey);
+        }
+    }
+
+    update(sysvia) {
+        // init gamepad
+        // gamepad not necessarily available until a button press
+        // so need to check gamepads[0] continuously
+        if (navigator.getGamepads && !this.gamepad0) {
+            const gamepads = navigator.getGamepads();
+            this.gamepad0 = gamepads[0];
+
+            if (this.gamepad0) {
+                console.log("initing gamepad");
+                // 16 buttons
+                this.gamepadButtons = [
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                ];
+
+                // two joysticks (so 4 axes)
+                this.gamepadAxes = [0, 0, 0, 0];
+            }
+        }
+
+        // process gamepad buttons
+        if (this.gamepad0) {
+            // these two lines needed in Chrome to update state, not Firefox
+            // TODO: what about IE? (can't get Gamepads to work in IE11/IE12. Mike)
+            if (!utils.isFirefox()) {
+                this.gamepad0 = navigator.getGamepads()[0];
+            }
+
+            for (let i = 0; i < 4; i++) {
+                const axisRaw = this.gamepad0.axes[i];
+
+                // Mike's XBox 360 controller, zero positions
+                // console.log(i, axisRaw, axis);
+                //0 -0.03456169366836548 -1
+                //1 -0.037033677101135254 -1
+                //2 0.055374979972839355 1
+                //3 0.06575113534927368 1
+                const threshold = 0.15;
+
+                // normalize to -1, 0, 1
+                let axis;
+                if (axisRaw < -threshold) {
+                    axis = -1;
+                } else if (axisRaw > threshold) {
+                    axis = 1;
+                } else {
+                    axis = 0;
+                }
+
+                if (axis !== this.gamepadAxes[i]) {
+                    // tricky because transition can be
+                    // -1 to 0
+                    // -1 to 1
+                    // 0 to 1
+                    // 0 to -1
+                    // 1 to 0
+                    // 1 to -1
+                    const oldKey = this.gamepadAxisMapping[i][this.gamepadAxes[i]];
+                    if (oldKey) {
+                        sysvia.keyUpRaw(oldKey);
+                    }
+
+                    const newKey = this.gamepadAxisMapping[i][axis];
+                    if (newKey) {
+                        sysvia.keyDownRaw(newKey);
+                    }
+                }
+
+                // store new state
+                this.gamepadAxes[i] = axis;
+            }
+
+            for (let i = 0; i < 16; i++) {
+                if (this.gamepad0.buttons[i]) {
+                    const button = this.gamepad0.buttons[i];
+
+                    if (button.pressed !== this.gamepadButtons[i]) {
+                        // different to last time
+
+                        if (this.gamepadMapping[i]) {
+                            if (button.pressed) {
+                                sysvia.keyDownRaw(this.gamepadMapping[i]);
+                            } else {
+                                sysvia.keyUpRaw(this.gamepadMapping[i]);
+                            }
+                        }
+                    }
+
+                    // store new state
+                    this.gamepadButtons[i] = button.pressed;
+                }
+            }
+        }
+    }
+}

package/src/google-drive.js

@@ -0,0 +1,160 @@
+"use strict";
+
+import _ from "underscore";
+import * as utils from "./utils.js";
+import { discFor } from "./fdc.js";
+
+const MIME_TYPE = "application/vnd.jsbeeb.disc-image";
+const CLIENT_ID = "356883185894-bhim19837nroivv18p0j25gecora60r5.apps.googleusercontent.com";
+const SCOPES = "https://www.googleapis.com/auth/drive.file";
+const DISCOVERY_DOC = "https://www.googleapis.com/discovery/v1/apis/drive/v3/rest";
+const FILE_FIELDS = "id,name,capabilities";
+const PARENT_FOLDER_NAME = "jsbeeb disc images";
+
+const boundary = "-------314159265358979323846";
+const delimiter = `\r\n--${boundary}\r\n`;
+const close_delim = `\r\n--${boundary}--`;
+
+const FOLDER_MIME_TYPE = "application/vnd.google-apps.folder";
+
+export class GoogleDriveLoader {
+    constructor() {
+        this.authorized = false;
+        this.parentFolderId = undefined;
+        this.driveClient = undefined;
+    }
+
+    async initialise() {
+        console.log("Creating GAPI");
+        await this._loadScript("https://apis.google.com/js/api.js");
+        console.log("Got GAPI, creating token client");
+        this.gapi = window.gapi;
+        await this._loadScript("https://accounts.google.com/gsi/client");
+        this.tokenClient = window.google.accounts.oauth2.initTokenClient({
+            client_id: CLIENT_ID,
+            scope: SCOPES,
+            error_callback: "", // defined later
+            callback: "", // defined later
+        });
+        console.log("Token client created, loading client");
+
+        await this.gapi.load("client", async () => {
+            console.log("Client loaded; initialising GAPI");
+            await this.gapi.client.init({ discoveryDocs: [DISCOVERY_DOC] });
+            console.log("GAPI initialised");
+            this.driveClient = this.gapi.client.drive;
+        });
+        console.log("Google Drive: available");
+        return true;
+    }
+
+    _loadScript(src) {
+        // https://github.com/google/google-api-javascript-client/issues/319
+        return new Promise((resolve) => {
+            const script = document.createElement("script");
+            script.src = src;
+            script.onload = resolve;
+            document.body.appendChild(script);
+        });
+    }
+
+    authorize(imm) {
+        if (this.authorized) return true;
+        if (imm) return false;
+        return new Promise((resolve, reject) => {
+            console.log("Authorizing...");
+            this.tokenClient.callback = (resp) => {
+                if (resp.error !== undefined) reject(resp);
+                console.log("Authorized OK");
+                this.authorized = true;
+                resolve(true);
+            };
+            this.tokenClient.error_callback = (resp) => {
+                console.log(`Token client failure: ${resp.type}; failed to authorize`);
+                reject(new Error(`Token client failure: ${resp.type}; failed to authorize`));
+            };
+            this.tokenClient.requestAccessToken({ select_account: false });
+        });
+    }
+
+    async listFiles() {
+        let response = await this.driveClient.files.list({ q: `mimeType = '${MIME_TYPE}' and trashed = false` });
+        let result = response.result.files;
+        while (response.result.nextPageToken) {
+            response = await this.driveClient.files.list({ pageToken: response.result.nextPageToken });
+            result = result.concat(response.result.files);
+        }
+        return result;
+    }
+
+    async _findOrCreateParentFolder() {
+        const list = await this.driveClient.files.list({
+            q: `name = '${PARENT_FOLDER_NAME}' and mimeType = '${FOLDER_MIME_TYPE}' and trashed = false`,
+            corpora: "user",
+        });
+        if (list.result.files.length === 1) {
+            console.log("Found existing parent folder");
+            return list.result.files[0].id;
+        }
+        console.log(`Creating parent folder ${PARENT_FOLDER_NAME}`);
+        const file = await this.driveClient.files.create({
+            resource: { name: PARENT_FOLDER_NAME, mimeType: FOLDER_MIME_TYPE },
+            fields: "id",
+        });
+        console.log("Folder Id:", file.result.id);
+        return file.result.id;
+    }
+
+    async saveFile(name, data, idOrNone) {
+        if (this.parentFolderId === undefined) {
+            this.parentFolderId = await this._findOrCreateParentFolder();
+        }
+        const metadata = { name, mimeType: MIME_TYPE };
+        if (!idOrNone) metadata.parents = [this.parentFolderId];
+
+        const base64Data = btoa(utils.uint8ArrayToString(data));
+        const multipartRequestBody =
+            `${delimiter}Content-Type: application/json\r\n\r\n` +
+            `${JSON.stringify(metadata)}${delimiter}` +
+            `Content-Type: ${MIME_TYPE}\r\nContent-Transfer-Encoding: base64\r\n\r\n` +
+            `${base64Data}${close_delim}`;
+
+        return this.gapi.client.request({
+            path: `/upload/drive/v3/files${idOrNone ? `/${idOrNone}` : ""}`,
+            method: idOrNone ? "PATCH" : "POST",
+            params: { uploadType: "multipart", newRevision: false, fields: FILE_FIELDS },
+            headers: { "Content-Type": `multipart/mixed; boundary="${boundary}"` },
+            body: multipartRequestBody,
+        });
+    }
+
+    async create(fdc, name, data) {
+        console.log(`Google Drive: creating disc image: '${name}'`);
+        const response = await this.saveFile(name, data);
+        const meta = response.result;
+        return { fileId: meta.id, disc: this.makeDisc(fdc, data, meta) };
+    }
+
+    makeDisc(fdc, data, meta) {
+        let flusher = null;
+        const name = meta.name;
+        const id = meta.id;
+        if (meta.capabilities.canEdit) {
+            console.log("Making editable disc");
+            flusher = _.debounce(async (changedData) => {
+                console.log("Data changed...");
+                await this.saveFile(name, changedData, id);
+                console.log("Saved ok");
+            }, 200);
+        } else {
+            console.log("Making read-only disc");
+        }
+        return discFor(fdc, name, data, flusher);
+    }
+
+    async load(fdc, fileId) {
+        const meta = (await this.driveClient.files.get({ fileId, fields: FILE_FIELDS })).result;
+        const data = (await this.driveClient.files.get({ fileId, alt: "media" })).body;
+        return this.makeDisc(fdc, data, meta);
+    }
+}