demostf/demo.js
1
0
Fork 0
mirror of https://github.com/demostf/demo.js synced 2026-06-04 00:54:14 +02:00
Code Issues Releases Wiki Activity

lint fixes

Browse source
This commit is contained in:
Robin Appelman 2017-09-26 02:29:45 +02:00
commit 0aad1e874b
78 changed files with 879 additions and 851 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/Parser/EntityDecoder.ts
View file

@ -2,8 +2,8 @@ import {BitStream} from 'bit-buffer';
import {SendProp} from '../Data/SendProp';
import {SendTable} from '../Data/SendTable';
import {readBitVar, writeBitVar} from './readBitVar';
import {SendPropParser} from './SendPropParser';
import {SendPropEncoder} from './SendPropEncoder';
import {SendPropParser} from './SendPropParser';
export function getEntityUpdate(sendTable: SendTable, stream: BitStream): SendProp[] {
let index = -1;
@ -29,13 +29,15 @@ export function encodeEntityUpdate(props: SendProp[], sendTable: SendTable, stre
let lastIndex = -1;
for (const prop of props) {
stream.writeBoolean(true);
const index = allProps.findIndex(propDef => propDef.fullName === prop.definition.fullName);
const index = allProps.findIndex((propDef) => propDef.fullName === prop.definition.fullName);
if (index === -1) {
throw new Error(`Unknown definition for property ${prop.definition.fullName} in ${sendTable.name}`);
}
if (index < lastIndex) {
throw new Error(`Property index not incremental while encoding ${prop.definition.fullName} after ${allProps[lastIndex].fullName} in ${sendTable.name} (current: ${index}, last: ${lastIndex})`);
throw new Error(`Property index not incremental while encoding` +
`${prop.definition.fullName} after ${allProps[lastIndex].fullName}` +
`in ${sendTable.name} (current: ${index}, last: ${lastIndex})`);
}
writeFieldIndex(index, stream, lastIndex);
lastIndex = index;

8
src/Parser/Message/ConsoleCmd.ts
View file

@ -1,14 +1,14 @@
import {BitStream} from 'bit-buffer';
import {TextEncoder} from 'text-encoding-shim';
import {ConsoleCmdMessage, MessageHandler, MessageType} from '../../Data/Message';
import {ConsoleCmdPacket} from '../../Data/Packet';
import {Parser} from './Parser';
import {BitStream} from 'bit-buffer';
import {ConsoleCmdMessage, MessageHandler, MessageType} from '../../Data/Message';
import {TextEncoder} from 'text-encoding-shim';
export class ConsoleCmd extends Parser {
public parse(): ConsoleCmdPacket[] {
return [{
packetType: 'consoleCmd',
command: this.stream.readUTF8String(),
command: this.stream.readUTF8String()
}];
}
}

6
src/Parser/Message/DataTable.ts
View file

@ -1,8 +1,8 @@
import {BitStream} from 'bit-buffer';
import {DataTablesMessage, MessageHandler, MessageType} from '../../Data/Message';
import {SendPropDefinition, SendPropFlag, SendPropType} from '../../Data/SendPropDefinition';
import {SendTable} from '../../Data/SendTable';
import {ServerClass} from '../../Data/ServerClass';
import {DataTablesMessage, MessageHandler, MessageType} from '../../Data/Message';
import {BitStream} from 'bit-buffer';
export const DataTableHandler: MessageHandler<DataTablesMessage> = {
parseMessage: (stream: BitStream) => {
@ -129,7 +129,7 @@ export const DataTableHandler: MessageHandler<DataTablesMessage> = {
tick,
rawData: messageStream,
tables,
serverClasses,
serverClasses
};
},
encodeMessage: (message, stream) => {

8
src/Parser/Message/Packet.ts
View file

@ -1,4 +1,3 @@
import {make} from '../Packet/ParserGenerator';
import {EncodeBSPDecal, ParseBSPDecal} from '../Packet/BSPDecal';
import {EncodeClassInfo, ParseClassInfo} from '../Packet/ClassInfo';
import {EncodeCreateStringTable, ParseCreateStringTable} from '../Packet/CreateStringTable';
@ -6,6 +5,7 @@ import {EncodeGameEvent, ParseGameEvent} from '../Packet/GameEvent';
import {EncodeGameEventList, ParseGameEventList} from '../Packet/GameEventList';
import {EncodePacketEntities, ParsePacketEntities} from '../Packet/PacketEntities';
import {PacketHandler} from '../Packet/Parser';
import {make} from '../Packet/ParserGenerator';
import {EncodeParseSounds, ParseParseSounds} from '../Packet/ParseSounds';
import {EncodeSetConVar, ParseSetConVar} from '../Packet/SetConVar';
import {EncodeTempEntities, ParseTempEntities} from '../Packet/TempEntities';
@ -14,9 +14,9 @@ import {EncodeUserMessage, ParseUserMessage} from '../Packet/UserMessage';
import {EncodeVoiceData, ParseVoiceData} from '../Packet/VoiceData';
import {EncodeVoiceInit, ParseVoiceInit} from '../Packet/VoiceInit';
import {Packet as IPacket, PacketTypeId} from '../../Data/Packet';
import {MessageHandler, MessageType, PacketMessage} from '../../Data/Message';
import {BitStream} from 'bit-buffer';
import {MessageHandler, MessageType, PacketMessage} from '../../Data/Message';
import {Packet as IPacket, PacketTypeId} from '../../Data/Packet';
import {ParserState} from '../../Data/ParserState';
import {Vector} from '../../Data/Vector';
@ -79,7 +79,7 @@ const handlers: PacketHandlerMap = new Map<PacketTypeId, PacketHandler<IPacket>>
[PacketTypeId.getCvarValue,
make('getCvarValue', 'cookie{32}value{s}')],
[PacketTypeId.cmdKeyValues,
make('cmdKeyValues', 'length{32}data{$length}')],
make('cmdKeyValues', 'length{32}data{$length}')]
]);
export const PacketMessageHandler: MessageHandler<PacketMessage> = {

2
src/Parser/Message/Parser.ts
View file

@ -1,6 +1,6 @@
import {BitStream} from 'bit-buffer';
import {Packet, PacketTypeId} from '../../Data/Packet';
import {MessageType} from '../../Data/Message';
import {Packet, PacketTypeId} from '../../Data/Packet';
import {ParserState} from '../../Data/ParserState';
export abstract class Parser {

10
src/Parser/Message/StringTable.ts
View file

@ -1,6 +1,6 @@
import {StringTable as StringTableObject, StringTableEntry} from '../../Data/StringTable';
import {MessageHandler, MessageType, StringTablesMessage} from '../../Data/Message';
import {BitStream} from 'bit-buffer';
import {MessageHandler, MessageType, StringTablesMessage} from '../../Data/Message';
import {StringTable as StringTableObject, StringTableEntry} from '../../Data/StringTable';
export const StringTableHandler: MessageHandler<StringTablesMessage> = {
parseMessage: (stream: BitStream) => {
@ -18,7 +18,7 @@ export const StringTableHandler: MessageHandler<StringTablesMessage> = {
const entryCount = messageStream.readUint16();
for (let j = 0; j < entryCount; j++) {
const entry: StringTableEntry = {
text: messageStream.readUTF8String(),
text: messageStream.readUTF8String()
};
if (messageStream.readBoolean()) {
const extraDataLength = messageStream.readUint16();
@ -40,7 +40,7 @@ export const StringTableHandler: MessageHandler<StringTablesMessage> = {
const table: StringTableObject = {
entries,
name: tableName,
maxEntries: entryCount,
maxEntries: entryCount
};
if (messageStream.readBoolean()) {
@ -57,7 +57,7 @@ export const StringTableHandler: MessageHandler<StringTablesMessage> = {
type: MessageType.StringTables,
tick,
rawData: messageStream,
tables,
tables
};
},
encodeMessage: (message, stream) => {

2
src/Parser/Message/SyncTick.ts
View file

@ -1,5 +1,5 @@
import {MessageHandler, MessageType, SyncTickMessage} from '../../Data/Message';
import {BitStream} from 'bit-buffer';
import {MessageHandler, MessageType, SyncTickMessage} from '../../Data/Message';
export const SyncTickHandler: MessageHandler<SyncTickMessage> = {
parseMessage: (stream: BitStream) => {

2
src/Parser/Message/UserCmd.ts
View file

@ -1,5 +1,5 @@
import {MessageHandler, MessageType, UserCmdMessage} from '../../Data/Message';
import {BitStream} from 'bit-buffer';
import {MessageHandler, MessageType, UserCmdMessage} from '../../Data/Message';
export const UserCmdHandler: MessageHandler<UserCmdMessage> = {
parseMessage: (stream: BitStream) => {

6
src/Parser/Packet/BSPDecal.ts
View file

@ -1,8 +1,8 @@
import {BitStream} from 'bit-buffer';
import {BSPDecalPacket} from '../../Data/Packet';
import {Vector} from '../../Data/Vector';
import {SendPropParser} from '../SendPropParser';
import {SendPropEncoder} from '../SendPropEncoder';
import {SendPropParser} from '../SendPropParser';
export function getVecCoord(stream: BitStream): Vector {
const hasX = stream.readBoolean();
@ -12,7 +12,7 @@ export function getVecCoord(stream: BitStream): Vector {
return {
x: hasX ? SendPropParser.readBitCoord(stream) : 0,
y: hasY ? SendPropParser.readBitCoord(stream) : 0,
z: hasZ ? SendPropParser.readBitCoord(stream) : 0,
z: hasZ ? SendPropParser.readBitCoord(stream) : 0
};
}
@ -49,7 +49,7 @@ export function ParseBSPDecal(stream: BitStream): BSPDecalPacket { // 21: ParseB
textureIndex,
entIndex,
modelIndex,
lowPriority,
lowPriority
};
}

9
src/Parser/Packet/ClassInfo.ts
View file

@ -2,22 +2,21 @@ import {BitStream} from 'bit-buffer';
import {ClassInfoPacket} from '../../Data/Packet';
import {logBase2} from '../../Math';
export function ParseClassInfo(stream: BitStream): ClassInfoPacket { // 10: classInfo
const count = stream.readUint16();
const create = stream.readBoolean();
const entries: {
const entries: Array<{
classId: number;
className: string;
dataTableName: string;
}[] = [];
}> = [];
if (!create) {
const bits = logBase2(count) + 1;
for (let i = 0; i < count; i++) {
const entry = {
classId: stream.readBits(bits),
className: stream.readASCIIString(),
dataTableName: stream.readASCIIString(),
dataTableName: stream.readASCIIString()
};
entries.push(entry);
}
@ -26,7 +25,7 @@ export function ParseClassInfo(stream: BitStream): ClassInfoPacket { // 10: clas
packetType: 'classInfo',
number: count,
create,
entries,
entries
};
}

4
src/Parser/Packet/CreateStringTable.ts
View file

@ -53,14 +53,14 @@ export function ParseCreateStringTable(stream: BitStream): CreateStringTablePack
entries: [],
maxEntries,
fixedUserDataSize: userDataSize,
fixedUserDataSizeBits: userDataSizeBits,
fixedUserDataSizeBits: userDataSizeBits
};
table.entries = parseStringTableEntries(data, table, entityCount);
return {
packetType: 'createStringTable',
table: table,
table
};
}

6
src/Parser/Packet/GameEvent.ts
View file

@ -1,7 +1,7 @@
import {BitStream} from 'bit-buffer';
import {
GameEventDefinition, GameEventEntry,
GameEventValue, GameEventValueType,
GameEventValue, GameEventValueType
} from '../../Data/GameEvent';
import {GameEvent, GameEventType, GameEventTypeIdMap, GameEventTypeMap} from '../../Data/GameEventTypes';
import {GameEventPacket} from '../../Data/Packet';
@ -19,7 +19,7 @@ function parseGameEvent<T extends GameEventType>(definition: GameEventDefinition
return {
name,
values,
values
};
}
@ -98,7 +98,7 @@ export function ParseGameEvent(stream: BitStream, state: ParserState): GameEvent
return {
packetType: 'gameEvent',
event: event as GameEvent,
event: event as GameEvent
};
}

8
src/Parser/Packet/GameEventList.ts
View file

@ -1,7 +1,7 @@
import {BitStream} from 'bit-buffer';
import {GameEventDefinition, GameEventEntry} from '../../Data/GameEvent';
import {GameEventListPacket} from '../../Data/Packet';
import {GameEvent, GameEventType} from '../../Data/GameEventTypes';
import {GameEventListPacket} from '../../Data/Packet';
export function ParseGameEventList(stream: BitStream): GameEventListPacket { // 30: gameEventList
const s = stream.index;
@ -18,19 +18,19 @@ export function ParseGameEventList(stream: BitStream): GameEventListPacket { //
while (type !== 0) {
entries.push({
type,
name: stream.readASCIIString(),
name: stream.readASCIIString()
});
type = stream.readBits(3);
}
eventList.set(id, {
id,
name,
entries,
entries
});
}
return {
packetType: 'gameEventList',
eventList,
eventList
};
}

22
src/Parser/Packet/PacketEntities.ts
View file

@ -1,23 +1,23 @@
import {BitStream} from 'bit-buffer';
import {PacketEntitiesPacket} from '../../Data/Packet';
import {EntityId, PacketEntity, PVS} from '../../Data/PacketEntity';
import {getClassBits, getSendTable, ParserState} from '../../Data/ParserState';
import {SendProp} from '../../Data/SendProp';
import {encodeEntityUpdate, getEntityUpdate} from '../EntityDecoder';
import {readUBitVar, writeBitVar} from '../readBitVar';
import {getClassBits, getSendTable, ParserState} from '../../Data/ParserState';
const pvsMap = new Map([
[0, PVS.PRESERVE],
[2, PVS.ENTER],
[1, PVS.LEAVE],
[3, PVS.LEAVE + PVS.DELETE],
[3, PVS.LEAVE + PVS.DELETE]
]);
const pvsReverseMap = new Map([
[PVS.PRESERVE, 0],
[PVS.ENTER, 2],
[PVS.LEAVE, 1],
[PVS.LEAVE + PVS.DELETE, 3],
[PVS.LEAVE + PVS.DELETE, 3]
]);
function readPVSType(stream: BitStream): PVS {
@ -70,7 +70,9 @@ function readEnterPVS(stream: BitStream, entityId: EntityId, state: ParserState,
}
function writeEnterPVS(entity: PacketEntity, stream: BitStream, state: ParserState, baseLineIndex: number) {
const serverClassId = state.serverClasses.findIndex(serverClass => serverClass && entity.serverClass.id === serverClass.id);
const serverClassId = state.serverClasses.findIndex(
(existingServerClass) => existingServerClass && entity.serverClass.id === existingServerClass.id
);
if (serverClassId === -1) {
throw new Error(`Unknown server class ${entity.serverClass.name}(${entity.serverClass.id})`);
}
@ -100,8 +102,8 @@ function writeEnterPVS(entity: PacketEntity, stream: BitStream, state: ParserSta
// console.log(propsToEncode.map(prop => `${prop.definition.name}: ${prop.value}`));
const allProps = sendTable.flattenedProps;
propsToEncode.sort((a, b) => allProps.findIndex(propDef => propDef.fullName === a.definition.fullName) -
allProps.findIndex(propDef => propDef.fullName === b.definition.fullName));
propsToEncode.sort((a, b) => allProps.findIndex((propDef) => propDef.fullName === a.definition.fullName) -
allProps.findIndex((propDef) => propDef.fullName === b.definition.fullName));
encodeEntityUpdate(propsToEncode, sendTable, stream);
}
@ -115,7 +117,11 @@ function getPacketEntityForExisting(entityId: EntityId, state: ParserState, pvs:
return new PacketEntity(serverClass, entityId, pvs);
}
export function ParsePacketEntities(stream: BitStream, state: ParserState, skip: boolean = false): PacketEntitiesPacket { // 26: packetEntities
export function ParsePacketEntities(
stream: BitStream,
state: ParserState,
skip: boolean = false
): PacketEntitiesPacket { // 26: packetEntities
// https://github.com/skadistats/smoke/blob/master/smoke/replay/handler/svc_packetentities.pyx
// https://github.com/StatsHelix/demoinfo/blob/3d28ea917c3d44d987b98bb8f976f1a3fcc19821/DemoInfo/DP/Handler/PacketEntitesHandler.cs
// https://github.com/StatsHelix/demoinfo/blob/3d28ea917c3d44d987b98bb8f976f1a3fcc19821/DemoInfo/DP/Entity.cs
@ -186,7 +192,7 @@ export function ParsePacketEntities(stream: BitStream, state: ParserState, skip:
maxEntries,
delta,
baseLine,
updatedBaseLine,
updatedBaseLine
};
}

4
src/Parser/Packet/Parser.ts
View file

@ -6,8 +6,8 @@ export type Parser<P extends Packet> = (stream: BitStream, state?: ParserState,
export type Encoder<P extends Packet> = (packet: P, stream: BitStream, state?: ParserState) => void;
export interface PacketHandler<P extends Packet> {
parser: Parser<P>,
encoder: Encoder<P>
parser: Parser<P>;
encoder: Encoder<P>;
}
export const voidEncoder: Encoder<VoidPacket> = () => {

6
src/Parser/Packet/ParserGenerator.ts
View file

@ -1,15 +1,15 @@
import {BitStream} from 'bit-buffer';
import {PacketMapType, PacketType} from '../../Data/Packet';
import {Encoder, PacketHandler, Parser} from './Parser';
import {BitStream} from 'bit-buffer';
export function make<T extends PacketType>(name: T, definition: string): PacketHandler<PacketMapType[T]> {
const parts = definition.split('}');
const items = parts.map((part) => {
return part.split('{');
}).filter(part => part[0]);
}).filter((part) => part[0]);
const parser: Parser<PacketMapType[T]> = (stream: BitStream) => {
const result = {
packetType: name,
packetType: name
};
try {
for (const group of items) {

2
src/Parser/Packet/SetConVar.ts
View file

@ -11,7 +11,7 @@ export function ParseSetConVar(stream: BitStream): SetConVarPacket { // 5: setco
}
return {
packetType: 'setConVar',
vars,
vars
};
}

8
src/Parser/Packet/TempEntities.ts
View file

@ -1,10 +1,10 @@
import {BitStream} from 'bit-buffer';
import {TempEntitiesPacket} from '../../Data/Packet';
import {PacketEntity, PVS} from '../../Data/PacketEntity';
import {getClassBits, getSendTable, ParserState} from '../../Data/ParserState';
import {DynamicBitStream} from '../../DynamicBitStream';
import {encodeEntityUpdate, getEntityUpdate} from '../EntityDecoder';
import {readVarInt, writeVarInt} from '../readBitVar';
import {DynamicBitStream} from '../../DynamicBitStream';
import {getClassBits, getSendTable, ParserState} from '../../Data/ParserState';
export function ParseTempEntities(stream: BitStream, state: ParserState, skip: boolean = false): TempEntitiesPacket { // 10: classInfo
const entityCount = stream.readUint8();
@ -45,7 +45,7 @@ export function ParseTempEntities(stream: BitStream, state: ParserState, skip: b
return {
packetType: 'tempEntities',
entities,
entities
};
}
@ -63,7 +63,7 @@ export function EncodeTempEntities(packet: TempEntitiesPacket, stream: BitStream
entityStream.writeBoolean(true);
const classId = state.serverClasses.findIndex(serverClass => serverClass && serverClass.name === entity.serverClass.name) + 1;
const classId = state.serverClasses.findIndex((serverClass) => serverClass && serverClass.name === entity.serverClass.name) + 1;
entityStream.writeBits(classId, getClassBits(state));
const sendTable = getSendTable(state, entity.serverClass.dataTable);

4
src/Parser/Packet/UpdateStringTable.ts
View file

@ -1,7 +1,7 @@
import {BitStream} from 'bit-buffer';
import {UpdateStringTablePacket} from '../../Data/Packet';
import {encodeStringTableEntries, guessStringTableEntryLength, parseStringTableEntries} from '../StringTableParser';
import {ParserState} from '../../Data/ParserState';
import {encodeStringTableEntries, guessStringTableEntryLength, parseStringTableEntries} from '../StringTableParser';
export function ParseUpdateStringTable(stream: BitStream, state: ParserState): UpdateStringTablePacket { // 12: updateStringTable
const tableId = stream.readBits(5);
@ -30,7 +30,7 @@ export function ParseUpdateStringTable(stream: BitStream, state: ParserState): U
export function EncodeUpdateStringTable(packet: UpdateStringTablePacket, stream: BitStream, state: ParserState) {
stream.writeBits(packet.tableId, 5);
const changedEntryCount = packet.entries.filter(entry => entry).length;
const changedEntryCount = packet.entries.filter((entry) => entry).length;
const multipleChanged = changedEntryCount > 1;
stream.writeBoolean(multipleChanged);

37
src/Parser/Packet/UserMessage.ts
View file

@ -1,15 +1,15 @@
import {BitStream} from 'bit-buffer';
import {EncodeSayText2, ParseSayText2} from '../UserMessage/SayText2';
import {make} from './ParserGenerator';
import {PacketHandler} from './Parser';
import {
UserMessageType,
UserMessagePacket,
UnknownUserMessagePacket,
UnknownUserMessageBasePacket,
UserMessageTypeMap,
UserMessagePacketTypeMap
UnknownUserMessagePacket,
UserMessagePacket,
UserMessagePacketTypeMap,
UserMessageType,
UserMessageTypeMap
} from '../../Data/UserMessage';
import {EncodeSayText2, ParseSayText2} from '../UserMessage/SayText2';
import {PacketHandler} from './Parser';
import {make} from './ParserGenerator';
function unknownPacketHandler<T extends UnknownUserMessagePacket['packetType']>(packetType: T): PacketHandler<UserMessageTypeMap[T]> {
return {
@ -28,15 +28,16 @@ function unknownPacketHandler<T extends UnknownUserMessagePacket['packetType']>(
};
}
const userMessageParsers: Map<UserMessageType, PacketHandler<UserMessagePacket>> = new Map<UserMessageType, PacketHandler<UserMessagePacket>>([
[UserMessageType.SayText2, {parser: ParseSayText2, encoder: EncodeSayText2}],
[UserMessageType.TextMsg, make('textMsg', 'destType{8}text{s}substitute1{s}substitute2{s}substitute3{s}substitute4{s}')],
[UserMessageType.ResetHUD, make('resetHUD', 'data{8}')],
[UserMessageType.Train, make('train', 'data{8}')],
[UserMessageType.VoiceSubtitle, make('voiceSubtitle', 'client{8}menu{8}item{8}')],
[UserMessageType.BreakModel_Pumpkin, unknownPacketHandler('breakModelPumpkin')],
[UserMessageType.Shake, make('shake', 'command{8}amplitude{f32}frequency{f32}duration{f32}')]
]);
const userMessageParsers: Map<UserMessageType, PacketHandler<UserMessagePacket>> =
new Map<UserMessageType, PacketHandler<UserMessagePacket>>([
[UserMessageType.SayText2, {parser: ParseSayText2, encoder: EncodeSayText2}],
[UserMessageType.TextMsg, make('textMsg', 'destType{8}text{s}substitute1{s}substitute2{s}substitute3{s}substitute4{s}')],
[UserMessageType.ResetHUD, make('resetHUD', 'data{8}')],
[UserMessageType.Train, make('train', 'data{8}')],
[UserMessageType.VoiceSubtitle, make('voiceSubtitle', 'client{8}menu{8}item{8}')],
[UserMessageType.BreakModel_Pumpkin, unknownPacketHandler('breakModelPumpkin')],
[UserMessageType.Shake, make('shake', 'command{8}amplitude{f32}frequency{f32}duration{f32}')]
]);
export function ParseUserMessage(stream: BitStream): UserMessagePacket { // 23: user message
const s = stream.index;
@ -50,7 +51,7 @@ export function ParseUserMessage(stream: BitStream): UserMessagePacket { // 23:
return {
packetType: 'unknownUserMessage',
type,
data: messageData,
data: messageData
};
} else {
return handler.parser(messageData);

2
src/Parser/Packet/VoiceData.ts
View file

@ -12,7 +12,7 @@ export function ParseVoiceData(stream: BitStream): VoiceDataPacket {
client,
proximity,
length,
data,
data
};
}

2
src/Parser/Packet/VoiceInit.ts
View file

@ -12,7 +12,7 @@ export function ParseVoiceInit(stream: BitStream): VoiceInitPacket {
packetType: 'voiceInit',
codec,
quality,
extraData,
extraData
};
}

3
src/Parser/SendPropParser.ts
View file

@ -27,9 +27,6 @@ export class SendPropParser {
}
public static readInt(propDefinition: SendPropDefinition, stream: BitStream) {
if (!propDefinition.hasFlag) {
console.log(propDefinition, propDefinition.hasFlag);
}
if (propDefinition.hasFlag(SendPropFlag.SPROP_VARINT)) {
return readVarInt(stream, !propDefinition.hasFlag(SendPropFlag.SPROP_UNSIGNED));
} else {

11
src/Parser/StringTableParser.ts
View file

@ -2,7 +2,12 @@ import {BitStream} from 'bit-buffer';
import {StringTable, StringTableEntry} from '../Data/StringTable';
import {logBase2} from '../Math';
export function parseStringTableEntries(stream: BitStream, table: StringTable, entryCount: number, existingEntries: StringTableEntry[] = []): StringTableEntry[] {
export function parseStringTableEntries(
stream: BitStream,
table: StringTable,
entryCount: number,
existingEntries: StringTableEntry[] = []
): StringTableEntry[] {
const entryBits = logBase2(table.maxEntries);
const entries: StringTableEntry[] = [];
let lastEntry = -1;
@ -64,7 +69,7 @@ export function parseStringTableEntries(stream: BitStream, table: StringTable, e
} else {
entries[entryIndex] = {
text: value,
extraData: userData,
extraData: userData
};
history.push(entries[entryIndex]);
}
@ -90,7 +95,7 @@ export function guessStringTableEntryLength(table: StringTable, entries: StringT
export function encodeStringTableEntries(stream: BitStream, table: StringTable, entries: StringTableEntry[]) {
const entryBits = logBase2(table.maxEntries);
let lastIndex = -1;
const lastIndex = -1;
for (let i = 0; i < entries.length; i++) {
if (entries[i]) {
const entry = entries[i];

2
src/Parser/UserMessage/SayText2.ts
View file

@ -49,7 +49,7 @@ export function ParseSayText2(stream: BitStream): SayText2Packet { // 4: ParseSa
raw,
kind,
from,
text,
text
};
}