cs2-protobuf 1.0.1

package/.dist/generated/c_peer2peer_netmessages.js

@@ -0,0 +1,405 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.11.8
+//   protoc               v4.25.9
+// source: c_peer2peer_netmessages.proto
+/* eslint-disable */
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { CMsgVoiceAudio } from "./netmessages.js";
+import { CMsgQAngle, CMsgVector } from "./networkbasetypes.js";
+export var P2PMessages;
+(function (P2PMessages) {
+    P2PMessages[P2PMessages["p2p_TextMessage"] = 256] = "p2p_TextMessage";
+    P2PMessages[P2PMessages["p2p_Voice"] = 257] = "p2p_Voice";
+    P2PMessages[P2PMessages["p2p_Ping"] = 258] = "p2p_Ping";
+    P2PMessages[P2PMessages["p2p_VRAvatarPosition"] = 259] = "p2p_VRAvatarPosition";
+    P2PMessages[P2PMessages["p2p_WatchSynchronization"] = 260] = "p2p_WatchSynchronization";
+    P2PMessages[P2PMessages["p2p_FightingGame_GameData"] = 261] = "p2p_FightingGame_GameData";
+    P2PMessages[P2PMessages["p2p_FightingGame_Connection"] = 262] = "p2p_FightingGame_Connection";
+    P2PMessages[P2PMessages["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(P2PMessages || (P2PMessages = {}));
+export var CP2PVoice_HandlerFlags;
+(function (CP2PVoice_HandlerFlags) {
+    CP2PVoice_HandlerFlags[CP2PVoice_HandlerFlags["Played_Audio"] = 1] = "Played_Audio";
+    CP2PVoice_HandlerFlags[CP2PVoice_HandlerFlags["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(CP2PVoice_HandlerFlags || (CP2PVoice_HandlerFlags = {}));
+function createBaseCP2PTextMessage() {
+    return { text: new Uint8Array(0) };
+}
+export const CP2PTextMessage = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.text !== undefined && message.text.length !== 0) {
+            writer.uint32(10).bytes(message.text);
+        }
+        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 = createBaseCP2PTextMessage();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.text = reader.bytes();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCSteamVoiceEncoding() {
+    return { voiceData: new Uint8Array(0) };
+}
+export const CSteamVoiceEncoding = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.voiceData !== undefined && message.voiceData.length !== 0) {
+            writer.uint32(10).bytes(message.voiceData);
+        }
+        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 = createBaseCSteamVoiceEncoding();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.voiceData = reader.bytes();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCP2PVoice() {
+    return { audio: undefined, broadcastGroup: 0 };
+}
+export const CP2PVoice = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.audio !== undefined) {
+            CMsgVoiceAudio.encode(message.audio, writer.uint32(10).fork()).join();
+        }
+        if (message.broadcastGroup !== undefined && message.broadcastGroup !== 0) {
+            writer.uint32(16).uint32(message.broadcastGroup);
+        }
+        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 = createBaseCP2PVoice();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.audio = CMsgVoiceAudio.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.broadcastGroup = reader.uint32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCP2PPing() {
+    return { sendTime: 0, isReply: false };
+}
+export const CP2PPing = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.sendTime !== undefined && message.sendTime !== 0) {
+            writer.uint32(8).uint64(message.sendTime);
+        }
+        if (message.isReply !== undefined && message.isReply !== false) {
+            writer.uint32(16).bool(message.isReply);
+        }
+        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 = createBaseCP2PPing();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.sendTime = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.isReply = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCP2PVRAvatarPosition() {
+    return { bodyParts: [], hatId: 0, sceneId: 0, worldScale: 0 };
+}
+export const CP2PVRAvatarPosition = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.bodyParts) {
+            CP2PVRAvatarPosition_COrientation.encode(v, writer.uint32(10).fork()).join();
+        }
+        if (message.hatId !== undefined && message.hatId !== 0) {
+            writer.uint32(16).int32(message.hatId);
+        }
+        if (message.sceneId !== undefined && message.sceneId !== 0) {
+            writer.uint32(24).int32(message.sceneId);
+        }
+        if (message.worldScale !== undefined && message.worldScale !== 0) {
+            writer.uint32(32).int32(message.worldScale);
+        }
+        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 = createBaseCP2PVRAvatarPosition();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.bodyParts.push(CP2PVRAvatarPosition_COrientation.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.hatId = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.sceneId = reader.int32();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.worldScale = reader.int32();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCP2PVRAvatarPosition_COrientation() {
+    return { pos: undefined, ang: undefined };
+}
+export const CP2PVRAvatarPosition_COrientation = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.pos !== undefined) {
+            CMsgVector.encode(message.pos, writer.uint32(10).fork()).join();
+        }
+        if (message.ang !== undefined) {
+            CMsgQAngle.encode(message.ang, 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 = createBaseCP2PVRAvatarPosition_COrientation();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.pos = CMsgVector.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.ang = CMsgQAngle.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseCP2PWatchSynchronization() {
+    return {
+        demoTick: 0,
+        paused: false,
+        tvListenVoiceIndices: 0,
+        dotaSpectatorMode: 0,
+        dotaSpectatorWatchingBroadcaster: false,
+        dotaSpectatorHeroIndex: 0,
+        dotaSpectatorAutospeed: 0,
+        dotaReplaySpeed: 0,
+    };
+}
+export const CP2PWatchSynchronization = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.demoTick !== undefined && message.demoTick !== 0) {
+            writer.uint32(8).int32(message.demoTick);
+        }
+        if (message.paused !== undefined && message.paused !== false) {
+            writer.uint32(16).bool(message.paused);
+        }
+        if (message.tvListenVoiceIndices !== undefined && message.tvListenVoiceIndices !== 0) {
+            writer.uint32(24).uint64(message.tvListenVoiceIndices);
+        }
+        if (message.dotaSpectatorMode !== undefined && message.dotaSpectatorMode !== 0) {
+            writer.uint32(32).int32(message.dotaSpectatorMode);
+        }
+        if (message.dotaSpectatorWatchingBroadcaster !== undefined && message.dotaSpectatorWatchingBroadcaster !== false) {
+            writer.uint32(40).bool(message.dotaSpectatorWatchingBroadcaster);
+        }
+        if (message.dotaSpectatorHeroIndex !== undefined && message.dotaSpectatorHeroIndex !== 0) {
+            writer.uint32(48).int32(message.dotaSpectatorHeroIndex);
+        }
+        if (message.dotaSpectatorAutospeed !== undefined && message.dotaSpectatorAutospeed !== 0) {
+            writer.uint32(56).int32(message.dotaSpectatorAutospeed);
+        }
+        if (message.dotaReplaySpeed !== undefined && message.dotaReplaySpeed !== 0) {
+            writer.uint32(64).int32(message.dotaReplaySpeed);
+        }
+        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 = createBaseCP2PWatchSynchronization();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.demoTick = reader.int32();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.paused = reader.bool();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.tvListenVoiceIndices = longToNumber(reader.uint64());
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.dotaSpectatorMode = reader.int32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.dotaSpectatorWatchingBroadcaster = reader.bool();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.dotaSpectatorHeroIndex = reader.int32();
+                    continue;
+                }
+                case 7: {
+                    if (tag !== 56) {
+                        break;
+                    }
+                    message.dotaSpectatorAutospeed = reader.int32();
+                    continue;
+                }
+                case 8: {
+                    if (tag !== 64) {
+                        break;
+                    }
+                    message.dotaReplaySpeed = reader.int32();
+                    continue;
+                }
+            }
+            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;
+}

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

@@ -0,0 +1,30 @@
+export * from "./c_peer2peer_netmessages.js";
+import * as GeneratedTypescript from "./c_peer2peer_netmessages.js";
+export declare const CP2PTextMessage: {
+    encode(message: GeneratedTypescript.CP2PTextMessage): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CP2PTextMessage;
+};
+export declare const CSteamVoiceEncoding: {
+    encode(message: GeneratedTypescript.CSteamVoiceEncoding): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CSteamVoiceEncoding;
+};
+export declare const CP2PVoice: {
+    encode(message: GeneratedTypescript.CP2PVoice): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CP2PVoice;
+};
+export declare const CP2PPing: {
+    encode(message: GeneratedTypescript.CP2PPing): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CP2PPing;
+};
+export declare const CP2PVRAvatarPosition: {
+    encode(message: GeneratedTypescript.CP2PVRAvatarPosition): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CP2PVRAvatarPosition;
+};
+export declare const CP2PVRAvatarPosition_COrientation: {
+    encode(message: GeneratedTypescript.CP2PVRAvatarPosition_COrientation): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CP2PVRAvatarPosition_COrientation;
+};
+export declare const CP2PWatchSynchronization: {
+    encode(message: GeneratedTypescript.CP2PWatchSynchronization): Uint8Array<ArrayBuffer>;
+    decode(input: Uint8Array): GeneratedTypescript.CP2PWatchSynchronization;
+};

package/.dist/generated/c_peer2peer_netmessages.wrapper.js

@@ -0,0 +1,63 @@
+// Code generated by cs2-protobuf. DO NOT EDIT.
+// versions:
+//   cs2-protobuf  1.0.1
+// source: c_peer2peer_netmessages.ts
+/* eslint-disable */
+export * from "./c_peer2peer_netmessages.js";
+import * as GeneratedTypescript from "./c_peer2peer_netmessages.js";
+export const CP2PTextMessage = {
+    encode(message) {
+        return GeneratedTypescript.CP2PTextMessage.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CP2PTextMessage.decode(input);
+    },
+};
+export const CSteamVoiceEncoding = {
+    encode(message) {
+        return GeneratedTypescript.CSteamVoiceEncoding.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CSteamVoiceEncoding.decode(input);
+    },
+};
+export const CP2PVoice = {
+    encode(message) {
+        return GeneratedTypescript.CP2PVoice.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CP2PVoice.decode(input);
+    },
+};
+export const CP2PPing = {
+    encode(message) {
+        return GeneratedTypescript.CP2PPing.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CP2PPing.decode(input);
+    },
+};
+export const CP2PVRAvatarPosition = {
+    encode(message) {
+        return GeneratedTypescript.CP2PVRAvatarPosition.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CP2PVRAvatarPosition.decode(input);
+    },
+};
+export const CP2PVRAvatarPosition_COrientation = {
+    encode(message) {
+        return GeneratedTypescript.CP2PVRAvatarPosition_COrientation.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CP2PVRAvatarPosition_COrientation.decode(input);
+    },
+};
+export const CP2PWatchSynchronization = {
+    encode(message) {
+        return GeneratedTypescript.CP2PWatchSynchronization.encode(message).finish();
+    },
+    decode(input) {
+        return GeneratedTypescript.CP2PWatchSynchronization.decode(input);
+    },
+};

package/.dist/generated/clientmessages.d.ts

@@ -0,0 +1,60 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+export declare enum EBaseClientMessages {
+    CM_CustomGameEvent = 280,
+    CM_CustomGameEventBounce = 281,
+    CM_ClientUIEvent = 282,
+    CM_DevPaletteVisibilityChanged = 283,
+    CM_WorldUIControllerHasPanelChanged = 284,
+    CM_RotateAnchor = 285,
+    CM_ListenForResponseFound = 286,
+    CM_MAX_BASE = 300,
+    UNRECOGNIZED = -1
+}
+export declare enum EClientUIEvent {
+    EClientUIEvent_Invalid = 0,
+    EClientUIEvent_DialogFinished = 1,
+    EClientUIEvent_FireOutput = 2,
+    UNRECOGNIZED = -1
+}
+export interface CClientMsgCustomGameEvent {
+    eventName?: string | undefined;
+    data?: Uint8Array | undefined;
+}
+export interface CClientMsgCustomGameEventBounce {
+    eventName?: string | undefined;
+    data?: Uint8Array | undefined;
+    playerSlot?: number | undefined;
+}
+export interface CClientMsgClientUIEvent {
+    event?: EClientUIEvent | undefined;
+    entEhandle?: number | undefined;
+    clientEhandle?: number | undefined;
+    data1?: string | undefined;
+    data2?: string | undefined;
+}
+export interface CClientMsgDevPaletteVisibilityChangedEvent {
+    visible?: boolean | undefined;
+}
+export interface CClientMsgWorldUIControllerHasPanelChangedEvent {
+    hasPanel?: boolean | undefined;
+    clientEhandle?: number | undefined;
+    literalHandType?: number | undefined;
+}
+export interface CClientMsgRotateAnchor {
+    angle?: number | undefined;
+}
+export interface CClientMsgListenForResponseFound {
+    playerSlot?: number | undefined;
+}
+export declare const CClientMsgCustomGameEvent: MessageFns<CClientMsgCustomGameEvent>;
+export declare const CClientMsgCustomGameEventBounce: MessageFns<CClientMsgCustomGameEventBounce>;
+export declare const CClientMsgClientUIEvent: MessageFns<CClientMsgClientUIEvent>;
+export declare const CClientMsgDevPaletteVisibilityChangedEvent: MessageFns<CClientMsgDevPaletteVisibilityChangedEvent>;
+export declare const CClientMsgWorldUIControllerHasPanelChangedEvent: MessageFns<CClientMsgWorldUIControllerHasPanelChangedEvent>;
+export declare const CClientMsgRotateAnchor: MessageFns<CClientMsgRotateAnchor>;
+export declare const CClientMsgListenForResponseFound: MessageFns<CClientMsgListenForResponseFound>;
+interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}
+export {};