@deademx/dota2

@deademx/dota2 is a Dota 2 (Source 2) demo parser and replay player for Node.js and modern browsers, built on top of @deademx/engine.

For the shared parser model, player lifecycle, interceptors, configuration, and the full API surface, see the engine documentation. This document covers Dota 2-specific usage only.

Contents

• Installation
  Install for Node.js or use the browser bundle.
• Quick start
  Minimal example to parse a Dota 2 demo file.
• Examples
  Runnable example scripts covering parsing and player.
• Usage
  Dota 2-specific usage patterns.
  • Replay file
    Parse a Dota 2 replay from a .dem file.
  • Data extraction
    Extract Dota 2 chat and query entities.
  • Playback and seeking
    Inspect Dota 2 state at a specific tick.
• Compatibility
  Supported game patch and runtimes.
• Performance
  Measured throughput benchmarks.
• License
  Project licensing information.

Installation

Node.js

npm install @deademx/dota2 --save

import { Parser, Player } from '@deademx/dota2';

Browser

<script src="//cdn.jsdelivr.net/npm/@deademx/dota2@0.X.X/dist/deadem-dota2.min.js"></script>

const { Parser, Player } = window.deademDota2;

Quick start

import { createReadStream } from 'node:fs';

import { Parser, Printer } from '@deademx/dota2';

const parser = new Parser();
const printer = new Printer(parser);

await parser.parse(createReadStream(PATH_TO_DEM_FILE));
await parser.dispose();

printer.printStats();

Parser and Player in @deademx/dota2 are drop-in subclasses of the engine classes — the schema registry is built automatically, so no extra wiring is required.

Examples

All example scripts live in the examples-node-dota2 package. They look for demo files in /demos; missing files are downloaded automatically from the public S3 bucket.

Parsing

Player

Usage

Replay file

import { createReadStream } from 'node:fs';

import { Parser, ParserConfiguration, Printer } from '@deademx/dota2';

const parser = new Parser(new ParserConfiguration({ parserThreads: 0 }));
const printer = new Printer(parser);

await parser.parse(createReadStream(PATH_TO_DEM_FILE));
await parser.dispose();

printer.printStats();

Data extraction

Dota 2-specific message types are exposed via the extended MessagePacketType — for example, DOTA_UM_CHAT_MESSAGE, DOTA_UM_CHAT_EVENT, DOTA_UM_OVERHEAD_EVENT, DOTA_UM_COMBAT_LOG_DATA_HLTV, and more. Dota 2-specific string tables (MODIFIER_NAMES, COMBAT_LOG_NAMES, ECON_ITEMS, …) are exposed via the extended StringTableType.

Filter and extract chat messages:

import { InterceptorStage, MessagePacketType, Parser, ParserConfiguration } from '@deademx/dota2';

const parser = new Parser(new ParserConfiguration({
    messagePacketTypes: [ MessagePacketType.DOTA_UM_CHAT_MESSAGE ]
}));

parser.registerPostInterceptor(InterceptorStage.MESSAGE_PACKET, (demoPacket, messagePacket) => {
    if (messagePacket.type === MessagePacketType.DOTA_UM_CHAT_MESSAGE) {
        console.log(messagePacket.data);
    }
});

await parser.parse(readable);
await parser.dispose();

Query entities and classes after the parse completes:

await parser.parse(readable);

const demo = parser.getDemo();
const entities = demo.getEntities();

console.log(`Total entities at end of demo: ${entities.length}`);

Playback and seeking

import { createReadStream } from 'node:fs';

import { Player } from '@deademx/dota2';

const player = new Player();

await player.load(createReadStream(PATH_TO_DEM_FILE));
await player.seekToTick(player.getLastTick());

const demo = player.getDemo();

console.log(`Ticks: ${player.getFirstTick()} → ${player.getLastTick()}`);
console.log(`Entities at last tick: ${demo.getEntities().length}`);

await player.dispose();

Compatibility

• Game patch: tested with Dota 2 demos from patch 7.41b and below.
• Node.js: v18.0.0 and above.
• Browsers: latest Chrome, Firefox, Safari, Edge.

Performance

See the engine performance notes for how configuration choices affect parser throughput in general.

Single-threaded (parserThreads = 0)

Memory below reports the sampled peak RSS from isolated runs.

License

This project is licensed under the MIT License.