@ianlucas/cs2-lib 1.0.0

package/dist/keyvalues.d.ts

@@ -0,0 +1 @@
+export declare function CS_parseValveKeyValue<T = any>(data: string): T;

package/dist/keyvalues.js

@@ -0,0 +1,93 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Ian Lucas. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { fail } from "./util.js";
+export function CS_parseValveKeyValue(data) {
+    data = data.replace(/\[[\$!][^\]]+\]/g, "");
+    let index = 0;
+    function skipWhitespace() {
+        while (data[index] && data[index].match(/[\s\t\r\n]/)) {
+            index += 1;
+        }
+        if (data[index] === "/" && data[index + 1] === "/") {
+            while (data[index] && data[index] !== "\n") {
+                index += 1;
+            }
+            skipWhitespace();
+        }
+    }
+    function parseString() {
+        if (data[index] === '"') {
+            index += 1;
+            let value = "";
+            while (data[index] && data[index] !== '"') {
+                while (data[index] && data[index] === "\\") {
+                    index += 1;
+                    value += data[index];
+                    index += 1;
+                }
+                if (data[index] !== '"') {
+                    value += data[index];
+                    index += 1;
+                }
+            }
+            if (data[index] !== '"') {
+                fail("Bad end of string.");
+            }
+            index += 1;
+            return value;
+        }
+        return "";
+    }
+    function parseValue() {
+        if (data[index] === '"') {
+            return parseString();
+        }
+        if (data[index] === "{") {
+            index += 1;
+            return parsePairs();
+        }
+        if (data[index] === "}") {
+            return "";
+        }
+        console.log(data.substring(Math.max(0, index - 64), index) +
+            data[index] +
+            data.substring(index + 1, Math.min(data.length, index + 63)));
+        console.log("".padStart(64, " ") + "^");
+        fail(`Unexpected character at index ${index}.`);
+    }
+    function parsePairs() {
+        const pairs = [];
+        while (data[index]) {
+            if (data[index] === "}") {
+                index += 1;
+                return pairs;
+            }
+            skipWhitespace();
+            const key = parseString();
+            skipWhitespace();
+            const value = parseValue();
+            skipWhitespace();
+            pairs.push([key, value]);
+        }
+        return pairs;
+    }
+    function walk(context, pairs) {
+        return pairs.reduce((object, pair) => {
+            const [key, value] = pair;
+            if (object[key] && !Array.isArray(object[key])) {
+                object[key] = [object[key]];
+            }
+            const newValue = typeof value === "string" ? value : walk({}, value);
+            if (Array.isArray(object[key])) {
+                object[key].push(newValue);
+            }
+            else {
+                object[key] = newValue;
+            }
+            return object;
+        }, context);
+    }
+    return walk({}, parsePairs());
+}

package/dist/maps.d.ts

@@ -0,0 +1,20 @@
+export interface CS_Map {
+    mapname: string;
+    name: string;
+    image: string;
+}
+export declare const CS_ANCIENT_MAP: CS_Map;
+export declare const CS_ANUBIS_MAP: CS_Map;
+export declare const CS_INFERNO_MAP: CS_Map;
+export declare const CS_MIRAGE_MAP: CS_Map;
+export declare const CS_DUST2_MAP: CS_Map;
+export declare const CS_NUKE_MAP: CS_Map;
+export declare const CS_OVERPASS_MAP: CS_Map;
+export declare const CS_VERTIGO_MAP: CS_Map;
+export declare const CS_TRAIN_MAP: CS_Map;
+export declare const CS_OLD_CBBLE_MAP: CS_Map;
+export declare const CS_OLD_CACHE_MAP: CS_Map;
+export declare const CS_ACTIVE_MAP_POOL: CS_Map[];
+export declare const CS_ALL_MAPS: CS_Map[];
+export declare function CS_getChangeLevelCommand(map: CS_Map | string): string;
+export declare function CS_getMapnameName(mapname: string): string;

package/dist/maps.js

@@ -0,0 +1,88 @@
+export const CS_ANCIENT_MAP = {
+    mapname: "de_ancient",
+    name: "Ancient",
+    image: "/de_ancient.jpg"
+};
+export const CS_ANUBIS_MAP = {
+    mapname: "de_anubis",
+    name: "Anubis",
+    image: "/de_anubis.jpg"
+};
+export const CS_INFERNO_MAP = {
+    mapname: "de_inferno",
+    name: "Inferno",
+    image: "/de_inferno.jpg"
+};
+export const CS_MIRAGE_MAP = {
+    mapname: "de_mirage",
+    name: "Mirage",
+    image: "/de_mirage.jpg"
+};
+export const CS_DUST2_MAP = {
+    mapname: "de_dust2",
+    name: "Dust 2",
+    image: "/de_dust2.jpg"
+};
+export const CS_NUKE_MAP = {
+    mapname: "de_nuke",
+    name: "Nuke",
+    image: "/de_nuke.jpg"
+};
+export const CS_OVERPASS_MAP = {
+    mapname: "de_overpass",
+    name: "Overpass",
+    image: "/de_overpass.jpg"
+};
+export const CS_VERTIGO_MAP = {
+    mapname: "de_vertigo",
+    name: "Vertigo",
+    image: "/de_vertigo.jpg"
+};
+export const CS_TRAIN_MAP = {
+    mapname: "de_train",
+    name: "Train",
+    image: "/de_train.jpg"
+};
+export const CS_OLD_CBBLE_MAP = {
+    mapname: "workshop/855577410/de_cbble",
+    name: "Cobblestone",
+    image: "/855577410_de_cbble.jpg"
+};
+export const CS_OLD_CACHE_MAP = {
+    mapname: "workshop/951327114/de_cache",
+    name: "Cache",
+    image: "/951327114_de_cache.jpg"
+};
+export const CS_ACTIVE_MAP_POOL = [
+    CS_ANCIENT_MAP,
+    CS_ANUBIS_MAP,
+    CS_INFERNO_MAP,
+    CS_MIRAGE_MAP,
+    CS_NUKE_MAP,
+    CS_OVERPASS_MAP,
+    CS_VERTIGO_MAP
+];
+export const CS_ALL_MAPS = [
+    CS_ANCIENT_MAP,
+    CS_ANUBIS_MAP,
+    CS_DUST2_MAP,
+    CS_INFERNO_MAP,
+    CS_MIRAGE_MAP,
+    CS_NUKE_MAP,
+    CS_TRAIN_MAP,
+    CS_OLD_CACHE_MAP,
+    CS_OLD_CBBLE_MAP,
+    CS_OVERPASS_MAP,
+    CS_VERTIGO_MAP
+];
+export function CS_getChangeLevelCommand(map) {
+    const mapstring = typeof map === "string" ? map : map.mapname;
+    const matches = mapstring.match(/workshop\/(\d+)\/[\w_]+/);
+    if (matches) {
+        return `host_workshop_map ${matches[1]}`;
+    }
+    return `changelevel ${mapstring}`;
+}
+export function CS_getMapnameName(mapname) {
+    return CS_ALL_MAPS.find((map) => map.mapname.includes(mapname))?.name ?? "undefined";
+}

package/dist/teams.d.ts

@@ -0,0 +1,6 @@
+export type CS_Team = 0 | 2 | 3;
+export declare const CS_TEAM_NONE: CS_Team;
+export declare const CS_TEAM_T: CS_Team;
+export declare const CS_TEAM_CT: CS_Team;
+export declare function CS_toggleTeam(team: CS_Team): CS_Team;
+export declare function CS_getTeamLabel(team: CS_Team): string;

package/dist/teams.js

@@ -0,0 +1,13 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Ian Lucas. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+export const CS_TEAM_NONE = 0;
+export const CS_TEAM_T = 2;
+export const CS_TEAM_CT = 3;
+export function CS_toggleTeam(team) {
+    return team === CS_TEAM_CT ? CS_TEAM_T : CS_TEAM_CT;
+}
+export function CS_getTeamLabel(team) {
+    return team === CS_TEAM_CT ? "ct" : "t";
+}

package/dist/util.d.ts

@@ -0,0 +1,5 @@
+import invariant from "tiny-invariant";
+export declare function compare<T, U>(var1: T, var2: U): boolean;
+export declare function float(literal: number, fractionDigits?: number): number;
+export declare const assert: typeof invariant;
+export declare function fail(message: string): never;

package/dist/util.js

@@ -0,0 +1,15 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Ian Lucas. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import invariant from "tiny-invariant";
+export function compare(var1, var2) {
+    return var1 === undefined || var1 === (typeof var1 === "boolean" ? var2 || false : var2);
+}
+export function float(literal, fractionDigits = 2) {
+    return parseFloat(literal.toFixed(fractionDigits));
+}
+export const assert = invariant;
+export function fail(message) {
+    throw new Error(message);
+}

package/dist/veto.d.ts

@@ -0,0 +1,26 @@
+import { CS_Map } from "./maps.js";
+export declare const CS_VETO_AVAILABLE = 0;
+export declare const CS_VETO_PICK = 1;
+export declare const CS_VETO_BAN = 2;
+export type CS_VetoValue = 0 | 1 | 2;
+export type CS_VetoType = "bo1" | "bo3" | "bo5" | "custom";
+export interface CS_VetoMap {
+    mapname: string;
+    value: CS_VetoValue;
+    team?: number;
+}
+export declare class CS_Veto {
+    private maps;
+    private actions;
+    private pickedMaps;
+    constructor(type: CS_VetoType, maps: CS_Map[], actions?: CS_VetoValue[]);
+    private getAvailableMaps;
+    private getMap;
+    private getAvailableMapnames;
+    getCurrentTeam(): number;
+    choose(mapname?: string): boolean;
+    random(): boolean;
+    getState(): CS_VetoMap[];
+    getMaps(): string[];
+    done(): boolean;
+}

package/dist/veto.js

@@ -0,0 +1,111 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Ian Lucas. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+import { assert, fail } from "./util.js";
+export const CS_VETO_AVAILABLE = 0;
+export const CS_VETO_PICK = 1;
+export const CS_VETO_BAN = 2;
+export class CS_Veto {
+    maps;
+    actions;
+    pickedMaps = [];
+    constructor(type, maps, actions) {
+        if (type !== "custom" && actions !== undefined) {
+            console.warn('stack provided, but the type is not "custom".');
+        }
+        if (type === "custom" && actions === undefined) {
+            fail("provide the stack for the custom type.");
+        }
+        if (maps.length !== 7) {
+            fail("you need to provide 7 maps to veto.");
+        }
+        if (actions !== undefined && actions.length !== 6) {
+            fail("you need to provide 6 actions to veto.");
+        }
+        this.maps = maps.map((map) => ({
+            mapname: map.mapname,
+            value: CS_VETO_AVAILABLE
+        }));
+        switch (type) {
+            case "bo1":
+                this.actions = [CS_VETO_BAN, CS_VETO_BAN, CS_VETO_BAN, CS_VETO_BAN, CS_VETO_BAN, CS_VETO_BAN];
+                break;
+            case "bo3":
+                this.actions = [CS_VETO_BAN, CS_VETO_BAN, CS_VETO_PICK, CS_VETO_PICK, CS_VETO_BAN, CS_VETO_BAN];
+                break;
+            case "bo5":
+                this.actions = [CS_VETO_BAN, CS_VETO_BAN, CS_VETO_PICK, CS_VETO_PICK, CS_VETO_PICK, CS_VETO_PICK];
+                break;
+            case "custom":
+                this.actions = actions;
+                break;
+        }
+    }
+    getAvailableMaps() {
+        return this.maps.filter((map) => map.value === CS_VETO_AVAILABLE);
+    }
+    getMap(mapname) {
+        return this.maps.find((map) => map.mapname === mapname);
+    }
+    getAvailableMapnames() {
+        return this.getAvailableMaps().map((map) => map.mapname);
+    }
+    getCurrentTeam() {
+        return this.actions.length % 2;
+    }
+    choose(mapname) {
+        if (this.actions.length === 0) {
+            return false;
+        }
+        if (mapname === undefined) {
+            return this.random();
+        }
+        const map = this.getMap(mapname);
+        if (map === undefined || map.value !== CS_VETO_AVAILABLE) {
+            return false;
+        }
+        const team = this.getCurrentTeam();
+        const value = this.actions.shift();
+        if (value === undefined) {
+            return false;
+        }
+        if (value === CS_VETO_PICK) {
+            this.pickedMaps.push(mapname);
+        }
+        this.maps = this.maps.map((map) => {
+            if (map.mapname !== mapname) {
+                return map;
+            }
+            return {
+                ...map,
+                value,
+                team
+            };
+        });
+        return true;
+    }
+    random() {
+        const available = this.getAvailableMapnames();
+        if (!available.length) {
+            return false;
+        }
+        const index = Math.floor(Math.random() * available.length);
+        const mapname = available[index];
+        assert(mapname, "Unable to get random mapname.");
+        return this.choose(mapname);
+    }
+    getState() {
+        return this.maps;
+    }
+    getMaps() {
+        if (this.actions.length > 0) {
+            return this.pickedMaps;
+        }
+        const available = this.getAvailableMapnames();
+        return [...this.pickedMaps, ...available];
+    }
+    done() {
+        return this.actions.length === 0;
+    }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "@ianlucas/cs2-lib",
+    "version": "1.0.0",
+    "description": "A TypeScript library for manipulating Counter-Strike 2 data",
+    "license": "MIT",
+    "author": "Ian Lucas",
+    "repository": "ianlucas/cslib",
+    "type": "module",
+    "main": "dist/index.js",
+    "scripts": {
+        "format": "prettier . --write",
+        "prepack": "([ -d dist ] && rm -rf dist); tsc",
+        "test": "jest",
+        "case-scraper": "tsx scripts/case-scraper.ts",
+        "item-generator": "tsx scripts/item-generator.ts > generate-log.txt",
+        "non-legacy-paint-scraper": "tsx scripts/non-legacy-paints-scraper.ts",
+        "tint-graffiti-image-scraper": "tsx scripts/tint-graffiti-image-scraper.ts",
+        "tint-graffiti-name-generator": "tsx scripts/tint-graffiti-name-generator.ts",
+        "upgrade": "npx npm-check-updates@latest --target minor -u"
+    },
+    "devDependencies": {
+        "@types/jest": "^29.5.12",
+        "@types/node": "^18.19.30",
+        "@types/node-fetch": "^2.6.11",
+        "cheerio": "^1.0.0-rc.12",
+        "dotenv": "^16.4.5",
+        "html-entities": "^2.5.2",
+        "jest": "^29.7.0",
+        "node-fetch": "^2.7.0",
+        "prettier": "3.2.5",
+        "ts-jest": "^29.1.2",
+        "tsx": "^4.7.2",
+        "typescript": "^5.4.4"
+    },
+    "dependencies": {
+        "tiny-invariant": "^1.3.3"
+    }
+}