cs2-protobuf 1.0.1

package/.dist/generated/fatdemo.js

@@ -0,0 +1,919 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.8
+//   protoc               v4.25.9
+// source: fatdemo.proto
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { CMsgQAngle, CMsgVector } from "./networkbasetypes.js";
+export var EHitGroup;
+(function (EHitGroup) {
+    EHitGroup[EHitGroup["EHG_Generic"] = 0] = "EHG_Generic";
+    EHitGroup[EHitGroup["EHG_Head"] = 1] = "EHG_Head";
+    EHitGroup[EHitGroup["EHG_Chest"] = 2] = "EHG_Chest";
+    EHitGroup[EHitGroup["EHG_Stomach"] = 3] = "EHG_Stomach";
+    EHitGroup[EHitGroup["EHG_LeftArm"] = 4] = "EHG_LeftArm";
+    EHitGroup[EHitGroup["EHG_RightArm"] = 5] = "EHG_RightArm";
+    EHitGroup[EHitGroup["EHG_LeftLeg"] = 6] = "EHG_LeftLeg";
+    EHitGroup[EHitGroup["EHG_RightLeg"] = 7] = "EHG_RightLeg";
+    EHitGroup[EHitGroup["EHG_Gear"] = 8] = "EHG_Gear";
+    EHitGroup[EHitGroup["EHG_Miss"] = 9] = "EHG_Miss";
+    EHitGroup[EHitGroup["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(EHitGroup || (EHitGroup = {}));
+export var ETeam;
+(function (ETeam) {
+    ETeam[ETeam["ET_Unknown"] = 0] = "ET_Unknown";
+    ETeam[ETeam["ET_Spectator"] = 1] = "ET_Spectator";
+    ETeam[ETeam["ET_Terrorist"] = 2] = "ET_Terrorist";
+    ETeam[ETeam["ET_CT"] = 3] = "ET_CT";
+    ETeam[ETeam["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ETeam || (ETeam = {}));
+export var EWeaponType;
+(function (EWeaponType) {
+    EWeaponType[EWeaponType["EWT_Knife"] = 0] = "EWT_Knife";
+    EWeaponType[EWeaponType["EWT_Pistol"] = 1] = "EWT_Pistol";
+    EWeaponType[EWeaponType["EWT_SubMachineGun"] = 2] = "EWT_SubMachineGun";
+    EWeaponType[EWeaponType["EWT_Rifle"] = 3] = "EWT_Rifle";
+    EWeaponType[EWeaponType["EWT_Shotgun"] = 4] = "EWT_Shotgun";
+    EWeaponType[EWeaponType["EWT_SniperRifle"] = 5] = "EWT_SniperRifle";
+    EWeaponType[EWeaponType["EWT_MachineGun"] = 6] = "EWT_MachineGun";
+    EWeaponType[EWeaponType["EWT_C4"] = 7] = "EWT_C4";
+    EWeaponType[EWeaponType["EWT_Grenade"] = 8] = "EWT_Grenade";
+    EWeaponType[EWeaponType["EWT_Equipment"] = 9] = "EWT_Equipment";
+    EWeaponType[EWeaponType["EWT_StackableItem"] = 10] = "EWT_StackableItem";
+    EWeaponType[EWeaponType["EWT_Unknown"] = 11] = "EWT_Unknown";
+    EWeaponType[EWeaponType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(EWeaponType || (EWeaponType = {}));
+function createBaseMLDict() {
+    return { key: "", valString: "", valInt: 0, valFloat: 0 };
+}
+export const MLDict = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== undefined && message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.valString !== undefined && message.valString !== "") {
+            writer.uint32(18).string(message.valString);
+        }
+        if (message.valInt !== undefined && message.valInt !== 0) {
+            writer.uint32(24).int32(message.valInt);
+        }
+        if (message.valFloat !== undefined && message.valFloat !== 0) {
+            writer.uint32(37).float(message.valFloat);
+        }
+        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 = createBaseMLDict();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.key = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.valString = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.valInt = reader.int32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 37) {
+                        break;
+                    }
+                    message.valFloat = reader.float();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseMLEvent() {
+    return { eventName: "", data: [] };
+}
+export const MLEvent = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.eventName !== undefined && message.eventName !== "") {
+            writer.uint32(10).string(message.eventName);
+        }
+        for (const v of message.data) {
+            MLDict.encode(v, writer.uint32(18).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 = createBaseMLEvent();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.eventName = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.data.push(MLDict.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseMLMatchState() {
+    return { gameMode: "", phase: "", round: 0, scoreCt: 0, scoreT: 0 };
+}
+export const MLMatchState = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.gameMode !== undefined && message.gameMode !== "") {
+            writer.uint32(10).string(message.gameMode);
+        }
+        if (message.phase !== undefined && message.phase !== "") {
+            writer.uint32(18).string(message.phase);
+        }
+        if (message.round !== undefined && message.round !== 0) {
+            writer.uint32(24).int32(message.round);
+        }
+        if (message.scoreCt !== undefined && message.scoreCt !== 0) {
+            writer.uint32(32).int32(message.scoreCt);
+        }
+        if (message.scoreT !== undefined && message.scoreT !== 0) {
+            writer.uint32(40).int32(message.scoreT);
+        }
+        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 = createBaseMLMatchState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.gameMode = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.phase = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.round = reader.int32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.scoreCt = reader.int32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.scoreT = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseMLRoundState() {
+    return { phase: "", winTeam: 0, bombState: "" };
+}
+export const MLRoundState = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.phase !== undefined && message.phase !== "") {
+            writer.uint32(10).string(message.phase);
+        }
+        if (message.winTeam !== undefined && message.winTeam !== 0) {
+            writer.uint32(16).int32(message.winTeam);
+        }
+        if (message.bombState !== undefined && message.bombState !== "") {
+            writer.uint32(26).string(message.bombState);
+        }
+        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 = createBaseMLRoundState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.phase = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.winTeam = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.bombState = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseMLWeaponState() {
+    return { index: 0, name: "", type: 0, ammoClip: 0, ammoClipMax: 0, ammoReserve: 0, state: "", recoilIndex: 0 };
+}
+export const MLWeaponState = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.index !== undefined && message.index !== 0) {
+            writer.uint32(8).int32(message.index);
+        }
+        if (message.name !== undefined && message.name !== "") {
+            writer.uint32(18).string(message.name);
+        }
+        if (message.type !== undefined && message.type !== 0) {
+            writer.uint32(24).int32(message.type);
+        }
+        if (message.ammoClip !== undefined && message.ammoClip !== 0) {
+            writer.uint32(32).int32(message.ammoClip);
+        }
+        if (message.ammoClipMax !== undefined && message.ammoClipMax !== 0) {
+            writer.uint32(40).int32(message.ammoClipMax);
+        }
+        if (message.ammoReserve !== undefined && message.ammoReserve !== 0) {
+            writer.uint32(48).int32(message.ammoReserve);
+        }
+        if (message.state !== undefined && message.state !== "") {
+            writer.uint32(58).string(message.state);
+        }
+        if (message.recoilIndex !== undefined && message.recoilIndex !== 0) {
+            writer.uint32(69).float(message.recoilIndex);
+        }
+        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 = createBaseMLWeaponState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.index = reader.int32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.type = reader.int32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.ammoClip = reader.int32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.ammoClipMax = reader.int32();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.ammoReserve = reader.int32();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.state = reader.string();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 69) {
+                        break;
+                    }
+                    message.recoilIndex = reader.float();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseMLPlayerState() {
+    return {
+        accountId: 0,
+        playerSlot: -1,
+        entindex: 0,
+        name: "",
+        clan: "",
+        team: 0,
+        abspos: undefined,
+        eyeangle: undefined,
+        eyeangleFwd: undefined,
+        health: 0,
+        armor: 0,
+        flashed: 0,
+        smoked: 0,
+        money: 0,
+        roundKills: 0,
+        roundKillhs: 0,
+        burning: 0,
+        helmet: false,
+        defuseKit: false,
+        weapons: [],
+    };
+}
+export const MLPlayerState = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.accountId !== undefined && message.accountId !== 0) {
+            writer.uint32(8).int32(message.accountId);
+        }
+        if (message.playerSlot !== undefined && message.playerSlot !== -1) {
+            writer.uint32(16).int32(message.playerSlot);
+        }
+        if (message.entindex !== undefined && message.entindex !== 0) {
+            writer.uint32(24).int32(message.entindex);
+        }
+        if (message.name !== undefined && message.name !== "") {
+            writer.uint32(34).string(message.name);
+        }
+        if (message.clan !== undefined && message.clan !== "") {
+            writer.uint32(42).string(message.clan);
+        }
+        if (message.team !== undefined && message.team !== 0) {
+            writer.uint32(48).int32(message.team);
+        }
+        if (message.abspos !== undefined) {
+            CMsgVector.encode(message.abspos, writer.uint32(58).fork()).join();
+        }
+        if (message.eyeangle !== undefined) {
+            CMsgQAngle.encode(message.eyeangle, writer.uint32(66).fork()).join();
+        }
+        if (message.eyeangleFwd !== undefined) {
+            CMsgVector.encode(message.eyeangleFwd, writer.uint32(74).fork()).join();
+        }
+        if (message.health !== undefined && message.health !== 0) {
+            writer.uint32(80).int32(message.health);
+        }
+        if (message.armor !== undefined && message.armor !== 0) {
+            writer.uint32(88).int32(message.armor);
+        }
+        if (message.flashed !== undefined && message.flashed !== 0) {
+            writer.uint32(101).float(message.flashed);
+        }
+        if (message.smoked !== undefined && message.smoked !== 0) {
+            writer.uint32(109).float(message.smoked);
+        }
+        if (message.money !== undefined && message.money !== 0) {
+            writer.uint32(112).int32(message.money);
+        }
+        if (message.roundKills !== undefined && message.roundKills !== 0) {
+            writer.uint32(120).int32(message.roundKills);
+        }
+        if (message.roundKillhs !== undefined && message.roundKillhs !== 0) {
+            writer.uint32(128).int32(message.roundKillhs);
+        }
+        if (message.burning !== undefined && message.burning !== 0) {
+            writer.uint32(141).float(message.burning);
+        }
+        if (message.helmet !== undefined && message.helmet !== false) {
+            writer.uint32(144).bool(message.helmet);
+        }
+        if (message.defuseKit !== undefined && message.defuseKit !== false) {
+            writer.uint32(152).bool(message.defuseKit);
+        }
+        for (const v of message.weapons) {
+            MLWeaponState.encode(v, writer.uint32(162).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 = createBaseMLPlayerState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.accountId = reader.int32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.playerSlot = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.entindex = reader.int32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.name = reader.string();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.clan = reader.string();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.team = reader.int32();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 58) {
+                        break;
+                    }
+                    message.abspos = CMsgVector.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 66) {
+                        break;
+                    }
+                    message.eyeangle = CMsgQAngle.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 9: {
+                    if (tag !== 74) {
+                        break;
+                    }
+                    message.eyeangleFwd = CMsgVector.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 10: {
+                    if (tag !== 80) {
+                        break;
+                    }
+                    message.health = reader.int32();
+                    continue;
+                }
+                case 11: {
+                    if (tag !== 88) {
+                        break;
+                    }
+                    message.armor = reader.int32();
+                    continue;
+                }
+                case 12: {
+                    if (tag !== 101) {
+                        break;
+                    }
+                    message.flashed = reader.float();
+                    continue;
+                }
+                case 13: {
+                    if (tag !== 109) {
+                        break;
+                    }
+                    message.smoked = reader.float();
+                    continue;
+                }
+                case 14: {
+                    if (tag !== 112) {
+                        break;
+                    }
+                    message.money = reader.int32();
+                    continue;
+                }
+                case 15: {
+                    if (tag !== 120) {
+                        break;
+                    }
+                    message.roundKills = reader.int32();
+                    continue;
+                }
+                case 16: {
+                    if (tag !== 128) {
+                        break;
+                    }
+                    message.roundKillhs = reader.int32();
+                    continue;
+                }
+                case 17: {
+                    if (tag !== 141) {
+                        break;
+                    }
+                    message.burning = reader.float();
+                    continue;
+                }
+                case 18: {
+                    if (tag !== 144) {
+                        break;
+                    }
+                    message.helmet = reader.bool();
+                    continue;
+                }
+                case 19: {
+                    if (tag !== 152) {
+                        break;
+                    }
+                    message.defuseKit = reader.bool();
+                    continue;
+                }
+                case 20: {
+                    if (tag !== 162) {
+                        break;
+                    }
+                    message.weapons.push(MLWeaponState.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseMLGameState() {
+    return { match: undefined, round: undefined, players: [] };
+}
+export const MLGameState = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.match !== undefined) {
+            MLMatchState.encode(message.match, writer.uint32(10).fork()).join();
+        }
+        if (message.round !== undefined) {
+            MLRoundState.encode(message.round, writer.uint32(18).fork()).join();
+        }
+        for (const v of message.players) {
+            MLPlayerState.encode(v, writer.uint32(26).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 = createBaseMLGameState();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.match = MLMatchState.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.round = MLRoundState.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.players.push(MLPlayerState.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseMLDemoHeader() {
+    return { mapName: "", tickRate: 0, version: 0, steamUniverse: 0 };
+}
+export const MLDemoHeader = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.mapName !== undefined && message.mapName !== "") {
+            writer.uint32(10).string(message.mapName);
+        }
+        if (message.tickRate !== undefined && message.tickRate !== 0) {
+            writer.uint32(16).int32(message.tickRate);
+        }
+        if (message.version !== undefined && message.version !== 0) {
+            writer.uint32(24).uint32(message.version);
+        }
+        if (message.steamUniverse !== undefined && message.steamUniverse !== 0) {
+            writer.uint32(32).uint32(message.steamUniverse);
+        }
+        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 = createBaseMLDemoHeader();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.mapName = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.tickRate = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.version = reader.uint32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.steamUniverse = reader.uint32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseMLTick() {
+    return { tickCount: 0, state: undefined, events: [] };
+}
+export const MLTick = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.tickCount !== undefined && message.tickCount !== 0) {
+            writer.uint32(8).int32(message.tickCount);
+        }
+        if (message.state !== undefined) {
+            MLGameState.encode(message.state, writer.uint32(18).fork()).join();
+        }
+        for (const v of message.events) {
+            MLEvent.encode(v, writer.uint32(26).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 = createBaseMLTick();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.tickCount = reader.int32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.state = MLGameState.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.events.push(MLEvent.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseVacNetShot() {
+    return {
+        steamidPlayer: 0,
+        roundNumber: 0,
+        hitType: 0,
+        weaponType: 0,
+        distanceToHurtTarget: 0,
+        deltaYawWindow: [],
+        deltaPitchWindow: [],
+    };
+}
+export const VacNetShot = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.steamidPlayer !== undefined && message.steamidPlayer !== 0) {
+            writer.uint32(9).fixed64(message.steamidPlayer);
+        }
+        if (message.roundNumber !== undefined && message.roundNumber !== 0) {
+            writer.uint32(16).int32(message.roundNumber);
+        }
+        if (message.hitType !== undefined && message.hitType !== 0) {
+            writer.uint32(24).int32(message.hitType);
+        }
+        if (message.weaponType !== undefined && message.weaponType !== 0) {
+            writer.uint32(32).int32(message.weaponType);
+        }
+        if (message.distanceToHurtTarget !== undefined && message.distanceToHurtTarget !== 0) {
+            writer.uint32(45).float(message.distanceToHurtTarget);
+        }
+        for (const v of message.deltaYawWindow) {
+            writer.uint32(53).float(v);
+        }
+        for (const v of message.deltaPitchWindow) {
+            writer.uint32(61).float(v);
+        }
+        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 = createBaseVacNetShot();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 9) {
+                        break;
+                    }
+                    message.steamidPlayer = longToNumber(reader.fixed64());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.roundNumber = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.hitType = reader.int32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.weaponType = reader.int32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 45) {
+                        break;
+                    }
+                    message.distanceToHurtTarget = reader.float();
+                    continue;
+                }
+                case 6: {
+                    if (tag === 53) {
+                        message.deltaYawWindow.push(reader.float());
+                        continue;
+                    }
+                    if (tag === 50) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.deltaYawWindow.push(reader.float());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+                case 7: {
+                    if (tag === 61) {
+                        message.deltaPitchWindow.push(reader.float());
+                        continue;
+                    }
+                    if (tag === 58) {
+                        const end2 = reader.uint32() + reader.pos;
+                        while (reader.pos < end2) {
+                            message.deltaPitchWindow.push(reader.float());
+                        }
+                        continue;
+                    }
+                    break;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function longToNumber(int64) {
+    const num = globalThis.Number(int64.toString());
+    if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+    }
+    if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+        throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+    }
+    return num;
+}