bitburner infiltration.js custom v2.6.0

const state = {
    // Name of the company that's infiltrated.
    company: "",

    // Whether infiltration started. False means, we're
    // waiting to arrive on the infiltration screen.
    started: false,

    // Details/state of the current mini game.
    // Is reset after every game.
    game: {},
};

// Speed of game actions, in milliseconds.
const speed = 22;

// Small hack to save RAM.
// This will work smoothly, because the script does not use
// any "ns" functions, it's a pure browser automation tool.
const wnd = eval("window");
const doc = wnd["document"];

// List of all games and an automated solver.
const infiltrationGames = [
    {
        name: "type it backward",
        init: function (screen) {
            const lines = getLines(getEl(screen, "p"));
            state.game.data = lines[0].split("");
        },
        play: function (screen) {
            if (!state.game.data || !state.game.data.length) {
                delete state.game.data;
                return;
            }

            pressKey(state.game.data.shift());
        },
    },
    {
        name: "type it",
        init: function (screen) {
            const lines = getLines(getEl(screen, "p"));
            state.game.data = lines[0].split("");
        },
        play: function (screen) {
            if (!state.game.data || !state.game.data.length) {
                delete state.game.data;
                return;
            }

            pressKey(state.game.data.shift());
        },
    },
    {
        name: "enter the code",
        init: function(screen) {
            console.log("Script initialized. Awaiting game start...");
        },
        play: function(screen) {
            const arrowsText = getEl(screen, "h4")[1].textContent; // Get arrow sequence from the second <h4>
            console.log(`Current sequence: '${arrowsText}'`);

            // Determine the last revealed arrow using its index
            const lastArrowIndex = Math.max(...["↑", "↓", "←", "→"].map(arrow => arrowsText.lastIndexOf(arrow)));

            if (lastArrowIndex !== -1) { // Arrow found
                const lastArrow = arrowsText.charAt(lastArrowIndex);
                console.log(`Responding to the most recent arrow: '${lastArrow}'`);

                // Mapping of arrows to keyboard inputs
                const keyMap = { "↑": "w", "↓": "s", "←": "a", "→": "d" };
                console.log(`Pressing '${keyMap[lastArrow]}' for ${lastArrow}`);
                pressKey(keyMap[lastArrow]);
            } else {
                console.log("No new arrow to respond to.");
            }
        },
    },
    {
        name: "close the brackets",
        init: function (screen) {
            const data = getLines(getEl(screen, "p"));
            const brackets = data.join("").split("");
            state.game.data = [];

            for (let i = brackets.length - 1; i >= 0; i--) {
                const char = brackets[i];

                if ("<" == char) {
                    state.game.data.push(">");
                } else if ("(" == char) {
                    state.game.data.push(")");
                } else if ("{" == char) {
                    state.game.data.push("}");
                } else if ("[" == char) {
                    state.game.data.push("]");
                }
            }
        },
        play: function (screen) {
            if (!state.game.data || !state.game.data.length) {
                delete state.game.data;
                return;
            }

            pressKey(state.game.data.shift());
        },
    },
    {
        name: "attack when his guard is down",
        init: function (screen) {
            console.log("Slash game initialized");
            state.game.data = "wait";
            state.game.guardingTimeStart = new Date().getTime();
            state.game.predictedPreparationTime = Math.random() * 3250 + 1500; // Approximate preparation time
        },
        play: function (screen) {
            if (state.game.data === "done") return; // Exit if game is already done

            const currentTime = new Date().getTime();
            const elapsedTime = currentTime - state.game.guardingTimeStart;

            // Fetch the current game phase from the screen
            const data = getLines(getEl(screen, "h4"));
            console.log(`Current phase: ${data}`);

            // Text Detection
            if ('wait' === state.game.data && (-1 !== data.indexOf("Preparing?") || -1 !== data.indexOf("ATTACKING!"))) {
                console.log("Text detection trigger activated");
                state.game.data = "attack";
            }

            // Execute Attack
            if ("attack" === state.game.data) {
                console.log("Pressing spacebar");
                pressKey(" ");
                state.game.data = "done";
            }
        },
    },
    {
        name: "say something nice about the guard",
        init: function (screen) { },
        play: function (screen) {
            const correct = [
                "affectionate",
                "agreeable",
                "bright",
                "charming",
                "creative",
                "determined",
                "energetic",
                "friendly",
                "funny",
                "generous",
                "polite",
                "likable",
                "diplomatic",
                "helpful",
                "giving",
                "kind",
                "hardworking",
                "patient",
                "dynamic",
                "loyal",
                "straightforward"
            ];
            const word = getLines(getEl(screen, "h5"))[1];

            if (-1 !== correct.indexOf(word)) {
                pressKey(" ");
            } else {
                pressKey("w");
            }
        },
    },
    {
        name: "remember all the mines",
        init: function (screen) {
            const rows = getEl(screen, "p");
            let gridSize = null;
            switch (rows.length) {
                case 9:
                    gridSize = [3, 3];
                    break;
                case 12:
                    gridSize = [3, 4];
                    break;
                case 16:
                    gridSize = [4, 4];
                    break;
                case 20:
                    gridSize = [4, 5];
                    break;
                case 25:
                    gridSize = [5, 5];
                    break;
                case 30:
                    gridSize = [5, 6];
                    break;
                case 36:
                    gridSize = [6, 6];
                    break;
            }
            if (gridSize == null) {
                return;
            }
            //12 20 30 42
            state.game.data = [];
            let index = 0;
            //for each row
            for (let y = 0; y < gridSize[1]; y++) {
                //initialize array data
                state.game.data[y] = [];
                for (let x = 0; x < gridSize[0]; x++) {
                    //for each column in the row add to state data if it has a child
                    if (rows[index].children.length > 0) {
                        state.game.data[y].push(true);
                    } else state.game.data[y].push(false);
                    index += 1;
                }
            }
        },
        play: function (screen) { },
    },
    {
        name: "mark all the mines",
        init: function (screen) {
            state.game.x = 0;
            state.game.y = 0;
            state.game.cols = state.game.data[0].length;
            state.game.dir = 1;
        },
        play: function (screen) {
            let { data, x, y, cols, dir } = state.game;

            if (data[y][x]) {
                pressKey(" ");
                data[y][x] = false;
            }

            x += dir;

            if (x < 0 || x >= cols) {
                x = Math.max(0, Math.min(cols - 1, x));
                y++;
                dir *= -1;
                pressKey("s");
            } else {
                pressKey(dir > 0 ? "d" : "a");
            }

            state.game.data = data;
            state.game.x = x;
            state.game.y = y;
            state.game.dir = dir;
        },
    },
    {
        name: "match the symbols",
        init: function (screen) {
            const data = getLines(getEl(screen, "h5 span"));
            const rows = getLines(getEl(screen, "p"));
            const keypad = [];
            const targets = [];
            let gridSize = null;
            switch (rows.length) {
                case 9:
                    gridSize = [3, 3];
                    break;
                case 12:
                    gridSize = [3, 4];
                    break;
                case 16:
                    gridSize = [4, 4];
                    break;
                case 20:
                    gridSize = [4, 5];
                    break;
                case 25:
                    gridSize = [5, 5];
                    break;
                case 30:
                    gridSize = [5, 6];
                    break;
                case 36:
                    gridSize = [6, 6];
                    break;
            }
            if (gridSize == null) {
                return;
            }
            //build the keypad grid.
            let index = 0;
            for (let i = 0; i < gridSize[1]; i++) {
                keypad[i] = [];
                for (let y = 0; y < gridSize[0]; y++) {

                    keypad[i].push(rows[index]);
                    index += 1;
                }
            }
            //foreach data get coords of keypad entry
            for (let i = 0; i < data.length; i++) {
                const symbol = data[i].trim();
                //for each keypad entry
                for (let j = 0; j < keypad.length; j++) {
                    const k = keypad[j].indexOf(symbol);

                    if (-1 !== k) {
                        targets.push([j, k]);
                        break;
                    }
                }
            }
            state.game.data = targets;
            state.game.x = 0;
            state.game.y = 0;
        },
        play: function (screen) {
            const target = state.game.data[0];
            let { x, y } = state.game;

            if (!target) {
                return;
            }

            const to_y = target[0];
            const to_x = target[1];

            if (to_y < y) {
                y--;
                pressKey("w");
            } else if (to_y > y) {
                y++;
                pressKey("s");
            } else if (to_x < x) {
                x--;
                pressKey("a");
            } else if (to_x > x) {
                x++;
                pressKey("d");
            } else {
                pressKey(" ");
                state.game.data.shift();
            }

            state.game.x = x;
            state.game.y = y;
        },
    },
    {
        name: "cut the wires with the following properties",
        init: function (screen) {
            let numberHack = ["1","2","3","4","5","6","7","8","9"];
            const colors = {
                red: "red",
                white: "white",
                blue: "blue",
                "rgb(255, 193, 7)": "yellow",
            };
            const wireColor = {
                red: [],
                white: [],
                blue: [],
                yellow: [],
            };
            //gather the instructions
            var instructions = []
            for (let child of screen.children) instructions.push(child);
            var wiresData = instructions.pop();
            instructions.shift();
            instructions = getLines(instructions);
            //get the wire information
            const samples = getEl(wiresData, "p");
            const wires = [];
            //get the amount of wires
            let wireCount = 0;
            for (let i = wireCount; i < samples.length; i++) {
                if (numberHack.includes(samples[i].innerText)) wireCount += 1;
                else break;
            }
            let index = 0;
            //get just the first 3 rows of wires.
            for (let i = 0; i < 3; i++) {
                //for each row
                for (let j = 0; j < wireCount; j++) {
                    const node = samples[index];
                    const color = colors[node.style.color];
                    if (!color) {
                        index += 1;
                        continue;
                    }
                    wireColor[color].push(j+1);
                    index += 1;
                }
            }

            for (let i = 0; i < instructions.length; i++) {
                const line = instructions[i].trim().toLowerCase();

                if (!line || line.length < 10) {
                    continue;
                }
                if (-1 !== line.indexOf("cut wires number")) {
                    const parts = line.split(/(number\s*|\.)/);
                    wires.push(parseInt(parts[2]));
                }
                if (-1 !== line.indexOf("cut all wires colored")) {
                    const parts = line.split(/(colored\s*|\.)/);
                    const color = parts[2];

                    if (!wireColor[color]) {
                        // should never happen.
                        continue;
                    }

                    wireColor[color].forEach((num) => wires.push(num));
                }
            }

            // new Set() removes duplicate elements.
            state.game.data = [...new Set(wires)];
        },
        play: function (screen) {
            const wire = state.game.data;
            //state.game.data.shift();
            if (!wire) {
                return;
            }
            for (let i=0;i<wire.length;i++) {
                pressKey(wire[i].toString());
            }
        },
    },
];

/** @param {NS} ns **/
export async function main(ns) {
    const args = ns.flags([
        ["start", false],
        ["stop", false],
        ["status", false],
        ["quiet", false],
    ]);

    function print(msg) {
        if (!args.quiet) {
            ns.tprint(`\n${msg}\n`);
        }
    }

    if (args.status) {
        if (wnd.tmrAutoInf) {
            print("Automated infiltration is active");
        } else {
            print("Automated infiltration is inactive");
        }
        return;
    }

    if (wnd.tmrAutoInf) {
        print("Stopping automated infiltration...");
        clearInterval(wnd.tmrAutoInf);
        delete wnd.tmrAutoInf;
    }

    if (args.stop) {
        return;
    }

    print(
        "Automated infiltration is enabled...\nVWhen you visit the infiltration screen of any company, all tasks are completed automatically."
    );

    endInfiltration();

    // Monitor the current screen and start infiltration once a
    // valid screen is detected.
    wnd.tmrAutoInf = setInterval(infLoop, speed);

    // Modify the addEventListener logic.
    wrapEventListeners();
}

/**
 * The infiltration loop, which is called at a rapid interval
 */
function infLoop() {
    if (!state.started) {
        waitForStart();
    } else {
        playGame();
    }
}

/**
 * Returns a list of DOM elements from the main game
 * container.
 */
function getEl(parent, selector) {
    let prefix = ":scope";

    if ("string" === typeof parent) {
        selector = parent;
        parent = doc;

        prefix = ".MuiBox-root>.MuiBox-root>.MuiBox-root";

        if (!doc.querySelectorAll(prefix).length) {
            prefix = ".MuiBox-root>.MuiBox-root>.MuiGrid-root";
        }
        if (!doc.querySelectorAll(prefix).length) {
            prefix = ".MuiContainer-root>.MuiPaper-root";
        }
        if (!doc.querySelectorAll(prefix).length) {
            return [];
        }
    }

    selector = selector.split(",");
    selector = selector.map((item) => `${prefix} ${item}`);
    selector = selector.join(",");

    return parent.querySelectorAll(selector);
}

/**
 * Returns the first element with matching text content.
 */
function filterByText(elements, text) {
    text = text.toLowerCase();

    for (let i = 0; i < elements.length; i++) {
        const content = elements[i].textContent.toLowerCase();

        if (-1 !== content.indexOf(text)) {
            return elements[i];
        }
    }

    return null;
}

/**
 * Returns an array with the text-contents of the given elements.
 *
 * @param {NodeList} elements
 * @returns {string[]}
 */
function getLines(elements) {
    const lines = [];
    elements.forEach((el) => lines.push(el.textContent));

    return lines;
}

/**
 * Reset the state after infiltration is done.
 */
function endInfiltration() {
    unwrapEventListeners();
    state.company = "";
    state.started = false;
}

/**
 * Simulate a keyboard event (keydown + keyup).
 *
 * @param {string|int} keyOrCode A single letter (string) or key-code to send.
 */
function pressKey(keyOrCode) {
    let keyCode = 0;
    let key = "";

    if ("string" === typeof keyOrCode && keyOrCode.length > 0) {
        key = keyOrCode.toLowerCase().substr(0, 1);
        keyCode = key.charCodeAt(0);
    } else if ("number" === typeof keyOrCode) {
        keyCode = keyOrCode;
        key = String.fromCharCode(keyCode);
    }

    if (!keyCode || key.length !== 1) {
        return;
    }

    function sendEvent(event) {
        const keyboardEvent = new KeyboardEvent(event, {
            key,
            keyCode,
        });

        doc.dispatchEvent(keyboardEvent);
    }

    sendEvent("keydown");
}

/**
 * Infiltration monitor to start automatic infiltration.
 *
 * This function runs asynchronously, after the "main" function ended,
 * so we cannot use any "ns" function here!
 */
function waitForStart() {
    if (state.started) {
        return;
    }

    const h4 = getEl("h4");

    if (!h4.length) {
        return;
    }
    const title = h4[0].textContent;
    if (0 !== title.indexOf("Infiltrating")) {
        return;
    }

    const btnStart = filterByText(getEl("button"), "Start");
    if (!btnStart) {
        return;
    }

    state.company = title.substr(13);
    state.started = true;
    wrapEventListeners();

    console.log("Start automatic infiltration of", state.company);
    btnStart.click();
}

/**
 * Identify the current infiltration game.
 */
function playGame() {
    const screens = doc.querySelectorAll(".MuiContainer-root");

    if (!screens.length) {
        endInfiltration();
        return;
    }
    if (screens[0].children.length < 3) {
        return;
    }

    const screen = screens[0].children[2];
    const h4 = getEl(screen, "h4");

    if (!h4.length) {
        endInfiltration();
        return;
    }

    const title = h4[0].textContent.trim().toLowerCase().split(/[!.(]/)[0];

    if ("infiltration successful" === title) {
        endInfiltration();
        return;
    }

    if ("get ready" === title) {
        return;
    }

    const game = infiltrationGames.find((game) => game.name === title);

    if (game) {
        if (state.game.current !== title) {
            state.game.current = title;
            game.init(screen);
        }

        game.play(screen);
    } else {
        console.error("Unknown game:", title);
    }
}

/**
 * Wrap all event listeners with a custom function that injects
 * the "isTrusted" flag.
 *
 * Is this cheating? Or is it real hacking? Don't care, as long
 * as it's working :)
 */
function wrapEventListeners() {
    if (!doc._addEventListener) {
        doc._addEventListener = doc.addEventListener;

        doc.addEventListener = function (type, callback, options) {
            if ("undefined" === typeof options) {
                options = false;
            }
            let handler = false;

            // For this script, we only want to modify "keydown" events.
            if ("keydown" === type) {
                handler = function (...args) {
                    if (!args[0].isTrusted) {
                        const hackedEv = {};

                        for (const key in args[0]) {
                            if ("isTrusted" === key) {
                                hackedEv.isTrusted = true;
                            } else if ("function" === typeof args[0][key]) {
                                hackedEv[key] = args[0][key].bind(args[0]);
                            } else {
                                hackedEv[key] = args[0][key];
                            }
                        }

                        args[0] = hackedEv;
                    }

                    return callback.apply(callback, args);
                };

                for (const prop in callback) {
                    if ("function" === typeof callback[prop]) {
                        handler[prop] = callback[prop].bind(callback);
                    } else {
                        handler[prop] = callback[prop];
                    }
                }
            }

            if (!this.eventListeners) {
                this.eventListeners = {};
            }
            if (!this.eventListeners[type]) {
                this.eventListeners[type] = [];
            }
            this.eventListeners[type].push({
                listener: callback,
                useCapture: options,
                wrapped: handler,
            });

            return this._addEventListener(
                type,
                handler ? handler : callback,
                options
            );
        };
    }

    if (!doc._removeEventListener) {
        doc._removeEventListener = doc.removeEventListener;

        doc.removeEventListener = function (type, callback, options) {
            if ("undefined" === typeof options) {
                options = false;
            }

            if (!this.eventListeners) {
                this.eventListeners = {};
            }
            if (!this.eventListeners[type]) {
                this.eventListeners[type] = [];
            }

            for (let i = 0; i < this.eventListeners[type].length; i++) {
                if (
                    this.eventListeners[type][i].listener === callback &&
                    this.eventListeners[type][i].useCapture === options
                ) {
                    if (this.eventListeners[type][i].wrapped) {
                        callback = this.eventListeners[type][i].wrapped;
                    }

                    this.eventListeners[type].splice(i, 1);
                    break;
                }
            }

            if (this.eventListeners[type].length == 0) {
                delete this.eventListeners[type];
            }

            return this._removeEventListener(type, callback, options);
        };
    }
}

/**
 * Revert the "wrapEventListeners" changes.
 */
function unwrapEventListeners() {
    if (doc._addEventListener) {
        doc.addEventListener = doc._addEventListener;
        delete doc._addEventListener;
    }
    if (doc._removeEventListener) {
        doc.removeEventListener = doc._removeEventListener;
        delete doc._removeEventListener;
    }
    delete doc.eventListeners;
}