demostf/parser
1
0
Fork 0
mirror of https://codeberg.org/demostf/parser.git synced 2026-06-03 10:14:06 +02:00
Code Issues Releases Wiki Activity

cleanup

Browse source
This commit is contained in:
Robin Appelman 2019-03-06 22:20:51 +01:00
commit 9f622385ca
20 changed files with 132 additions and 173 deletions
Download patch file Download diff file Expand all files Collapse all files

10
src/bin/main.rs
View file

@ -1,21 +1,19 @@
#[allow(unused_variables)]
use std::error::Error;
use std::fs;
use std::env;
use std::fs;
pub use tf_demo_parser::{Demo, DemoParser, Parse, ParseError, ParserState, Result, Stream};
fn main() -> std::result::Result<(), Box<ParseError>> {
let args: Vec<_> = env::args().collect();
if args.len() < 2{
if args.len() < 2 {
panic!("1 argument required");
}
let path = args[1].clone();
let file = fs::read(path).expect("Unable to read file");
let demo = Demo::new(file);
let stream: Stream = demo.get_stream();
let mut parser = DemoParser::new(stream);
let (header, state) = parser.parse_demo()?;
let parser = DemoParser::new(stream);
let (_, state) = parser.parse_demo()?;
let json = serde_json::to_string(&state).unwrap_or("err".to_string());
println!("{}", json);
Ok(())

142
src/demo/gameevent_gen.rs
View file

@ -1,7 +1,5 @@
use super::gamevent::{FromGameEventValue, FromRawGameEvent, GameEventValue, RawGameEvent};
use crate::{ParseError, Result};
use bitstream_reader::BitRead;
use std::collections::HashMap;
// auto generated, nobody in their right mind would write this manually
@ -617,7 +615,7 @@ impl FromRawGameEvent for ClientFullConnectEvent {
#[derive(Debug)]
pub struct HostQuitEvent {}
impl FromRawGameEvent for HostQuitEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(HostQuitEvent {})
}
}
@ -1327,7 +1325,7 @@ impl FromRawGameEvent for BasePlayerTeleportedEvent {
#[derive(Debug)]
pub struct GameInitEvent {}
impl FromRawGameEvent for GameInitEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(GameInitEvent {})
}
}
@ -1741,7 +1739,7 @@ impl FromRawGameEvent for FlareIgniteNpcEvent {
#[derive(Debug)]
pub struct HelicopterGrenadePuntMissEvent {}
impl FromRawGameEvent for HelicopterGrenadePuntMissEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(HelicopterGrenadePuntMissEvent {})
}
}
@ -1749,7 +1747,7 @@ impl FromRawGameEvent for HelicopterGrenadePuntMissEvent {
#[derive(Debug)]
pub struct UserDataDownloadedEvent {}
impl FromRawGameEvent for UserDataDownloadedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(UserDataDownloadedEvent {})
}
}
@ -1841,7 +1839,7 @@ impl FromRawGameEvent for HLTVChangedTargetEvent {
#[derive(Debug)]
pub struct VoteEndedEvent {}
impl FromRawGameEvent for VoteEndedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(VoteEndedEvent {})
}
}
@ -2091,7 +2089,7 @@ impl FromRawGameEvent for VoteOptionsEvent {
#[derive(Debug)]
pub struct ReplaySavedEvent {}
impl FromRawGameEvent for ReplaySavedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(ReplaySavedEvent {})
}
}
@ -2099,7 +2097,7 @@ impl FromRawGameEvent for ReplaySavedEvent {
#[derive(Debug)]
pub struct EnteredPerformanceModeEvent {}
impl FromRawGameEvent for EnteredPerformanceModeEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(EnteredPerformanceModeEvent {})
}
}
@ -2107,7 +2105,7 @@ impl FromRawGameEvent for EnteredPerformanceModeEvent {
#[derive(Debug)]
pub struct BrowseReplaysEvent {}
impl FromRawGameEvent for BrowseReplaysEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(BrowseReplaysEvent {})
}
}
@ -2149,7 +2147,7 @@ impl FromRawGameEvent for ReplayYoutubeStatsEvent {
#[derive(Debug)]
pub struct InventoryUpdatedEvent {}
impl FromRawGameEvent for InventoryUpdatedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(InventoryUpdatedEvent {})
}
}
@ -2157,7 +2155,7 @@ impl FromRawGameEvent for InventoryUpdatedEvent {
#[derive(Debug)]
pub struct CartUpdatedEvent {}
impl FromRawGameEvent for CartUpdatedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(CartUpdatedEvent {})
}
}
@ -2165,7 +2163,7 @@ impl FromRawGameEvent for CartUpdatedEvent {
#[derive(Debug)]
pub struct StorePriceSheetUpdatedEvent {}
impl FromRawGameEvent for StorePriceSheetUpdatedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(StorePriceSheetUpdatedEvent {})
}
}
@ -2173,7 +2171,7 @@ impl FromRawGameEvent for StorePriceSheetUpdatedEvent {
#[derive(Debug)]
pub struct GcConnectedEvent {}
impl FromRawGameEvent for GcConnectedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(GcConnectedEvent {})
}
}
@ -2181,7 +2179,7 @@ impl FromRawGameEvent for GcConnectedEvent {
#[derive(Debug)]
pub struct ItemSchemaInitializedEvent {}
impl FromRawGameEvent for ItemSchemaInitializedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(ItemSchemaInitializedEvent {})
}
}
@ -2375,7 +2373,7 @@ impl FromRawGameEvent for CtfFlagCapturedEvent {
#[derive(Debug)]
pub struct ControlPointInitializedEvent {}
impl FromRawGameEvent for ControlPointInitializedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(ControlPointInitializedEvent {})
}
}
@ -2587,7 +2585,7 @@ impl FromRawGameEvent for TeamPlayRoundStartEvent {
#[derive(Debug)]
pub struct TeamPlayRoundActiveEvent {}
impl FromRawGameEvent for TeamPlayRoundActiveEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(TeamPlayRoundActiveEvent {})
}
}
@ -2595,7 +2593,7 @@ impl FromRawGameEvent for TeamPlayRoundActiveEvent {
#[derive(Debug)]
pub struct TeamPlayWaitingBeginsEvent {}
impl FromRawGameEvent for TeamPlayWaitingBeginsEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(TeamPlayWaitingBeginsEvent {})
}
}
@ -2603,7 +2601,7 @@ impl FromRawGameEvent for TeamPlayWaitingBeginsEvent {
#[derive(Debug)]
pub struct TeamPlayWaitingEndsEvent {}
impl FromRawGameEvent for TeamPlayWaitingEndsEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(TeamPlayWaitingEndsEvent {})
}
}
@ -2611,7 +2609,7 @@ impl FromRawGameEvent for TeamPlayWaitingEndsEvent {
#[derive(Debug)]
pub struct TeamPlayWaitingAboutToEndEvent {}
impl FromRawGameEvent for TeamPlayWaitingAboutToEndEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(TeamPlayWaitingAboutToEndEvent {})
}
}
@ -2619,7 +2617,7 @@ impl FromRawGameEvent for TeamPlayWaitingAboutToEndEvent {
#[derive(Debug)]
pub struct TeamPlayRestartRoundEvent {}
impl FromRawGameEvent for TeamPlayRestartRoundEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(TeamPlayRestartRoundEvent {})
}
}
@ -2627,7 +2625,7 @@ impl FromRawGameEvent for TeamPlayRestartRoundEvent {
#[derive(Debug)]
pub struct TeamPlayReadyRestartEvent {}
impl FromRawGameEvent for TeamPlayReadyRestartEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(TeamPlayReadyRestartEvent {})
}
}
@ -2733,7 +2731,7 @@ impl FromRawGameEvent for TeamPlayRoundWinEvent {
#[derive(Debug)]
pub struct TeamPlayUpdateTimerEvent {}
impl FromRawGameEvent for TeamPlayUpdateTimerEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(TeamPlayUpdateTimerEvent {})
}
}
@ -2757,7 +2755,7 @@ impl FromRawGameEvent for TeamPlayRoundStalemateEvent {
#[derive(Debug)]
pub struct TeamPlayOvertimeBeginEvent {}
impl FromRawGameEvent for TeamPlayOvertimeBeginEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(TeamPlayOvertimeBeginEvent {})
}
}
@ -2765,7 +2763,7 @@ impl FromRawGameEvent for TeamPlayOvertimeBeginEvent {
#[derive(Debug)]
pub struct TeamPlayOvertimeEndEvent {}
impl FromRawGameEvent for TeamPlayOvertimeEndEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(TeamPlayOvertimeEndEvent {})
}
}
@ -2773,7 +2771,7 @@ impl FromRawGameEvent for TeamPlayOvertimeEndEvent {
#[derive(Debug)]
pub struct TeamPlaySuddenDeathBeginEvent {}
impl FromRawGameEvent for TeamPlaySuddenDeathBeginEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(TeamPlaySuddenDeathBeginEvent {})
}
}
@ -2781,7 +2779,7 @@ impl FromRawGameEvent for TeamPlaySuddenDeathBeginEvent {
#[derive(Debug)]
pub struct TeamPlaySuddenDeathEndEvent {}
impl FromRawGameEvent for TeamPlaySuddenDeathEndEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(TeamPlaySuddenDeathEndEvent {})
}
}
@ -3326,7 +3324,7 @@ impl FromRawGameEvent for TeamPlayTeamBalancedPlayerEvent {
#[derive(Debug)]
pub struct TeamPlaySetupFinishedEvent {}
impl FromRawGameEvent for TeamPlaySetupFinishedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(TeamPlaySetupFinishedEvent {})
}
}
@ -3400,7 +3398,7 @@ impl FromRawGameEvent for ShowFreezePanelEvent {
#[derive(Debug)]
pub struct HideFreezePanelEvent {}
impl FromRawGameEvent for HideFreezePanelEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(HideFreezePanelEvent {})
}
}
@ -3408,7 +3406,7 @@ impl FromRawGameEvent for HideFreezePanelEvent {
#[derive(Debug)]
pub struct FreezeCamStartedEvent {}
impl FromRawGameEvent for FreezeCamStartedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(FreezeCamStartedEvent {})
}
}
@ -3416,7 +3414,7 @@ impl FromRawGameEvent for FreezeCamStartedEvent {
#[derive(Debug)]
pub struct LocalPlayerChangeTeamEvent {}
impl FromRawGameEvent for LocalPlayerChangeTeamEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(LocalPlayerChangeTeamEvent {})
}
}
@ -3440,7 +3438,7 @@ impl FromRawGameEvent for LocalPlayerScoreChangedEvent {
#[derive(Debug)]
pub struct LocalPlayerChangeClassEvent {}
impl FromRawGameEvent for LocalPlayerChangeClassEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(LocalPlayerChangeClassEvent {})
}
}
@ -3448,7 +3446,7 @@ impl FromRawGameEvent for LocalPlayerChangeClassEvent {
#[derive(Debug)]
pub struct LocalPlayerRespawnEvent {}
impl FromRawGameEvent for LocalPlayerRespawnEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(LocalPlayerRespawnEvent {})
}
}
@ -3532,7 +3530,7 @@ impl FromRawGameEvent for PlayerAccountChangedEvent {
#[derive(Debug)]
pub struct SpyPdaResetEvent {}
impl FromRawGameEvent for SpyPdaResetEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(SpyPdaResetEvent {})
}
}
@ -3579,7 +3577,7 @@ impl FromRawGameEvent for PlayerStatsUpdatedEvent {
#[derive(Debug)]
pub struct PlayingCommentaryEvent {}
impl FromRawGameEvent for PlayingCommentaryEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(PlayingCommentaryEvent {})
}
}
@ -3922,7 +3920,7 @@ impl FromRawGameEvent for AchievementEarnedEvent {
#[derive(Debug)]
pub struct SpecTargetUpdatedEvent {}
impl FromRawGameEvent for SpecTargetUpdatedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(SpecTargetUpdatedEvent {})
}
}
@ -3972,7 +3970,7 @@ impl FromRawGameEvent for TournamentStateUpdateEvent {
#[derive(Debug)]
pub struct TournamentEnableCountdownEvent {}
impl FromRawGameEvent for TournamentEnableCountdownEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(TournamentEnableCountdownEvent {})
}
}
@ -3996,7 +3994,7 @@ impl FromRawGameEvent for PlayerCalledForMedicEvent {
#[derive(Debug)]
pub struct LocalPlayerBecameObserverEvent {}
impl FromRawGameEvent for LocalPlayerBecameObserverEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(LocalPlayerBecameObserverEvent {})
}
}
@ -4145,7 +4143,7 @@ impl FromRawGameEvent for PlayerHealedMedicCallEvent {
#[derive(Debug)]
pub struct LocalPlayerChargeReadyEvent {}
impl FromRawGameEvent for LocalPlayerChargeReadyEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(LocalPlayerChargeReadyEvent {})
}
}
@ -4153,7 +4151,7 @@ impl FromRawGameEvent for LocalPlayerChargeReadyEvent {
#[derive(Debug)]
pub struct LocalPlayerWindDownEvent {}
impl FromRawGameEvent for LocalPlayerWindDownEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(LocalPlayerWindDownEvent {})
}
}
@ -4278,7 +4276,7 @@ impl FromRawGameEvent for EscortRecedeEvent {
#[derive(Debug)]
pub struct GameUIActivatedEvent {}
impl FromRawGameEvent for GameUIActivatedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(GameUIActivatedEvent {})
}
}
@ -4286,7 +4284,7 @@ impl FromRawGameEvent for GameUIActivatedEvent {
#[derive(Debug)]
pub struct GameUIHiddenEvent {}
impl FromRawGameEvent for GameUIHiddenEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(GameUIHiddenEvent {})
}
}
@ -4464,7 +4462,7 @@ impl FromRawGameEvent for ArenaMatchMaxStreakEvent {
#[derive(Debug)]
pub struct ArenaRoundStartEvent {}
impl FromRawGameEvent for ArenaRoundStartEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(ArenaRoundStartEvent {})
}
}
@ -5565,7 +5563,7 @@ impl FromRawGameEvent for MedicDeathEvent {
#[derive(Debug)]
pub struct OvertimeNagEvent {}
impl FromRawGameEvent for OvertimeNagEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(OvertimeNagEvent {})
}
}
@ -5573,7 +5571,7 @@ impl FromRawGameEvent for OvertimeNagEvent {
#[derive(Debug)]
pub struct TeamsChangedEvent {}
impl FromRawGameEvent for TeamsChangedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(TeamsChangedEvent {})
}
}
@ -5794,7 +5792,7 @@ impl FromRawGameEvent for PlayerMvpEvent {
#[derive(Debug)]
pub struct RaidSpawnMobEvent {}
impl FromRawGameEvent for RaidSpawnMobEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(RaidSpawnMobEvent {})
}
}
@ -5802,7 +5800,7 @@ impl FromRawGameEvent for RaidSpawnMobEvent {
#[derive(Debug)]
pub struct RaidSpawnSquadEvent {}
impl FromRawGameEvent for RaidSpawnSquadEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(RaidSpawnSquadEvent {})
}
}
@ -5872,7 +5870,7 @@ impl FromRawGameEvent for NumCappersChangedEvent {
#[derive(Debug)]
pub struct PlayerRegenerateEvent {}
impl FromRawGameEvent for PlayerRegenerateEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(PlayerRegenerateEvent {})
}
}
@ -5903,7 +5901,7 @@ impl FromRawGameEvent for UpdateStatusItemEvent {
#[derive(Debug)]
pub struct StatsResetRoundEvent {}
impl FromRawGameEvent for StatsResetRoundEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(StatsResetRoundEvent {})
}
}
@ -5911,7 +5909,7 @@ impl FromRawGameEvent for StatsResetRoundEvent {
#[derive(Debug)]
pub struct ScoreStatsAccumulatedUpdateEvent {}
impl FromRawGameEvent for ScoreStatsAccumulatedUpdateEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(ScoreStatsAccumulatedUpdateEvent {})
}
}
@ -5919,7 +5917,7 @@ impl FromRawGameEvent for ScoreStatsAccumulatedUpdateEvent {
#[derive(Debug)]
pub struct ScoreStatsAccumulatedResetEvent {}
impl FromRawGameEvent for ScoreStatsAccumulatedResetEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(ScoreStatsAccumulatedResetEvent {})
}
}
@ -6466,7 +6464,7 @@ impl FromRawGameEvent for ThrowableHitEvent {
#[derive(Debug)]
pub struct PumpkinLordSummonedEvent {}
impl FromRawGameEvent for PumpkinLordSummonedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(PumpkinLordSummonedEvent {})
}
}
@ -6474,7 +6472,7 @@ impl FromRawGameEvent for PumpkinLordSummonedEvent {
#[derive(Debug)]
pub struct PumpkinLordKilledEvent {}
impl FromRawGameEvent for PumpkinLordKilledEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(PumpkinLordKilledEvent {})
}
}
@ -6855,7 +6853,7 @@ impl FromRawGameEvent for PlayerBonusPointsEvent {
#[derive(Debug)]
pub struct PlayerUpgradedEvent {}
impl FromRawGameEvent for PlayerUpgradedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(PlayerUpgradedEvent {})
}
}
@ -6966,7 +6964,7 @@ impl FromRawGameEvent for PlayerKilledAchievementZoneEvent {
#[derive(Debug)]
pub struct PartyUpdatedEvent {}
impl FromRawGameEvent for PartyUpdatedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(PartyUpdatedEvent {})
}
}
@ -6974,7 +6972,7 @@ impl FromRawGameEvent for PartyUpdatedEvent {
#[derive(Debug)]
pub struct LobbyUpdatedEvent {}
impl FromRawGameEvent for LobbyUpdatedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(LobbyUpdatedEvent {})
}
}
@ -7005,7 +7003,7 @@ impl FromRawGameEvent for MvmMissionUpdateEvent {
#[derive(Debug)]
pub struct RecalculateHolidaysEvent {}
impl FromRawGameEvent for RecalculateHolidaysEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(RecalculateHolidaysEvent {})
}
}
@ -7061,7 +7059,7 @@ impl FromRawGameEvent for RemoveNemesisRelationshipsEvent {
#[derive(Debug)]
pub struct MvmCreditBonusWaveEvent {}
impl FromRawGameEvent for MvmCreditBonusWaveEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(MvmCreditBonusWaveEvent {})
}
}
@ -7069,7 +7067,7 @@ impl FromRawGameEvent for MvmCreditBonusWaveEvent {
#[derive(Debug)]
pub struct MvmCreditBonusAllEvent {}
impl FromRawGameEvent for MvmCreditBonusAllEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(MvmCreditBonusAllEvent {})
}
}
@ -7077,7 +7075,7 @@ impl FromRawGameEvent for MvmCreditBonusAllEvent {
#[derive(Debug)]
pub struct MvmCreditBonusAllAdvancedEvent {}
impl FromRawGameEvent for MvmCreditBonusAllAdvancedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(MvmCreditBonusAllAdvancedEvent {})
}
}
@ -7101,7 +7099,7 @@ impl FromRawGameEvent for MvmQuickSentryUpgradeEvent {
#[derive(Debug)]
pub struct MvmTankDestroyedByPlayersEvent {}
impl FromRawGameEvent for MvmTankDestroyedByPlayersEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(MvmTankDestroyedByPlayersEvent {})
}
}
@ -7320,7 +7318,7 @@ impl FromRawGameEvent for MvmBombResetByPlayerEvent {
#[derive(Debug)]
pub struct MvmBombAlarmTriggeredEvent {}
impl FromRawGameEvent for MvmBombAlarmTriggeredEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(MvmBombAlarmTriggeredEvent {})
}
}
@ -7344,7 +7342,7 @@ impl FromRawGameEvent for MvmBombDeployResetByPlayerEvent {
#[derive(Debug)]
pub struct MvmWaveFailedEvent {}
impl FromRawGameEvent for MvmWaveFailedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(MvmWaveFailedEvent {})
}
}
@ -7352,7 +7350,7 @@ impl FromRawGameEvent for MvmWaveFailedEvent {
#[derive(Debug)]
pub struct MvmResetStatsEvent {}
impl FromRawGameEvent for MvmResetStatsEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(MvmResetStatsEvent {})
}
}
@ -7512,7 +7510,7 @@ impl FromRawGameEvent for MvmSniperHeadshotCurrencyEvent {
#[derive(Debug)]
pub struct MvmMannhattanPitEvent {}
impl FromRawGameEvent for MvmMannhattanPitEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(MvmMannhattanPitEvent {})
}
}
@ -7520,7 +7518,7 @@ impl FromRawGameEvent for MvmMannhattanPitEvent {
#[derive(Debug)]
pub struct FlagCarriedInDetectionZoneEvent {}
impl FromRawGameEvent for FlagCarriedInDetectionZoneEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(FlagCarriedInDetectionZoneEvent {})
}
}
@ -7528,7 +7526,7 @@ impl FromRawGameEvent for FlagCarriedInDetectionZoneEvent {
#[derive(Debug)]
pub struct MvmAdvWaveKilledStunRadioEvent {}
impl FromRawGameEvent for MvmAdvWaveKilledStunRadioEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(MvmAdvWaveKilledStunRadioEvent {})
}
}
@ -7625,7 +7623,7 @@ impl FromRawGameEvent for RdTeamPointsChangedEvent {
#[derive(Debug)]
pub struct RdRulesStateChangedEvent {}
impl FromRawGameEvent for RdRulesStateChangedEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(RdRulesStateChangedEvent {})
}
}
@ -7895,7 +7893,7 @@ impl FromRawGameEvent for PlayerInitialSpawnEvent {
#[derive(Debug)]
pub struct CompetitiveVictoryEvent {}
impl FromRawGameEvent for CompetitiveVictoryEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(CompetitiveVictoryEvent {})
}
}
@ -8306,7 +8304,7 @@ impl FromRawGameEvent for HLTVChatEvent {
#[derive(Debug)]
pub struct ReplayStartRecordEvent {}
impl FromRawGameEvent for ReplayStartRecordEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(ReplayStartRecordEvent {})
}
}
@ -8351,7 +8349,7 @@ impl FromRawGameEvent for ReplaySessionInfoEvent {
#[derive(Debug)]
pub struct ReplayEndRecordEvent {}
impl FromRawGameEvent for ReplayEndRecordEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(ReplayEndRecordEvent {})
}
}
@ -8359,7 +8357,7 @@ impl FromRawGameEvent for ReplayEndRecordEvent {
#[derive(Debug)]
pub struct ReplayReplaysAvailableEvent {}
impl FromRawGameEvent for ReplayReplaysAvailableEvent {
fn from_raw_event(values: Vec<GameEventValue>) -> Result<Self> {
fn from_raw_event(_values: Vec<GameEventValue>) -> Result<Self> {
Ok(ReplayReplaysAvailableEvent {})
}
}

1
src/demo/gamevent.rs
View file

@ -1,5 +1,4 @@
use bitstream_reader::BitRead;
use std::collections::HashMap;
use crate::{ParseError, Result};

2
src/demo/message/bspdecal.rs
View file

@ -1,4 +1,4 @@
use bitstream_reader::{BitRead, BitReadSized, LittleEndian};
use bitstream_reader::{BitRead, LittleEndian};
use crate::demo::sendprop::read_bit_coord;
use crate::demo::vector::Vector;

4
src/demo/message/gameevent.rs
View file

@ -1,14 +1,14 @@
use std::collections::HashMap;
use std::iter::FromIterator;
use bitstream_reader::{BitRead, BitReadSized, LittleEndian};
use bitstream_reader::{BitRead, LittleEndian};
use crate::demo::gameevent_gen::GameEventType;
use crate::demo::gamevent::{
GameEvent, GameEventDefinition, GameEventEntry, GameEventValue, GameEventValueType,
RawGameEvent,
};
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
use crate::{Parse, ParserState, ReadResult, Result, Stream};
fn read_event_value(stream: &mut Stream, definition: &GameEventEntry) -> Result<GameEventValue> {
Ok(match definition.kind {

2
src/demo/message/generated.rs
View file

@ -1,6 +1,6 @@
use crate::Stream;
/// Messages that consists only of primitives and string and can be derived
use bitstream_reader::{BitRead, BitStream, LittleEndian};
use bitstream_reader::{BitRead, LittleEndian};
use std::collections::HashMap;
#[derive(BitRead, Debug)]

6
src/demo/message/mod.rs
View file

@ -1,6 +1,3 @@
use std::mem::discriminant;
use bitstream_reader::{BitRead, LittleEndian};
use enum_primitive_derive::Primitive;
use num_traits::FromPrimitive;
@ -9,13 +6,12 @@ pub use generated::*;
use crate::demo::message::bspdecal::*;
use crate::demo::message::classinfo::*;
use crate::demo::message::gameevent::*;
use crate::demo::message::generated::*;
use crate::demo::message::packetentities::*;
use crate::demo::message::stringtable::*;
use crate::demo::message::tempentities::*;
use crate::demo::message::usermessage::*;
use crate::demo::message::voice::*;
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
use crate::{Parse, ParseError, ParserState, Result, Stream};
pub mod bspdecal;
pub mod classinfo;

10
src/demo/message/packetentities.rs
View file

@ -1,9 +1,9 @@
use bitstream_reader::{BitRead, BitReadSized, LittleEndian};
use bitstream_reader::BitRead;
use serde::Serialize;
use crate::demo::packet::datatable::ServerClass;
use crate::demo::sendprop::SendProp;
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
use crate::{Parse, ParserState, Result, Stream};
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Serialize)]
pub struct EntityId(u32);
@ -45,14 +45,14 @@ pub struct PacketEntitiesMessage {
}
impl Parse for PacketEntitiesMessage {
fn parse(stream: &mut Stream, state: &ParserState) -> Result<Self> {
fn parse(stream: &mut Stream, _state: &ParserState) -> Result<Self> {
let max_entries = stream.read_sized(11)?;
let delta = stream.read()?;
let base_line = stream.read_sized(1)?;
let updated_entries: u16 = stream.read_sized(11)?;
let _updated_entries: u16 = stream.read_sized(11)?;
let length: u32 = stream.read_sized(20)?;
let updated_base_line = stream.read()?;
let data = stream.read_bits(length as usize)?;
let _data = stream.read_bits(length as usize)?;
// TODO

30
src/demo/message/stringtable.rs
View file

@ -1,13 +1,11 @@
use std::collections::HashMap;
use bitstream_reader::{BitBuffer, BitRead, BitReadSized, BitStream, LittleEndian};
use bitstream_reader::{BitBuffer, BitStream, LittleEndian};
use num_traits::{PrimInt, Unsigned};
use snap::Decoder;
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
use crate::demo::packet::stringtable::{
ExtraData, FixedUserdataSize, StringTable, StringTableEntry,
};
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
#[derive(Debug)]
pub struct CreateStringTableMessage {
@ -30,7 +28,7 @@ impl From<&StringTable> for StringTableMeta {
}
impl Parse for CreateStringTableMessage {
fn parse(stream: &mut Stream, state: &ParserState) -> Result<Self> {
fn parse(stream: &mut Stream, _state: &ParserState) -> Result<Self> {
let name = stream.read()?;
let max_entries: u16 = stream.read()?;
let encode_bits = log_base2(max_entries);
@ -106,11 +104,7 @@ impl Parse for UpdateStringTableMessage {
let mut data = stream.read_bits(len)?;
let entries = match state.string_tables.get(table_id as usize) {
Some(table) => parse_string_table_update(
&mut data,
table,
changed,
),
Some(table) => parse_string_table_update(&mut data, table, changed),
None => return Err(ParseError::StringTableNotFound(table_id)),
}?;
@ -129,7 +123,7 @@ fn parse_string_table_update(
let mut last_entry: i16 = -1;
let mut history: Vec<Option<String>> = Vec::new();
for i in 0..entry_count {
for _ in 0..entry_count {
let index = if stream.read()? {
(last_entry + 1) as u16
} else {
@ -138,11 +132,7 @@ fn parse_string_table_update(
last_entry = index as i16;
let entry = read_table_entry(
stream,
table_meta,
&history
)?;
let entry = read_table_entry(stream, table_meta, &history)?;
// optimize: any way to get rid of the clone here?
// `entries` always outlives `history` without reallocation
let text = entry.text.clone();
@ -163,12 +153,11 @@ fn parse_string_table_list(
table_meta: &StringTableMeta,
entry_count: u16,
) -> ReadResult<Vec<StringTableEntry>> {
let entry_bits = log_base2(table_meta.max_entries);
let mut entries = Vec::with_capacity(entry_count as usize);
let mut history: Vec<Option<String>> = Vec::new();
for i in 0..entry_count {
for _ in 0..entry_count {
if !stream.read::<bool>()? {
panic!("there should be no holes when reading CreateStringTable message");
};
@ -231,10 +220,7 @@ fn read_table_entry(
}
.map(ExtraData::new);
Ok(StringTableEntry {
text,
extra_data,
})
Ok(StringTableEntry { text, extra_data })
}
pub fn read_var_int(stream: &mut Stream) -> ReadResult<u32> {

10
src/demo/message/tempentities.rs
View file

@ -1,6 +1,4 @@
use bitstream_reader::{BitRead, BitReadSized, LittleEndian};
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
use crate::{Parse, ParserState, Result, Stream};
use super::packetentities::PacketEntity;
use super::stringtable::read_var_int;
@ -11,10 +9,10 @@ pub struct TempEntitiesMessage {
}
impl Parse for TempEntitiesMessage {
fn parse(stream: &mut Stream, state: &ParserState) -> Result<Self> {
let count: u8 = stream.read()?;
fn parse(stream: &mut Stream, _state: &ParserState) -> Result<Self> {
let _count: u8 = stream.read()?;
let length = read_var_int(stream)?;
let data = stream.read_bits(length as usize)?;
let _data = stream.read_bits(length as usize)?;
Ok(TempEntitiesMessage {
entities: Vec::new(),

5
src/demo/message/usermessage.rs
View file

@ -1,9 +1,8 @@
use bitstream_reader::{BitRead, BitReadSized, LittleEndian};
use bitstream_reader::{BitRead, LittleEndian};
use enum_primitive_derive::Primitive;
use num_traits::{FromPrimitive, ToPrimitive};
use num_traits::FromPrimitive;
use serde::Serialize;
use crate::demo::message::usermessage::UserMessage::SayText2;
use crate::{ReadResult, Stream};
#[derive(Primitive, Clone, Copy, Debug)]

4
src/demo/message/voice.rs
View file

@ -1,6 +1,6 @@
use bitstream_reader::{BitRead, BitStream, LittleEndian};
use bitstream_reader::{BitRead, LittleEndian};
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
use crate::{ReadResult, Stream};
#[derive(Debug, Clone)]
pub struct VoiceInitMessage {

3
src/demo/packet/datatable.rs
View file

@ -28,7 +28,6 @@ pub struct DataTablePacket {
impl Parse for DataTablePacket {
fn parse(stream: &mut Stream, _state: &ParserState) -> Result<Self> {
let tick = stream.read()?;
let start = stream.pos();
let len = stream.read_int::<usize>(32)?;
let mut packet_data = stream.read_bits(len * 8)?;
@ -41,7 +40,7 @@ impl Parse for DataTablePacket {
let mut array_element_prop = None;
let mut props = Vec::with_capacity(prop_count);
for i in 0..prop_count {
for _ in 0..prop_count {
let prop: SendPropDefinition =
SendPropDefinition::read(&mut packet_data, name.clone())?;
if prop.flags.contains(SendPropFlag::InsideArray) {

2
src/demo/packet/message.rs
View file

@ -2,7 +2,7 @@ use bitstream_reader::{BitRead, BitSize, LazyBitRead, LittleEndian};
use crate::demo::message::Message;
use crate::demo::vector::Vector;
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
use crate::{Parse, ParserState, ReadResult, Result, Stream};
#[derive(Debug)]
pub struct MessagePacket {

7
src/demo/packet/stringtable.rs
View file

@ -3,7 +3,6 @@ use std::fmt;
use bitstream_reader::{BitRead, LittleEndian};
use crate::demo::message::stringtable::StringTableMeta;
use crate::demo::sendprop::SendPropFlag::Exclude;
use crate::{Parse, ParseError, ParserState, ReadResult, Result, Stream};
#[derive(BitRead, Clone, Copy, Debug)]
@ -88,7 +87,7 @@ impl BitRead<LittleEndian> for StringTableEntry {
fn read(stream: &mut Stream) -> ReadResult<Self> {
Ok(StringTableEntry {
text: Some(stream.read()?),
extra_data: stream.read()?
extra_data: stream.read()?,
})
}
}
@ -100,7 +99,8 @@ impl fmt::Debug for StringTableEntry {
Some(extra_data) => write!(
f,
"StringTableEntry{{ text: \"{}\" extra_data: {} bytes }}",
self.text(), extra_data.byte_len
self.text(),
extra_data.byte_len
),
}
}
@ -115,7 +115,6 @@ pub struct StringTablePacket {
impl Parse for StringTablePacket {
fn parse(stream: &mut Stream, _state: &ParserState) -> Result<Self> {
let tick = stream.read_int(32)?;
let start = stream.pos();
let length: usize = stream.read_int(32)?;
let mut packet_data = stream.read_bits(length * 8)?;
let count: usize = packet_data.read_int(8)?;

14
src/demo/parser/analyser.rs
View file

@ -1,5 +1,4 @@
use std::collections::HashMap;
use std::thread::spawn;
use serde::Serialize;
use serde_repr::Serialize_repr;
@ -197,7 +196,7 @@ impl MessageHandler for Analyser {
}
impl StringTableEntryHandler for Analyser {
fn handle_string_entry(&mut self, table: &String, index: usize, entry: &StringTableEntry) {
fn handle_string_entry(&mut self, table: &String, _index: usize, entry: &StringTableEntry) {
match table.as_str() {
"userinfo" => {
match (&entry.text, &entry.extra_data) {
@ -230,7 +229,7 @@ impl Analyser {
}
fn change_name(&mut self, from: String, to: String) {
for (id, user) in self.users.iter_mut() {
for (_, user) in self.users.iter_mut() {
if user.name == from {
user.name = to;
return;
@ -239,12 +238,13 @@ impl Analyser {
}
fn handle_event(&mut self, event: GameEvent, tick: u32) {
const WIN_REASON_TIME_LIMIT: u8 = 6;
match event {
GameEvent::PlayerDeath(event) => self.deaths.push(Death::from_event(event, tick)),
GameEvent::PlayerSpawn(event) => self.user_spawns.push(Spawn::from_event(event, tick)),
GameEvent::TeamPlayRoundWin(event) => {
// 6 = time limit
if event.win_reason != 6 {
if event.win_reason != WIN_REASON_TIME_LIMIT {
self.rounds.push(Round::from_event(event, tick))
}
}
@ -274,7 +274,7 @@ impl Analyser {
pub fn get_match_state(self, state: ParserState) -> MatchState {
MatchState {
start_tick: self.start_tick,
interval_per_tick: state.interval_per_tick,
interval_per_tick: state.demo_meta.interval_per_tick,
chat: self.chat,
deaths: self.deaths,
rounds: self.rounds,
@ -304,7 +304,7 @@ impl UserState {
for spawn in spawns {
teams.insert(spawn.user, spawn.team);
let user_classes = classes.entry(spawn.user).or_default();
let mut class_spawns = user_classes.entry(spawn.class).or_default();
let class_spawns = user_classes.entry(spawn.class).or_default();
*class_spawns += 1;
}

9
src/demo/parser/handler.rs
View file

@ -1,7 +1,3 @@
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;
use crate::demo::message::{Message, MessageType};
use crate::demo::packet::datatable::{SendTable, ServerClass};
use crate::demo::packet::stringtable::{StringTable, StringTableEntry};
@ -68,7 +64,8 @@ impl DemoHandler {
fn handle_string_table(&mut self, table: StringTable) {
self.string_table_names.push(table.name.clone());
self.state_handler.handle_string_table_meta(table.get_table_meta());
self.state_handler
.handle_string_table_meta(table.get_table_meta());
for (entry_index, entry) in table.entries.into_iter().enumerate() {
self.handle_string_entry(&table.name, entry_index, entry);
}
@ -110,7 +107,7 @@ impl DemoHandler {
}
}
pub fn get_match_state(mut self) -> MatchState {
pub fn get_match_state(self) -> MatchState {
self.analyser.get_match_state(self.state_handler)
}

14
src/demo/parser/mod.rs
View file

@ -1,20 +1,12 @@
use std::collections::HashMap;
use std::rc::Rc;
use bitstream_reader::{BitRead, LittleEndian, ReadError};
use crate::demo::gameevent_gen::GameEventType;
use crate::demo::gamevent::{GameEventValue, GameEventValueType};
use crate::demo::header::Header;
use crate::demo::message::{Message, MessageType};
use crate::demo::packet::stringtable::StringTableEntry;
use crate::demo::packet::Packet;
use crate::demo::parser::analyser::{Analyser, MatchState};
use crate::demo::parser::handler::{DemoHandler, MessageHandler, StringTableEntryHandler};
use crate::demo::parser::analyser::MatchState;
use crate::demo::parser::handler::DemoHandler;
pub use crate::demo::parser::state::ParserState;
use crate::Stream;
use std::cell::RefCell;
use std::ops::Deref;
mod analyser;
mod handler;
@ -77,7 +69,7 @@ pub trait Parse: Sized {
}
impl<T: BitRead<LittleEndian>> Parse for T {
fn parse(stream: &mut Stream, state: &ParserState) -> Result<Self> {
fn parse(stream: &mut Stream, _state: &ParserState) -> Result<Self> {
Self::read(stream).map_err(ParseError::from)
}
}

24
src/demo/parser/state.rs
View file

@ -1,24 +1,25 @@
use std::collections::HashMap;
use crate::demo::gameevent_gen::GameEventType;
use crate::demo::gamevent::GameEventDefinition;
use crate::demo::message::gameevent::GameEventTypeId;
use crate::demo::message::packetentities::EntityId;
use crate::demo::message::stringtable::StringTableMeta;
use crate::demo::message::{Message, MessageType};
use crate::demo::packet::datatable::{SendTable, ServerClass};
use crate::demo::packet::stringtable::{StringTable, StringTableEntry};
use crate::demo::packet::Packet;
use crate::demo::packet::stringtable::StringTableEntry;
use crate::demo::parser::handler::{MessageHandler, StringTableEntryHandler};
use crate::demo::sendprop::SendProp;
use crate::Stream;
use std::mem::replace;
pub type StringEntryHandler = Box<FnMut(&String, &StringTableEntry) -> ()>;
#[derive(Default)]
pub struct DemoMeta {
pub version: u16,
pub game: String,
pub interval_per_tick: f32,
}
#[derive(Default)]
pub struct ParserState {
pub version: u16,
pub static_baselines: HashMap<u32, StaticBaseline>,
pub event_definitions: HashMap<GameEventTypeId, GameEventDefinition>,
pub string_tables: Vec<StringTableMeta>,
@ -26,8 +27,7 @@ pub struct ParserState {
pub send_tables: HashMap<String, SendTable>,
pub server_classes: Vec<ServerClass>,
pub instance_baselines: [HashMap<EntityId, Vec<SendProp>>; 2],
pub game: String,
pub interval_per_tick: f32,
pub demo_meta: DemoMeta,
}
pub struct StaticBaseline {
@ -81,9 +81,9 @@ impl MessageHandler for ParserState {
fn handle_message(&mut self, message: Message, _tick: u32) {
match message {
Message::ServerInfo(message) => {
self.version = message.version;
self.game = message.game;
self.interval_per_tick = message.interval_per_tick
self.demo_meta.version = message.version;
self.demo_meta.game = message.game;
self.demo_meta.interval_per_tick = message.interval_per_tick
}
Message::GameEventList(message) => {
self.event_definitions = message.event_list;
@ -94,7 +94,7 @@ impl MessageHandler for ParserState {
}
impl StringTableEntryHandler for ParserState {
fn handle_string_entry(&mut self, table: &String, index: usize, entry: &StringTableEntry) {
fn handle_string_entry(&mut self, table: &String, _index: usize, entry: &StringTableEntry) {
match table.as_str() {
"instancebaseline" => match &entry.extra_data {
Some(extra) => match entry.text().parse::<u32>() {

4
src/demo/vector.rs
View file

@ -1,8 +1,6 @@
use bitstream_reader::{BitRead, BitSize, LittleEndian};
use bitstream_reader::{BitRead, BitSize};
use serde::Serialize;
use crate::{ReadResult, Stream};
#[derive(BitRead, BitSize, Debug, Clone, Copy, Default, Serialize)]
pub struct Vector {
pub x: f32,