Archipelago WIP

.eslintrc.json

@@ -0,0 +1,22 @@
+{
+    "env": {
+        "browser": true,
+        "es2021": true
+    },
+    "extends": [
+        "eslint:recommended",
+        "plugin:@typescript-eslint/recommended"
+    ],
+    "overrides": [
+    ],
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+        "ecmaVersion": "latest",
+        "sourceType": "module"
+    },
+    "plugins": [
+        "@typescript-eslint"
+    ],
+    "rules": {
+    }
+}

.gitignore

@@ -105,3 +105,4 @@ dist
 
 # TernJS port file
 .tern-port
+FormatCodes.cpp

package.json

@@ -9,11 +9,15 @@
     "scripts": {
         "build": "tsc",
         "watch": "tsc --watch --outFile %USERPROFILE%/Documents/OpenRCT2/plugin/rctrando.js",
+        "watchLinux": "tsc --watch --outFile ~/.config/OpenRCT2/plugin/rctrando.js",
         "minify": "uglifyjs --compress --mangle --output out/rctrando.min.js -- out/rctrando.js",
         "build-release": "npm run build"
     },
     "devDependencies": {
-        "typescript": "^4.6.3",
+        "@typescript-eslint/eslint-plugin": "^6.4.0",
+        "@typescript-eslint/parser": "^6.4.0",
+        "eslint": "^8.47.0",
+        "typescript": "^4.9.5",
         "uglify-js": "^3.15.3"
     }
 }

src/OpenRCT2-CrowdControl/CCAds.ts

@@ -3,7 +3,8 @@ interface Ad {
     title: string,
     header: string,
     message: string,
-    button: string
+    button: string,
+    onClick?: Function
 }
 
 const adPool: Ad[] = [
@@ -126,6 +127,55 @@ const adPool: Ad[] = [
         header: "Here is your download:",
         message: "openrct3.dat (43.5 mB)",
         button: "DOWNLOAD"
+    },
+    {
+        title: "CLOSE THIS WINDOW!",
+        header: "Tired of the buttons not closing these windows?",
+        message: "Fix it today!",
+        button: "Click here!"
+    },
+    {
+        title: "Archipelago",
+        header: "Have you checked your tracker?",
+        message: "do it.",
+        button: "Finish Sphere 1"
+    },
+    {
+        title: "",
+        header: "",
+        message: "",
+        button: ""
+    },
+    {
+        title: "DANGER",
+        header: "Don't click this button!",
+        message: "It's extremely hazardous!",
+        button: "SEND DEATHLINK",
+        onClick: () => 
+            {try{
+                var DeathLink = GetModule("RCTRArchipelago") as RCTRArchipelago;
+                DeathLink.SendDeathLink(null,"A popup window with the text \"SEND DEATHLINK\"");}
+            catch{ui.showError("Archipelago not open", "You should try this while playing Archipelago!")}
+            ui.closeAllWindows()}//We don't know the ID, so close everything. Besides, it "Crashed"
+    },
+    {
+        title: "Freedom!",
+        header: "This game is sponsored by Linux Mint!",
+        message: "Linux is vastly superior to Windows!",
+        button: "Upgrade today!",
+        onClick: () => {archipelago_print_message("Go to LinuxMint.com and click \"Download\"")}
+    },
+    {
+        title: "Lorem ipsum",
+        header: "Aliquam euismod, risus vel ultricies ornare",
+        message: "Nam feugiat est in diam maximus consectetur.",
+        button: "Phasellus imperdiet auctor nisi."
+    },
+    {
+        title: "Uh oh!",
+        header: "Something broke!",
+        message: "TELL COLBY RIGHT NOW!",
+        button: "CALL 1-800-FIX-IT-4-U!"
     }
 ]
 
@@ -163,7 +213,8 @@ function showAd(ad: Ad): void {
                     y: 75,
                     width: 300,
                     height: 25,
-                    text: ad.button
+                    text: ad.button,
+                    onClick: ad.onClick as () => void || (() => { console.log("No button code provided"); })
                 }
             ]
         });

src/api.ts

@@ -0,0 +1,219 @@
+
+class APIConnection
+{
+    sock:Socket = null;
+    good: boolean = false;
+    reconnect_interval: number = null;
+    name:string = "API";
+    port:number;
+    callback:CallableFunction;
+    errorCallback:CallableFunction;
+    connectCallback:CallableFunction;
+    onCloseCallback: (hadError: any) => void;
+    onExpectedCloseCallback: (hadError: any) => void;
+    onErrorCallback: (hadError: any) => void;
+    onDataCallback: (hadError: any) => void;
+    buffer:string = "";
+
+    constructor(name:string, port:number, callback:CallableFunction, errorCallback?:CallableFunction, connectCallback?:CallableFunction) {
+        this.name = name;
+        this.port = port;
+        this.callback = callback;
+        this.errorCallback = errorCallback;
+        this.connectCallback = connectCallback;
+
+        var self = this;
+        this.onCloseCallback = function(hadError){self.onClose(hadError);};
+        this.onExpectedCloseCallback = function(hadError){self.onExpectedClose(hadError);}
+        this.onErrorCallback = function(hadError){self.onError(hadError);};
+        this.onDataCallback = function(hadError){self.onData(hadError);};
+
+        this.connect();
+    }
+
+    send(data:Object) {
+        try {
+            let r: string = JSON.stringify(data) + '\0';
+            info(this.name+' sending:', r.length, r);
+            this.end(r);
+        } catch(e) {
+            printException('error sending '+this.name, e);
+        }
+    }
+
+    destroy() {
+        if(!this.sock) return;
+
+        info(this.name+'.destroy()');
+        try {
+            this.sock.off('close', this.onCloseCallback);
+        } catch(e) {
+            printException('error closing event handlers in '+this.name+'.close', e);
+        }
+
+        try {
+            this.sock.off('close', this.onExpectedCloseCallback);
+        } catch(e) {
+            printException('error closing event handlers in '+this.name+'.close', e);
+        }
+
+        try {
+            this.sock.destroy(null);
+        } catch(e) {
+            printException('error destroying old '+this.name+' connection ', e);
+        }
+
+        this.sock = null;
+    }
+
+    private onError(hadError: boolean) {
+        info('error in '+this.name+' connection, will keep trying...');
+        if(this.good) {
+            park.postMessage(
+                {type: 'blank', text: 'error in '+this.name+' connection, will keep trying...'} as ParkMessageDesc
+            );
+        }
+        if(this.errorCallback) {
+            this.errorCallback();
+        }
+        this.good = false;
+        this.connect();
+    }
+
+    private onClose(hadError: boolean) {
+        info(this.name+' connection closed, will keep trying...');
+        if(this.good) {
+            park.postMessage(
+                {type: 'blank', text: this.name+' connection closed, will keep trying...'} as ParkMessageDesc
+            );
+        }
+        this.good = false;
+        this.connect();
+    }
+
+    private onExpectedClose(hadError: boolean) {
+        info(this.name+' connection closed cc_onExpectedClose, will keep trying...');
+        this.good = true;
+        this.connect();
+    }
+
+    private reconnect() {
+        debug(this.name+' reconnecting...');
+        this.connect();
+    }
+
+    private onData(message: string) {
+        let data: Object = null;
+        let resp: Object = null;
+
+        let packets = message.split('\0')
+        message = packets[0];
+
+        // try
+        try {
+            data = JSON.parse(message);
+            this.buffer = "";
+        } catch(e) {
+            try {
+                this.buffer += message;
+                data = JSON.parse(this.buffer);
+                this.buffer = "";
+            }
+            catch(e) {
+                printException('error parsing '+this.name+' request JSON: ' + message, e);
+                return;
+            }
+        }
+
+        try {
+            info(this.name+" received data: ", data);
+            resp = this.callback(data);
+            // this.send(resp);
+        } catch(e) {
+            printException('error handling '+this.name+' request: ' + message, e);
+        }
+
+        if(packets.length > 1) {
+            packets = packets.slice(1);
+            message = packets.join('\0');
+            if(message.length > 1) {
+                this.onData(message);
+            }
+        }
+    }
+
+    private reset_timeout() {
+        if(this.reconnect_interval !== null) {
+            context.clearInterval(this.reconnect_interval);
+            this.reconnect_interval = null;
+        }
+
+        //this.reconnect_interval = context.setInterval(this.end, 5000);
+    }
+
+    private end(data?:string) {
+        if(!this.sock) return;
+
+        info(this.name+'.end()');
+        try {
+            this.sock.off('close', this.onCloseCallback);
+            this.sock.on('close', this.onExpectedCloseCallback);
+        } catch(e) {
+            printException('error closing event handlers in '+this.name+'.close', e);
+        }
+
+        try {
+            data = data ? data : '{"id": 0, "status": 0}\0';
+            info(this.name+'.sock.end('+data+')');
+            this.sock.end(data);
+        } catch(e) {
+            printException('error closing old '+this.name+' connection ', e);
+        }
+
+        try {
+            this.sock.destroy(null);
+        } catch(e) {
+            printException('error destroying old '+this.name+' connection ', e);
+        }
+
+        this.reset_timeout();
+        this.good = true;
+    }
+
+    private connect() {
+        var self = this;
+
+        if (network.mode == "server") {
+            //info("This is a server...");
+        } else if (network.mode == "client") {
+            //info("This is a client...");
+            return;
+        } else {
+            //info("This is single player...");
+        }
+
+        this.reset_timeout();
+        this.destroy();
+
+        info(this.name+'.connect');
+        this.sock = network.createSocket();
+
+        this.sock.connect(this.port, '127.0.0.1', function() {
+            if(!self.good) {
+                info(self.name+' connected to port '+self.port);
+                park.postMessage(
+                    {type: 'blank', text: self.name+' connected!'} as ParkMessageDesc
+                );
+                if(self.connectCallback) {
+                    self.connectCallback();
+                }
+            }
+            self.good = true;
+        });
+        this.sock.setNoDelay(true);
+
+        this.sock.on('error', this.onErrorCallback);
+        this.sock.on('close', this.onCloseCallback);
+        this.sock.on('data', this.onDataCallback);
+    }
+}