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

start splitting parserstate from analysing

Browse source
This commit is contained in:
Robin Appelman 2017-09-23 17:41:52 +02:00
commit 198fe0b1ba
18 changed files with 459 additions and 421 deletions
Download patch file Download diff file Expand all files Collapse all files

82
src/Data/Match.ts
View file

@ -1,19 +1,12 @@
import {BitStream} from 'bit-buffer';
import {handleDataTable} from '../PacketHandler/DataTable';
import {handleGameEvent} from '../PacketHandler/GameEvent';
import {handleGameEventList} from '../PacketHandler/GameEventList';
import {handlePacketEntities} from '../PacketHandler/PacketEntities';
import {handleSayText2} from '../PacketHandler/SayText2';
import {handleStringTable, handleStringTables, handleStringTableUpdate} from '../PacketHandler/StringTable';
import {Building} from './Building';
import {Death} from './Death';
import {GameEventDefinition} from './GameEvent';
import {EntityId, PacketEntity} from './PacketEntity';
import {Player} from './Player';
import {PlayerResource} from './PlayerResource';
import {SendTable, SendTableName} from './SendTable';
import {ServerClass, ServerClassId} from './ServerClass';
import {StringTable} from './StringTable';
import {Team, TeamNumber} from './Team';
import {UserInfo} from './UserInfo';
import {Weapon} from './Weapon';
@ -21,11 +14,10 @@ import {World} from './World';
import {Round} from './Round';
import {Chat} from './Chat';
import {Packet} from './Packet';
import {GameEventType} from './GameEventTypes';
import {ParserState} from './ParserState';
import {SendProp} from './SendProp';
import {StringTableEntry} from './StringTable';
export class Match implements ParserState {
export class Match {
public tick: number = 0;
public chat: Chat[] = [];
public users: Map<number, UserInfo> = new Map();
@ -33,26 +25,18 @@ export class Match implements ParserState {
public rounds: Round[] = [];
public startTick: number = 0;
public intervalPerTick: number = 0;
public staticBaseLines: Map<ServerClassId, BitStream> = new Map();
public staticBaselineCache: Map<ServerClassId, SendProp[]> = new Map();
public eventDefinitions: Map<number, GameEventDefinition<GameEventType>> = new Map();
public world: World = {
boundaryMin: {x: 0, y: 0, z: 0},
boundaryMax: {x: 0, y: 0, z: 0},
};
public playerEntityMap: Map<EntityId, Player> = new Map();
public entityClasses: Map<EntityId, ServerClass> = new Map();
public sendTables: Map<SendTableName, SendTable> = new Map();
public instanceBaselines: [Map<EntityId, SendProp[]>, Map<EntityId, SendProp[]>] = [new Map(), new Map()];
public weaponMap: Map<EntityId, Weapon> = new Map();
public outerMap: Map<number, EntityId> = new Map();
public teams: Map<TeamNumber, Team> = new Map();
public teamEntityMap: Map<EntityId, Team> = new Map();
public version: number = 0;
public buildings: Map<EntityId, Building> = new Map();
public playerResources: PlayerResource[] = [];
public stringTables: StringTable[] = [];
public serverClasses: ServerClass[] = [];
public readonly parserState: ParserState = new ParserState();
public getState() {
const users = {};
@ -91,32 +75,55 @@ export class Match implements ParserState {
break;
case 'serverInfo':
this.intervalPerTick = packet.intervalPerTick;
this.version = packet.version;
break;
case 'createStringTable':
if (packet.table.name === 'userinfo') {
this.calculateUserInfo();
}
break;
case 'sayText2':
handleSayText2(packet, this);
break;
case 'dataTable':
handleDataTable(packet, this);
break;
case 'stringTable':
handleStringTables(packet, this);
break;
case 'createStringTable':
handleStringTable(packet, this);
break;
case 'updateStringTable':
handleStringTableUpdate(packet, this);
break;
case 'gameEventList':
handleGameEventList(packet, this);
break;
case 'gameEvent':
handleGameEvent(packet, this);
break;
}
}
private calculateUserInfo() {
for (const [text, extraData] of this.parserState.userInfoEntries.entries()) {
this.calculateUserInfoFromEntry(text, extraData);
}
}
private calculateUserInfoByEntityId(entityId: number) {
const text = `${entityId - 1}`;
const extraData = this.parserState.userInfoEntries.get(text);
if (!extraData) {
throw new Error(`No user info in stringable for entity id ${entityId}`);
}
return this.calculateUserInfoFromEntry(text, extraData);
}
private calculateUserInfoFromEntry(text: string, extraData: BitStream): UserInfo {
if (extraData.bitsLeft > (32 * 8)) {
const name = extraData.readUTF8String(32);
const userId = extraData.readUint32();
const steamId = extraData.readUTF8String();
if (steamId) {
const userState = this.getUserInfo(userId);
userState.name = name;
userState.steamId = steamId;
userState.entityId = parseInt(text, 10) + 1;
return userState;
} else {
throw new Error(`No steamid for user info ${text}`);
}
} else {
throw new Error();
}
}
public getUserInfo(userId: number): UserInfo {
// no clue why it does this
// only seems to be the case with per user ready
@ -125,6 +132,7 @@ export class Match implements ParserState {
}
const user = this.users.get(userId);
if (!user) {
const newUser = {
name: '',
userId,
@ -139,12 +147,12 @@ export class Match implements ParserState {
return user;
}
public getUserInfoForEntity(entity: PacketEntity): UserInfo {
public getUserInfoForEntity(entity: PacketEntity): UserInfo | null {
for (const user of this.users.values()) {
if (user && user.entityId === entity.entityIndex) {
return user;
}
}
throw new Error('User not found for entity ' + entity.entityIndex);
return this.calculateUserInfoByEntityId(entity.entityIndex);
}
}

74
src/Data/Message.ts Normal file
View file

@ -0,0 +1,74 @@
import {Packet} from './Packet';
import {BitStream} from 'bit-buffer';
import {ServerClass} from './ServerClass';
import {SendTable} from './SendTable';
import {StringTable} from './StringTable';
import {ParserState} from './ParserState';
export enum MessageType {
Sigon = 1,
Packet = 2,
SyncTick = 3,
ConsoleCmd = 4,
UserCmd = 5,
DataTables = 6,
Stop = 7,
StringTables = 8,
}
export interface BaseMessage {
tick: number;
rawData: BitStream;
}
export interface SigonMessage extends BaseMessage {
type: MessageType.Sigon;
packets: Packet[];
}
export interface PacketMessage extends BaseMessage {
type: MessageType.Packet;
packets: Packet[];
}
export interface SyncTickMessage extends BaseMessage {
type: MessageType.SyncTick;
}
export interface ConsoleCmdMessage extends BaseMessage {
type: MessageType.ConsoleCmd;
command: string;
}
export interface UserCmdMessage extends BaseMessage {
type: MessageType.UserCmd;
}
export interface DataTablesMessage extends BaseMessage {
type: MessageType.DataTables;
tables: SendTable[];
serverClasses: ServerClass[]
}
export interface StopMessage extends BaseMessage {
type: MessageType.Stop;
}
export interface StringTablesMessage extends BaseMessage {
type: MessageType.StringTables;
tables: StringTable[]
}
export type Message = SigonMessage |
PacketMessage |
SyncTickMessage |
ConsoleCmdMessage |
UserCmdMessage |
DataTablesMessage |
StopMessage |
StringTablesMessage;
export interface MessageHandler<M extends Message> {
parseMessage: (stream: BitStream, tick: number, state: ParserState) => M;
encodeMessage: (message: M, stream: BitStream, state: ParserState) => void;
}

104
src/Data/ParserState.ts
View file

@ -1,22 +1,83 @@
import {BitStream} from 'bit-buffer';
import {GameEventDefinition} from './GameEvent';
import {EntityId, PacketEntity} from './PacketEntity';
import {EntityId} from './PacketEntity';
import {SendTable, SendTableName} from './SendTable';
import {ServerClass, ServerClassId} from './ServerClass';
import {StringTable} from './StringTable';
import {GameEventType} from './GameEventTypes';
import {SendProp} from './SendProp';
import {Packet, PacketTypeId} from './Packet';
import {
handleStringTable, handleStringTables, handleStringTableUpdate,
handleTable
} from '../PacketHandler/StringTable';
import {handleGameEventList} from '../PacketHandler/GameEventList';
import {DataTablesMessage, Message, MessageType, StringTablesMessage} from './Message';
export interface ParserState {
staticBaseLines: Map<ServerClassId, BitStream>;
staticBaselineCache: Map<ServerClassId, SendProp[]>;
eventDefinitions: Map<number, GameEventDefinition<GameEventType>>;
entityClasses: Map<EntityId, ServerClass>;
sendTables: Map<SendTableName, SendTable>;
version: number;
stringTables: StringTable[];
serverClasses: ServerClass[];
instanceBaselines: [Map<EntityId, SendProp[]>, Map<EntityId, SendProp[]>];
export class ParserState {
public version: number = 0;
public staticBaseLines: Map<ServerClassId, BitStream> = new Map();
public staticBaselineCache: Map<ServerClassId, SendProp[]> = new Map();
public eventDefinitions: Map<number, GameEventDefinition<GameEventType>> = new Map();
public entityClasses: Map<EntityId, ServerClass> = new Map();
public sendTables: Map<SendTableName, SendTable> = new Map();
public stringTables: StringTable[] = [];
public serverClasses: ServerClass[] = [];
public instanceBaselines: [Map<EntityId, SendProp[]>, Map<EntityId, SendProp[]>] = [new Map(), new Map()];
public skippedPackets: PacketTypeId[] = [];
public userInfoEntries: Map<string, BitStream> = new Map();
public handlePacket(packet: Packet) {
switch (packet.packetType) {
case 'serverInfo':
this.version = packet.version;
break;
case 'stringTable':
handleStringTables(packet, this);
break;
case 'createStringTable':
handleStringTable(packet, this);
break;
case 'updateStringTable':
handleStringTableUpdate(packet, this);
break;
case 'gameEventList':
handleGameEventList(packet, this);
break;
}
}
public handleMessage(message: Message) {
switch (message.type) {
case MessageType.DataTables:
this.handleDataTableMessage(message);
break;
case MessageType.StringTables:
this.handleStringTableMessage(message);
break;
}
}
private handleDataTableMessage(message: DataTablesMessage) {
for (const table of message.tables) {
this.sendTables.set(table.name, table);
}
this.serverClasses = message.serverClasses;
}
private handleStringTableMessage(message: StringTablesMessage) {
for (const table of message.tables) {
handleTable(table, this);
}
}
public getStringTable(name: string): StringTable | null {
const table = this.stringTables.find(table => table.name === name);
if (!table) {
return null;
}
return table;
}
}
export function getClassBits(state: ParserState) {
@ -32,24 +93,5 @@ export function getSendTable(state: ParserState, dataTable: string): SendTable {
}
export function createParserState(): ParserState {
return {
staticBaseLines: new Map(),
staticBaselineCache: new Map(),
eventDefinitions: new Map(),
entityClasses: new Map(),
sendTables: new Map(),
version: 0,
stringTables: [],
serverClasses: [],
instanceBaselines: [new Map(), new Map()]
};
}
export function getStringTable(state: ParserState, name: string) {
for (const table of state.stringTables) {
if (table.name === name) {
return table;
}
}
return null;
return new ParserState();
}

7
src/Demo.ts
View file

@ -1,10 +1,7 @@
import {BitStream} from 'bit-buffer';
import {Parser} from './Parser';
import {StreamDemo} from './StreamDemo';
import {PacketTypeId} from './Data/Packet';
export {StreamDemo} from './StreamDemo';
export class Demo {
public static fromNodeBuffer(nodeBuffer) {
const arrayBuffer = new ArrayBuffer(nodeBuffer.length);
@ -15,10 +12,6 @@ export class Demo {
return new Demo(arrayBuffer);
}
public static fromNodeStream(nodeStream) {
return new StreamDemo(nodeStream);
}
public stream: BitStream;
public parser: Parser | null;

9
src/PacketHandler/DataTable.ts
View file

@ -1,9 +0,0 @@
import {Match} from '../Data/Match';
import {DataTablePacket} from '../Data/Packet';
export function handleDataTable(packet: DataTablePacket, match: Match) {
for (const table of packet.tables) {
match.sendTables.set(table.name, table);
}
match.serverClasses = packet.serverClasses;
}

6
src/PacketHandler/GameEventList.ts
View file

@ -1,6 +1,6 @@
import {Match} from '../Data/Match';
import {GameEventListPacket} from '../Data/Packet';
import {ParserState} from '../Data/ParserState';
export function handleGameEventList(packet: GameEventListPacket, match: Match) {
match.eventDefinitions = packet.eventList;
export function handleGameEventList(packet: GameEventListPacket, state: ParserState) {
state.eventDefinitions = packet.eventList;
}

12
src/PacketHandler/PacketEntities.ts
View file

@ -10,7 +10,7 @@ import {TeamNumber} from '../Data/Team';
export function handlePacketEntities(packet: PacketEntitiesPacket, match: Match) {
for (const removedEntityId of packet.removedEntities) {
match.entityClasses.delete(removedEntityId);
match.parserState.entityClasses.delete(removedEntityId);
}
for (const entity of packet.entities) {
@ -21,10 +21,10 @@ export function handlePacketEntities(packet: PacketEntitiesPacket, match: Match)
function saveEntity(packetEntity: PacketEntity, match: Match) {
if (packetEntity.pvs === PVS.DELETE) {
match.entityClasses.delete(packetEntity.entityIndex);
match.parserState.entityClasses.delete(packetEntity.entityIndex);
}
match.entityClasses.set(packetEntity.entityIndex, packetEntity.serverClass);
match.parserState.entityClasses.set(packetEntity.entityIndex, packetEntity.serverClass);
}
function handleEntity(entity: PacketEntity, match: Match) {
@ -80,9 +80,13 @@ function handleEntity(entity: PacketEntity, match: Match) {
* "DT_TFPlayerShared.m_flCloakMeter": 100,
*/
const userInfo = match.getUserInfoForEntity(entity);
if (!userInfo) {
throw new Error(`No user info for entity ${entity.entityIndex}`);
}
const player: Player = (match.playerEntityMap.has(entity.entityIndex)) ?
match.playerEntityMap.get(entity.entityIndex) as Player :
new Player(match, match.getUserInfoForEntity(entity));
new Player(match, userInfo);
if (!match.playerEntityMap.has(entity.entityIndex)) {
match.playerEntityMap.set(entity.entityIndex, player);
}

57
src/PacketHandler/StringTable.ts
View file

@ -1,68 +1,53 @@
import {Match} from '../Data/Match';
import {CreateStringTablePacket, StringTablePacket, UpdateStringTablePacket} from '../Data/Packet';
import {StringTable, StringTableEntry} from '../Data/StringTable';
import {getStringTable} from '../Data/ParserState';
import {ParserState} from '../Data/ParserState';
export function handleStringTable(packet: CreateStringTablePacket, match: Match) {
handleTable(packet.table, match);
export function handleStringTable(packet: CreateStringTablePacket, state: ParserState) {
handleTable(packet.table, state);
}
export function handleStringTables(packet: StringTablePacket, match: Match) {
export function handleStringTables(packet: StringTablePacket, state: ParserState) {
for (const table of packet.tables) {
handleTable(table, match);
handleTable(table, state);
}
}
export function handleStringTableUpdate(packet: UpdateStringTablePacket, match: Match) {
const updatedTable = match.stringTables[packet.tableId];
handleStringTableEntries(updatedTable.name, packet.entries, match);
export function handleStringTableUpdate(packet: UpdateStringTablePacket, state: ParserState) {
const updatedTable = state.stringTables[packet.tableId];
handleStringTableEntries(updatedTable.name, packet.entries, state);
}
function handleTable(table: StringTable, match: Match) {
if (!getStringTable(match, table.name)) {
match.stringTables.push(table);
export function handleTable(table: StringTable, state: ParserState) {
if (!state.getStringTable(table.name)) {
state.stringTables.push(table);
}
handleStringTableEntries(table.name, table.entries, match);
handleStringTableEntries(table.name, table.entries, state);
}
function handleStringTableEntries(tableName: string, entries: StringTableEntry[], match: Match) {
function handleStringTableEntries(tableName: string, entries: StringTableEntry[], state: ParserState) {
if (tableName === 'userinfo') {
for (const userData of entries) {
saveUserData(userData, match);
for (const entry of entries) {
if (entry && entry.extraData) {
state.userInfoEntries.set(entry.text, entry.extraData);
}
}
}
if (tableName === 'instancebaseline') {
for (const instanceBaseLine of entries) {
if (instanceBaseLine) {
saveInstanceBaseLine(instanceBaseLine, match);
saveInstanceBaseLine(instanceBaseLine, state);
}
}
}
}
function saveUserData(userData: StringTableEntry, match: Match) {
if (userData && userData.extraData) {
if (userData.extraData.bitsLeft > (32 * 8)) {
const name = userData.extraData.readUTF8String(32);
const userId = userData.extraData.readUint32();
const steamId = userData.extraData.readUTF8String();
if (steamId) {
const userState = match.getUserInfo(userId);
userState.name = name;
userState.steamId = steamId;
userState.entityId = parseInt(userData.text, 10) + 1;
}
}
}
}
function saveInstanceBaseLine(entry: StringTableEntry, match: Match) {
function saveInstanceBaseLine(entry: StringTableEntry, state: ParserState) {
if (entry.extraData) {
const serverClassId = parseInt(entry.text, 10);
match.staticBaselineCache.delete(serverClassId);
match.staticBaseLines.set(serverClassId, entry.extraData);
state.staticBaselineCache.delete(serverClassId);
state.staticBaseLines.set(serverClassId, entry.extraData);
} else {
throw new Error('Missing baseline');
}

108
src/Parser.ts
View file

@ -2,19 +2,31 @@ import {BitStream} from 'bit-buffer';
import {EventEmitter} from 'events';
import {Header} from './Data/Header';
import {Match} from './Data/Match';
import {ConsoleCmd} from './Parser/Message/ConsoleCmd';
import {DataTable} from './Parser/Message/DataTable';
import {Packet} from './Parser/Message/Packet';
import {Parser as MessageParser} from './Parser/Message/Parser';
import {StringTable} from './Parser/Message/StringTable';
import {UserCmd} from './Parser/Message/UserCmd';
import {ConsoleCmdHandler} from './Parser/Message/ConsoleCmd';
import {DataTableHandler} from './Parser/Message/DataTable';
import {PacketMessageHandler} from './Parser/Message/Packet';
import {StringTableHandler} from './Parser/Message/StringTable';
import {UserCmdHandler} from './Parser/Message/UserCmd';
import {PacketTypeId} from './Data/Packet';
import {Message, MessageHandler, MessageType, PacketMessage} from './Data/Message';
const messageHandlers: Map<MessageType, MessageHandler<Message>> = new Map<MessageType, MessageHandler<Message>>([
[MessageType.Sigon, PacketMessageHandler],
[MessageType.Packet, PacketMessageHandler],
[MessageType.ConsoleCmd, ConsoleCmdHandler],
[MessageType.UserCmd, UserCmdHandler],
[MessageType.DataTables, DataTableHandler],
[MessageType.StringTables, StringTableHandler],
]);
export class Parser extends EventEmitter {
public stream: BitStream;
public match: Match;
protected skipPackets: PacketTypeId[];
public viewOrigin: number[][] = [[], []];
public viewAngles: number[][] = [[], []];
constructor(stream: BitStream, skipPackets: PacketTypeId[] = []) {
super();
this.stream = stream;
@ -28,39 +40,40 @@ export class Parser extends EventEmitter {
}
public parseBody() {
let hasNext = true;
while (hasNext) {
hasNext = this.tick();
const messages = this.getMessages();
for (const message of messages) {
this.handleMessage(message);
}
this.emit('done', this.match);
return this.match;
}
private * getMessages(): Iterable<Message> {
let hasNext: boolean = true;
while (hasNext) {
const message = this.readMessage(this.stream, this.match);
if (!message) {
hasNext = false;
} else {
yield message;
}
}
}
public tick() {
const message = this.readMessage(this.stream, this.match);
if (message instanceof MessageParser) {
if (message) {
this.handleMessage(message);
}
return !!message;
}
protected parseMessage(data: BitStream, type: MessageType, tick: number, length: number, match: Match): MessageParser {
switch (type) {
case MessageType.Sigon:
case MessageType.Packet:
return new Packet(type, tick, data, length, match, this.skipPackets);
case MessageType.ConsoleCmd:
return new ConsoleCmd(type, tick, data, length, match, this.skipPackets);
case MessageType.UserCmd:
return new UserCmd(type, tick, data, length, match, this.skipPackets);
case MessageType.DataTables:
return new DataTable(type, tick, data, length, match, this.skipPackets);
case MessageType.StringTables:
return new StringTable(type, tick, data, length, match, this.skipPackets);
default:
throw new Error('unknown message type');
protected parseMessage(data: BitStream, type: MessageType, tick: number, match: Match): Message {
const handler = messageHandlers.get(type);
if (!handler) {
throw new Error(`No handler for message of type ${MessageType[type]}`);
}
return handler.parseMessage(data, tick, match.parserState);
}
protected parseHeader(stream): Header {
@ -79,18 +92,17 @@ export class Parser extends EventEmitter {
};
}
protected handleMessage(message: MessageParser) {
if (message.parse) {
const packets = message.parse();
for (const packet of packets) {
if (packet) {
this.emit('packet', packet);
}
protected handleMessage(message: Message) {
this.match.parserState.handleMessage(message);
if (message.type === MessageType.Packet) {
for (const packet of (message as PacketMessage).packets) {
this.match.parserState.handlePacket(packet);
this.emit('packet', packet);
}
}
}
protected readMessage(stream: BitStream, match: Match): MessageParser | boolean {
protected readMessage(stream: BitStream, match: Match): Message | false {
if (stream.bitsLeft < 8) {
return false;
}
@ -100,21 +112,16 @@ export class Parser extends EventEmitter {
}
const tick = stream.readInt32();
const viewOrigin: number[][] = [];
const viewAngles: number[][] = [];
switch (type) {
case MessageType.Sigon:
case MessageType.Packet:
this.stream.readInt32(); // flags
for (let j = 0; j < 2; j++) {
viewOrigin[j] = [];
viewAngles[j] = [];
for (let i = 0; i < 3; i++) {
viewOrigin[j][i] = this.stream.readInt32();
this.viewOrigin[j][i] = this.stream.readFloat32();
}
for (let i = 0; i < 3; i++) {
viewAngles[j][i] = this.stream.readInt32();
this.viewAngles[j][i] = this.stream.readFloat32();
}
for (let i = 0; i < 3; i++) {
this.stream.readInt32(); // local viewAngles
@ -127,22 +134,15 @@ export class Parser extends EventEmitter {
stream.byteIndex += 0x04; // unknown / outgoing sequence
break;
case MessageType.SyncTick:
return true;
return {
type: MessageType.SyncTick,
tick,
rawData: stream.readBitStream(0)
};
}
const length = stream.readInt32();
const buffer = stream.readBitStream(length * 8);
return this.parseMessage(buffer, type, tick, length, match);
return this.parseMessage(buffer, type, tick, match);
}
}
export enum MessageType {
Sigon = 1,
Packet = 2,
SyncTick = 3,
ConsoleCmd = 4,
UserCmd = 5,
DataTables = 6,
Stop = 7,
StringTables = 8,
}

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

@ -1,5 +1,7 @@
import {ConsoleCmdPacket} from '../../Data/Packet';
import {Parser} from './Parser';
import {BitStream} from 'bit-buffer';
import {ConsoleCmdMessage, MessageHandler, MessageType} from '../../Data/Message';
export class ConsoleCmd extends Parser {
public parse(): ConsoleCmdPacket[] {
@ -9,3 +11,17 @@ export class ConsoleCmd extends Parser {
}];
}
}
export const ConsoleCmdHandler: MessageHandler<ConsoleCmdMessage> = {
parseMessage: (stream: BitStream, tick: number) => {
return {
type: MessageType.ConsoleCmd,
tick,
rawData: stream,
command: stream.readUTF8String()
};
},
encodeMessage: (message: ConsoleCmdMessage, stream: BitStream) => {
stream.writeUTF8String(message.command);
}
};

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

@ -1,41 +1,41 @@
import {DataTablePacket} from '../../Data/Packet';
import {SendPropDefinition, SendPropFlag, SendPropType} from '../../Data/SendPropDefinition';
import {SendTable} from '../../Data/SendTable';
import {ServerClass} from '../../Data/ServerClass';
import {Parser} from './Parser';
import {DataTablesMessage, MessageHandler, MessageType} from '../../Data/Message';
import {BitStream} from 'bit-buffer';
export class DataTable extends Parser {
public parse(): DataTablePacket[] {
export const DataTableHandler: MessageHandler<DataTablesMessage> = {
parseMessage: (stream: BitStream, tick: number) => {
// https://github.com/LestaD/SourceEngine2007/blob/43a5c90a5ada1e69ca044595383be67f40b33c61/src_main/engine/dt_common_eng.cpp#L356
// https://github.com/LestaD/SourceEngine2007/blob/43a5c90a5ada1e69ca044595383be67f40b33c61/src_main/engine/dt_recv_eng.cpp#L310
// https://github.com/PazerOP/DemoLib/blob/master/DemoLib/Commands/DemoDataTablesCommand.cs
const tables: SendTable[] = [];
const tables: SendTable[] = [];
const tableMap: {[key: string]: SendTable} = {};
while (this.stream.readBoolean()) {
const needsDecoder = this.stream.readBoolean();
const tableName = this.stream.readASCIIString();
const numProps = this.stream.readBits(10);
const table = new SendTable(tableName);
while (stream.readBoolean()) {
const needsDecoder = stream.readBoolean();
const tableName = stream.readASCIIString();
const numProps = stream.readBits(10);
const table = new SendTable(tableName);
// get props metadata
let arrayElementProp;
for (let i = 0; i < numProps; i++) {
const propType = this.stream.readBits(5);
const propName = this.stream.readASCIIString();
const propType = stream.readBits(5);
const propName = stream.readASCIIString();
const nFlagsBits = 16; // might be 11 (old?), 13 (new?), 16(networked) or 17(??)
const flags = this.stream.readBits(nFlagsBits);
const prop = new SendPropDefinition(propType, propName, flags, tableName);
const flags = stream.readBits(nFlagsBits);
const prop = new SendPropDefinition(propType, propName, flags, tableName);
if (propType === SendPropType.DPT_DataTable) {
prop.excludeDTName = this.stream.readASCIIString();
prop.excludeDTName = stream.readASCIIString();
} else {
if (prop.isExcludeProp()) {
prop.excludeDTName = this.stream.readASCIIString();
prop.excludeDTName = stream.readASCIIString();
} else if (prop.type === SendPropType.DPT_Array) {
prop.numElements = this.stream.readBits(10);
prop.numElements = stream.readBits(10);
} else {
prop.lowValue = this.stream.readFloat32();
prop.highValue = this.stream.readFloat32();
prop.bitCount = this.stream.readBits(7);
prop.lowValue = stream.readFloat32();
prop.highValue = stream.readFloat32();
prop.bitCount = stream.readBits(7);
}
}
@ -54,7 +54,7 @@ export class DataTable extends Parser {
throw new Error('expected prop of type array');
}
prop.arrayProperty = arrayElementProp;
arrayElementProp = null;
arrayElementProp = null;
}
if (prop.hasFlag(SendPropFlag.SPROP_INSIDEARRAY)) {
@ -78,38 +78,43 @@ export class DataTable extends Parser {
for (const prop of table.props) {
if (prop.type === SendPropType.DPT_DataTable) {
if (prop.excludeDTName) {
prop.table = tableMap[prop.excludeDTName];
prop.table = tableMap[prop.excludeDTName];
prop.excludeDTName = null;
}
}
}
}
const numServerClasses = this.stream.readUint16(); // short
const numServerClasses = stream.readUint16(); // short
const serverClasses: ServerClass[] = [];
if (numServerClasses <= 0) {
throw new Error('expected one or more serverclasses');
}
for (let i = 0; i < numServerClasses; i++) {
const classId = this.stream.readUint16();
const classId = stream.readUint16();
if (classId > numServerClasses) {
throw new Error('invalid class id');
}
const className = this.stream.readASCIIString();
const dataTable = this.stream.readASCIIString();
const className = stream.readASCIIString();
const dataTable = stream.readASCIIString();
serverClasses.push(new ServerClass(classId, className, dataTable));
}
const bitsLeft = (this.length * 8) - this.stream.index;
const bitsLeft = (this.length * 8) - stream.index;
if (bitsLeft > 7 || bitsLeft < 0) {
throw new Error('unexpected remaining data in datatable (' + bitsLeft + ' bits)');
}
return [{
packetType: 'dataTable',
return {
type: MessageType.DataTables,
tick,
rawData: stream,
tables,
serverClasses,
}];
};
},
encodeMessage: (message, stream) => {
throw new Error('Not implemented');
}
}
};

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

@ -13,83 +13,85 @@ import {EncodeUpdateStringTable, ParseUpdateStringTable} from '../Packet/UpdateS
import {EncodeUserMessage, ParseUserMessage} from '../Packet/UserMessage';
import {EncodeVoiceData, ParseVoiceData} from '../Packet/VoiceData';
import {EncodeVoiceInit, ParseVoiceInit} from '../Packet/VoiceInit';
import {Parser} from './Parser';
import {Packet as IPacket, PacketTypeId} from '../../Data/Packet';
import {MessageHandler, MessageType, PacketMessage} from '../../Data/Message';
import {BitStream} from 'bit-buffer';
import {ParserState} from '../../Data/ParserState';
type PacketHandlerMap = Map<PacketTypeId, PacketHandler<IPacket>>;
export class Packet extends Parser {
private static handlers: PacketHandlerMap = new Map<PacketTypeId, PacketHandler<IPacket>>([
[PacketTypeId.file,
make('file', 'transferId{32}fileName{s}requested{b}')],
[PacketTypeId.netTick,
make('netTick', 'tick{32}frameTime{16}stdDev{16}')],
[PacketTypeId.stringCmd,
make('stringCmd', 'command{s}')],
[PacketTypeId.setConVar,
{parser: ParseSetConVar, encoder: EncodeSetConVar}],
[PacketTypeId.sigOnState,
make('sigOnState', 'state{8}count{32}')],
[PacketTypeId.print,
make('print', 'value{s}')],
[PacketTypeId.serverInfo,
make('serverInfo',
'version{16}serverCount{32}stv{b}dedicated{b}maxCrc{32}maxClasses{16}' +
'mapHash{128}playerCount{8}maxPlayerCount{8}intervalPerTick{f32}platform{s1}' +
'game{s}map{s}skybox{s}serverName{s}replay{b}')],
[PacketTypeId.classInfo,
{parser: ParseClassInfo, encoder: EncodeClassInfo}],
[PacketTypeId.setPause,
make('setPause', 'paused{b}')],
[PacketTypeId.createStringTable,
{parser: ParseCreateStringTable, encoder: EncodeCreateStringTable}],
[PacketTypeId.updateStringTable,
{parser: ParseUpdateStringTable, encoder: EncodeUpdateStringTable}],
[PacketTypeId.voiceInit,
{parser: ParseVoiceInit, encoder: EncodeVoiceInit}],
[PacketTypeId.voiceData,
{parser: ParseVoiceData, encoder: EncodeVoiceData}],
[PacketTypeId.parseSounds,
{parser: ParseParseSounds, encoder: EncodeParseSounds}],
[PacketTypeId.setView,
make('setView', 'index{11}')],
[PacketTypeId.fixAngle,
make('fixAngle', 'relative{b}x{16}y{16}z{16}')],
[PacketTypeId.bspDecal,
{parser: ParseBSPDecal, encoder: EncodeBSPDecal}],
[PacketTypeId.userMessage,
{parser: ParseUserMessage, encoder: EncodeUserMessage}],
[PacketTypeId.entityMessage,
make('entityMessage', 'index{11}classId{9}length{11}data{$length}')],
[PacketTypeId.gameEvent,
{parser: ParseGameEvent, encoder: EncodeGameEvent}],
[PacketTypeId.packetEntities,
{parser: ParsePacketEntities, encoder: voidEncoder}],
[PacketTypeId.tempEntities,
{parser: ParseTempEntities, encoder: EncodeTempEntities}],
[PacketTypeId.preFetch,
make('preFetch', 'index{14}')],
[PacketTypeId.menu,
make('menu', 'type{u16}length{u16}data{$length*8}')],
[PacketTypeId.gameEventList,
{parser: ParseGameEventList, encoder: EncodeGameEventList}],
[PacketTypeId.getCvarValue,
make('getCvarValue', 'cookie{32}value{s}')],
[PacketTypeId.cmdKeyValues,
make('cmdKeyValues', 'length{32}data{$length}')],
]);
const handlers: PacketHandlerMap = new Map<PacketTypeId, PacketHandler<IPacket>>([
[PacketTypeId.file,
make('file', 'transferId{32}fileName{s}requested{b}')],
[PacketTypeId.netTick,
make('netTick', 'tick{32}frameTime{16}stdDev{16}')],
[PacketTypeId.stringCmd,
make('stringCmd', 'command{s}')],
[PacketTypeId.setConVar,
{parser: ParseSetConVar, encoder: EncodeSetConVar}],
[PacketTypeId.sigOnState,
make('sigOnState', 'state{8}count{32}')],
[PacketTypeId.print,
make('print', 'value{s}')],
[PacketTypeId.serverInfo,
make('serverInfo',
'version{16}serverCount{32}stv{b}dedicated{b}maxCrc{32}maxClasses{16}' +
'mapHash{128}playerCount{8}maxPlayerCount{8}intervalPerTick{f32}platform{s1}' +
'game{s}map{s}skybox{s}serverName{s}replay{b}')],
[PacketTypeId.classInfo,
{parser: ParseClassInfo, encoder: EncodeClassInfo}],
[PacketTypeId.setPause,
make('setPause', 'paused{b}')],
[PacketTypeId.createStringTable,
{parser: ParseCreateStringTable, encoder: EncodeCreateStringTable}],
[PacketTypeId.updateStringTable,
{parser: ParseUpdateStringTable, encoder: EncodeUpdateStringTable}],
[PacketTypeId.voiceInit,
{parser: ParseVoiceInit, encoder: EncodeVoiceInit}],
[PacketTypeId.voiceData,
{parser: ParseVoiceData, encoder: EncodeVoiceData}],
[PacketTypeId.parseSounds,
{parser: ParseParseSounds, encoder: EncodeParseSounds}],
[PacketTypeId.setView,
make('setView', 'index{11}')],
[PacketTypeId.fixAngle,
make('fixAngle', 'relative{b}x{16}y{16}z{16}')],
[PacketTypeId.bspDecal,
{parser: ParseBSPDecal, encoder: EncodeBSPDecal}],
[PacketTypeId.userMessage,
{parser: ParseUserMessage, encoder: EncodeUserMessage}],
[PacketTypeId.entityMessage,
make('entityMessage', 'index{11}classId{9}length{11}data{$length}')],
[PacketTypeId.gameEvent,
{parser: ParseGameEvent, encoder: EncodeGameEvent}],
[PacketTypeId.packetEntities,
{parser: ParsePacketEntities, encoder: voidEncoder}],
[PacketTypeId.tempEntities,
{parser: ParseTempEntities, encoder: EncodeTempEntities}],
[PacketTypeId.preFetch,
make('preFetch', 'index{14}')],
[PacketTypeId.menu,
make('menu', 'type{u16}length{u16}data{$length*8}')],
[PacketTypeId.gameEventList,
{parser: ParseGameEventList, encoder: EncodeGameEventList}],
[PacketTypeId.getCvarValue,
make('getCvarValue', 'cookie{32}value{s}')],
[PacketTypeId.cmdKeyValues,
make('cmdKeyValues', 'length{32}data{$length}')],
]);
public parse() {
export const PacketMessageHandler: MessageHandler<PacketMessage> = {
parseMessage: (stream: BitStream, tick: number, state: ParserState) => {
const packets: IPacket[] = [];
let lastPacketType = 0;
while (this.bitsLeft > 6) { // last 6 bits for NOOP
const type = this.stream.readBits(6) as PacketTypeId;
while (stream.bitsLeft > 6) { // last 6 bits for NOOP
const type = stream.readBits(6) as PacketTypeId;
if (type !== 0) {
const parser = Packet.handlers.get(type);
const parser = handlers.get(type);
if (parser) {
const skip = this.skippedPackets.indexOf(type) !== -1;
const packet = parser.parser(this.stream, this.state, skip);
const skip = state.skippedPackets.indexOf(type) !== -1;
const packet = parser.parser(stream, state, skip);
packets.push(packet);
} else {
throw new Error(`Unknown packet type ${type} just parsed a ${PacketTypeId[lastPacketType]}`);
@ -97,10 +99,14 @@ export class Packet extends Parser {
lastPacketType = type;
}
}
return packets;
return {
type: MessageType.Packet,
tick,
rawData: stream,
packets
};
},
encodeMessage: (message, stream) => {
throw new Error('Not implemented');
}
get bitsLeft() {
return (this.length * 8) - this.stream.index;
}
}
};

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 '../../Parser';
import {MessageType} from '../../Data/Message';
import {ParserState} from '../../Data/ParserState';
export abstract class Parser {

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

@ -1,45 +1,49 @@
import {StringTablePacket} from '../../Data/Packet';
import {StringTable as StringTableObject, StringTableEntry} from '../../Data/StringTable';
import {Parser} from './Parser';
import {MessageHandler, MessageType, StringTablesMessage} from '../../Data/Message';
import {BitStream} from 'bit-buffer';
export class StringTable extends Parser {
public parse(): StringTablePacket[] {
export const StringTableHandler: MessageHandler<StringTablesMessage> = {
parseMessage: (stream: BitStream, tick: number) => {
// we get the tables from the packets
// return [{
// packetType: 'stringTable',
// tables: []
// }];
// https://github.com/StatsHelix/demoinfo/blob/3d28ea917c3d44d987b98bb8f976f1a3fcc19821/DemoInfo/ST/StringTableParser.cs
const tableCount = this.stream.readUint8();
const tableCount = stream.readUint8();
const tables: StringTableObject[] = [];
let extraDataLength;
for (let i = 0; i < tableCount; i++) {
const entries: StringTableEntry[] = [];
const tableName = this.stream.readASCIIString();
const entryCount = this.stream.readUint16();
const tableName = stream.readASCIIString();
const entryCount = stream.readUint16();
for (let j = 0; j < entryCount; j++) {
let entry: StringTableEntry;
try {
entry = {
text: this.stream.readUTF8String(),
text: stream.readUTF8String(),
};
} catch (e) {
return [{
packetType: 'stringTable',
return {
type: MessageType.StringTables,
tick,
rawData: stream,
tables,
}];
};
}
if (this.stream.readBoolean()) {
extraDataLength = this.stream.readUint16();
if ((extraDataLength * 8) > this.stream.bitsLeft) {
if (stream.readBoolean()) {
extraDataLength = stream.readUint16();
if ((extraDataLength * 8) > stream.bitsLeft) {
// extradata to long, can't continue parsing the tables
// seems to happen in POV demos after the MyM update
return [{
packetType: 'stringTable',
return {
type: MessageType.StringTables,
tick,
rawData: stream,
tables,
}];
};
}
entry.extraData = this.stream.readBitStream(extraDataLength * 8);
entry.extraData = stream.readBitStream(extraDataLength * 8);
}
entries.push(entry);
}
@ -49,18 +53,23 @@ export class StringTable extends Parser {
maxEntries: entryCount,
};
tables.push(table);
if (this.stream.readBits(1)) {
this.stream.readASCIIString();
if (this.stream.readBits(1)) {
if (stream.readBits(1)) {
stream.readASCIIString();
if (stream.readBits(1)) {
// throw 'more extra data not implemented';
extraDataLength = this.stream.readBits(16);
this.stream.readBits(extraDataLength);
extraDataLength = stream.readBits(16);
stream.readBits(extraDataLength);
}
}
}
return [{
packetType: 'stringTable',
return {
type: MessageType.StringTables,
tick,
rawData: stream,
tables,
}];
};
},
encodeMessage: (message, stream) => {
throw new Error('Not implemented');
}
}
};

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

@ -1,7 +1,15 @@
import {Parser} from './Parser';
import {MessageHandler, MessageType, UserCmdMessage} from '../../Data/Message';
import {BitStream} from 'bit-buffer';
export class UserCmd extends Parser {
public parse() {
return [];
export const UserCmdHandler: MessageHandler<UserCmdMessage> = {
parseMessage: (stream: BitStream, tick: number) => {
return {
type: MessageType.UserCmd,
tick,
rawData: stream
};
},
encodeMessage: (message, stream) => {
throw new Error('not implemented');
}
}
};

14
src/StreamDemo.ts
View file

@ -1,14 +0,0 @@
import {Stream} from 'stream';
import {StreamParser} from './StreamParser';
export class StreamDemo {
public stream: Stream;
constructor(nodeStream: Stream) {
this.stream = nodeStream;
}
public getParser() {
return new StreamParser(this.stream);
}
}

88
src/StreamParser.ts
View file

@ -1,88 +0,0 @@
import {BitStream} from 'bit-buffer';
import {Buffer} from 'buffer';
import {Stream} from 'stream';
import {MessageType, Parser} from './Parser';
export class StreamParser extends Parser {
public header: any;
private buffer: Buffer;
private sourceStream: Stream;
constructor(stream: Stream) {
super(new BitStream(new ArrayBuffer(0)));
this.sourceStream = stream;
this.on('packet', this.match.handlePacket.bind(this.match));
this.header = null;
this.buffer = new Buffer(0);
}
public start() {
this.sourceStream.on('data', this.handleData.bind(this));
this.sourceStream.on('end', function() {
this.emit('done', this.match);
}.bind(this));
}
private eatBuffer(length) {
this.buffer = shrinkBuffer(this.buffer, length);
}
private handleData(data) {
this.buffer = Buffer.concat([this.buffer, data]);
if (this.header === null) {
if (this.buffer.length > 1072) {
this.header = this.parseHeader(new BitStream(this.buffer));
this.eatBuffer(1072);
}
} else {
this.readStreamMessage();
}
}
private readStreamMessage() {
if (this.buffer.length < 9) { // 9 byte minimum message header (type, tick, length)
return;
}
const stream = new BitStream(this.buffer);
const type = stream.readBits(8);
if (type === MessageType.Stop) {
return;
}
const tick = stream.readInt32();
let headerSize = 5;
let extraHeader = 0;
switch (type) {
case MessageType.Sigon:
case MessageType.Packet:
extraHeader += 0x54; // command/sequence info
break;
case MessageType.UserCmd:
extraHeader += 0x04; // unknown / outgoing sequence
break;
case MessageType.Stop:
case MessageType.SyncTick:
this.eatBuffer(headerSize);
return;
}
stream.byteIndex += extraHeader;
const length = stream.readInt32();
headerSize += extraHeader + 4;
if (this.buffer.length < (headerSize + length)) {
return;
}
const messageStream = stream.readBitStream(length * 8);
const message = this.parseMessage(messageStream, type, tick, length, this.match);
this.handleMessage(message);
}
}
function shrinkBuffer(buffer, length) {
if (length < 0) {
throw new Error('cant shrink by negative length ' + length);
}
return buffer.slice(length, buffer.length);
}

1
src/index.ts
View file

@ -1,6 +1,5 @@
export {Demo} from './Demo';
export {Parser} from './Parser';
export {StreamParser} from './StreamParser';
export {Match} from './Data/Match';
export {Player} from './Data/Player';
export {PlayerCondition} from './Data/PlayerCondition';