@rustwirebot/rustplus.js 2.5.0

package/camera.js

@@ -0,0 +1,425 @@
+"use strict";
+
+const { EventEmitter } = require("events");
+const Jimp = require("jimp");
+
+class Camera extends EventEmitter {
+
+    /**
+     * These represent the possible buttons that can be sent to the server.
+     */
+    static Buttons = {
+        NONE: 0,
+        FORWARD: 2,
+        BACKWARD: 4,
+        LEFT: 8,
+        RIGHT: 16,
+        JUMP: 32,
+        DUCK: 64,
+        SPRINT: 128,
+        USE: 256,
+        FIRE_PRIMARY: 1024,
+        FIRE_SECONDARY: 2048,
+        RELOAD: 8192,
+        FIRE_THIRD: 134217728,
+    }
+
+    /**
+     * These represent the possible control flags that can be sent to the server.
+     * For example, Static CCTV cameras will not support movement.
+     */
+    static ControlFlags = {
+        NONE: 0,
+        MOVEMENT: 1,
+        MOUSE: 2,
+        SPRINT_AND_DUCK: 4,
+        FIRE: 8,
+        RELOAD: 16,
+        CROSSHAIR: 32,
+    }
+
+    /**
+     * @param rustplus An existing RustPlus instance
+     * @param identifier Camera Identifier, such as OILRIG1 (or custom name)
+     *
+     * Events emitted by the Camera class instance
+     * - subscribing: When we are subscribing to the Camera.
+     * - subscribed: When we are subscribed to the Camera.
+     * - unsubscribing: When we are unsubscribing from the Camera.
+     * - unsubscribed: When we are unsubscribed from the Camera.
+     * - render: When a camera frame has been rendered. A png image buffer will be provided.
+     */
+    constructor(rustplus, identifier) {
+
+        super();
+
+        this.rustplus = rustplus;
+        this.identifier = identifier;
+        this.isSubscribed = false;
+
+        this.cameraRays = [];
+        this.cameraSubscribeInfo = null;
+        this.subscribeInterval = null;
+
+        // listen to camera message broadcasts
+        this.rustplus.on('message', async (message) => {
+            await this._onMessage(message);
+        });
+
+        // unsubscribe when rustplus is disconnected (to prevent hanging due to intervals still running)
+        this.rustplus.on('disconnected', async () => {
+            if(this.isSubscribed){
+                await this.unsubscribe();
+            }
+        });
+
+    }
+
+    async _onMessage(message) {
+
+        // do nothing if not subscribed
+        if(!this.isSubscribed){
+            return;
+        }
+
+        if(message.broadcast && message.broadcast.cameraRays){
+            await this._onCameraRays(message.broadcast.cameraRays);
+        }
+
+    }
+
+    async _onCameraRays(cameraRays) {
+
+        // do nothing if not subscribed
+        if(!this.isSubscribed){
+            return;
+        }
+
+        // add new camera rays to cache
+        this.cameraRays.push(cameraRays);
+
+        // wait until we have enough camera rays to render an image
+        if(this.cameraRays.length > 10){
+
+            // remove first oldest rayData
+            this.cameraRays.shift();
+
+            // render to png
+            const frame = await this._renderCameraFrame(this.cameraRays, this.cameraSubscribeInfo.width, this.cameraSubscribeInfo.height);
+
+            // fire callback
+            await this._onRender(frame);
+
+        }
+
+    }
+
+    async _onRender(image) {
+
+        // do nothing if not subscribed
+        if(!this.isSubscribed){
+            return;
+        }
+
+        this.emit('render', image);
+
+    }
+
+    /**
+     * Render a camera frame to a PNG image buffer
+     * @param frames the frame data to render. This will be an array of camera rays from the server.
+     * @param width the width of the frame
+     * @param height the height of the frame
+     */
+    async _renderCameraFrame(frames, width, height) {
+
+        // First we populate the samplePositionBuffer with the positions of each sample
+        const samplePositionBuffer = new Int16Array(width * height * 2);
+        for (let w = 0, _ = 0; _ < height; _++)
+            for (let g = 0; g < width; g++) {
+                samplePositionBuffer[w] = g;
+                samplePositionBuffer[++w] = _;
+                w++;
+            }
+
+        for (let B = new IndexGenerator(1337), R = width * height - 1; R >= 1; R--) {
+            let C = 2 * R,
+                I = 2 * B.nextInt(R + 1),
+                P = samplePositionBuffer[C],
+                k = samplePositionBuffer[C + 1],
+                A = samplePositionBuffer[I],
+                F = samplePositionBuffer[I + 1];
+            samplePositionBuffer[I] = P;
+            samplePositionBuffer[I + 1] = k;
+            samplePositionBuffer[C] = A;
+            samplePositionBuffer[C + 1] = F;
+        }
+
+        // Create the output buffer
+        const output = new Array(width * height);
+        // Loop through each frame
+        for (let frame of frames) {
+
+            // Reset some look back and pointer variables
+            let sampleOffset = 2 * frame.sampleOffset;
+            let dataPointer = 0;
+            let rayLookback = new Array(64);
+            for (let r = 0; r < 64; r++) rayLookback[r] = [0, 0, 0];
+
+            const rayData = frame.rayData;
+
+            // Loop through the ray data
+            while (true) {
+                if (dataPointer >= rayData.length - 1)
+                    break;
+
+                // Get the first byte and set some variables
+                let t, r, i, n = rayData[dataPointer++];
+
+                // Ray Decoding Logic
+                if (255 === n) {
+                    let l = rayData[dataPointer++],
+                        o = rayData[dataPointer++],
+                        s = rayData[dataPointer++],
+                        u = (3 * (((t = (l << 2) | (o >> 6)) / 128) | 0) + 5 * (((r = 63 & o) / 16) | 0) + 7 * (i = s)) & 63,
+                        f = rayLookback[u];
+                    f[0] = t;
+                    f[1] = r;
+                    f[2] = i;
+                } else {
+                    let c = 192 & n;
+
+                    if (0 === c) {
+                        let h = 63 & n, y = rayLookback[h];
+                        t = y[0];
+                        r = y[1];
+                        i = y[2];
+                    } else if (64 === c) {
+                        let p = 63 & n,
+                            v = rayLookback[p],
+                            b = v[0],
+                            w = v[1],
+                            _ = v[2],
+                            g = rayData[dataPointer++];
+                        t = b + ((g >> 3) - 15);
+                        r = w + ((7 & g) - 3);
+                        i = _;
+                    } else if (128 === c) {
+                        let R = 63 & n,
+                            C = rayLookback[R],
+                            I = C[0],
+                            P = C[1],
+                            k = C[2];
+                        t = I + (rayData[dataPointer++] - 127);
+                        r = P;
+                        i = k;
+                    } else {
+                        let A = rayData[dataPointer++],
+                            F = rayData[dataPointer++],
+                            D = (3 * (((t = (A << 2) | (F >> 6)) / 128) | 0) + 5 * (((r = 63 & F) / 16) | 0) + 7 * (i = 63 & n)) & 63,
+                            E = rayLookback[D];
+                        E[0] = t;
+                        E[1] = r;
+                        E[2] = i;
+                    }
+                }
+
+                sampleOffset %= 2 * width * height;
+                const index = samplePositionBuffer[sampleOffset++] + samplePositionBuffer[sampleOffset++] * width;
+                output[index] = [t / 1023, r / 63, i];
+            }
+        }
+
+        const colours = [
+            [0.5, 0.5, 0.5], [0.8, 0.7, 0.7], [0.3, 0.7, 1], [0.6, 0.6, 0.6],
+            [0.7, 0.7, 0.7], [0.8, 0.6, 0.4], [1, 0.4, 0.4], [1, 0.1, 0.1],
+        ];
+
+        const image = new Jimp(width, height);
+
+        for (let i = 0; i < output.length; i++) {
+            let ray = output[i];
+            if (!ray) {
+                continue;
+            }
+
+            let distance = ray[0]
+            let alignment = ray[1]
+            let material = ray[2]
+
+            let target_colour;
+
+            if (distance === 1 && alignment === 0 && material === 0) {
+                target_colour = [208, 230, 252];
+            } else {
+                let colour = colours[material];
+                target_colour = [(alignment * colour[0] * 255), (alignment * colour[1] * 255), (alignment * colour[2] * 255)]
+            }
+
+            let x = i % width;
+            let y = height - 1 - Math.floor(i / width);
+            image.setPixelColor(Jimp.rgbaToInt(target_colour[0], target_colour[1], target_colour[2], 255), x, y);
+        }
+
+        // return png buffer
+        return image.getBufferAsync(Jimp.MIME_PNG);
+
+    }
+
+    async _subscribe() {
+
+        // subscribe to camera
+        const response = await this.rustplus.sendRequestAsync({
+            cameraSubscribe: {
+                cameraId: this.identifier,
+            },
+        });
+
+        // update camera subscribe info
+        this.cameraSubscribeInfo = response.cameraSubscribeInfo;
+        this.isSubscribed = true;
+
+    }
+
+    async subscribe() {
+
+        this.emit('subscribing');
+
+        // subscribe to camera
+        await this._subscribe();
+
+        this.emit('subscribed');
+
+        // automatically resubscribe to the camera every 10 seconds
+        this.subscribeInterval = setInterval(async () => {
+            if(this.isSubscribed){
+                await this._subscribe();
+            }
+        }, 10_000);
+
+    }
+
+    async unsubscribe() {
+
+        this.emit('unsubscribing');
+
+        this.isSubscribed = false;
+
+        // stop automatically resubscribing
+        clearInterval(this.subscribeInterval);
+
+        // release memory
+        this.cameraRays = [];
+        this.cameraSubscribeInfo = null;
+        this.subscribeInterval = null;
+
+        // unsubscribe from camera on server (if connected)
+        if(this.rustplus.isConnected()){
+            try {
+                await this.rustplus.sendRequestAsync({
+                    cameraUnsubscribe: {
+
+                    },
+                });
+            } catch (error) {
+                // ignore errors unsubscribing from camera
+            }
+        }
+
+        this.emit('unsubscribed');
+
+    }
+
+    /**
+     * Sends camera movement to the server (mouse movement)
+     * @param buttons The buttons that are currently pressed
+     * @param x The x delta of the mouse movement
+     * @param y The y delta of the mouse movement
+     */
+    async move(buttons, x, y) {
+        return await this.rustplus.sendRequestAsync({
+            cameraInput: {
+                buttons: buttons,
+                mouseDelta: {
+                    x: x,
+                    y: y,
+                }
+            },
+        });
+    }
+
+    /**
+     * Zooms a PTZ camera in by 1 level.
+     * PTZ cameras have 4 zoom levels.
+     * If the PTZ camera is already at max zoom (level 4), it zooms out as far as it can (level 1).
+     */
+    async zoom() {
+
+        // press left mouse button to zoom in
+        await this.move(Camera.Buttons.FIRE_PRIMARY, 0, 0);
+
+        // release all mouse buttons
+        await this.move(Camera.Buttons.NONE, 0, 0);
+
+    }
+
+    /**
+     * Shoots a PTZ controllable Auto Turret.
+     */
+    async shoot() {
+
+        // press left mouse button to shoot
+        await this.move(Camera.Buttons.FIRE_PRIMARY, 0, 0);
+
+        // release all mouse buttons
+        await this.move(Camera.Buttons.NONE, 0, 0);
+
+    }
+
+    /**
+     * Reloads a PTZ controllable Auto Turret
+     */
+    async reload() {
+
+        // press reload button to reload turret
+        await this.move(Camera.Buttons.RELOAD, 0, 0);
+
+        // release all mouse buttons
+        await this.move(Camera.Buttons.NONE, 0, 0);
+
+    }
+
+    /**
+     * Check if camera is an auto turret
+     * @returns {boolean}
+     */
+    isAutoTurret() {
+        const crosshairControlFlag = Camera.ControlFlags.CROSSHAIR;
+        return (this.cameraSubscribeInfo?.controlFlags & crosshairControlFlag) === crosshairControlFlag;
+    }
+
+}
+
+class IndexGenerator {
+
+    constructor(e) {
+        this.state = 0 | e;
+        this.nextState();
+    }
+
+    nextInt(e) {
+        let t = ((this.nextState() * (0 | e)) / 4294967295) | 0;
+        if (t < 0) t = e + t - 1;
+        return 0 | t;
+    }
+
+    nextState() {
+        let e = this.state, t = e;
+        e = ((e = ((e = (e ^ ((e << 13) | 0)) | 0) ^ ((e >>> 17) | 0)) | 0) ^ ((e << 5) | 0)) | 0;
+        this.state = e;
+        return t >= 0 ? t : 4294967295 + t - 1;
+    }
+
+}
+
+module.exports = Camera;