def advance(self, tick, pbmsg):
packet = i.construct(p_io.construct(pbmsg.data))
all_ust = packet.find_all(pb_n.svc_UpdateStringTable)
for _pbmsg in [p_io.parse(p.kind, m) for p, m in all_ust]:
key = self.string_tables.keys()[_pbmsg.table_id]
_st = self.string_tables[key]
bs = b_io.construct(_pbmsg.string_data)
ne = _pbmsg.num_changed_entries
eb, sf, sb = _st.entry_bits, _st.size_fixed, _st.size_bits
for entry in u_st.construct(bs, ne, eb, sf, sb):
_st.update(entry)
p, m = packet.find(pb_n.svc_PacketEntities)
pe = p_io.parse(p.kind, m)
ct = pe.updated_entries
bs = b_io.construct(pe.entity_data)
class_bits = self.prologue.class_bits
recv_tables = self.prologue.recv_tables
unpacker = u_ent.construct(bs, -1, ct, False, class_bits, self.world)
for index, mode, context in unpacker:
if mode & u_ent.PVS.Entering:
cls, serial, diff = context
data = self.string_tables['instancebaseline'].get(cls)[1]
bs = b_io.construct(data)
unpacker = u_ent.construct(bs, -1, 1, False, class_bits, self.world)
state = unpacker.unpack_baseline(self.prologue.recv_tables[cls])
state.update(diff)
self.world.create(cls, index, serial, state)
elif mode & u_ent.PVS.Deleting:
self.world.delete(index)
elif mode ^ u_ent.PVS.Leaving:
state = {} if self.sparse else dict(self.world.find_index(index))
state.update(context)
self.world.update(index, state)
all_um = packet.find_all(pb_n.svc_UserMessage)
user_messages = [e_um.parse(p_io.parse(p.kind, m)) for p, m in all_um]
all_ge = packet.find_all(pb_n.svc_GameEvent)
gel = self.prologue.game_event_list
game_events = [e_ge.parse(p_io.parse(p.kind, m), gel) for p, m in all_ge]
modifiers = self.string_tables['ActiveModifiers'].observer
_, gamerules = self.world.find_by_dt('DT_DOTAGamerulesProxy')
modifiers.expire(gamerules[('DT_DOTAGamerules', 'm_fGameTime')])
return tick, user_messages, game_events, self.world, modifiers
def fast_forward(prologue, demo_io, tick=None):
full_packets, remaining_packets = [], []
world = w.construct(prologue.recv_tables)
string_tables = copy.deepcopy(prologue.string_tables)
if tick:
iter_bootstrap = iter(demo_io)
try:
while True:
p, m = next(iter_bootstrap)
if p.kind == pb_d.DEM_FullPacket:
full_packets.append((p, m))
remaining_packets = []
else:
remaining_packets.append((p, m))
if p.tick > tick - 2: # hack?
break
except StopIteration:
raise EOFError()
if full_packets:
for peek, message in full_packets:
full_packet = d_io.parse(peek.kind, peek.compressed, message)
for table in full_packet.string_table.tables:
assert not table.items_clientside
entries = [(_i, e.str, e.data)
for _i, e in enumerate(table.items)]
string_tables[table.table_name].update_all(entries)
peek, message = full_packets[-1]
pbmsg = d_io.parse(peek.kind, peek.compressed, message)
packet = i.construct(p_io.construct(pbmsg.packet.data))
peek, message = packet.find(pb_n.svc_PacketEntities)
pe = p_io.parse(peek.kind, message)
ct = pe.updated_entries
bs = b_io.construct(pe.entity_data)
unpacker = u_ent.construct(bs, -1, ct, False, prologue.class_bits,
world)
for index, mode, (cls, serial, diff) in unpacker:
data = string_tables['instancebaseline'].get(cls)[1]
bs = b_io.construct(data)
unpacker = u_ent.construct(bs, -1, 1, False, prologue.class_bits,
world)
state = unpacker.unpack_baseline(prologue.recv_tables[cls])
state.update(diff)
try:
world.create(cls, index, serial, state)
except AssertionError, e:
# TODO: log here.
pass
def fast_forward(prologue, demo_io, tick=None):
full_packets, remaining_packets = [], []
world = w.construct(prologue.recv_tables)
string_tables = copy.deepcopy(prologue.string_tables)
if tick:
iter_bootstrap = iter(demo_io)
try:
while True:
p, m = next(iter_bootstrap)
if p.kind == pb_d.DEM_FullPacket:
full_packets.append((p, m))
remaining_packets = []
else:
remaining_packets.append((p, m))
if p.tick > tick - 2: # hack?
break
except StopIteration:
raise EOFError()
if full_packets:
for peek, message in full_packets:
full_packet = d_io.parse(peek.kind, peek.compressed, message)
for table in full_packet.string_table.tables:
assert not table.items_clientside
entries = [(_i, e.str, e.data) for _i, e in enumerate(table.items)]
string_tables[table.table_name].update_all(entries)
peek, message = full_packets[-1]
pbmsg = d_io.parse(peek.kind, peek.compressed, message)
packet = i.construct(p_io.construct(pbmsg.packet.data))
peek, message = packet.find(pb_n.svc_PacketEntities)
pe = p_io.parse(peek.kind, message)
ct = pe.updated_entries
bs = b_io.construct(pe.entity_data)
unpacker = u_ent.construct(bs, -1, ct, False, prologue.class_bits, world)
for index, mode, (cls, serial, diff) in unpacker:
data = string_tables['instancebaseline'].get(cls)[1]
bs = b_io.construct(data)
unpacker = u_ent.construct(bs, -1, 1, False, prologue.class_bits, world)
state = unpacker.unpack_baseline(prologue.recv_tables[cls])
state.update(diff)
try:
world.create(cls, index, serial, state)
except AssertionError, e:
# TODO: log here.
pass
def all_svc_update_string_table(self):
kind = pb_n.svc_UpdateStringTable
return ((p, p_io.parse(kind, m)) for p, m in self.find_all(kind))
def net_tick(self):
kind = pb_n.net_Tick
p, m = self.find(kind)
return p, p_io.parse(kind, m)
def svc_packet_entities(self):
kind = pb_n.svc_PacketEntities
p, m = self.find(kind)
return p, p_io.parse(kind, m)
def svc_server_info(self): kind = pb_n.svc_ServerInfo p, m = self.find(kind) return p, p_io.parse(kind, m)
def svc_voice_init(self):
kind = pb_n.svc_VoiceInit
p, m = self.find(kind)
return p, p_io.parse(kind, m)
def svc_voice_init(self): kind = pb_n.svc_VoiceInit p, m = self.find(kind) return p, p_io.parse(kind, m)
def advance(self, tick, pbmsg):
self.tick = tick
packet = ie_packet.construct(p_io.construct(pbmsg.data))
am_entries = []
for _, _pbmsg in packet.all_svc_update_string_table:
key = self.string_tables.keys()[_pbmsg.table_id]
_st = self.string_tables[key]
bs = b_io.construct(_pbmsg.string_data)
ne = _pbmsg.num_changed_entries
eb, sf, sb = _st.entry_bits, _st.size_fixed, _st.size_bits
entries = u_st.construct(bs, ne, eb, sf, sb)
if key == 'ActiveModifiers':
am_entries = list(entries)
else:
[_st.update(e) for e in entries]
um = packet.find_all(pb_n.svc_UserMessage)
self.user_messages = [e_um.parse(p_io.parse(p.kind, m)) for p, m in um]
ge = packet.find_all(pb_n.svc_GameEvent)
gel = self.prologue.game_event_list
self.game_events = [
e_ge.parse(p_io.parse(p.kind, m), gel) for p, m in ge
]
p, m = packet.find(pb_n.svc_PacketEntities)
pe = p_io.parse(p.kind, m)
ct = pe.updated_entries
bs = b_io.construct(pe.entity_data)
class_bits = self.prologue.class_bits
recv_tables = self.prologue.recv_tables
unpacker = u_ent.construct(bs, -1, ct, False, class_bits, self.world)
for index, mode, context in unpacker:
if mode & u_ent.PVS.Entering:
cls, serial, diff = context
data = self.string_tables['instancebaseline'].get(cls)[1]
bs = b_io.construct(data)
unpacker = u_ent.construct(bs, -1, 1, False, class_bits,
self.world)
state = unpacker.unpack_baseline(
self.prologue.recv_tables[cls])
state.update(diff)
self.world.create(cls, index, serial, state, dict(diff))
elif mode & u_ent.PVS.Deleting:
self.world.delete(index)
elif mode ^ u_ent.PVS.Leaving:
state = dict(context) if self.sparse else dict(
self.world.find_index(index), **context)
diff = state if self.sparse else dict(context)
self.world.update(index, state, diff)
[self.modifiers.note(e) for e in am_entries]
self.modifiers.limit(self.world)
_, gamerules = self.world.find_by_dt('DT_DOTAGamerulesProxy')
game_time_key = ('DT_DOTAGamerulesProxy',
'DT_DOTAGamerules.m_fGameTime')
self.modifiers.expire(gamerules[game_time_key])
def all_svc_game_event(self):
kind = pb_n.svc_GameEvent
return ((p, p_io.parse(kind, m)) for p, m in self.find_all(kind))
def all_svc_send_table(self):
kind = pb_n.svc_SendTable
return ((p, p_io.parse(kind, m)) for p, m in self.find_all(kind))
def all_svc_user_message(self): kind = pb_n.svc_UserMessage return ((p, p_io.parse(kind, m)) for p, m in self.find_all(kind))
def all_svc_game_event(self): kind = pb_n.svc_GameEvent return ((p, p_io.parse(kind, m)) for p, m in self.find_all(kind))
def all_svc_update_string_table(self): kind = pb_n.svc_UpdateStringTable return ((p, p_io.parse(kind, m)) for p, m in self.find_all(kind))
def svc_packet_entities(self): kind = pb_n.svc_PacketEntities p, m = self.find(kind) return p, p_io.parse(kind, m)
def net_tick(self): kind = pb_n.net_Tick p, m = self.find(kind) return p, p_io.parse(kind, m)
def all_svc_user_message(self):
kind = pb_n.svc_UserMessage
return ((p, p_io.parse(kind, m)) for p, m in self.find_all(kind))
def load(io, tick=0):
demo_io = d_io.construct(io)
prologue = i_p.construct(demo_io)
# mash all packet svc messages together, then index them
signon_packets = list(prologue.signon_packets)
pbmsgs = [d_io.parse(p.kind, p.compressed, m) for p, m in signon_packets]
data = ''.join([p.data for p in pbmsgs])
packet_io = p_io.construct(data)
packet = i.construct(packet_io)
# class info
peek, message = prologue.class_info
pbmsg = d_io.parse(peek.kind, peek.compressed, message)
class_info = c.OrderedDict()
for _c in pbmsg.classes:
_id, dt, name = str(_c.class_id), _c.table_name, _c.network_name
class_info[_id] = (dt, name)
# send tables
peek, message = prologue.send_tables
pbmsg = d_io.parse(peek.kind, peek.compressed, message)
send_tables = c.OrderedDict()
for peek, message in p_io.construct(pbmsg.data):
pbmsg = p_io.parse(peek.kind, message)
if pbmsg.is_end:
break
send_table = _parse_cdemo_send_table(pbmsg)
send_tables[send_table.dt] = send_table
# recv tables
flattener = Flattener(send_tables)
recv_tables = c.OrderedDict()
for st in filter(test_needs_decoder, send_tables.values()):
props = flattener.flatten(st)
cls = next(_id for _id, (dt, _) in class_info.items() if dt == st.dt)
recv_tables[cls] = dt_r.construct(st.dt, props)
# game event list
peek, message = packet.find(pb_n.svc_GameEventList)
pbmsg = p_io.parse(peek.kind, message)
game_event_list = c.OrderedDict()
for desc in pbmsg.descriptors:
_id, name = desc.eventid, desc.name
keys = [(k.type, k.name) for k in desc.keys]
game_event_list[_id] = (name, keys)
# string tables
entries = packet.find_all(pb_n.svc_CreateStringTable)
pbmsgs = [p_io.parse(p.kind, m) for p, m in entries]
string_tables = _parse_all_csvc_create_string_tables(pbmsgs)
# meta: file header
peek, message = prologue.file_header
pbmsg = d_io.parse(peek.kind, peek.compressed, message)
file_header = FileHeader(*[getattr(pbmsg, a) for a in FileHeader._fields])
# meta: server_info
peek, message = packet.find(pb_n.svc_ServerInfo)
pbmsg = p_io.parse(peek.kind, message)
server_info = ServerInfo(*[getattr(pbmsg, a) for a in ServerInfo._fields])
# meta: class bits
class_bits = server_info.max_classes.bit_length()
# meta: voice init
peek, message = packet.find(pb_n.svc_VoiceInit)
pbmsg = p_io.parse(peek.kind, message)
voice_init = VoiceInit(*[getattr(pbmsg, a) for a in VoiceInit._fields])
meta = Meta(file_header, server_info, voice_init)
return Prologue(meta, recv_tables, string_tables, game_event_list,
class_bits)
def advance(self, tick, pbmsg):
packet = i.construct(p_io.construct(pbmsg.data))
all_ust = packet.find_all(pb_n.svc_UpdateStringTable)
for _pbmsg in [p_io.parse(p.kind, m) for p, m in all_ust]:
key = self.string_tables.keys()[_pbmsg.table_id]
_st = self.string_tables[key]
bs = b_io.construct(_pbmsg.string_data)
ne = _pbmsg.num_changed_entries
eb, sf, sb = _st.entry_bits, _st.size_fixed, _st.size_bits
for entry in u_st.construct(bs, ne, eb, sf, sb):
_st.update(entry)
p, m = packet.find(pb_n.svc_PacketEntities)
pe = p_io.parse(p.kind, m)
ct = pe.updated_entries
bs = b_io.construct(pe.entity_data)
class_bits = self.prologue.class_bits
recv_tables = self.prologue.recv_tables
unpacker = u_ent.construct(bs, -1, ct, False, class_bits, self.world)
for index, mode, context in unpacker:
if mode & u_ent.PVS.Entering:
cls, serial, diff = context
data = self.string_tables['instancebaseline'].get(cls)[1]
bs = b_io.construct(data)
unpacker = u_ent.construct(bs, -1, 1, False, class_bits,
self.world)
state = unpacker.unpack_baseline(
self.prologue.recv_tables[cls])
state.update(diff)
self.world.create(cls, index, serial, state)
elif mode & u_ent.PVS.Deleting:
self.world.delete(index)
elif mode ^ u_ent.PVS.Leaving:
state = {} if self.sparse else dict(
self.world.find_index(index))
state.update(context)
self.world.update(index, state)
all_um = packet.find_all(pb_n.svc_UserMessage)
user_messages = [e_um.parse(p_io.parse(p.kind, m)) for p, m in all_um]
all_ge = packet.find_all(pb_n.svc_GameEvent)
gel = self.prologue.game_event_list
game_events = [
e_ge.parse(p_io.parse(p.kind, m), gel) for p, m in all_ge
]
modifiers = self.string_tables['ActiveModifiers'].observer
_, gamerules = self.world.find_by_dt('DT_DOTAGamerulesProxy')
modifiers.expire(gamerules[('DT_DOTAGamerules', 'm_fGameTime')])
return tick, user_messages, game_events, self.world, modifiers
def svc_game_event_list(self):
kind = pb_n.svc_GameEventList
p, m = self.find(kind)
return p, p_io.parse(kind, m)
def advance(self, tick, pbmsg):
self.tick = tick
packet = ie_packet.construct(p_io.construct(pbmsg.data))
am_entries = []
for _, _pbmsg in packet.all_svc_update_string_table:
key = self.string_tables.keys()[_pbmsg.table_id]
_st = self.string_tables[key]
bs = b_io.construct(_pbmsg.string_data)
ne = _pbmsg.num_changed_entries
eb, sf, sb = _st.entry_bits, _st.size_fixed, _st.size_bits
entries = u_st.construct(bs, ne, eb, sf, sb)
if key == 'ActiveModifiers':
am_entries = list(entries)
else:
[_st.update(e) for e in entries]
um = packet.find_all(pb_n.svc_UserMessage)
self.user_messages = [e_um.parse(p_io.parse(p.kind, m)) for p, m in um]
ge = packet.find_all(pb_n.svc_GameEvent)
gel = self.prologue.game_event_list
self.game_events = [e_ge.parse(p_io.parse(p.kind, m), gel) for p, m in ge]
p, m = packet.find(pb_n.svc_PacketEntities)
pe = p_io.parse(p.kind, m)
ct = pe.updated_entries
bs = b_io.construct(pe.entity_data)
class_bits = self.prologue.class_bits
recv_tables = self.prologue.recv_tables
unpacker = u_ent.construct(bs, -1, ct, False, class_bits, self.world)
for index, mode, context in unpacker:
if mode & u_ent.PVS.Entering:
cls, serial, diff = context
data = self.string_tables['instancebaseline'].get(cls)[1]
bs = b_io.construct(data)
unpacker = u_ent.construct(bs, -1, 1, False, class_bits, self.world)
state = unpacker.unpack_baseline(self.prologue.recv_tables[cls])
state.update(diff)
self.world.create(cls, index, serial, state, dict(diff))
elif mode & u_ent.PVS.Deleting:
self.world.delete(index)
elif mode ^ u_ent.PVS.Leaving:
state = dict(context) if self.sparse else dict(self.world.find_index(index), **context)
diff = state if self.sparse else dict(context)
self.world.update(index, state, diff)
[self.modifiers.note(e) for e in am_entries]
self.modifiers.limit(self.world)
_, gamerules = self.world.find_by_dt('DT_DOTAGamerulesProxy')
game_time_key = ('DT_DOTAGamerulesProxy', 'DT_DOTAGamerules.m_fGameTime')
self.modifiers.expire(gamerules[game_time_key])
def svc_server_info(self):
kind = pb_n.svc_ServerInfo
p, m = self.find(kind)
return p, p_io.parse(kind, m)
def all_svc_send_table(self): kind = pb_n.svc_SendTable return ((p, p_io.parse(kind, m)) for p, m in self.find_all(kind))
def svc_game_event_list(self): kind = pb_n.svc_GameEventList p, m = self.find(kind) return p, p_io.parse(kind, m)
