cs2-protobuf 1.0.1

package/.dist/generated/connectionless_netmessages.wrapper.d.ts

@@ -0,0 +1,14 @@
+export * from "./connectionless_netmessages.js";
+import * as GeneratedTypescript from "./connectionless_netmessages.js";
+export declare const C2SCONNECTSameProcessCheck: {
+    encode(message: GeneratedTypescript.C2SCONNECTSameProcessCheck): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.C2SCONNECTSameProcessCheck;
+};
+export declare const C2SCONNECTMessage: {
+    encode(message: GeneratedTypescript.C2SCONNECTMessage): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.C2SCONNECTMessage;
+};
+export declare const C2SCONNECTIONMessage: {
+    encode(message: GeneratedTypescript.C2SCONNECTIONMessage): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.C2SCONNECTIONMessage;
+};

package/.dist/generated/connectionless_netmessages.wrapper.js

@@ -0,0 +1,31 @@
+// Code generated by cs2-protobuf. DO NOT EDIT.
+// versions:
+//   cs2-protobuf  1.0.1
+// source: connectionless_netmessages.ts
+/* eslint-disable */
+export * from "./connectionless_netmessages.js";
+import * as GeneratedTypescript from "./connectionless_netmessages.js";
+export const C2SCONNECTSameProcessCheck = {
+    encode(message) {
+        return GeneratedTypescript.C2SCONNECTSameProcessCheck.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.C2SCONNECTSameProcessCheck.decode(input);
+    },
+};
+export const C2SCONNECTMessage = {
+    encode(message) {
+        return GeneratedTypescript.C2SCONNECTMessage.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.C2SCONNECTMessage.decode(input);
+    },
+};
+export const C2SCONNECTIONMessage = {
+    encode(message) {
+        return GeneratedTypescript.C2SCONNECTIONMessage.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.C2SCONNECTIONMessage.decode(input);
+    },
+};

package/.dist/generated/cs_gameevents.d.ts

@@ -0,0 +1,68 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { CMsgQAngle, CMsgVector } from "./networkbasetypes.js";
+export declare enum ECsgoGameEvents {
+    GE_PlayerAnimEventId = 450,
+    GE_RadioIconEventId = 451,
+    GE_FireBulletsId = 452,
+    GE_PlayerBulletHitId = 453,
+    UNRECOGNIZED = -1
+}
+export interface CMsgTEPlayerAnimEvent {
+    player?: number | undefined;
+    event?: number | undefined;
+    data?: number | undefined;
+}
+export interface CMsgTERadioIcon {
+    player?: number | undefined;
+}
+export interface CMsgTEFireBullets {
+    origin?: CMsgVector | undefined;
+    angles?: CMsgQAngle | undefined;
+    weaponId?: number | undefined;
+    mode?: number | undefined;
+    seed?: number | undefined;
+    player?: number | undefined;
+    inaccuracy?: number | undefined;
+    recoilIndex?: number | undefined;
+    spread?: number | undefined;
+    soundType?: number | undefined;
+    itemDefIndex?: number | undefined;
+    soundDspEffect?: number | undefined;
+    entOrigin?: CMsgVector | undefined;
+    numBulletsRemaining?: number | undefined;
+    attackType?: number | undefined;
+    playerInair?: boolean | undefined;
+    playerScoped?: boolean | undefined;
+    tick?: number | undefined;
+    extra?: CMsgTEFireBullets_Extra | undefined;
+}
+export interface CMsgTEFireBullets_Extra {
+    aimPunch?: CMsgQAngle | undefined;
+    attackTickCount?: number | undefined;
+    attackTickFrac?: number | undefined;
+    renderTickCount?: number | undefined;
+    renderTickFrac?: number | undefined;
+    inaccuracyMove?: number | undefined;
+    inaccuracyAir?: number | undefined;
+    type?: number | undefined;
+}
+export interface CMsgPlayerBulletHit {
+    attackerSlot?: number | undefined;
+    victimSlot?: number | undefined;
+    victimPos?: CMsgVector | undefined;
+    hitGroup?: number | undefined;
+    damage?: number | undefined;
+    penetrationCount?: number | undefined;
+    isKill?: boolean | undefined;
+    throughSmoke?: boolean | undefined;
+}
+export declare const CMsgTEPlayerAnimEvent: MessageFns<CMsgTEPlayerAnimEvent>;
+export declare const CMsgTERadioIcon: MessageFns<CMsgTERadioIcon>;
+export declare const CMsgTEFireBullets: MessageFns<CMsgTEFireBullets>;
+export declare const CMsgTEFireBullets_Extra: MessageFns<CMsgTEFireBullets_Extra>;
+export declare const CMsgPlayerBulletHit: MessageFns<CMsgPlayerBulletHit>;
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}
+export {};

package/.dist/generated/cs_gameevents.js

@@ -0,0 +1,559 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.8
+//   protoc               v4.25.9
+// source: cs_gameevents.proto
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { CMsgQAngle, CMsgVector } from "./networkbasetypes.js";
+export var ECsgoGameEvents;
+(function (ECsgoGameEvents) {
+    ECsgoGameEvents[ECsgoGameEvents["GE_PlayerAnimEventId"] = 450] = "GE_PlayerAnimEventId";
+    ECsgoGameEvents[ECsgoGameEvents["GE_RadioIconEventId"] = 451] = "GE_RadioIconEventId";
+    ECsgoGameEvents[ECsgoGameEvents["GE_FireBulletsId"] = 452] = "GE_FireBulletsId";
+    ECsgoGameEvents[ECsgoGameEvents["GE_PlayerBulletHitId"] = 453] = "GE_PlayerBulletHitId";
+    ECsgoGameEvents[ECsgoGameEvents["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ECsgoGameEvents || (ECsgoGameEvents = {}));
+function createBaseCMsgTEPlayerAnimEvent() {
+    return { player: 16777215, event: 0, data: 0 };
+}
+export const CMsgTEPlayerAnimEvent = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.player !== undefined && message.player !== 16777215) {
+            writer.uint32(13).fixed32(message.player);
+        }
+        if (message.event !== undefined && message.event !== 0) {
+            writer.uint32(16).uint32(message.event);
+        }
+        if (message.data !== undefined && message.data !== 0) {
+            writer.uint32(24).int32(message.data);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCMsgTEPlayerAnimEvent();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 13) {
+                        break;
+                    }
+                    message.player = reader.fixed32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.event = reader.uint32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.data = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCMsgTERadioIcon() {
+    return { player: 16777215 };
+}
+export const CMsgTERadioIcon = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.player !== undefined && message.player !== 16777215) {
+            writer.uint32(13).fixed32(message.player);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCMsgTERadioIcon();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 13) {
+                        break;
+                    }
+                    message.player = reader.fixed32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCMsgTEFireBullets() {
+    return {
+        origin: undefined,
+        angles: undefined,
+        weaponId: 16777215,
+        mode: 0,
+        seed: 0,
+        player: 16777215,
+        inaccuracy: 0,
+        recoilIndex: 0,
+        spread: 0,
+        soundType: 0,
+        itemDefIndex: 0,
+        soundDspEffect: 0,
+        entOrigin: undefined,
+        numBulletsRemaining: 0,
+        attackType: 0,
+        playerInair: false,
+        playerScoped: false,
+        tick: 0,
+        extra: undefined,
+    };
+}
+export const CMsgTEFireBullets = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.origin !== undefined) {
+            CMsgVector.encode(message.origin, writer.uint32(10).fork()).join();
+        }
+        if (message.angles !== undefined) {
+            CMsgQAngle.encode(message.angles, writer.uint32(18).fork()).join();
+        }
+        if (message.weaponId !== undefined && message.weaponId !== 16777215) {
+            writer.uint32(24).uint32(message.weaponId);
+        }
+        if (message.mode !== undefined && message.mode !== 0) {
+            writer.uint32(32).uint32(message.mode);
+        }
+        if (message.seed !== undefined && message.seed !== 0) {
+            writer.uint32(40).uint32(message.seed);
+        }
+        if (message.player !== undefined && message.player !== 16777215) {
+            writer.uint32(53).fixed32(message.player);
+        }
+        if (message.inaccuracy !== undefined && message.inaccuracy !== 0) {
+            writer.uint32(61).float(message.inaccuracy);
+        }
+        if (message.recoilIndex !== undefined && message.recoilIndex !== 0) {
+            writer.uint32(69).float(message.recoilIndex);
+        }
+        if (message.spread !== undefined && message.spread !== 0) {
+            writer.uint32(77).float(message.spread);
+        }
+        if (message.soundType !== undefined && message.soundType !== 0) {
+            writer.uint32(80).int32(message.soundType);
+        }
+        if (message.itemDefIndex !== undefined && message.itemDefIndex !== 0) {
+            writer.uint32(88).uint32(message.itemDefIndex);
+        }
+        if (message.soundDspEffect !== undefined && message.soundDspEffect !== 0) {
+            writer.uint32(101).fixed32(message.soundDspEffect);
+        }
+        if (message.entOrigin !== undefined) {
+            CMsgVector.encode(message.entOrigin, writer.uint32(106).fork()).join();
+        }
+        if (message.numBulletsRemaining !== undefined && message.numBulletsRemaining !== 0) {
+            writer.uint32(112).uint32(message.numBulletsRemaining);
+        }
+        if (message.attackType !== undefined && message.attackType !== 0) {
+            writer.uint32(120).uint32(message.attackType);
+        }
+        if (message.playerInair !== undefined && message.playerInair !== false) {
+            writer.uint32(136).bool(message.playerInair);
+        }
+        if (message.playerScoped !== undefined && message.playerScoped !== false) {
+            writer.uint32(144).bool(message.playerScoped);
+        }
+        if (message.tick !== undefined && message.tick !== 0) {
+            writer.uint32(152).int32(message.tick);
+        }
+        if (message.extra !== undefined) {
+            CMsgTEFireBullets_Extra.encode(message.extra, writer.uint32(130).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCMsgTEFireBullets();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.origin = CMsgVector.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.angles = CMsgQAngle.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.weaponId = reader.uint32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.mode = reader.uint32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.seed = reader.uint32();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 53) {
+                        break;
+                    }
+                    message.player = reader.fixed32();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 61) {
+                        break;
+                    }
+                    message.inaccuracy = reader.float();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 69) {
+                        break;
+                    }
+                    message.recoilIndex = reader.float();
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 77) {
+                        break;
+                    }
+                    message.spread = reader.float();
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 80) {
+                        break;
+                    }
+                    message.soundType = reader.int32();
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 88) {
+                        break;
+                    }
+                    message.itemDefIndex = reader.uint32();
+                    continue;
+                }
+                case 12: {
+                    if (tag !== 101) {
+                        break;
+                    }
+                    message.soundDspEffect = reader.fixed32();
+                    continue;
+                }
+                case 13: {
+                    if (tag !== 106) {
+                        break;
+                    }
+                    message.entOrigin = CMsgVector.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 14: {
+                    if (tag !== 112) {
+                        break;
+                    }
+                    message.numBulletsRemaining = reader.uint32();
+                    continue;
+                }
+                case 15: {
+                    if (tag !== 120) {
+                        break;
+                    }
+                    message.attackType = reader.uint32();
+                    continue;
+                }
+                case 17: {
+                    if (tag !== 136) {
+                        break;
+                    }
+                    message.playerInair = reader.bool();
+                    continue;
+                }
+                case 18: {
+                    if (tag !== 144) {
+                        break;
+                    }
+                    message.playerScoped = reader.bool();
+                    continue;
+                }
+                case 19: {
+                    if (tag !== 152) {
+                        break;
+                    }
+                    message.tick = reader.int32();
+                    continue;
+                }
+                case 16: {
+                    if (tag !== 130) {
+                        break;
+                    }
+                    message.extra = CMsgTEFireBullets_Extra.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCMsgTEFireBullets_Extra() {
+    return {
+        aimPunch: undefined,
+        attackTickCount: 0,
+        attackTickFrac: 0,
+        renderTickCount: 0,
+        renderTickFrac: 0,
+        inaccuracyMove: 0,
+        inaccuracyAir: 0,
+        type: 0,
+    };
+}
+export const CMsgTEFireBullets_Extra = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.aimPunch !== undefined) {
+            CMsgQAngle.encode(message.aimPunch, writer.uint32(10).fork()).join();
+        }
+        if (message.attackTickCount !== undefined && message.attackTickCount !== 0) {
+            writer.uint32(16).int32(message.attackTickCount);
+        }
+        if (message.attackTickFrac !== undefined && message.attackTickFrac !== 0) {
+            writer.uint32(29).float(message.attackTickFrac);
+        }
+        if (message.renderTickCount !== undefined && message.renderTickCount !== 0) {
+            writer.uint32(32).int32(message.renderTickCount);
+        }
+        if (message.renderTickFrac !== undefined && message.renderTickFrac !== 0) {
+            writer.uint32(45).float(message.renderTickFrac);
+        }
+        if (message.inaccuracyMove !== undefined && message.inaccuracyMove !== 0) {
+            writer.uint32(53).float(message.inaccuracyMove);
+        }
+        if (message.inaccuracyAir !== undefined && message.inaccuracyAir !== 0) {
+            writer.uint32(61).float(message.inaccuracyAir);
+        }
+        if (message.type !== undefined && message.type !== 0) {
+            writer.uint32(64).int32(message.type);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCMsgTEFireBullets_Extra();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.aimPunch = CMsgQAngle.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.attackTickCount = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 29) {
+                        break;
+                    }
+                    message.attackTickFrac = reader.float();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.renderTickCount = reader.int32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 45) {
+                        break;
+                    }
+                    message.renderTickFrac = reader.float();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 53) {
+                        break;
+                    }
+                    message.inaccuracyMove = reader.float();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 61) {
+                        break;
+                    }
+                    message.inaccuracyAir = reader.float();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 64) {
+                        break;
+                    }
+                    message.type = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCMsgPlayerBulletHit() {
+    return {
+        attackerSlot: -1,
+        victimSlot: -1,
+        victimPos: undefined,
+        hitGroup: 0,
+        damage: 0,
+        penetrationCount: 0,
+        isKill: false,
+        throughSmoke: false,
+    };
+}
+export const CMsgPlayerBulletHit = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.attackerSlot !== undefined && message.attackerSlot !== -1) {
+            writer.uint32(8).int32(message.attackerSlot);
+        }
+        if (message.victimSlot !== undefined && message.victimSlot !== -1) {
+            writer.uint32(16).int32(message.victimSlot);
+        }
+        if (message.victimPos !== undefined) {
+            CMsgVector.encode(message.victimPos, writer.uint32(26).fork()).join();
+        }
+        if (message.hitGroup !== undefined && message.hitGroup !== 0) {
+            writer.uint32(32).int32(message.hitGroup);
+        }
+        if (message.damage !== undefined && message.damage !== 0) {
+            writer.uint32(40).int32(message.damage);
+        }
+        if (message.penetrationCount !== undefined && message.penetrationCount !== 0) {
+            writer.uint32(48).int32(message.penetrationCount);
+        }
+        if (message.isKill !== undefined && message.isKill !== false) {
+            writer.uint32(56).bool(message.isKill);
+        }
+        if (message.throughSmoke !== undefined && message.throughSmoke !== false) {
+            writer.uint32(64).bool(message.throughSmoke);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseCMsgPlayerBulletHit();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.attackerSlot = reader.int32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.victimSlot = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.victimPos = CMsgVector.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.hitGroup = reader.int32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.damage = reader.int32();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.penetrationCount = reader.int32();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.isKill = reader.bool();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 64) {
+                        break;
+                    }
+                    message.throughSmoke = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};

package/.dist/generated/cs_gameevents.wrapper.d.ts

@@ -0,0 +1,22 @@
+export * from "./cs_gameevents.js";
+import * as GeneratedTypescript from "./cs_gameevents.js";
+export declare const CMsgTEPlayerAnimEvent: {
+    encode(message: GeneratedTypescript.CMsgTEPlayerAnimEvent): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEPlayerAnimEvent;
+};
+export declare const CMsgTERadioIcon: {
+    encode(message: GeneratedTypescript.CMsgTERadioIcon): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTERadioIcon;
+};
+export declare const CMsgTEFireBullets: {
+    encode(message: GeneratedTypescript.CMsgTEFireBullets): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEFireBullets;
+};
+export declare const CMsgTEFireBullets_Extra: {
+    encode(message: GeneratedTypescript.CMsgTEFireBullets_Extra): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgTEFireBullets_Extra;
+};
+export declare const CMsgPlayerBulletHit: {
+    encode(message: GeneratedTypescript.CMsgPlayerBulletHit): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CMsgPlayerBulletHit;
+};