demostf/demo.js
1
0
Fork 0
mirror of https://github.com/demostf/demo.js synced 2026-06-04 09:04:13 +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

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
};
}