diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e164edba..502575f7 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -5,62 +5,25 @@ on: branches: - main -jobs: - test-py: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v2 - - uses: actions-rs/toolchain@v1 - with: - toolchain: stable - - uses: actions/setup-python@v2 - with: - python-version: "3.10" +on: [push] - - name: Setup Python and Run Tests - working-directory: ./src/python - run: | - python3 -m venv .venv - source .venv/bin/activate - pip install pytest maturin patchelf +name: CI - cd tests/ - unzip test_demo.zip -d data/ - unzip zipped_testdata.zip -d data/ - cd .. - - maturin develop --release - pytest - test-js: +jobs: + build_and_test: + name: Test Parser Rust runs-on: ubuntu-latest + defaults: + run: + working-directory: src/parser steps: - - uses: actions/checkout@v2 - - name: Setup Node.js and Build - uses: actions/setup-node@v2 - with: - node-version: "18" # Replace with the desired Node.js version + - name: Checkout repository + uses: actions/checkout@v2 - - name: Unzip Test Data - working-directory: ./src/node - run: | - cd tests/ - unzip zipped_testdata.zip -d data/ - cd ../.. - - - name: unzip demo from py dir - working-directory: ./src/python - run: | - cd tests/ - 7z x test_demo.zip - cd ../.. - - name: Build - working-directory: ./src/node - run: | - yarn global add @napi-rs/cli - yarn build + - name: Set up Rust toolchain + uses: actions-rs/toolchain@v1 + with: + toolchain: stable - - name: Test - working-directory: ./src/node - run: | - npm install --save-dev jest - npm test + - name: Build in src/parser directory + run: cargo build --release --all-features diff --git a/.github/workflows/perftest.yml b/.github/workflows/perftest.yml deleted file mode 100644 index 97552e09..00000000 --- a/.github/workflows/perftest.yml +++ /dev/null @@ -1,29 +0,0 @@ -name: Test - -on: - pull_request_target: - branches: - - main - -jobs: - test-py: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v2 - - uses: actions-rs/toolchain@v1 - with: - toolchain: stable - - uses: actions/setup-python@v2 - with: - python-version: "3.10" - - - name: Setup Python and Run Tests - working-directory: ./src/python - run: | - python3 -m venv .venv - source .venv/bin/activate - pip install pytest maturin patchelf - - unzip tests/test_demo.zip - maturin develop --release - python3 test_perf.py diff --git a/.gitignore b/.gitignore index 2018e0cf..3bdad56a 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,5 @@ /Protobufs /target -*.dem .vscode/ venv .venv diff --git a/src/parser/.gitignore b/src/parser/.gitignore index d99627a4..df9f8e40 100644 --- a/src/parser/.gitignore +++ b/src/parser/.gitignore @@ -1,6 +1,5 @@ /Protobufs /target -*.dem .vscode/ venv .venv diff --git a/src/parser/Cargo.lock b/src/parser/Cargo.lock index 3eef844e..1536303c 100644 --- a/src/parser/Cargo.lock +++ b/src/parser/Cargo.lock @@ -4,14 +4,15 @@ version = 3 [[package]] name = "ahash" -version = "0.8.3" +version = "0.8.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f" +checksum = "77c3a9648d43b9cd48db467b3f87fdd6e146bcc88ab0180006cef2179fe11d01" dependencies = [ "cfg-if", "getrandom", "once_cell", "version_check", + "zerocopy", ] [[package]] @@ -41,15 +42,6 @@ version = "0.6.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "803ffa563b84251ab8856d83d6b891e8d161e7df73806e10f78b35af05ba1a04" -[[package]] -name = "cc" -version = "1.0.83" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0" -dependencies = [ - "libc", -] - [[package]] name = "cfg-if" version = "1.0.0" @@ -62,16 +54,6 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" -[[package]] -name = "crossbeam-channel" -version = "0.5.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200" -dependencies = [ - "cfg-if", - "crossbeam-utils", -] - [[package]] name = "crossbeam-deque" version = "0.8.3" @@ -98,12 +80,9 @@ dependencies = [ [[package]] name = "crossbeam-utils" -version = "0.8.16" +version = "0.8.19" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a22b2d63d4d1dc0b7f1b6b2747dd0088008a9be28b6ddf0b1e7d335e3037294" -dependencies = [ - "cfg-if", -] +checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345" [[package]] name = "csgoproto" @@ -127,9 +106,9 @@ dependencies = [ [[package]] name = "either" -version = "1.8.1" +version = "1.9.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91" +checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07" [[package]] name = "getrandom" @@ -142,12 +121,6 @@ dependencies = [ "wasi", ] -[[package]] -name = "hermit-abi" -version = "0.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "443144c8cdadd93ebf52ddb4056d257f5b52c04d3c804e657d19eb73fc33668b" - [[package]] name = "itertools" version = "0.10.5" @@ -165,25 +138,15 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" [[package]] name = "libc" -version = "0.2.147" +version = "0.2.152" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3" - -[[package]] -name = "libmimalloc-sys" -version = "0.1.35" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3979b5c37ece694f1f5e51e7ecc871fdb0f517ed04ee45f88d15d6d553cb9664" -dependencies = [ - "cc", - "libc", -] +checksum = "13e3bf6590cbc649f4d1a3eefc9d5d6eb746f5200ffb04e5e142700b8faa56e7" [[package]] name = "memchr" -version = "2.5.0" +version = "2.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d" +checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149" [[package]] name = "memmap2" @@ -203,30 +166,11 @@ dependencies = [ "autocfg", ] -[[package]] -name = "mimalloc" -version = "0.1.39" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fa01922b5ea280a911e323e4d2fd24b7fe5cc4042e0d2cda3c40775cdc4bdc9c" -dependencies = [ - "libmimalloc-sys", -] - -[[package]] -name = "num_cpus" -version = "1.16.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43" -dependencies = [ - "hermit-abi", - "libc", -] - [[package]] name = "once_cell" -version = "1.17.1" +version = "1.19.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3" +checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" [[package]] name = "parser" @@ -241,7 +185,6 @@ dependencies = [ "lazy_static", "libc", "memmap2", - "mimalloc", "phf", "phf_macros", "proc-macro2", @@ -251,7 +194,6 @@ dependencies = [ "regex", "serde", "snap", - "stats_alloc", ] [[package]] @@ -326,9 +268,9 @@ dependencies = [ [[package]] name = "quote" -version = "1.0.26" +version = "1.0.33" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4424af4bf778aae2051a77b60283332f386554255d722233d09fbfc7e30da2fc" +checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" dependencies = [ "proc-macro2", ] @@ -350,9 +292,9 @@ checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" [[package]] name = "rayon" -version = "1.7.0" +version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b" +checksum = "9c27db03db7734835b3f53954b534c91069375ce6ccaa2e065441e07d9b6cdb1" dependencies = [ "either", "rayon-core", @@ -360,21 +302,31 @@ dependencies = [ [[package]] name = "rayon-core" -version = "1.11.0" +version = "1.12.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d" +checksum = "5ce3fb6ad83f861aac485e76e1985cd109d9a3713802152be56c3b1f0e0658ed" dependencies = [ - "crossbeam-channel", "crossbeam-deque", "crossbeam-utils", - "num_cpus", ] [[package]] name = "regex" -version = "1.8.1" +version = "1.10.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343" +dependencies = [ + "aho-corasick", + "memchr", + "regex-automata", + "regex-syntax", +] + +[[package]] +name = "regex-automata" +version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "af83e617f331cc6ae2da5443c602dfa5af81e517212d9d611a5b3ba1777b5370" +checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f" dependencies = [ "aho-corasick", "memchr", @@ -383,9 +335,9 @@ dependencies = [ [[package]] name = "regex-syntax" -version = "0.7.1" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a5996294f19bd3aae0453a862ad728f60e6600695733dd5df01da90c54363a3c" +checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f" [[package]] name = "rustc_version" @@ -410,22 +362,22 @@ checksum = "bebd363326d05ec3e2f532ab7660680f3b02130d780c299bca73469d521bc0ed" [[package]] name = "serde" -version = "1.0.164" +version = "1.0.193" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e8c8cf938e98f769bc164923b06dce91cea1751522f46f8466461af04c9027d" +checksum = "25dd9975e68d0cb5aa1120c288333fc98731bd1dd12f561e468ea4728c042b89" dependencies = [ "serde_derive", ] [[package]] name = "serde_derive" -version = "1.0.164" +version = "1.0.193" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9735b638ccc51c28bf6914d90a2e9725b377144fc612c49a611fddd1b631d68" +checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3" dependencies = [ "proc-macro2", "quote", - "syn 2.0.15", + "syn 2.0.43", ] [[package]] @@ -440,12 +392,6 @@ version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5e9f0ab6ef7eb7353d9119c170a436d1bf248eea575ac42d19d12f4e34130831" -[[package]] -name = "stats_alloc" -version = "0.1.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c0e04424e733e69714ca1bbb9204c1a57f09f5493439520f9f68c132ad25eec" - [[package]] name = "syn" version = "1.0.109" @@ -459,9 +405,9 @@ dependencies = [ [[package]] name = "syn" -version = "2.0.15" +version = "2.0.43" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a34fcf3e8b60f57e6a14301a2e916d323af98b0ea63c599441eec8558660c822" +checksum = "ee659fb5f3d355364e1f3e5bc10fb82068efbf824a1e9d1c9504244a6469ad53" dependencies = [ "proc-macro2", "quote", @@ -485,7 +431,7 @@ checksum = "f9456a42c5b0d803c8cd86e73dd7cc9edd429499f37a3550d286d5e86720569f" dependencies = [ "proc-macro2", "quote", - "syn 2.0.15", + "syn 2.0.43", ] [[package]] @@ -505,3 +451,23 @@ name = "wasi" version = "0.11.0+wasi-snapshot-preview1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" + +[[package]] +name = "zerocopy" +version = "0.7.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be" +dependencies = [ + "zerocopy-derive", +] + +[[package]] +name = "zerocopy-derive" +version = "0.7.32" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.43", +] diff --git a/src/parser/rustfmt.toml b/src/parser/rustfmt.toml index 56578e9b..979a3146 100644 --- a/src/parser/rustfmt.toml +++ b/src/parser/rustfmt.toml @@ -1 +1 @@ -max_width = 130 +max_width = 130 \ No newline at end of file diff --git a/src/parser/src/decoder.rs b/src/parser/src/decoder.rs index a3ce85f0..9160f481 100644 --- a/src/parser/src/decoder.rs +++ b/src/parser/src/decoder.rs @@ -225,10 +225,4 @@ mod tests { let mut bitreader = Bitreader::new(&bytes); assert_eq!("ape_zone_02.vcd", bitreader.read_string().unwrap()); } - #[test] - fn test_read_string_no_null() { - let bytes = [97, 112, 101, 95, 122, 111, 110, 101, 95, 48, 50, 46, 118, 99, 100]; - let mut bitreader = Bitreader::new(&bytes); - assert_eq!(Err(DemoParserError::OutOfBitsError), bitreader.read_string()); - } } diff --git a/src/parser/src/e2e_test.rs b/src/parser/src/e2e_test.rs new file mode 100644 index 00000000..2eb4290d --- /dev/null +++ b/src/parser/src/e2e_test.rs @@ -0,0 +1,14118 @@ +use crate::parser::DemoOutput; +use crate::parser_settings::Parser; +use crate::parser_settings::ParserInputs; +use crate::parser_thread_settings::create_huffman_lookup_table; +use crate::prop_controller::PropController; +use crate::prop_controller::*; +use crate::variants::PropColumn; +use ahash::AHashMap; +use itertools::Itertools; +use memmap2::MmapOptions; +use std::fs::File; + +pub fn create_tests() { + let wanted_events = vec![]; + let wanted_props = vec![]; + let huf = create_huffman_lookup_table(); + + let settings = ParserInputs { + wanted_player_props: wanted_props.clone(), + wanted_events: wanted_events, + real_name_to_og_name: AHashMap::default(), + wanted_player_props_og_names: wanted_props.clone(), + wanted_other_props: vec![], + wanted_other_props_og_names: vec![], + parse_ents: true, + wanted_ticks: (0..5).into_iter().map(|x| x * 10000).collect_vec(), + parse_projectiles: true, + only_header: false, + count_props: false, + only_convars: false, + huffman_lookup_table: &huf, + }; + + let mut ds = Parser::new(&settings); + ds.is_multithreadable = false; + let file = File::open("test_demo.dem".to_string()).unwrap(); + let mmap = unsafe { MmapOptions::new().map(&file).unwrap() }; + let d = ds.parse_demo(&mmap).unwrap(); + let mut custom = AHashMap::default(); + + custom.insert(WEAPON_ORIGINGAL_OWNER_ID, "active_weapon_original_owner"); + custom.insert(INVENTORY_ID, "inventory"); + custom.insert(USERID_ID, "user_id"); + custom.insert(VELOCITY_X_ID, "velocity_X"); + custom.insert(VELOCITY_Y_ID, "velocity_Y"); + custom.insert(VELOCITY_Z_ID, "velocity_Z"); + custom.insert(VELOCITY_ID, "velocity"); + custom.insert(IS_ALIVE_ID, "is_alive"); + custom.insert(ENTITY_ID_ID, "entity_id"); + custom.insert(GAME_TIME_ID, "game_time"); + custom.insert(WEAPON_SKIN_ID, "weapon_skin"); + + custom.insert(WEAPON_NAME_ID, "weapon_name"); + custom.insert(PITCH_ID, "pitch"); + custom.insert(AGENT_SKIN_ID, "yaw"); + custom.insert(PLAYER_X_ID, "X"); + custom.insert(PLAYER_Y_ID, "Y"); + custom.insert(PLAYER_Z_ID, "Z"); + custom.insert(TICK_ID, "tick"); + custom.insert(STEAMID_ID, "steamid"); + custom.insert(NAME_ID, "name"); + + for (k, v) in d.df { + if let Some(real_name) = ds.prop_controller.id_to_name.get(&k) { + let test_name = real_name.replace(".", "_"); + let s = "".to_string(); + let s = s + &format!("fn {}() {{", test_name); + let s = s + &format!("let prop = ({:?}, {:?});", real_name, v); + let s = s.replace("[", "vec!["); + let s = s.replace("\")", "\".to_string())"); + println!("#[test]"); + println!("{}", s); + println!("let prop_id = out.1.name_to_id[prop.0];"); + println!("assert_eq!(out.0.df[&prop_id], prop.1);"); + println!("}}"); + } else { + if let Some(name) = custom.get(&k) { + let test_name = name.replace(".", "_"); + let s = "".to_string(); + let s = s + &format!("fn {}() {{", test_name); + let s = s + &format!("let prop = ({:?}, {:?});", name, v); + let s = s.replace("[", "vec!["); + let s = s.replace("\")", "\".to_string())"); + + println!("#[test]"); + println!("{}", s); + println!("let prop_id = out.1.name_to_id[prop.0];"); + println!("assert_eq!(out.0.df[&prop_id], prop.1);"); + println!("}}"); + } + } + } +} + +fn create_data() -> (DemoOutput, PropController) { + let wanted_props = vec![ + "CCSPlayerPawn.CBodyComponentBaseAnimGraph.m_flLastTeleportTime".to_string(), + "CCSPlayerPawn.CCSPlayer_BulletServices.m_totalHitsOnServer".to_string(), + "CCSPlayerPawn.CCSPlayer_ItemServices.m_bHasDefuser".to_string(), + "CCSPlayerPawn.CCSPlayer_ItemServices.m_bHasHelmet".to_string(), + "CCSPlayerPawn.CCSPlayer_MovementServices.m_arrForceSubtickMoveWhen".to_string(), + "CCSPlayerPawn.CCSPlayer_MovementServices.m_bDesiresDuck".to_string(), + "CCSPlayerPawn.CCSPlayer_MovementServices.m_bDuckOverride".to_string(), + "CCSPlayerPawn.CCSPlayer_MovementServices.m_bOldJumpPressed".to_string(), + "CCSPlayerPawn.CCSPlayer_MovementServices.m_fStashGrenadeParameterWhen".to_string(), + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flDuckAmount".to_string(), + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flDuckSpeed".to_string(), + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flJumpUntil".to_string(), + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flJumpVel".to_string(), + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flOffsetTickCompleteTime".to_string(), + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flOffsetTickStashedSpeed".to_string(), + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flStamina".to_string(), + "CCSPlayerPawn.CCSPlayer_MovementServices.m_nButtonDownMaskPrev".to_string(), + "CCSPlayerPawn.CCSPlayer_MovementServices.m_nLadderSurfacePropIndex".to_string(), + "CCSPlayerPawn.CCSPlayer_MovementServices.m_vecLadderNormal".to_string(), + "CCSPlayerPawn.CCSPlayer_WeaponServices.m_iAmmo".to_string(), + "CCSPlayerPawn.m_ArmorValue".to_string(), + "CCSPlayerPawn.m_MoveType".to_string(), + "CCSPlayerPawn.m_aimPunchAngle".to_string(), + "CCSPlayerPawn.m_aimPunchAngleVel".to_string(), + "CCSPlayerPawn.m_aimPunchTickBase".to_string(), + "CCSPlayerPawn.m_aimPunchTickFraction".to_string(), + "CCSPlayerPawn.m_angEyeAngles".to_string(), + "CCSPlayerPawn.m_bClientRagdoll".to_string(), + "CCSPlayerPawn.m_bClientSideRagdoll".to_string(), + "CCSPlayerPawn.m_bHasMovedSinceSpawn".to_string(), + "CCSPlayerPawn.m_bInBombZone".to_string(), + "CCSPlayerPawn.m_bInBuyZone".to_string(), + "CCSPlayerPawn.m_bIsBuyMenuOpen".to_string(), + "CCSPlayerPawn.m_bIsDefusing".to_string(), + "CCSPlayerPawn.m_bIsScoped".to_string(), + "CCSPlayerPawn.m_bIsWalking".to_string(), + "CCSPlayerPawn.m_bKilledByHeadshot".to_string(), + "CCSPlayerPawn.m_bRagdollDamageHeadshot".to_string(), + "CCSPlayerPawn.m_bResumeZoom".to_string(), + "CCSPlayerPawn.m_bSpotted".to_string(), + "CCSPlayerPawn.m_bSpottedByMask".to_string(), + "CCSPlayerPawn.m_bWaitForNoAttack".to_string(), + "CCSPlayerPawn.m_fFlags".to_string(), + "CCSPlayerPawn.m_fMolotovDamageTime".to_string(), + "CCSPlayerPawn.m_flCreateTime".to_string(), + "CCSPlayerPawn.m_flDeathTime".to_string(), + "CCSPlayerPawn.m_flEmitSoundTime".to_string(), + "CCSPlayerPawn.m_flFlashDuration".to_string(), + "CCSPlayerPawn.m_flFlashMaxAlpha".to_string(), + "CCSPlayerPawn.m_flHitHeading".to_string(), + "CCSPlayerPawn.m_flProgressBarStartTime".to_string(), + "CCSPlayerPawn.m_flSlopeDropHeight".to_string(), + "CCSPlayerPawn.m_flSlopeDropOffset".to_string(), + "CCSPlayerPawn.m_flTimeOfLastInjury".to_string(), + "CCSPlayerPawn.m_flVelocityModifier".to_string(), + "CCSPlayerPawn.m_iHealth".to_string(), + "CCSPlayerPawn.m_iMoveState".to_string(), + "CCSPlayerPawn.m_iPlayerState".to_string(), + "CCSPlayerPawn.m_iProgressBarDuration".to_string(), + "CCSPlayerPawn.m_iShotsFired".to_string(), + "CCSPlayerPawn.m_iTeamNum".to_string(), + "CCSPlayerPawn.m_lifeState".to_string(), + "CCSPlayerPawn.m_nCollisionFunctionMask".to_string(), + "CCSPlayerPawn.m_nEnablePhysics".to_string(), + "CCSPlayerPawn.m_nEntityId".to_string(), + "CCSPlayerPawn.m_nForceBone".to_string(), + "CCSPlayerPawn.m_nHierarchyId".to_string(), + "CCSPlayerPawn.m_nHitBodyPart".to_string(), + "CCSPlayerPawn.m_nInteractsAs".to_string(), + "CCSPlayerPawn.m_nInteractsExclude".to_string(), + "CCSPlayerPawn.m_nInteractsWith".to_string(), + "CCSPlayerPawn.m_nLastConcurrentKilled".to_string(), + "CCSPlayerPawn.m_nLastKillerIndex".to_string(), + "CCSPlayerPawn.m_nRagdollDamageBone".to_string(), + "CCSPlayerPawn.m_nWhichBombZone".to_string(), + "CCSPlayerPawn.m_qDeathEyeAngles".to_string(), + "CCSPlayerPawn.m_szLastPlaceName".to_string(), + "CCSPlayerPawn.m_szRagdollDamageWeaponName".to_string(), + "CCSPlayerPawn.m_thirdPersonHeading".to_string(), + "CCSPlayerPawn.m_ubInterpolationFrame".to_string(), + "CCSPlayerPawn.m_unCurrentEquipmentValue".to_string(), + "CCSPlayerPawn.m_unFreezetimeEndEquipmentValue".to_string(), + "CCSPlayerPawn.m_unRoundStartEquipmentValue".to_string(), + "CCSPlayerPawn.m_vDecalForwardAxis".to_string(), + "CCSPlayerPawn.m_vDecalPosition".to_string(), + "CCSPlayerPawn.m_vHeadConstraintOffset".to_string(), + "CCSPlayerPawn.m_vRagdollDamageForce".to_string(), + "CCSPlayerPawn.m_vRagdollDamagePosition".to_string(), + "CCSPlayerPawn.m_vRagdollServerOrigin".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_bBombDropped".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_bBombPlanted".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_bFreezePeriod".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_bGameRestart".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_bHasMatchStarted".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_bTeamIntroPeriod".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_bWarmupPeriod".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_eRoundWinReason".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_fMatchStartTime".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_fRoundStartTime".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_fWarmupPeriodEnd".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_fWarmupPeriodStart".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_flGameStartTime".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_flRestartRoundTime".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_gamePhase".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_iMatchStats_PlayersAlive_CT".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_iMatchStats_PlayersAlive_T".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_iMatchStats_RoundResults".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_iNumConsecutiveCTLoses".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_iNumConsecutiveTerroristLoses".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_iRoundTime".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_iRoundWinStatus".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_nRoundsPlayedThisPhase".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_timeUntilNextPhaseStarts".to_string(), + "CCSGameRulesProxy.CCSGameRules.m_totalRoundsPlayed".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iAssists".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iCashEarned".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iDamage".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iDeaths".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iEnemiesFlashed".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iEquipmentValue".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iHeadShotKills".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iKillReward".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iKills".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iLiveTime".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iMoneySaved".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iObjective".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iUtilityDamage".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iAssists".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iCashEarned".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iDamage".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iDeaths".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iEnemiesFlashed".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iEnemy3Ks".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iEquipmentValue".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iHeadShotKills".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iKillReward".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iKills".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iLiveTime".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iMoneySaved".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iNumRoundKills".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iNumRoundKillsHeadshots".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iObjective".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iUtilityDamage".to_string(), + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_unTotalRoundDamageDealt".to_string(), + "CCSPlayerController.CCSPlayerController_InGameMoneyServices.m_iAccount".to_string(), + "CCSPlayerController.CCSPlayerController_InGameMoneyServices.m_iCashSpentThisRound".to_string(), + "CCSPlayerController.CCSPlayerController_InGameMoneyServices.m_iStartAccount".to_string(), + "CCSPlayerController.CCSPlayerController_InGameMoneyServices.m_iTotalCashSpent".to_string(), + "CCSPlayerController.CCSPlayerController_InventoryServices.m_nPersonaDataPublicCommendsFriendly".to_string(), + "CCSPlayerController.CCSPlayerController_InventoryServices.m_nPersonaDataPublicCommendsLeader".to_string(), + "CCSPlayerController.CCSPlayerController_InventoryServices.m_nPersonaDataPublicCommendsTeacher".to_string(), + "CCSPlayerController.CCSPlayerController_InventoryServices.m_nPersonaDataPublicLevel".to_string(), + "CCSPlayerController.CCSPlayerController_InventoryServices.m_rank".to_string(), + "CCSPlayerController.CCSPlayerController_InventoryServices.m_unMusicID".to_string(), + "CCSPlayerController.m_bCanControlObservedBot".to_string(), + "CCSPlayerController.m_bEverPlayedOnTeam".to_string(), + "CCSPlayerController.m_bPawnHasDefuser".to_string(), + "CCSPlayerController.m_bPawnHasHelmet".to_string(), + "CCSPlayerController.m_bPawnIsAlive".to_string(), + "CCSPlayerController.m_fFlags".to_string(), + "CCSPlayerController.m_flCreateTime".to_string(), + "CCSPlayerController.m_hOriginalControllerOfCurrentPawn".to_string(), + "CCSPlayerController.m_hPawn".to_string(), + "CCSPlayerController.m_hPlayerPawn".to_string(), + "CCSPlayerController.m_iCompTeammateColor".to_string(), + "CCSPlayerController.m_iCompetitiveRankType".to_string(), + "CCSPlayerController.m_iCompetitiveRanking".to_string(), + "CCSPlayerController.m_iCompetitiveRankingPredicted_Loss".to_string(), + "CCSPlayerController.m_iCompetitiveRankingPredicted_Tie".to_string(), + "CCSPlayerController.m_iCompetitiveRankingPredicted_Win".to_string(), + "CCSPlayerController.m_iCompetitiveWins".to_string(), + "CCSPlayerController.m_iConnected".to_string(), + "CCSPlayerController.m_iMVPs".to_string(), + "CCSPlayerController.m_iPawnArmor".to_string(), + "CCSPlayerController.m_iPawnHealth".to_string(), + "CCSPlayerController.m_iPawnLifetimeEnd".to_string(), + "CCSPlayerController.m_iPawnLifetimeStart".to_string(), + "CCSPlayerController.m_iPendingTeamNum".to_string(), + "CCSPlayerController.m_iPing".to_string(), + "CCSPlayerController.m_iScore".to_string(), + "CCSPlayerController.m_iTeamNum".to_string(), + "CCSPlayerController.m_iszPlayerName".to_string(), + "CCSPlayerController.m_nDisconnectionTick".to_string(), + "CCSPlayerController.m_nPawnCharacterDefIndex".to_string(), + "CCSPlayerController.m_nQuestProgressReason".to_string(), + "CCSPlayerController.m_nTickBase".to_string(), + "CCSPlayerController.m_steamID".to_string(), + "CCSPlayerController.m_szCrosshairCodes".to_string(), + "CCSPlayerController.m_unActiveQuestId".to_string(), + "CCSPlayerController.m_unPlayerTvControlFlags".to_string(), + "CBodyComponentBaseAnimGraph.m_MeshGroupMask".to_string(), + "CBodyComponentBaseAnimGraph.m_angRotation".to_string(), + "CBodyComponentBaseAnimGraph.m_cellX".to_string(), + "CBodyComponentBaseAnimGraph.m_cellY".to_string(), + "CBodyComponentBaseAnimGraph.m_cellZ".to_string(), + "CBodyComponentBaseAnimGraph.m_hParent".to_string(), + "CBodyComponentBaseAnimGraph.m_hSequence".to_string(), + "CBodyComponentBaseAnimGraph.m_nAnimLoopMode".to_string(), + "CBodyComponentBaseAnimGraph.m_nIdealMotionType".to_string(), + "CBodyComponentBaseAnimGraph.m_nNewSequenceParity".to_string(), + "CBodyComponentBaseAnimGraph.m_nRandomSeedOffset".to_string(), + "CBodyComponentBaseAnimGraph.m_nResetEventsParity".to_string(), + "CBodyComponentBaseAnimGraph.m_vecX".to_string(), + "CBodyComponentBaseAnimGraph.m_vecY".to_string(), + "CBodyComponentBaseAnimGraph.m_vecZ".to_string(), + "CEconItemAttribute.m_bSetBonus".to_string(), + "CEconItemAttribute.m_flInitialValue".to_string(), + "CEconItemAttribute.m_iAttributeDefinitionIndex".to_string(), + "CEconItemAttribute.m_iRawValue32".to_string(), + "CEconItemAttribute.m_nRefundableCurrency".to_string(), + "m_MoveType".to_string(), + "m_OriginalOwnerXuidHigh".to_string(), + "m_OriginalOwnerXuidLow".to_string(), + "m_bBurstMode".to_string(), + "m_bInReload".to_string(), + "m_bReloadVisuallyComplete".to_string(), + "m_fAccuracyPenalty".to_string(), + "m_fEffects".to_string(), + "m_fLastShotTime".to_string(), + "m_flCreateTime".to_string(), + "m_flDroppedAtTime".to_string(), + "m_flFireSequenceStartTime".to_string(), + "m_flNextPrimaryAttackTickRatio".to_string(), + "m_flNextSecondaryAttackTickRatio".to_string(), + "m_flRecoilIndex".to_string(), + "m_flSimulationTime".to_string(), + "m_flTimeSilencerSwitchComplete".to_string(), + "m_hOuter".to_string(), + "m_hOwnerEntity".to_string(), + "m_hPrevOwner".to_string(), + "m_iAccountID".to_string(), + "m_iClip1".to_string(), + "m_iClip2".to_string(), + "m_iEntityQuality".to_string(), + "m_iInventoryPosition".to_string(), + "m_iIronSightMode".to_string(), + "m_iItemIDHigh".to_string(), + "m_iItemIDLow".to_string(), + "m_iState".to_string(), + "m_nAddDecal".to_string(), + "m_nCollisionFunctionMask".to_string(), + "m_nDropTick".to_string(), + "m_nEnablePhysics".to_string(), + "m_nEntityId".to_string(), + "m_nFireSequenceStartTimeChange".to_string(), + "m_nHierarchyId".to_string(), + "m_nInteractsAs".to_string(), + "m_nNextPrimaryAttackTick".to_string(), + "m_nNextSecondaryAttackTick".to_string(), + "m_nNextThinkTick".to_string(), + "m_nOwnerId".to_string(), + "m_nSubclassID".to_string(), + "m_nViewModelIndex".to_string(), + "m_pReserveAmmo".to_string(), + "m_ubInterpolationFrame".to_string(), + "m_usSolidFlags".to_string(), + "m_vDecalForwardAxis".to_string(), + "m_vDecalPosition".to_string(), + "m_weaponMode".to_string(), + "X".to_string(), + "Y".to_string(), + "Z".to_string(), + "velocity".to_string(), + "velocity_X".to_string(), + "velocity_Y".to_string(), + "velocity_Z".to_string(), + "pitch".to_string(), + "yaw".to_string(), + "weapon_name".to_string(), + "weapon_skin".to_string(), + "active_weapon_original_owner".to_string(), + "inventory".to_string(), + "entity_id".to_string(), + "is_alive".to_string(), + "user_id".to_string(), + "agent_skin".to_string(), + ]; + + let wanted_events = vec![]; + let huf = create_huffman_lookup_table(); + + let settings = ParserInputs { + wanted_player_props: wanted_props.clone(), + wanted_events: wanted_events, + real_name_to_og_name: AHashMap::default(), + wanted_player_props_og_names: wanted_props.clone(), + wanted_other_props: vec![], + wanted_other_props_og_names: vec![], + parse_ents: true, + wanted_ticks: (0..5).into_iter().map(|x| x * 10000).collect_vec(), + parse_projectiles: true, + only_header: false, + count_props: false, + only_convars: false, + huffman_lookup_table: &huf, + }; + + let mut ds = Parser::new(&settings); + ds.is_multithreadable = false; + + let file = File::open("test_demo.dem".to_string()).unwrap(); + let mmap = unsafe { MmapOptions::new().map(&file).unwrap() }; + let out = ds.parse_demo(&mmap).unwrap(); + + (out, ds.prop_controller) +} + +#[cfg(test)] +mod tests { + use crate::e2e_test::create_data; + use crate::parser::DemoOutput; + use crate::prop_controller::PropController; + use crate::prop_controller::PITCH_ID; + use crate::prop_controller::PLAYER_Y_ID; + use crate::prop_controller::WEAPON_NAME_ID; + use crate::prop_controller::WEAPON_ORIGINGAL_OWNER_ID; + use crate::prop_controller::YAW_ID; + use crate::prop_controller::*; + use crate::read_bits::Bitreader; + use crate::read_bits::DemoParserError; + use crate::variants::PropColumn; + use crate::variants::VarVec::String; + use crate::variants::VarVec::*; + use ahash::AHashMap; + use lazy_static::lazy_static; + + lazy_static! { + static ref out: (DemoOutput, PropController) = create_data(); + } + #[test] + fn Y() { + let prop = ( + "Y", + PropColumn { + data: Some(F32(vec![ + Some(-256.0), + Some(-1812.0), + Some(-304.0), + Some(-115.0), + Some(-1732.0), + Some(-1988.0), + Some(-1800.0), + Some(-64.0), + Some(-1896.0), + Some(-211.0), + Some(707.73047), + Some(284.07272), + Some(-895.6396), + Some(-434.33887), + Some(-391.00195), + Some(-2352.6865), + Some(-1103.3751), + Some(-1711.9717), + Some(-1336.3375), + Some(-134.1239), + Some(-1690.152), + Some(-961.5833), + Some(-1591.5037), + Some(-1459.2153), + Some(-471.58636), + Some(-1324.3574), + Some(-2395.391), + Some(-1950.639), + Some(-2294.539), + Some(-2375.4458), + Some(-211.0), + Some(-2072.0), + Some(32.0), + Some(-304.0), + Some(-1976.0), + Some(-1800.0), + Some(-1976.0), + Some(-16.0), + Some(-1800.0), + Some(-115.0), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&PLAYER_Y_ID], prop.1); + } + #[test] + fn weapon_name() { + let prop = ( + "weapon_name", + PropColumn { + data: Some(String(vec![ + None, + Some("knife_survival_bowie".to_string()), + None, + None, + Some("knife".to_string()), + Some("knife".to_string()), + Some("knife_m9_bayonet".to_string()), + None, + Some("knife".to_string()), + None, + None, + Some("M4A4".to_string()), + None, + None, + None, + Some("M4A4".to_string()), + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some("knife".to_string()), + None, + Some("knife_m9_bayonet".to_string()), + None, + Some("USP-S".to_string()), + Some("knife_tactical".to_string()), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&WEAPON_NAME_ID], prop.1); + } + #[test] + fn entity_id() { + let prop = ( + "entity_id", + PropColumn { + data: Some(I32(vec![ + Some(104), + Some(109), + Some(114), + Some(119), + Some(126), + Some(134), + Some(141), + Some(159), + Some(202), + Some(226), + Some(104), + Some(109), + Some(114), + Some(119), + Some(126), + Some(134), + Some(141), + Some(159), + Some(202), + Some(226), + Some(104), + Some(109), + Some(114), + Some(119), + Some(126), + Some(134), + Some(141), + Some(159), + Some(202), + Some(226), + Some(104), + Some(109), + Some(114), + Some(119), + Some(126), + Some(134), + Some(141), + Some(159), + Some(202), + Some(226), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&ENTITY_ID_ID], prop.1); + } + #[test] + fn pitch() { + let prop = ( + "pitch", + PropColumn { + data: Some(F32(vec![ + Some(-2.2631836), + Some(-3.1108398), + Some(3.06073), + Some(2.2748566), + Some(0.7041626), + Some(-8.254517), + Some(-2.8248596), + Some(0.12634277), + Some(0.035369873), + Some(14.900543), + Some(7.879257), + Some(2.2020721), + Some(0.66708374), + Some(-12.976913), + Some(27.015717), + Some(0.4576416), + Some(-3.1307678), + Some(15.228088), + Some(-5.262451), + Some(1.1556244), + Some(-11.231812), + Some(0.9702301), + Some(8.397675), + Some(0.72372437), + Some(4.839813), + Some(5.5968475), + Some(-14.218018), + Some(-5.181427), + Some(0.9328003), + Some(4.334442), + Some(-58.338776), + Some(-1.9713593), + Some(3.4926147), + Some(-5.066757), + Some(7.515335), + Some(-9.539215), + Some(-0.89434814), + Some(6.603119), + Some(4.4350433), + Some(10.610733), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&PITCH_ID], prop.1); + } + #[test] + fn active_weapon_original_owner() { + let prop = ( + "active_weapon_original_owner", + PropColumn { + data: Some(String(vec![ + None, + Some("76561198324843075".to_string()), + None, + Some("76561198244754626".to_string()), + Some("76561198194694750".to_string()), + Some("76561198073049527".to_string()), + Some("76561198258044111".to_string()), + Some("76561197964020430".to_string()), + Some("76561198280975787".to_string()), + Some("76561198202353993".to_string()), + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some("76561198244754626".to_string()), + Some("76561198194694750".to_string()), + None, + Some("76561198258044111".to_string()), + None, + None, + Some("76561198202353993".to_string()), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&WEAPON_ORIGINGAL_OWNER_ID], prop.1); + } + #[test] + fn tick() { + let prop = ( + "tick", + PropColumn { + data: Some(I32(vec![ + Some(10000), + Some(10000), + Some(10000), + Some(10000), + Some(10000), + Some(10000), + Some(10000), + Some(10000), + Some(10000), + Some(10000), + Some(20000), + Some(20000), + Some(20000), + Some(20000), + Some(20000), + Some(20000), + Some(20000), + Some(20000), + Some(20000), + Some(20000), + Some(30000), + Some(30000), + Some(30000), + Some(30000), + Some(30000), + Some(30000), + Some(30000), + Some(30000), + Some(30000), + Some(30000), + Some(40000), + Some(40000), + Some(40000), + Some(40000), + Some(40000), + Some(40000), + Some(40000), + Some(40000), + Some(40000), + Some(40000), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&TICK_ID], prop.1); + } + #[test] + fn yaw() { + let prop = ( + "yaw", + PropColumn { + data: Some(F32(vec![ + Some(-120.846176), + Some(-4.5582886), + Some(118.377686), + Some(-88.57178), + Some(107.24957), + Some(17.670471), + Some(92.258026), + Some(-116.438255), + Some(-38.2623), + Some(-26.279297), + Some(-34.673187), + Some(-67.40662), + Some(123.82553), + Some(-121.45386), + Some(-64.44443), + Some(35.886505), + Some(82.49875), + Some(95.833405), + Some(-45.82364), + Some(-145.5589), + Some(-62.706528), + Some(-42.504395), + Some(-106.25805), + Some(-33.746216), + Some(-44.32846), + Some(143.18549), + Some(80.36258), + Some(-83.19191), + Some(-170.05429), + Some(7.7237244), + Some(-170.79552), + Some(88.6806), + Some(-105.864944), + Some(-56.005898), + Some(136.82407), + Some(-88.32802), + Some(5.202362), + Some(165.99347), + Some(-38.887817), + Some(81.79184), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&YAW_ID], prop.1); + } + #[test] + fn velocity() { + let prop = ( + "velocity", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(207854.4), + Some(150870.27), + Some(114379.734), + Some(139744.61), + Some(89762.07), + Some(73647.7), + Some(54650.164), + None, + Some(73827.75), + Some(56149.902), + Some(180225.58), + Some(85360.7), + Some(50693.67), + Some(65602.23), + Some(45387.305), + Some(68026.805), + Some(82963.77), + None, + Some(103496.87), + Some(144571.95), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&VELOCITY_ID], prop.1); + } + #[test] + fn name() { + let prop = ( + "name", + PropColumn { + data: Some(String(vec![ + Some("123".to_string()), + Some("Trahun <3 V".to_string()), + Some("Голова, глаза".to_string()), + Some("NIGHTSOUL".to_string()), + Some("Dog".to_string()), + Some("miu miu".to_string()), + Some("-ExΩtiC-".to_string()), + None, + Some("povergo".to_string()), + Some("IMI Negev".to_string()), + Some("123".to_string()), + Some("Trahun <3 V".to_string()), + Some("Голова, глаза".to_string()), + Some("NIGHTSOUL".to_string()), + Some("Dog".to_string()), + Some("miu miu".to_string()), + Some("-ExΩtiC-".to_string()), + None, + Some("povergo".to_string()), + Some("IMI Negev".to_string()), + Some("123".to_string()), + Some("Trahun <3 V".to_string()), + Some("Голова, глаза".to_string()), + Some("NIGHTSOUL".to_string()), + Some("Dog".to_string()), + Some("miu miu".to_string()), + Some("-ExΩtiC-".to_string()), + None, + Some("povergo".to_string()), + Some("IMI Negev".to_string()), + Some("123".to_string()), + Some("Trahun <3 V".to_string()), + Some("Голова, глаза".to_string()), + Some("NIGHTSOUL".to_string()), + Some("Dog".to_string()), + Some("miu miu".to_string()), + Some("-ExΩtiC-".to_string()), + None, + Some("povergo".to_string()), + Some("IMI Negev".to_string()), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&NAME_ID], prop.1); + } + #[test] + fn steamid() { + let prop = ( + "steamid", + PropColumn { + data: Some(U64(vec![ + Some(76561198265366770), + Some(76561198324843075), + Some(76561198118803912), + Some(76561198244754626), + Some(76561198194694750), + Some(76561198073049527), + Some(76561198258044111), + Some(0), + Some(76561198280975787), + Some(76561198202353993), + Some(76561198265366770), + Some(76561198324843075), + Some(76561198118803912), + Some(76561198244754626), + Some(76561198194694750), + Some(76561198073049527), + Some(76561198258044111), + Some(0), + Some(76561198280975787), + Some(76561198202353993), + Some(76561198265366770), + Some(76561198324843075), + Some(76561198118803912), + Some(76561198244754626), + Some(76561198194694750), + Some(76561198073049527), + Some(76561198258044111), + Some(0), + Some(76561198280975787), + Some(76561198202353993), + Some(76561198265366770), + Some(76561198324843075), + Some(76561198118803912), + Some(76561198244754626), + Some(76561198194694750), + Some(76561198073049527), + Some(76561198258044111), + Some(0), + Some(76561198280975787), + Some(76561198202353993), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&STEAMID_ID], prop.1); + } + #[test] + fn is_alive() { + let prop = ( + "is_alive", + PropColumn { + data: Some(Bool(vec![ + Some(false), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(false), + Some(true), + Some(true), + Some(true), + Some(true), + Some(false), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(false), + Some(true), + Some(true), + Some(false), + Some(true), + Some(false), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&IS_ALIVE_ID], prop.1); + } + #[test] + fn inventory() { + let prop = ( + "inventory", + PropColumn { + data: Some(StringVec(vec![ + vec![], + vec!["knife_survival_bowie".to_string(), "USP-S".to_string()], + vec![], + vec![], + vec!["knife".to_string(), "USP-S".to_string()], + vec!["knife".to_string()], + vec!["knife_m9_bayonet".to_string(), "USP-S".to_string()], + vec![], + vec!["knife".to_string(), "USP-S".to_string()], + vec![], + vec![], + vec!["knife_survival_bowie".to_string(), "USP-S".to_string(), "M4A4".to_string()], + vec![], + vec![], + vec![], + vec!["knife".to_string(), "M4A4".to_string()], + vec!["knife_m9_bayonet".to_string(), "USP-S".to_string()], + vec![], + vec!["knife".to_string(), "USP-S".to_string()], + vec!["knife_tactical".to_string()], + vec![], + vec!["knife_survival_bowie".to_string()], + vec![], + vec![], + vec!["knife".to_string(), "USP-S".to_string()], + vec![], + vec!["knife_m9_bayonet".to_string(), "USP-S".to_string()], + vec![], + vec!["knife".to_string()], + vec!["knife_tactical".to_string()], + vec![], + vec!["knife_survival_bowie".to_string(), "USP-S".to_string()], + vec![], + vec![], + vec!["knife".to_string(), "USP-S".to_string()], + vec!["knife".to_string()], + vec!["knife_m9_bayonet".to_string(), "USP-S".to_string()], + vec![], + vec!["knife".to_string(), "USP-S".to_string()], + vec!["knife_tactical".to_string(), "R8 Revolver".to_string()], + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&INVENTORY_ID], prop.1); + } + #[test] + fn velocity_X() { + let prop = ( + "velocity_X", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(-3101.442), + Some(1078.6882), + Some(-1686.4124), + Some(-2160.0315), + Some(410.87854), + Some(1091.4297), + Some(493.83606), + None, + Some(1008.6998), + Some(-873.96765), + Some(1476.535), + Some(-476.7174), + Some(-378.38812), + Some(18.015198), + Some(704.5833), + Some(268.95282), + Some(105.41089), + None, + Some(1302.6844), + Some(-281.55255), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&VELOCITY_X_ID], prop.1); + } + #[test] + fn X() { + let prop = ( + "X", + PropColumn { + data: Some(F32(vec![ + Some(1296.0), + Some(-1976.0), + Some(1376.0), + Some(1216.0), + Some(-1598.0), + Some(-1972.0), + Some(-1656.0), + Some(1296.0), + Some(-1830.0), + Some(1216.0), + Some(-1805.442), + Some(-897.31177), + Some(-310.4124), + Some(-944.03143), + Some(-1187.1215), + Some(-880.5703), + Some(-1162.164), + Some(280.03235), + Some(-821.3002), + Some(342.03232), + Some(-328.90698), + Some(-1374.0292), + Some(-688.80054), + Some(-926.01624), + Some(-482.53815), + Some(-611.6175), + Some(-1056.753), + Some(-140.86218), + Some(481.38428), + Some(60.47976), + Some(1216.0), + Some(-1632.0), + Some(1296.0), + Some(1376.0), + Some(-1656.0), + Some(-1656.0), + Some(-1902.0), + Some(1376.0), + Some(-1776.0), + Some(1216.0), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&PLAYER_X_ID], prop.1); + } + #[test] + fn user_id() { + let prop = ( + "user_id", + PropColumn { + data: Some(I32(vec![ + Some(65283), + Some(65285), + Some(65282), + Some(65281), + Some(65287), + Some(65288), + Some(65289), + None, + Some(65286), + Some(65284), + Some(65283), + Some(65285), + Some(65282), + Some(65281), + Some(65287), + Some(65288), + Some(65289), + None, + Some(65286), + Some(65284), + Some(65283), + Some(65285), + Some(65282), + Some(65281), + Some(65287), + Some(65288), + Some(65289), + None, + Some(65286), + Some(65284), + Some(65283), + Some(65285), + Some(65282), + Some(65281), + Some(65287), + Some(65288), + Some(65289), + None, + Some(65286), + Some(65284), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&USERID_ID], prop.1); + } + #[test] + fn weapon_skin() { + let prop = ( + "weapon_skin", + PropColumn { + data: Some(String(vec![ + None, + Some("Lore".to_string()), + None, + None, + None, + None, + Some("Scorched".to_string()), + None, + None, + None, + None, + Some("TheEmperor".to_string()), + None, + None, + None, + Some("Magnesium".to_string()), + None, + None, + None, + Some("Necropos".to_string()), + None, + Some("Printstream".to_string()), + None, + None, + Some("BorealForest".to_string()), + None, + None, + None, + Some("FacilityDraft".to_string()), + Some("Necropos".to_string()), + None, + Some("BorealForest".to_string()), + None, + None, + None, + Some("Ivory".to_string()), + Some("Scorched".to_string()), + None, + None, + Some("CaseHardened".to_string()), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&WEAPON_SKIN_ID], prop.1); + } + #[test] + fn velocity_Z() { + let prop = ( + "velocity_Z", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(97.63086), + None, + None, + Some(-42.189636), + None, + Some(96.0), + Some(-77.12134), + None, + Some(0.0), + None, + Some(128.0), + Some(125.5), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&VELOCITY_Z_ID], prop.1); + } + #[test] + fn velocity_Y() { + let prop = ( + "velocity_Y", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(963.73047), + Some(2096.0728), + Some(-591.6396), + Some(-319.33887), + Some(1340.998), + Some(-364.68652), + Some(696.6249), + None, + Some(559.6625), + Some(76.8761), + Some(-2397.8823), + Some(-1245.656), + Some(-695.8641), + Some(-1024.8765), + Some(-80.58441), + Some(1028.3291), + Some(-1292.016), + None, + Some(-958.20154), + Some(-2241.3218), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&VELOCITY_Y_ID], prop.1); + } + #[test] + fn Z() { + let prop = ( + "Z", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + Some(-265.5996), + None, + None, + Some(-125.77911), + None, + Some(-263.96875), + Some(-55.96875), + None, + Some(-167.96875), + None, + Some(-167.96875), + Some(-165.46875), + None, + Some(-167.96875), + Some(-167.96875), + Some(-167.96875), + Some(-133.09009), + Some(-167.96875), + Some(-167.96875), + Some(-167.96875), + Some(-39.96875), + Some(-39.96875), + None, + Some(-261.0), + Some(-167.96875), + Some(-167.96875), + Some(-267.4583), + Some(-267.20642), + Some(-273.9879), + Some(-167.96875), + Some(-263.96875), + Some(-163.96875), + ])), + num_nones: 0, + }, + ); + assert_eq!(out.0.df[&PLAYER_Z_ID], prop.1); + } + + #[test] + fn CCSPlayerPawn_CBodyComponentBaseAnimGraph_m_flLastTeleportTime() { + let prop = ( + "CCSPlayerPawn.CBodyComponentBaseAnimGraph.m_flLastTeleportTime", + PropColumn { + data: Some(F32(vec![ + Some(216.92188), + Some(216.92188), + Some(216.92188), + Some(216.92188), + Some(216.92188), + Some(216.92188), + Some(216.92188), + Some(216.92188), + Some(216.92188), + Some(216.92188), + Some(314.75), + Some(314.75), + Some(314.75), + Some(314.75), + Some(314.75), + Some(314.75), + Some(314.75), + Some(314.75), + Some(314.75), + Some(314.75), + Some(484.0), + Some(484.0), + Some(484.0), + Some(484.0), + Some(484.0), + Some(484.0), + Some(484.0), + Some(484.0), + Some(484.0), + Some(484.0), + Some(683.3125), + Some(683.3125), + Some(683.3125), + Some(683.3125), + Some(683.3125), + Some(683.3125), + Some(683.3125), + Some(683.3125), + Some(683.3125), + Some(683.3125), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_flSimulationTime() { + let prop = ( + "m_flSimulationTime", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(632.7667), + None, + None, + None, + None, + None, + None, + Some(856.7667), + None, + None, + None, + None, + None, + None, + Some(1379.9668), + Some(1479.4668), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_bCanControlObservedBot() { + let prop = ( + "CCSPlayerController.m_bCanControlObservedBot", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_OriginalOwnerXuidHigh() { + let prop = ( + "m_OriginalOwnerXuidHigh", + PropColumn { + data: Some(U32(vec![ + None, + Some(17825793), + None, + Some(17825793), + Some(17825793), + Some(17825793), + Some(17825793), + Some(17825793), + Some(17825793), + Some(17825793), + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(17825793), + Some(17825793), + None, + Some(17825793), + None, + None, + Some(17825793), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_szCrosshairCodes() { + let prop = ( + "CCSPlayerController.m_szCrosshairCodes", + PropColumn { + data: Some(String(vec![ + Some("CSGO-aAhcL-YbVFH-SpAvG-dM3PV-9mUCP".to_string()), + Some("CSGO-oVQVm-VnzOz-RNsAf-FaZTC-z5VeL".to_string()), + Some("CSGO-VisQq-mTARE-sN3Ei-mo3TC-VfdBN".to_string()), + Some("CSGO-VisQq-mTARE-sN3Ei-mo3TC-VfdBN".to_string()), + Some("CSGO-GjYG4-fYXAt-8U47O-Q4UUK-ATnMC".to_string()), + Some("CSGO-poWfA-tp4rq-Vi7M5-6B8BY-RMQNN".to_string()), + Some("CSGO-YSQdL-YGttX-OzwmR-huLBx-VY2UO".to_string()), + None, + Some("CSGO-CVyXT-B96An-hy9CE-ubFy4-5a4NF".to_string()), + Some("CSGO-EOoDJ-6Ouo9-JqKiO-kfcGW-FnHrL".to_string()), + Some("CSGO-aAhcL-YbVFH-SpAvG-dM3PV-9mUCP".to_string()), + Some("CSGO-oVQVm-VnzOz-RNsAf-FaZTC-z5VeL".to_string()), + Some("CSGO-VisQq-mTARE-sN3Ei-mo3TC-VfdBN".to_string()), + Some("CSGO-VisQq-mTARE-sN3Ei-mo3TC-VfdBN".to_string()), + Some("CSGO-GjYG4-fYXAt-8U47O-Q4UUK-ATnMC".to_string()), + Some("CSGO-poWfA-tp4rq-Vi7M5-6B8BY-RMQNN".to_string()), + Some("CSGO-YSQdL-YGttX-OzwmR-huLBx-VY2UO".to_string()), + None, + Some("CSGO-CVyXT-B96An-hy9CE-ubFy4-5a4NF".to_string()), + Some("CSGO-EOoDJ-6Ouo9-JqKiO-kfcGW-FnHrL".to_string()), + Some("CSGO-aAhcL-YbVFH-SpAvG-dM3PV-9mUCP".to_string()), + Some("CSGO-oVQVm-VnzOz-RNsAf-FaZTC-z5VeL".to_string()), + Some("CSGO-VisQq-mTARE-sN3Ei-mo3TC-VfdBN".to_string()), + Some("CSGO-VisQq-mTARE-sN3Ei-mo3TC-VfdBN".to_string()), + Some("CSGO-GjYG4-fYXAt-8U47O-Q4UUK-ATnMC".to_string()), + Some("CSGO-poWfA-tp4rq-Vi7M5-6B8BY-RMQNN".to_string()), + Some("CSGO-YSQdL-YGttX-OzwmR-huLBx-VY2UO".to_string()), + None, + Some("CSGO-CVyXT-B96An-hy9CE-ubFy4-5a4NF".to_string()), + Some("CSGO-EOoDJ-6Ouo9-JqKiO-kfcGW-FnHrL".to_string()), + Some("CSGO-aAhcL-YbVFH-SpAvG-dM3PV-9mUCP".to_string()), + Some("CSGO-oVQVm-VnzOz-RNsAf-FaZTC-z5VeL".to_string()), + Some("CSGO-VisQq-mTARE-sN3Ei-mo3TC-VfdBN".to_string()), + Some("CSGO-VisQq-mTARE-sN3Ei-mo3TC-VfdBN".to_string()), + Some("CSGO-GjYG4-fYXAt-8U47O-Q4UUK-ATnMC".to_string()), + Some("CSGO-poWfA-tp4rq-Vi7M5-6B8BY-RMQNN".to_string()), + Some("CSGO-YSQdL-YGttX-OzwmR-huLBx-VY2UO".to_string()), + None, + Some("CSGO-CVyXT-B96An-hy9CE-ubFy4-5a4NF".to_string()), + Some("CSGO-EOoDJ-6Ouo9-JqKiO-kfcGW-FnHrL".to_string()), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_CSPerRoundStats_t_m_iHeadShotKills() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iHeadShotKills", + PropColumn { + data: Some(I32(vec![ + Some(1), + None, + Some(1), + None, + None, + None, + None, + Some(1), + Some(1), + Some(2), + Some(1), + Some(1), + Some(1), + Some(1), + None, + None, + None, + Some(1), + Some(1), + Some(2), + Some(1), + Some(1), + Some(1), + Some(1), + None, + None, + None, + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + None, + None, + None, + Some(1), + Some(1), + Some(1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_thirdPersonHeading() { + let prop = ( + "CCSPlayerPawn.m_thirdPersonHeading", + PropColumn { + data: Some(XYZVec(vec![ + Some([0.0, -130.40326, 0.0]), + Some([0.0, -28.618698, 0.0]), + Some([0.0, 117.88812, 0.0]), + Some([0.0, -85.43003, 0.0]), + Some([0.0, 105.99988, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 94.00006, 0.0]), + Some([0.0, -116.81728, 0.0]), + Some([0.0, -13.908691, 0.0]), + Some([0.0, -27.106018, 0.0]), + Some([0.0, -35.857315, 0.0]), + Some([0.0, -66.82949, 0.0]), + Some([0.0, 121.426056, 0.0]), + Some([0.0, -121.45386, 0.0]), + Some([0.0, -64.759254, 0.0]), + Some([0.0, 35.886505, 0.0]), + Some([0.0, 82.49875, 0.0]), + Some([0.0, 94.52533, 0.0]), + Some([0.0, -45.80612, 0.0]), + Some([0.0, -145.5589, 0.0]), + Some([0.0, -60.42137, 0.0]), + Some([0.0, -22.725555, 0.0]), + Some([0.0, -86.54137, 0.0]), + Some([0.0, -33.746216, 0.0]), + Some([0.0, -37.22786, 0.0]), + Some([0.0, 114.522156, 0.0]), + Some([0.0, 68.98898, 0.0]), + Some([0.0, 7.3034973, 0.0]), + Some([0.0, -170.91225, 0.0]), + Some([0.0, 7.812317, 0.0]), + Some([0.0, -171.97037, 0.0]), + Some([0.0, 90.21939, 0.0]), + Some([0.0, -107.425, 0.0]), + Some([0.0, -55.725403, 0.0]), + Some([0.0, 108.01416, 0.0]), + Some([0.0, -112.60025, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 162.4205, 0.0]), + Some([0.0, -38.886444, 0.0]), + Some([0.0, 61.380615, 0.0]), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_bClientRagdoll() { + let prop = ( + "CCSPlayerPawn.m_bClientRagdoll", + PropColumn { + data: Some(Bool(vec![ + None, + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + None, + Some(false), + Some(false), + Some(false), + Some(false), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(true), + Some(false), + Some(false), + Some(true), + Some(false), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_bResumeZoom() { + let prop = ( + "CCSPlayerPawn.m_bResumeZoom", + PropColumn { + data: Some(Bool(vec![ + None, + None, + None, + None, + None, + None, + None, + Some(false), + None, + None, + None, + None, + None, + None, + None, + None, + Some(false), + Some(false), + None, + Some(false), + None, + None, + None, + None, + None, + None, + Some(false), + Some(false), + None, + Some(false), + None, + Some(false), + Some(false), + None, + None, + None, + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_CSPerRoundStats_t_m_iEquipmentValue() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iEquipmentValue", + PropColumn { + data: Some(I32(vec![ + Some(700), + Some(800), + Some(200), + Some(200), + Some(500), + Some(850), + Some(850), + Some(300), + Some(650), + Some(1000), + Some(4300), + Some(5900), + Some(5100), + Some(2750), + Some(5600), + Some(5300), + Some(5700), + Some(1950), + Some(4200), + Some(3100), + Some(5100), + Some(700), + Some(5100), + Some(5100), + Some(4100), + Some(3100), + Some(4250), + Some(2600), + Some(300), + Some(4200), + Some(5100), + Some(700), + Some(5100), + Some(5100), + Some(4100), + Some(3100), + Some(4250), + Some(2600), + Some(300), + Some(4200), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_nForceBone() { + let prop = ( + "CCSPlayerPawn.m_nForceBone", + PropColumn { + data: Some(I32(vec![ + Some(14), + Some(6), + Some(4), + Some(6), + Some(6), + Some(6), + Some(6), + Some(13), + Some(6), + None, + Some(4), + Some(6), + Some(6), + Some(4), + Some(6), + Some(6), + Some(6), + Some(6), + Some(4), + Some(6), + Some(6), + Some(1), + Some(14), + Some(4), + Some(6), + Some(4), + Some(4), + Some(1), + Some(1), + Some(4), + Some(-1), + Some(5), + Some(25), + Some(6), + Some(4), + Some(4), + Some(6), + Some(0), + Some(1), + Some(-1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_iPlayerState() { + let prop = ( + "CCSPlayerPawn.m_iPlayerState", + PropColumn { + data: Some(U64(vec![ + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(8), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(8), + Some(0), + Some(0), + Some(8), + Some(0), + Some(8), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_iItemIDHigh() { + let prop = ( + "m_iItemIDHigh", + PropColumn { + data: Some(U32(vec![ + None, + Some(8), + None, + None, + None, + None, + Some(8), + None, + None, + None, + Some(7), + Some(8), + None, + Some(0), + None, + Some(8), + None, + Some(0), + None, + None, + Some(7), + Some(8), + None, + None, + Some(7), + None, + None, + None, + Some(8), + None, + None, + Some(7), + None, + None, + None, + Some(8), + Some(8), + None, + None, + Some(7), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iCompetitiveWins() { + let prop = ( + "CCSPlayerController.m_iCompetitiveWins", + PropColumn { + data: Some(I32(vec![ + Some(125), + Some(56), + Some(37), + Some(63), + Some(60), + Some(24), + Some(59), + Some(41), + Some(38), + Some(19), + Some(125), + Some(56), + Some(37), + Some(63), + Some(60), + Some(24), + Some(59), + Some(41), + Some(38), + Some(19), + Some(125), + Some(56), + Some(37), + Some(63), + Some(60), + Some(24), + Some(59), + Some(41), + Some(38), + Some(19), + Some(125), + Some(56), + Some(37), + Some(63), + Some(60), + Some(24), + Some(59), + Some(41), + Some(38), + Some(19), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_unRoundStartEquipmentValue() { + let prop = ( + "CCSPlayerPawn.m_unRoundStartEquipmentValue", + PropColumn { + data: Some(U32(vec![ + Some(700), + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(200), + None, + None, + None, + Some(3700), + None, + Some(2900), + None, + None, + None, + Some(4400), + None, + Some(3900), + Some(4200), + Some(200), + None, + Some(200), + Some(2300), + None, + Some(3300), + Some(4200), + None, + Some(200), + Some(200), + Some(200), + Some(5300), + Some(200), + Some(200), + None, + Some(4300), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_bSpotted() { + let prop = ( + "CCSPlayerPawn.m_bSpotted", + PropColumn { + data: Some(Bool(vec![ + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_nNextPrimaryAttackTick() { + let prop = ( + "m_nNextPrimaryAttackTick", + PropColumn { + data: Some(U32(vec![ + Some(28714), + Some(28006), + Some(28260), + Some(28444), + Some(29020), + Some(28768), + Some(28968), + Some(28788), + Some(29050), + Some(28726), + Some(44648), + Some(49060), + Some(46326), + Some(48414), + None, + Some(46920), + Some(47992), + Some(43736), + Some(48966), + Some(48852), + Some(68608), + Some(68916), + None, + Some(68616), + Some(69172), + None, + Some(68956), + None, + Some(68940), + Some(68702), + Some(87976), + Some(89042), + Some(88524), + Some(88024), + Some(89002), + Some(88172), + Some(87766), + Some(88972), + Some(88838), + Some(88626), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_totalRoundsPlayed() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_totalRoundsPlayed", + PropColumn { + data: Some(I32(vec![ + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(4), + Some(4), + Some(4), + Some(4), + Some(4), + Some(4), + Some(4), + Some(4), + Some(4), + Some(4), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iTeamNum() { + let prop = ( + "CCSPlayerController.m_iTeamNum", + PropColumn { + data: Some(U32(vec![ + None, + Some(3), + None, + None, + Some(3), + Some(3), + Some(3), + None, + Some(3), + None, + None, + Some(3), + None, + None, + Some(3), + Some(3), + Some(3), + None, + Some(3), + None, + None, + Some(3), + None, + None, + Some(3), + Some(3), + Some(3), + None, + Some(3), + None, + None, + Some(3), + None, + None, + Some(3), + Some(3), + Some(3), + None, + Some(3), + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_InventoryServices_m_nPersonaDataPublicLevel() { + let prop = ( + "CCSPlayerController.CCSPlayerController_InventoryServices.m_nPersonaDataPublicLevel", + PropColumn { + data: Some(I32(vec![ + Some(29), + Some(31), + Some(9), + Some(38), + Some(40), + Some(35), + Some(2), + Some(20), + Some(28), + Some(27), + Some(29), + Some(31), + Some(9), + Some(38), + Some(40), + Some(35), + Some(2), + Some(20), + Some(28), + Some(27), + Some(29), + Some(31), + Some(9), + Some(38), + Some(40), + Some(35), + Some(2), + Some(20), + Some(28), + Some(27), + Some(29), + Some(31), + Some(9), + Some(38), + Some(40), + Some(35), + Some(2), + Some(20), + Some(28), + Some(27), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_nLastKillerIndex() { + let prop = ( + "CCSPlayerPawn.m_nLastKillerIndex", + PropColumn { + data: Some(U64(vec![ + None, + Some(452), + Some(404), + Some(404), + Some(228), + Some(318), + Some(208), + Some(252), + Some(452), + None, + Some(252), + Some(238), + Some(404), + Some(252), + Some(238), + Some(318), + Some(208), + Some(282), + Some(318), + Some(218), + Some(252), + Some(318), + Some(282), + Some(252), + Some(208), + Some(238), + Some(238), + Some(282), + Some(208), + Some(218), + Some(252), + Some(238), + Some(282), + Some(268), + Some(318), + Some(238), + Some(208), + Some(282), + Some(318), + Some(404), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_flDeathTime() { + let prop = ( + "CCSPlayerPawn.m_flDeathTime", + PropColumn { + data: Some(F32(vec![ + None, + Some(139.95313), + Some(179.32813), + Some(145.9375), + Some(140.34375), + Some(117.96875), + Some(181.21875), + Some(136.70313), + Some(209.92188), + None, + Some(296.04688), + Some(262.0625), + Some(258.57813), + Some(264.76563), + Some(373.32813), + Some(265.20313), + Some(181.21875), + Some(295.59375), + Some(270.32813), + Some(259.9375), + Some(296.04688), + Some(450.6875), + Some(535.7969), + Some(264.76563), + Some(456.15625), + Some(529.46875), + Some(457.79688), + Some(532.7969), + Some(470.1875), + Some(259.9375), + Some(557.2031), + Some(607.71875), + Some(640.40625), + Some(679.4219), + Some(609.2031), + Some(529.46875), + Some(645.8594), + Some(642.1406), + Some(619.6875), + Some(539.15625), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_unTotalRoundDamageDealt() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_unTotalRoundDamageDealt", + PropColumn { + data: Some(U32(vec![ + Some(0), + Some(0), + Some(0), + None, + Some(0), + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(52), + Some(0), + Some(100), + Some(99), + None, + Some(26), + Some(0), + Some(0), + Some(71), + Some(28), + Some(0), + Some(44), + Some(50), + Some(46), + Some(76), + Some(130), + Some(108), + Some(23), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_MovementServices_m_flDuckAmount() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flDuckAmount", + PropColumn { + data: Some(F32(vec![ + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(1.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.47264498), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_flDroppedAtTime() { + let prop = ( + "m_flDroppedAtTime", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(295.59375), + None, + None, + None, + None, + None, + None, + Some(400.71875), + None, + None, + None, + None, + None, + None, + Some(645.8594), + Some(693.40625), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_CSPerRoundStats_t_m_iLiveTime() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iLiveTime", + PropColumn { + data: Some(I32(vec![ + None, + Some(42), + Some(82), + Some(48), + Some(43), + Some(20), + Some(83), + Some(39), + Some(112), + None, + Some(59), + Some(25), + Some(21), + Some(27), + Some(38), + Some(28), + Some(160), + Some(58), + Some(33), + Some(23), + Some(51), + Some(18), + Some(31), + Some(51), + Some(24), + Some(25), + Some(25), + Some(28), + Some(38), + Some(51), + Some(152), + Some(36), + Some(31), + Some(40), + Some(84), + Some(124), + Some(40), + Some(28), + Some(47), + Some(134), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iHeadShotKills() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iHeadShotKills", + PropColumn { + data: Some(I32(vec![ + Some(1), + Some(0), + Some(1), + Some(0), + None, + Some(0), + None, + Some(1), + Some(1), + Some(2), + Some(1), + Some(1), + Some(1), + Some(2), + None, + Some(0), + None, + Some(2), + Some(2), + Some(2), + Some(4), + Some(1), + Some(1), + Some(3), + None, + Some(0), + None, + Some(3), + Some(2), + Some(3), + Some(6), + Some(1), + Some(1), + Some(4), + None, + Some(1), + None, + Some(3), + Some(2), + Some(3), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_angEyeAngles() { + let prop = ( + "CCSPlayerPawn.m_angEyeAngles", + PropColumn { + data: Some(XYZVec(vec![ + Some([-2.2631836, -120.846176, 0.0]), + Some([-3.1108398, -4.5582886, 0.0]), + Some([3.06073, 118.377686, 0.0]), + Some([2.2748566, -88.57178, 0.0]), + Some([0.7041626, 107.24957, 0.0]), + Some([-8.254517, 17.670471, 0.0]), + Some([-2.8248596, 92.258026, 0.0]), + Some([0.12634277, -116.438255, 0.0]), + Some([0.035369873, -38.2623, 0.0]), + Some([14.900543, -26.279297, 0.0]), + Some([7.879257, -34.673187, 0.0]), + Some([2.2020721, -67.40662, 0.0]), + Some([0.66708374, 123.82553, 0.0]), + Some([-12.976913, -121.45386, 0.0]), + Some([27.015717, -64.44443, 0.0]), + Some([0.4576416, 35.886505, 0.0]), + Some([-3.1307678, 82.49875, 0.0]), + Some([15.228088, 95.833405, 0.0]), + Some([-5.262451, -45.82364, 0.0]), + Some([1.1556244, -145.5589, 0.0]), + Some([-11.231812, -62.706528, 0.0]), + Some([0.9702301, -42.504395, 0.0]), + Some([8.397675, -106.25805, 0.0]), + Some([0.72372437, -33.746216, 0.0]), + Some([4.839813, -44.32846, 0.0]), + Some([5.5968475, 143.18549, 0.0]), + Some([-14.218018, 80.36258, 0.0]), + Some([-5.181427, -83.19191, 0.0]), + Some([0.9328003, -170.05429, 0.0]), + Some([4.334442, 7.7237244, 0.0]), + Some([-58.338776, -170.79552, 0.0]), + Some([-1.9713593, 88.6806, 0.0]), + Some([3.4926147, -105.864944, 0.0]), + Some([-5.066757, -56.005898, 0.0]), + Some([7.515335, 136.82407, 0.0]), + Some([-9.539215, -88.32802, 0.0]), + Some([-0.89434814, 5.202362, 0.0]), + Some([6.603119, 165.99347, 0.0]), + Some([4.4350433, -38.887817, 0.0]), + Some([10.610733, 81.79184, 0.0]), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_flFireSequenceStartTime() { + let prop = ( + "m_flFireSequenceStartTime", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(0.040438853), + None, + None, + None, + Some(0.040459678), + None, + None, + Some(0.047859564), + None, + Some(0.041319698), + Some(0.023653211), + Some(0.049818836), + None, + None, + Some(0.041941315), + Some(0.08304096), + None, + None, + None, + Some(0.048115853), + Some(0.02575165), + None, + Some(0.09012867), + None, + None, + None, + None, + None, + None, + None, + Some(0.033517454), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_flCreateTime() { + let prop = ( + "CCSPlayerPawn.m_flCreateTime", + PropColumn { + data: Some(F32(vec![ + Some(4.796875), + Some(5.109375), + Some(5.578125), + Some(6.40625), + None, + Some(11.640625), + Some(13.890625), + Some(10.984375), + Some(46.359375), + Some(54.765625), + Some(4.796875), + Some(5.109375), + Some(5.578125), + Some(6.40625), + None, + Some(11.640625), + Some(13.890625), + Some(10.984375), + Some(46.359375), + Some(54.765625), + Some(4.796875), + Some(5.109375), + Some(5.578125), + Some(6.40625), + None, + Some(11.640625), + Some(13.890625), + Some(10.984375), + Some(46.359375), + Some(54.765625), + Some(4.796875), + Some(5.109375), + Some(5.578125), + Some(6.40625), + None, + Some(11.640625), + Some(13.890625), + Some(10.984375), + Some(46.359375), + Some(54.765625), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_usSolidFlags() { + let prop = ( + "m_usSolidFlags", + PropColumn { + data: Some(U32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(3), + None, + None, + None, + None, + None, + None, + Some(3), + None, + None, + None, + None, + None, + None, + Some(3), + Some(3), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_flFlashDuration() { + let prop = ( + "CCSPlayerPawn.m_flFlashDuration", + PropColumn { + data: Some(F32(vec![ + None, + Some(0.0), + Some(0.0), + None, + None, + None, + None, + Some(0.0), + None, + None, + None, + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_bPawnHasHelmet() { + let prop = ( + "CCSPlayerController.m_bPawnHasHelmet", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_ItemServices_m_bHasHelmet() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_ItemServices.m_bHasHelmet", + PropColumn { + data: Some(Bool(vec![ + Some(true), + None, + None, + Some(true), + Some(false), + None, + None, + Some(true), + None, + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(false), + Some(true), + Some(true), + Some(false), + Some(false), + Some(true), + Some(true), + Some(false), + Some(false), + Some(true), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(true), + Some(true), + Some(false), + Some(true), + Some(true), + Some(false), + Some(true), + Some(false), + Some(true), + Some(false), + Some(true), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_bHasMatchStarted() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_bHasMatchStarted", + PropColumn { + data: Some(Bool(vec![ + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CEconItemAttribute_m_nRefundableCurrency() { + let prop = ( + "CEconItemAttribute.m_nRefundableCurrency", + PropColumn { + data: Some(I32(vec![ + None, + Some(0), + None, + None, + None, + None, + Some(0), + None, + None, + None, + Some(0), + Some(0), + None, + None, + None, + Some(0), + None, + None, + None, + None, + Some(0), + Some(0), + None, + None, + Some(0), + None, + None, + None, + Some(0), + None, + None, + Some(0), + None, + None, + None, + Some(0), + Some(0), + None, + None, + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_nInteractsWith() { + let prop = ( + "CCSPlayerPawn.m_nInteractsWith", + PropColumn { + data: Some(U64(vec![ + None, + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + None, + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(34361847825), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(34361847825), + Some(2895889), + Some(2895889), + Some(34361847825), + Some(2895889), + Some(34361847825), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + Some(2895889), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_MovementServices_m_flOffsetTickCompleteTime() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flOffsetTickCompleteTime", + PropColumn { + data: Some(F32(vec![ + Some(214.70894), + Some(139.11497), + Some(179.13269), + Some(145.6925), + Some(139.75066), + Some(117.80774), + Some(181.02057), + Some(136.5264), + Some(209.8517), + Some(213.52574), + Some(382.15256), + Some(381.5084), + Some(381.8938), + Some(382.24454), + Some(372.66974), + Some(382.1154), + Some(381.3079), + Some(361.11783), + Some(382.22818), + Some(382.2228), + Some(538.49634), + Some(538.511), + Some(535.7737), + Some(538.4727), + Some(538.34064), + Some(529.3963), + Some(538.42053), + Some(532.6795), + Some(538.38007), + Some(537.43854), + Some(682.8653), + Some(607.44965), + Some(639.7773), + Some(679.336), + Some(609.0068), + Some(682.9732), + Some(645.4027), + Some(641.43146), + Some(619.48346), + Some(681.91705), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_qDeathEyeAngles() { + let prop = ( + "CCSPlayerPawn.m_qDeathEyeAngles", + PropColumn { + data: Some(XYZVec(vec![ + None, + Some([27.125, -71.03125, 0.0]), + Some([4.3125, -110.75, 0.0]), + Some([-5.71875, -37.53125, 0.0]), + Some([13.96875, -1.625, 0.0]), + Some([7.6875, 83.9375, 0.0]), + Some([-0.65625, -72.9375, 0.0]), + Some([6.78125, -108.0625, 0.0]), + Some([0.6875, 132.0, 0.0]), + None, + Some([3.09375, 27.0, 0.0]), + Some([0.625, 70.40625, 0.0]), + Some([18.59375, 108.71875, 0.0]), + Some([-6.0, 64.09375, 0.0]), + Some([38.53125, -64.5625, 0.0]), + Some([3.09375, 81.46875, 0.0]), + Some([-0.65625, -72.9375, 0.0]), + Some([-3.21875, 165.65625, 0.0]), + Some([2.5625, 6.1875, 0.0]), + Some([8.03125, 125.21875, 0.0]), + Some([3.09375, 27.0, 0.0]), + Some([0.0, 82.15625, 0.0]), + Some([0.96875, -98.0, 0.0]), + Some([-6.0, 64.09375, 0.0]), + Some([2.0, 80.4375, 0.0]), + Some([4.09375, 128.6875, 0.0]), + Some([22.21875, 56.15625, 0.0]), + Some([-14.8125, 5.5, 0.0]), + Some([-0.15625, 109.6875, 0.0]), + Some([8.03125, 125.21875, 0.0]), + Some([4.34375, 177.90625, 0.0]), + Some([0.09375, 62.34375, 0.0]), + Some([3.875, 5.5625, 0.0]), + Some([-19.78125, 3.96875, 0.0]), + Some([0.84375, -52.28125, 0.0]), + Some([4.09375, 128.6875, 0.0]), + Some([-1.40625, -102.625, 0.0]), + Some([5.75, 145.71875, 0.0]), + Some([1.96875, 110.34375, 0.0]), + Some([6.125, 9.6875, 0.0]), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iCompetitiveRanking() { + let prop = ( + "CCSPlayerController.m_iCompetitiveRanking", + PropColumn { + data: Some(I32(vec![ + Some(18244), + Some(18153), + Some(9999), + Some(14999), + Some(18891), + Some(16250), + Some(19084), + Some(13756), + Some(17709), + None, + Some(18244), + Some(18153), + Some(9999), + Some(14999), + Some(18891), + Some(16250), + Some(19084), + Some(13756), + Some(17709), + None, + Some(18244), + Some(18153), + Some(9999), + Some(14999), + Some(18891), + Some(16250), + Some(19084), + Some(13756), + Some(17709), + None, + Some(18244), + Some(18153), + Some(9999), + Some(14999), + Some(18891), + Some(16250), + Some(19084), + Some(13756), + Some(17709), + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_lifeState() { + let prop = ( + "CCSPlayerPawn.m_lifeState", + PropColumn { + data: Some(U32(vec![ + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(2), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(2), + Some(0), + Some(0), + Some(2), + Some(0), + Some(2), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_flNextPrimaryAttackTickRatio() { + let prop = ( + "m_flNextPrimaryAttackTickRatio", + PropColumn { + data: Some(F32(vec![ + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.5333328), + Some(0.0), + Some(0.26667786), + None, + Some(0.5333328), + Some(0.8666687), + Some(0.0), + Some(0.0), + Some(0.56849414), + Some(0.0), + Some(0.0), + None, + Some(0.3865242), + Some(0.2666626), + None, + Some(0.0), + None, + Some(0.08510375), + Some(0.0), + Some(0.0), + Some(0.5333328), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.93333435), + Some(0.0), + Some(0.0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_bIsDefusing() { + let prop = ( + "CCSPlayerPawn.m_bIsDefusing", + PropColumn { + data: Some(Bool(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(false), + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(false), + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(false), + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_vDecalPosition() { + let prop = ( + "m_vDecalPosition", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iConnected() { + let prop = ( + "CCSPlayerController.m_iConnected", + PropColumn { + data: Some(U32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_flProgressBarStartTime() { + let prop = ( + "CCSPlayerPawn.m_flProgressBarStartTime", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(297.75), + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(297.75), + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(297.75), + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CBodyComponentBaseAnimGraph_m_cellX() { + let prop = ( + "CBodyComponentBaseAnimGraph.m_cellX", + PropColumn { + data: Some(U32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(32), + None, + None, + None, + None, + None, + None, + Some(32), + None, + None, + None, + None, + None, + None, + Some(32), + Some(32), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_InGameMoneyServices_m_iAccount() { + let prop = ( + "CCSPlayerController.CCSPlayerController_InGameMoneyServices.m_iAccount", + PropColumn { + data: Some(I32(vec![ + Some(1950), + Some(1900), + Some(3650), + Some(50), + Some(2200), + Some(2050), + Some(2050), + Some(50), + Some(2650), + Some(3150), + Some(50), + Some(0), + Some(950), + Some(600), + Some(4400), + Some(450), + Some(1650), + Some(1400), + Some(200), + Some(100), + Some(5950), + Some(2600), + Some(2550), + Some(5900), + Some(1900), + Some(150), + Some(600), + Some(8750), + Some(1850), + Some(4500), + Some(6150), + Some(1500), + Some(2750), + Some(1600), + Some(3250), + Some(2700), + Some(2000), + Some(150), + Some(1550), + Some(3000), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_CSPerRoundStats_t_m_iEnemiesFlashed() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iEnemiesFlashed", + PropColumn { + data: Some(I32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(1), + None, + None, + None, + None, + Some(3), + Some(2), + Some(2), + None, + Some(1), + Some(1), + None, + None, + None, + Some(1), + Some(3), + Some(1), + Some(2), + None, + Some(1), + Some(1), + None, + None, + None, + Some(1), + Some(3), + Some(1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_CSPerRoundStats_t_m_iMoneySaved() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iMoneySaved", + PropColumn { + data: Some(I32(vec![ + Some(100), + None, + Some(800), + Some(800), + Some(300), + Some(150), + Some(150), + Some(500), + Some(150), + None, + Some(50), + Some(1900), + Some(950), + Some(50), + Some(4400), + Some(450), + Some(1650), + Some(1400), + Some(200), + Some(100), + Some(5950), + Some(2600), + Some(2550), + Some(5600), + Some(1900), + Some(1150), + Some(200), + Some(8750), + Some(1850), + Some(4500), + Some(5950), + Some(2600), + Some(2550), + Some(5600), + Some(1900), + Some(1150), + Some(200), + Some(8750), + Some(1850), + Some(4500), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_BulletServices_m_totalHitsOnServer() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_BulletServices.m_totalHitsOnServer", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(5), + Some(4), + Some(0), + Some(0), + Some(0), + Some(0), + Some(1), + Some(4), + Some(0), + Some(0), + Some(1), + Some(2), + Some(3), + Some(6), + Some(5), + Some(1), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_nSubclassID() { + let prop = ( + "m_nSubclassID", + PropColumn { + data: Some(U32(vec![ + Some(3901722307), + Some(2511498851), + Some(628863847), + Some(1058568214), + Some(294910436), + Some(294910436), + Some(1638561588), + Some(1058568214), + Some(294910436), + Some(1058568214), + Some(2242710103), + Some(2746029779), + Some(2242710103), + Some(3427122024), + None, + Some(2746029779), + Some(2242710103), + Some(3427122024), + Some(2973572455), + Some(3902792221), + Some(2242710103), + Some(628863847), + None, + Some(2242710103), + Some(4152478990), + None, + Some(1977124450), + None, + Some(1573262270), + Some(3902792221), + Some(3901722307), + Some(4152478990), + Some(2242710103), + Some(1058568214), + Some(294910436), + Some(1721431921), + Some(1638561588), + Some(3748345010), + Some(2343690088), + Some(2282479884), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_nWhichBombZone() { + let prop = ( + "CCSPlayerPawn.m_nWhichBombZone", + PropColumn { + data: Some(I32(vec![ + None, + None, + None, + None, + Some(0), + None, + None, + None, + Some(0), + Some(0), + None, + Some(0), + None, + None, + Some(0), + None, + Some(0), + Some(0), + Some(0), + Some(0), + None, + Some(0), + None, + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + None, + Some(0), + None, + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_iAccountID() { + let prop = ( + "m_iAccountID", + PropColumn { + data: Some(U32(vec![ + None, + Some(364577347), + Some(1), + None, + None, + None, + Some(297778383), + None, + None, + None, + Some(305101042), + Some(364577347), + None, + Some(0), + None, + Some(112783799), + None, + Some(0), + Some(1), + Some(242088265), + Some(305101042), + Some(364577347), + None, + None, + Some(234429022), + None, + None, + None, + Some(320710059), + Some(242088265), + None, + Some(234429022), + None, + None, + None, + Some(112783799), + Some(297778383), + None, + Some(1), + Some(242088265), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_iClip2() { + let prop = ( + "m_iClip2", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + None, + Some(0), + Some(0), + None, + Some(0), + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_InventoryServices_m_unMusicID() { + let prop = ( + "CCSPlayerController.CCSPlayerController_InventoryServices.m_unMusicID", + PropColumn { + data: Some(U32(vec![ + Some(70), + Some(70), + Some(1), + Some(1), + Some(1), + Some(70), + Some(1), + Some(70), + Some(70), + Some(68), + Some(70), + Some(70), + Some(1), + Some(1), + Some(1), + Some(70), + Some(1), + Some(70), + Some(70), + Some(68), + Some(70), + Some(70), + Some(1), + Some(1), + Some(1), + Some(70), + Some(1), + Some(70), + Some(70), + Some(68), + Some(70), + Some(70), + Some(1), + Some(1), + Some(1), + Some(70), + Some(1), + Some(70), + Some(70), + Some(68), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CBodyComponentBaseAnimGraph_m_vecZ() { + let prop = ( + "CBodyComponentBaseAnimGraph.m_vecZ", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(0.0), + None, + None, + None, + None, + None, + None, + Some(0.0), + None, + None, + None, + None, + None, + None, + Some(0.0), + Some(0.0), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_nOwnerId() { + let prop = ( + "m_nOwnerId", + PropColumn { + data: Some(U32(vec![ + Some(174817384), + Some(3920199789), + None, + Some(237174903), + Some(702021758), + Some(4025155718), + Some(3006070925), + Some(3048603807), + Some(3535995082), + Some(576422114), + None, + Some(3920199789), + Some(4014669938), + Some(237174903), + None, + Some(4025155718), + Some(3006070925), + Some(3048603807), + Some(3535995082), + Some(576422114), + None, + Some(3920199789), + None, + Some(237174903), + Some(702021758), + None, + Some(3006070925), + None, + Some(3535995082), + Some(576422114), + Some(174817384), + Some(3920199789), + Some(4014669938), + Some(237174903), + Some(702021758), + Some(4025155718), + Some(3006070925), + None, + Some(3535995082), + Some(576422114), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_MovementServices_m_fStashGrenadeParameterWhen() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_MovementServices.m_fStashGrenadeParameterWhen", + PropColumn { + data: Some(F32(vec![ + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_bKilledByHeadshot() { + let prop = ( + "CCSPlayerPawn.m_bKilledByHeadshot", + PropColumn { + data: Some(Bool(vec![ + None, + Some(false), + None, + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + None, + None, + Some(false), + Some(false), + Some(false), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + None, + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + None, + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_InGameMoneyServices_m_iTotalCashSpent() { + let prop = ( + "CCSPlayerController.CCSPlayerController_InGameMoneyServices.m_iTotalCashSpent", + PropColumn { + data: Some(I32(vec![ + Some(2400), + Some(800), + Some(700), + Some(4000), + Some(800), + Some(650), + Some(650), + Some(4300), + Some(650), + Some(1800), + Some(6500), + Some(6500), + Some(5600), + Some(6550), + Some(2700), + Some(5750), + Some(5150), + Some(6050), + Some(7200), + Some(7050), + Some(8300), + Some(7200), + Some(10500), + Some(8650), + Some(8500), + Some(9650), + Some(10100), + Some(7000), + Some(8850), + Some(9450), + Some(13900), + Some(12950), + Some(15200), + Some(18450), + Some(12400), + Some(12050), + Some(13950), + Some(20700), + Some(14100), + Some(16150), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_hPrevOwner() { + let prop = ( + "m_hPrevOwner", + PropColumn { + data: Some(U32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(16777215), + None, + None, + None, + None, + None, + None, + Some(16777215), + None, + None, + None, + None, + None, + None, + Some(9863309), + Some(15466622), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_gamePhase() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_gamePhase", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CBodyComponentBaseAnimGraph_m_vecX() { + let prop = ( + "CBodyComponentBaseAnimGraph.m_vecX", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(0.0), + None, + None, + None, + None, + None, + None, + Some(0.0), + None, + None, + None, + None, + None, + None, + Some(0.0), + Some(0.0), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_nViewModelIndex() { + let prop = ( + "m_nViewModelIndex", + PropColumn { + data: Some(U32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + None, + Some(0), + Some(0), + None, + Some(0), + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_bEverPlayedOnTeam() { + let prop = ( + "CCSPlayerController.m_bEverPlayedOnTeam", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_bPawnHasDefuser() { + let prop = ( + "CCSPlayerController.m_bPawnHasDefuser", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_bSpottedByMask() { + let prop = ( + "CCSPlayerPawn.m_bSpottedByMask", + PropColumn { + data: Some(U64Vec(vec![ + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![76561198118803912, 76561198265366770], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + vec![], + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_ArmorValue() { + let prop = ( + "CCSPlayerPawn.m_ArmorValue", + PropColumn { + data: Some(I32(vec![ + Some(100), + Some(0), + None, + Some(100), + Some(0), + Some(0), + Some(0), + Some(100), + Some(0), + Some(100), + Some(66), + Some(100), + Some(100), + Some(89), + Some(0), + Some(100), + Some(100), + Some(0), + Some(94), + Some(100), + Some(46), + Some(0), + Some(0), + Some(78), + Some(48), + Some(0), + Some(100), + Some(0), + Some(0), + Some(54), + Some(56), + Some(0), + Some(100), + Some(100), + Some(0), + Some(86), + Some(0), + Some(100), + Some(0), + Some(46), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_CSPerRoundStats_t_m_iCashEarned() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iCashEarned", + PropColumn { + data: Some(I32(vec![ + Some(3650), + Some(1900), + Some(4350), + Some(4050), + Some(2200), + Some(2050), + Some(2050), + Some(4050), + Some(2650), + Some(4150), + Some(4150), + Some(300), + Some(5850), + Some(600), + Some(6300), + Some(5550), + Some(4450), + Some(3150), + Some(3050), + Some(3000), + Some(6650), + Some(3300), + Some(3750), + Some(5900), + Some(5800), + Some(4050), + Some(600), + Some(9050), + Some(2150), + Some(5400), + Some(7950), + Some(4850), + Some(3950), + Some(7600), + Some(5750), + Some(3400), + Some(3850), + Some(10150), + Some(1100), + Some(5900), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iLiveTime() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iLiveTime", + PropColumn { + data: Some(I32(vec![ + None, + Some(42), + Some(82), + Some(48), + Some(43), + Some(20), + Some(83), + Some(39), + Some(112), + None, + Some(59), + Some(67), + Some(103), + Some(75), + Some(81), + Some(48), + Some(83), + Some(97), + Some(145), + Some(23), + Some(59), + Some(138), + Some(199), + Some(75), + Some(105), + Some(187), + Some(173), + Some(125), + Some(246), + Some(23), + Some(112), + Some(197), + Some(255), + Some(210), + Some(130), + Some(187), + Some(274), + Some(182), + Some(328), + Some(58), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_nAddDecal() { + let prop = ( + "m_nAddDecal", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_hOuter() { + let prop = ( + "m_hOuter", + PropColumn { + data: Some(U32(vec![ + Some(5439588), + Some(8290703), + Some(3506327), + Some(3916005), + Some(11894994), + Some(1409172), + Some(10895583), + Some(1228924), + Some(9257057), + Some(15991031), + Some(4325647), + Some(14385274), + Some(3948806), + Some(8700126), + None, + Some(1769877), + Some(13385865), + Some(5455972), + Some(1655192), + Some(8274323), + Some(4325647), + Some(1868065), + None, + Some(3948806), + Some(2867657), + None, + Some(12648850), + None, + Some(12075220), + Some(8274323), + Some(2048117), + Some(8323471), + Some(14549389), + Some(11026752), + Some(4620520), + Some(1573292), + Some(2244701), + Some(2900425), + Some(7586023), + Some(557561), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iDeaths() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iDeaths", + PropColumn { + data: Some(I32(vec![ + None, + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + None, + Some(1), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(1), + Some(2), + Some(2), + Some(1), + Some(1), + Some(4), + Some(4), + Some(2), + Some(3), + Some(5), + Some(3), + Some(3), + Some(4), + Some(1), + Some(2), + Some(6), + Some(5), + Some(4), + Some(4), + Some(5), + Some(5), + Some(4), + Some(6), + Some(2), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_MovementServices_m_bDuckOverride() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_MovementServices.m_bDuckOverride", + PropColumn { + data: Some(Bool(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(false), + None, + None, + None, + None, + None, + None, + None, + Some(false), + None, + Some(false), + None, + None, + None, + None, + None, + None, + None, + Some(false), + None, + Some(false), + None, + None, + None, + None, + None, + None, + None, + Some(false), + None, + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_MovementServices_m_flOffsetTickStashedSpeed() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flOffsetTickStashedSpeed", + PropColumn { + data: Some(F32(vec![ + Some(248.19319), + Some(123.80049), + Some(0.0), + Some(236.50314), + Some(75.04947), + Some(118.488304), + Some(69.17062), + Some(33.747005), + Some(43.19094), + Some(240.35031), + Some(111.799995), + Some(223.33702), + Some(0.0), + Some(0.0), + Some(100.603096), + Some(71.43422), + Some(0.0), + Some(0.0), + Some(148.41351), + Some(101.91207), + Some(214.99998), + Some(161.77322), + Some(24.236797), + Some(0.0), + Some(225.0), + Some(0.0), + Some(119.39063), + Some(69.76295), + Some(45.415276), + Some(25.288815), + Some(245.0), + Some(104.00001), + Some(12.693243), + Some(188.73602), + Some(186.24919), + Some(111.92654), + Some(216.28789), + Some(42.646595), + Some(29.218338), + Some(118.57139), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CEconItemAttribute_m_flInitialValue() { + let prop = ( + "CEconItemAttribute.m_flInitialValue", + PropColumn { + data: Some(F32(vec![ + None, + Some(9.733886e22), + None, + None, + None, + None, + Some(9.422597e22), + None, + None, + None, + Some(0.43085524), + Some(9.344775e22), + None, + None, + None, + Some(6.363e-42), + None, + None, + None, + Some(6.711e-42), + Some(0.43085524), + Some(7.636e-42), + None, + None, + Some(3.1171214e22), + None, + None, + None, + Some(0.07466238), + Some(6.7e-43), + None, + Some(3.1171214e22), + None, + None, + None, + Some(0.0), + Some(9.422597e22), + None, + None, + Some(3.525688e22), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_iItemIDLow() { + let prop = ( + "m_iItemIDLow", + PropColumn { + data: Some(U32(vec![ + None, + Some(914452028), + None, + None, + None, + None, + Some(854287206), + None, + None, + None, + Some(3479784940), + Some(845495747), + None, + Some(0), + None, + Some(929347954), + None, + Some(0), + None, + Some(1683145287), + Some(3479784940), + Some(923585316), + None, + None, + Some(1944159844), + None, + None, + None, + Some(199113976), + Some(1683145287), + None, + Some(1944159844), + None, + None, + None, + Some(903512841), + Some(854287206), + None, + None, + Some(2526560054), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_nTickBase() { + let prop = ( + "CCSPlayerController.m_nTickBase", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iAssists() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iAssists", + PropColumn { + data: Some(I32(vec![ + None, + Some(1), + Some(1), + None, + Some(1), + Some(0), + None, + None, + None, + None, + Some(1), + Some(1), + Some(1), + None, + Some(1), + Some(0), + Some(1), + None, + None, + None, + Some(1), + Some(1), + Some(1), + None, + Some(2), + Some(0), + Some(1), + Some(1), + None, + None, + Some(1), + Some(1), + Some(2), + None, + Some(2), + Some(2), + Some(1), + Some(2), + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_iEntityQuality() { + let prop = ( + "m_iEntityQuality", + PropColumn { + data: Some(I32(vec![ + None, + Some(3), + Some(4), + None, + None, + None, + Some(3), + None, + None, + None, + Some(4), + Some(4), + None, + Some(0), + None, + Some(9), + None, + Some(0), + Some(4), + None, + Some(4), + Some(4), + None, + None, + Some(4), + None, + None, + None, + Some(4), + None, + None, + Some(4), + None, + None, + None, + Some(9), + Some(3), + None, + Some(4), + Some(3), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_vDecalForwardAxis() { + let prop = ( + "CCSPlayerPawn.m_vDecalForwardAxis", + PropColumn { + data: Some(XYZVec(vec![ + Some([0.9962316, 0.04332799, 0.07513555]), + Some([-0.36965293, 0.8204877, 0.43606976]), + Some([0.3519783, 0.9337104, 0.06554684]), + Some([-0.7955056, 0.59699875, -0.103746854]), + Some([-0.98760796, 0.06803899, 0.14142609]), + Some([-0.110260986, -0.98646504, 0.12136375]), + Some([-0.17406072, 0.9846432, -0.013441297]), + Some([0.20821588, 0.97713315, 0.04309331]), + Some([0.71194553, -0.70223355, -0.0012826255]), + None, + Some([0.47314593, 0.46949002, 0.745461]), + Some([-0.055346057, -0.99708104, -0.052593328]), + Some([0.28832167, -0.8944757, 0.34173664]), + Some([0.403741, -0.78814685, -0.46456194]), + Some([-0.4105553, 0.7865878, 0.46122]), + Some([-0.66103494, -0.74798745, 0.059562158]), + Some([-0.17406072, 0.9846432, -0.013441297]), + Some([-0.25435287, -0.96658885, 0.031789355]), + Some([-0.8547955, -0.5187766, -0.013978702]), + Some([-0.4219073, 0.90456927, 0.061226096]), + Some([0.1608407, 0.986972, -0.0040686773]), + Some([-0.77879447, 0.6027072, -0.1738484]), + Some([0.16890377, 0.985381, -0.022266503]), + Some([-0.62725496, 0.7759586, -0.06662918]), + Some([-0.25199124, 0.9140058, -0.3179526]), + Some([0.6415635, -0.76615864, 0.037380785]), + Some([-0.31095564, -0.94612, 0.09035235]), + Some([0.8955867, 0.4444743, -0.01915702]), + Some([0.92318046, 0.08607937, 0.37460384]), + Some([-0.9850848, -0.17148674, -0.014149931]), + Some([0.64448905, 0.7635272, 0.040744133]), + Some([0.04956518, 0.47145265, -0.8804975]), + Some([0.06833177, -0.9974961, -0.01822531]), + Some([-0.9389287, -0.041765645, -0.34156787]), + Some([-0.48087683, 0.8767267, -0.010383588]), + Some([0.98124886, 0.0036932125, -0.19271004]), + Some([0.97416055, -0.16350822, -0.15580845]), + Some([0.08398245, -0.9959502, 0.032095056]), + Some([0.28198183, -0.9593014, -0.015066432]), + Some([-0.98698556, 0.15377362, -0.047044586]), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_iMoveState() { + let prop = ( + "CCSPlayerPawn.m_iMoveState", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(2), + Some(2), + Some(2), + Some(0), + Some(2), + Some(0), + Some(0), + Some(1), + Some(2), + Some(1), + Some(1), + Some(0), + Some(1), + Some(2), + Some(0), + Some(2), + Some(2), + Some(2), + Some(2), + Some(0), + Some(2), + Some(2), + Some(0), + Some(0), + Some(0), + Some(2), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(2), + Some(0), + Some(2), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_eRoundWinReason() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_eRoundWinReason", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iCashEarned() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iCashEarned", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_MovementServices_m_flJumpUntil() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flJumpUntil", + PropColumn { + data: Some(F32(vec![ + Some(216.04475), + Some(135.80637), + Some(129.18237), + Some(131.097), + Some(133.1981), + Some(115.438866), + Some(144.381), + Some(135.77995), + Some(202.29239), + Some(216.84464), + Some(343.86166), + Some(381.74268), + Some(339.4241), + Some(379.6832), + Some(365.14783), + Some(371.47992), + Some(340.85938), + Some(360.2568), + Some(347.99414), + Some(337.08), + Some(482.85815), + Some(537.3743), + Some(511.2774), + Some(522.0915), + Some(538.371), + Some(511.39636), + Some(530.2532), + Some(531.3966), + Some(535.84375), + Some(511.25818), + Some(683.0324), + Some(606.3953), + Some(628.438), + Some(673.52167), + Some(591.38965), + Some(652.89545), + Some(643.85236), + Some(641.73694), + Some(597.8334), + Some(672.13086), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iszPlayerName() { + let prop = ( + "CCSPlayerController.m_iszPlayerName", + PropColumn { + data: Some(String(vec![ + Some("123".to_string()), + Some("Trahun <3 V".to_string()), + Some("Голова, глаза".to_string()), + Some("NIGHTSOUL".to_string()), + Some("Dog".to_string()), + Some("miu miu".to_string()), + Some("-ExΩtiC-".to_string()), + None, + Some("povergo".to_string()), + Some("IMI Negev".to_string()), + Some("123".to_string()), + Some("Trahun <3 V".to_string()), + Some("Голова, глаза".to_string()), + Some("NIGHTSOUL".to_string()), + Some("Dog".to_string()), + Some("miu miu".to_string()), + Some("-ExΩtiC-".to_string()), + None, + Some("povergo".to_string()), + Some("IMI Negev".to_string()), + Some("123".to_string()), + Some("Trahun <3 V".to_string()), + Some("Голова, глаза".to_string()), + Some("NIGHTSOUL".to_string()), + Some("Dog".to_string()), + Some("miu miu".to_string()), + Some("-ExΩtiC-".to_string()), + None, + Some("povergo".to_string()), + Some("IMI Negev".to_string()), + Some("123".to_string()), + Some("Trahun <3 V".to_string()), + Some("Голова, глаза".to_string()), + Some("NIGHTSOUL".to_string()), + Some("Dog".to_string()), + Some("miu miu".to_string()), + Some("-ExΩtiC-".to_string()), + None, + Some("povergo".to_string()), + Some("IMI Negev".to_string()), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_iNumConsecutiveTerroristLoses() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_iNumConsecutiveTerroristLoses", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_flTimeSilencerSwitchComplete() { + let prop = ( + "m_flTimeSilencerSwitchComplete", + PropColumn { + data: Some(F32(vec![ + Some(224.32813), + Some(218.79688), + Some(220.78125), + Some(222.21875), + Some(226.71875), + Some(224.75), + Some(226.3125), + Some(224.90625), + Some(226.95313), + Some(224.42188), + Some(348.8125), + Some(383.28958), + Some(361.92188), + Some(357.14063), + None, + Some(366.57083), + Some(359.14063), + Some(341.6875), + Some(382.54688), + Some(346.28125), + Some(529.2969), + Some(538.40625), + None, + Some(526.71875), + Some(519.2115), + None, + Some(538.71875), + None, + Some(520.3281), + Some(536.7344), + Some(687.3125), + Some(695.649), + Some(691.59375), + Some(687.6875), + Some(695.3281), + Some(688.84375), + Some(685.6719), + Some(695.10834), + Some(694.0469), + Some(692.3906), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_vRagdollDamagePosition() { + let prop = ( + "CCSPlayerPawn.m_vRagdollDamagePosition", + PropColumn { + data: Some(XYZVec(vec![ + None, + Some([-1177.3091, -393.89706, -11.370972]), + Some([-504.80264, -1454.2224, -24.087448]), + Some([-912.3319, -1481.2107, -105.44267]), + Some([-1161.0746, -606.4787, -109.58214]), + Some([-828.7623, -2534.7646, 27.780762]), + Some([-1329.447, -975.2356, -124.65142]), + Some([-1105.1072, -604.2416, -92.25015]), + Some([-803.9081, 10.710815, -107.94034]), + None, + Some([-1034.5951, -1490.5745, -118.766106]), + Some([-2302.8567, 320.36478, -112.783165]), + Some([-314.79352, -922.4806, -103.29794]), + Some([-2290.6543, 482.9251, -113.752785]), + Some([-1182.3367, -394.19177, 3.4436035]), + Some([-859.2573, -2460.5, -29.6559]), + Some([-1329.447, -975.2356, -124.65142]), + Some([-229.48274, -2385.9326, -121.67381]), + Some([-562.3154, -1690.9232, -136.90385]), + Some([-2169.6887, 690.8084, -70.36412]), + Some([-1034.5951, -1490.5745, -118.766106]), + Some([-2291.2625, 373.48062, -122.94483]), + Some([-693.6147, -1593.5266, -125.98947]), + Some([-2290.6543, 482.9251, -113.752785]), + Some([-746.0539, -1414.7804, -111.439384]), + Some([-627.2682, -1325.6891, -110.70767]), + Some([-2332.9026, -290.97577, -117.977135]), + Some([-157.4043, -1945.0631, -124.29493]), + Some([-573.5157, -1003.0835, -133.33249]), + Some([-2169.6887, 690.8084, -70.36412]), + Some([-118.10736, -1666.3192, -124.282166]), + Some([-1308.5262, -1171.368, -50.149086]), + Some([-630.76263, -1662.4001, -144.75473]), + Some([-999.77985, 391.99142, -305.51318]), + Some([-764.8695, -110.90314, -113.249084]), + Some([-627.2682, -1325.6891, -110.70767]), + Some([-582.8451, -781.82654, -199.15674]), + Some([-614.638, -1577.8723, -81.12184]), + Some([-778.0574, -1577.9769, -124.16199]), + Some([63.989655, -2358.9756, 4.193103]), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iMVPs() { + let prop = ( + "CCSPlayerController.m_iMVPs", + PropColumn { + data: Some(I32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(1), + None, + None, + None, + None, + None, + None, + Some(1), + None, + None, + Some(1), + Some(1), + None, + None, + Some(1), + None, + None, + Some(1), + None, + None, + Some(1), + Some(1), + None, + None, + Some(1), + Some(1), + None, + Some(1), + None, + None, + Some(2), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CBodyComponentBaseAnimGraph_m_nNewSequenceParity() { + let prop = ( + "CBodyComponentBaseAnimGraph.m_nNewSequenceParity", + PropColumn { + data: Some(I32(vec![ + None, + None, + Some(3), + None, + Some(4), + Some(5), + Some(6), + Some(4), + Some(3), + Some(0), + Some(3), + Some(0), + Some(3), + Some(6), + None, + Some(3), + Some(4), + Some(2), + Some(2), + Some(1), + Some(1), + Some(3), + None, + Some(2), + Some(7), + None, + Some(3), + None, + Some(7), + Some(3), + Some(7), + Some(5), + Some(0), + Some(3), + Some(3), + Some(4), + None, + Some(2), + Some(2), + Some(5), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_bBombPlanted() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_bBombPlanted", + PropColumn { + data: Some(Bool(vec![ + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CBodyComponentBaseAnimGraph_m_angRotation() { + let prop = ( + "CBodyComponentBaseAnimGraph.m_angRotation", + PropColumn { + data: Some(XYZVec(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some([0.0, 0.0, 0.0]), + None, + None, + None, + None, + None, + None, + Some([0.0, 0.0, 0.0]), + None, + None, + None, + None, + None, + None, + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CBodyComponentBaseAnimGraph_m_nResetEventsParity() { + let prop = ( + "CBodyComponentBaseAnimGraph.m_nResetEventsParity", + PropColumn { + data: Some(I32(vec![ + None, + None, + Some(3), + None, + Some(4), + Some(5), + Some(6), + Some(4), + Some(3), + Some(0), + Some(3), + Some(0), + Some(3), + Some(6), + None, + Some(3), + Some(4), + Some(2), + Some(2), + Some(1), + Some(1), + Some(3), + None, + Some(2), + Some(7), + None, + Some(3), + None, + Some(7), + Some(3), + Some(7), + Some(5), + Some(0), + Some(3), + Some(3), + Some(4), + None, + Some(2), + Some(2), + Some(5), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iNumRoundKills() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iNumRoundKills", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + None, + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(1), + Some(0), + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(1), + Some(0), + Some(0), + Some(2), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_bClientSideRagdoll() { + let prop = ( + "CCSPlayerPawn.m_bClientSideRagdoll", + PropColumn { + data: Some(Bool(vec![ + None, + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + None, + Some(false), + Some(false), + Some(false), + Some(false), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(true), + Some(false), + Some(false), + Some(true), + Some(false), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_CSPerRoundStats_t_m_iDeaths() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iDeaths", + PropColumn { + data: Some(I32(vec![ + None, + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + None, + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_CSPerRoundStats_t_m_iKillReward() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iKillReward", + PropColumn { + data: Some(I32(vec![ + Some(300), + None, + Some(300), + None, + Some(300), + None, + None, + Some(300), + Some(600), + Some(600), + Some(300), + Some(300), + Some(300), + Some(600), + Some(600), + None, + Some(300), + Some(600), + Some(600), + Some(600), + Some(600), + Some(300), + Some(300), + Some(300), + Some(600), + Some(300), + Some(600), + Some(600), + Some(600), + Some(300), + Some(600), + Some(300), + Some(300), + Some(600), + Some(600), + Some(300), + Some(600), + Some(600), + Some(300), + Some(300), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_MovementServices_m_arrForceSubtickMoveWhen() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_MovementServices.m_arrForceSubtickMoveWhen", + PropColumn { + data: Some(F32(vec![ + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(382.15256), + Some(382.0967), + Some(381.8938), + Some(382.24454), + Some(372.66974), + Some(382.1154), + Some(381.3079), + Some(361.11783), + Some(382.22818), + Some(382.2228), + Some(538.49634), + Some(538.511), + Some(535.7737), + Some(538.4727), + Some(538.371), + Some(529.3963), + Some(538.42053), + Some(532.6795), + Some(538.38007), + Some(537.43854), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_fWarmupPeriodEnd() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_fWarmupPeriodEnd", + PropColumn { + data: Some(F32(vec![ + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + Some(69.765625), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_nInteractsAs() { + let prop = ( + "CCSPlayerPawn.m_nInteractsAs", + PropColumn { + data: Some(U64(vec![ + None, + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + None, + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(131073), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(131073), + Some(393216), + Some(393216), + Some(131073), + Some(393216), + Some(131073), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + Some(393216), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_nQuestProgressReason() { + let prop = ( + "CCSPlayerController.m_nQuestProgressReason", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_nCollisionFunctionMask() { + let prop = ( + "m_nCollisionFunctionMask", + PropColumn { + data: Some(U32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(0), + None, + None, + None, + None, + None, + None, + Some(0), + None, + None, + None, + None, + None, + None, + Some(0), + Some(0), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_hOriginalControllerOfCurrentPawn() { + let prop = ( + "CCSPlayerController.m_hOriginalControllerOfCurrentPawn", + PropColumn { + data: Some(U32(vec![ + Some(13582340), + Some(4669446), + Some(6569987), + Some(11747330), + Some(8536072), + Some(4685833), + Some(11337738), + Some(1327105), + Some(14581767), + Some(8355845), + Some(13582340), + Some(4669446), + Some(6569987), + Some(11747330), + Some(8536072), + Some(4685833), + Some(11337738), + Some(1327105), + Some(14581767), + Some(8355845), + Some(13582340), + Some(4669446), + Some(6569987), + Some(11747330), + Some(8536072), + Some(4685833), + Some(11337738), + Some(1327105), + Some(14581767), + Some(8355845), + Some(13582340), + Some(4669446), + Some(6569987), + Some(11747330), + Some(8536072), + Some(4685833), + Some(11337738), + Some(1327105), + Some(14581767), + Some(8355845), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_nNextSecondaryAttackTick() { + let prop = ( + "m_nNextSecondaryAttackTick", + PropColumn { + data: Some(U32(vec![ + Some(28714), + Some(28006), + Some(28260), + Some(28444), + Some(29020), + Some(28768), + Some(28968), + Some(28788), + Some(29050), + Some(28726), + Some(44648), + Some(49060), + Some(46326), + Some(48414), + None, + Some(46920), + Some(47992), + Some(43736), + Some(48966), + Some(48852), + Some(68608), + Some(68916), + None, + Some(68616), + Some(69172), + None, + Some(68956), + None, + Some(68940), + Some(68702), + Some(87976), + Some(89042), + Some(88524), + Some(88024), + Some(89002), + Some(88172), + Some(87766), + Some(88972), + Some(88838), + Some(88626), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CBodyComponentBaseAnimGraph_m_MeshGroupMask() { + let prop = ( + "CBodyComponentBaseAnimGraph.m_MeshGroupMask", + PropColumn { + data: Some(U64(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(2), + Some(2), + None, + Some(1), + None, + Some(2), + None, + Some(1), + None, + None, + Some(2), + Some(2), + None, + None, + Some(2), + None, + None, + None, + Some(2), + None, + None, + Some(2), + None, + None, + None, + Some(2), + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_nHierarchyId() { + let prop = ( + "m_nHierarchyId", + PropColumn { + data: Some(U32(vec![ + Some(104), + Some(109), + None, + Some(119), + Some(126), + Some(134), + Some(141), + Some(159), + Some(202), + Some(226), + None, + Some(109), + Some(114), + Some(119), + None, + Some(134), + Some(141), + Some(159), + Some(202), + Some(226), + None, + Some(109), + None, + Some(119), + Some(126), + None, + Some(141), + None, + Some(202), + Some(226), + Some(104), + Some(109), + Some(114), + Some(119), + Some(126), + Some(134), + Some(141), + None, + Some(202), + Some(226), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_bBurstMode() { + let prop = ( + "m_bBurstMode", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_bInBombZone() { + let prop = ( + "CCSPlayerPawn.m_bInBombZone", + PropColumn { + data: Some(Bool(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(false), + None, + None, + None, + None, + None, + None, + None, + Some(false), + None, + Some(false), + None, + None, + None, + None, + None, + None, + None, + Some(false), + None, + Some(false), + None, + None, + None, + None, + None, + None, + None, + Some(false), + None, + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_MovementServices_m_bOldJumpPressed() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_MovementServices.m_bOldJumpPressed", + PropColumn { + data: Some(Bool(vec![ + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_flRestartRoundTime() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_flRestartRoundTime", + PropColumn { + data: Some(F32(vec![ + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_iMatchStats_PlayersAlive_T() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_iMatchStats_PlayersAlive_T", + PropColumn { + data: Some(I32(vec![ + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_iMatchStats_PlayersAlive_CT() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_iMatchStats_PlayersAlive_CT", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_iRoundWinStatus() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_iRoundWinStatus", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CEconItemAttribute_m_bSetBonus() { + let prop = ( + "CEconItemAttribute.m_bSetBonus", + PropColumn { + data: Some(Bool(vec![ + None, + Some(false), + None, + None, + None, + None, + Some(false), + None, + None, + None, + Some(false), + Some(false), + None, + None, + None, + Some(false), + None, + None, + None, + None, + Some(false), + Some(false), + None, + None, + Some(false), + None, + None, + None, + Some(false), + None, + None, + Some(false), + None, + None, + None, + Some(false), + Some(false), + None, + None, + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iKills() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iKills", + PropColumn { + data: Some(I32(vec![ + Some(1), + Some(0), + Some(1), + Some(0), + Some(1), + Some(0), + None, + Some(1), + Some(2), + Some(2), + Some(1), + Some(1), + Some(1), + Some(2), + Some(3), + Some(0), + Some(1), + Some(3), + Some(3), + Some(2), + Some(5), + Some(1), + Some(1), + Some(5), + Some(3), + Some(1), + Some(3), + Some(5), + Some(3), + Some(3), + Some(8), + Some(1), + Some(1), + Some(7), + Some(5), + Some(2), + Some(5), + Some(7), + Some(4), + Some(3), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_bBombDropped() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_bBombDropped", + PropColumn { + data: Some(Bool(vec![ + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_bReloadVisuallyComplete() { + let prop = ( + "m_bReloadVisuallyComplete", + PropColumn { + data: Some(Bool(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(true), + None, + None, + Some(true), + None, + Some(true), + Some(true), + Some(true), + None, + None, + None, + None, + None, + None, + None, + None, + Some(true), + None, + Some(false), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_CSPerRoundStats_t_m_iObjective() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iObjective", + PropColumn { + data: Some(I32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(1), + None, + None, + None, + None, + None, + None, + Some(1), + Some(1), + None, + Some(1), + None, + None, + None, + None, + None, + None, + Some(1), + Some(1), + None, + Some(1), + None, + None, + None, + None, + None, + None, + Some(1), + Some(1), + None, + Some(1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iPawnHealth() { + let prop = ( + "CCSPlayerController.m_iPawnHealth", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_fMatchStartTime() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_fMatchStartTime", + PropColumn { + data: Some(F32(vec![ + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + Some(70.78125), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_MovementServices_m_vecLadderNormal() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_MovementServices.m_vecLadderNormal", + PropColumn { + data: Some(XYZVec(vec![ + None, + Some([0.0, -2046.0005, 0.0]), + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some([0.0, -2046.0005, 0.0]), + None, + None, + Some([0.0, -2046.0005, 0.0]), + None, + Some([2043.002, 0.0, 0.0]), + None, + None, + None, + Some([0.0, -2046.0005, 0.0]), + Some([0.0, -2046.0005, 0.0]), + None, + None, + Some([0.0, -2046.0005, 0.0]), + None, + Some([2043.002, 0.0, 0.0]), + None, + Some([2043.002, 0.0, 0.0]), + None, + Some([0.0, -2046.0005, 0.0]), + Some([0.0, -2046.0005, 0.0]), + None, + None, + Some([0.0, -2046.0005, 0.0]), + None, + Some([2043.002, 0.0, 0.0]), + None, + Some([2043.002, 0.0, 0.0]), + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_unFreezetimeEndEquipmentValue() { + let prop = ( + "CCSPlayerPawn.m_unFreezetimeEndEquipmentValue", + PropColumn { + data: Some(U32(vec![ + Some(700), + Some(800), + Some(200), + Some(200), + Some(500), + Some(850), + Some(850), + Some(300), + Some(650), + Some(1000), + Some(4300), + Some(5900), + Some(5100), + Some(2750), + Some(5600), + Some(5300), + Some(5700), + Some(1950), + Some(4200), + Some(3100), + Some(5100), + Some(700), + Some(5100), + Some(5100), + Some(4100), + Some(3100), + Some(4250), + Some(2600), + Some(300), + Some(4200), + Some(5000), + Some(5950), + Some(1000), + Some(5100), + Some(4900), + Some(5500), + Some(4050), + Some(7150), + Some(5450), + Some(5500), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_aimPunchAngleVel() { + let prop = ( + "CCSPlayerPawn.m_aimPunchAngleVel", + PropColumn { + data: Some(XYZVec(vec![ + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + None, + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([-68.96222, -18.955631, 0.0]), + None, + Some([-69.75149, -34.54583, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([-0.07983507, -0.0102492375, 0.0]), + Some([-24.388832, 8.735709, 0.0]), + Some([-60.76184, 6.060968, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([-34.808304, 0.03878641, 0.0]), + Some([-44.095695, -2.2964132, 0.0]), + Some([-46.364265, -5.10213, 0.0]), + Some([-28.697758, -3.439148, 0.0]), + Some([-52.065315, -10.179849, 0.0]), + Some([-47.481705, 15.148917, 0.0]), + Some([-38.53029, 3.1640582, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_flVelocityModifier() { + let prop = ( + "CCSPlayerPawn.m_flVelocityModifier", + PropColumn { + data: Some(F32(vec![ + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + None, + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(0.97448665), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(0.47221145), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + Some(1.0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_MovementServices_m_flDuckSpeed() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flDuckSpeed", + PropColumn { + data: Some(F32(vec![ + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(5.236247), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(6.28749), + Some(4.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + Some(8.0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_iIronSightMode() { + let prop = ( + "m_iIronSightMode", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(2), + Some(0), + Some(2), + Some(0), + None, + Some(0), + Some(0), + Some(2), + Some(0), + Some(0), + None, + Some(0), + Some(0), + Some(0), + Some(2), + Some(0), + Some(0), + Some(0), + None, + Some(0), + Some(0), + None, + Some(2), + None, + Some(0), + Some(0), + Some(0), + Some(2), + Some(0), + Some(0), + None, + Some(0), + Some(0), + None, + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CBodyComponentBaseAnimGraph_m_nAnimLoopMode() { + let prop = ( + "CBodyComponentBaseAnimGraph.m_nAnimLoopMode", + PropColumn { + data: Some(U32(vec![ + None, + None, + Some(0), + None, + None, + None, + None, + None, + None, + None, + Some(0), + Some(0), + Some(0), + Some(0), + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + None, + Some(0), + Some(0), + None, + Some(0), + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + None, + None, + Some(0), + None, + Some(0), + Some(0), + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_fEffects() { + let prop = ( + "m_fEffects", + PropColumn { + data: Some(U32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(32), + None, + None, + None, + None, + None, + None, + Some(32), + None, + None, + None, + None, + None, + None, + Some(32), + Some(32), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CBodyComponentBaseAnimGraph_m_hSequence() { + let prop = ( + "CBodyComponentBaseAnimGraph.m_hSequence", + PropColumn { + data: Some(U64(vec![ + None, + Some(17), + Some(4), + None, + None, + None, + None, + None, + None, + None, + Some(3), + Some(4), + Some(3), + Some(16), + None, + Some(4), + Some(19), + Some(4), + Some(4), + Some(18), + Some(16), + Some(4), + None, + Some(16), + Some(25), + None, + Some(11), + None, + Some(18), + Some(4), + Some(11), + Some(3), + Some(3), + None, + None, + Some(4), + None, + Some(4), + Some(4), + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_CSPerRoundStats_t_m_iKills() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iKills", + PropColumn { + data: Some(I32(vec![ + Some(1), + None, + Some(1), + None, + Some(1), + None, + None, + Some(1), + Some(2), + Some(2), + Some(1), + Some(1), + Some(1), + Some(1), + Some(2), + None, + Some(1), + Some(2), + Some(1), + Some(2), + Some(2), + Some(1), + Some(1), + Some(1), + Some(2), + Some(1), + Some(2), + Some(1), + Some(1), + Some(1), + Some(2), + Some(1), + Some(1), + Some(2), + Some(2), + Some(1), + Some(2), + Some(1), + Some(1), + Some(1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_flCreateTime() { + let prop = ( + "CCSPlayerController.m_flCreateTime", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_bIsScoped() { + let prop = ( + "CCSPlayerPawn.m_bIsScoped", + PropColumn { + data: Some(Bool(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(false), + None, + None, + Some(true), + None, + None, + None, + None, + None, + None, + Some(false), + None, + None, + Some(false), + None, + Some(false), + Some(false), + None, + None, + None, + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_fAccuracyPenalty() { + let prop = ( + "m_fAccuracyPenalty", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(0.10217), + Some(0.00641), + Some(0.0133), + None, + Some(0.004900002), + Some(0.0048100017), + Some(0.0133), + Some(0.00985), + Some(0.0030019027), + Some(0.0064100022), + Some(0.020077005), + None, + Some(0.0064100022), + Some(0.1046), + None, + None, + None, + Some(0.054671634), + Some(0.0317), + None, + Some(0.0049), + None, + None, + None, + Some(0.0049), + None, + None, + Some(0.0049), + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_flEmitSoundTime() { + let prop = ( + "CCSPlayerPawn.m_flEmitSoundTime", + PropColumn { + data: Some(F32(vec![ + Some(223.6875), + Some(216.92188), + Some(218.46875), + Some(220.53125), + Some(216.92188), + Some(216.92188), + Some(216.92188), + Some(221.5625), + Some(216.92188), + Some(225.84375), + Some(344.42188), + Some(381.73438), + Some(361.5), + Some(379.67188), + Some(373.32813), + Some(372.20313), + Some(370.98438), + Some(360.25), + Some(379.04688), + Some(381.375), + Some(538.40625), + Some(538.3906), + Some(535.7969), + Some(535.3281), + Some(538.3594), + Some(529.46875), + Some(536.5), + Some(532.7969), + Some(538.2656), + Some(538.2656), + Some(685.375), + Some(693.5156), + Some(686.1094), + Some(685.7969), + Some(688.3281), + Some(683.3125), + Some(683.3125), + Some(687.28125), + Some(683.3125), + Some(688.6094), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iCompetitiveRankingPredicted_Tie() { + let prop = ( + "CCSPlayerController.m_iCompetitiveRankingPredicted_Tie", + PropColumn { + data: Some(I32(vec![ + Some(18190), + Some(18205), + Some(9999), + Some(14999), + Some(18947), + Some(16302), + Some(19140), + Some(13703), + Some(17769), + None, + Some(18190), + Some(18205), + Some(9999), + Some(14999), + Some(18947), + Some(16302), + Some(19140), + Some(13703), + Some(17769), + None, + Some(18190), + Some(18205), + Some(9999), + Some(14999), + Some(18947), + Some(16302), + Some(19140), + Some(13703), + Some(17769), + None, + Some(18190), + Some(18205), + Some(9999), + Some(14999), + Some(18947), + Some(16302), + Some(19140), + Some(13703), + Some(17769), + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_flSlopeDropHeight() { + let prop = ( + "CCSPlayerPawn.m_flSlopeDropHeight", + PropColumn { + data: Some(F32(vec![ + Some(-167.96875), + Some(-291.16428), + Some(-167.96875), + Some(-166.95316), + Some(-265.4476), + Some(-290.30576), + Some(-267.80722), + Some(-167.96875), + Some(-267.46368), + Some(-164.61621), + Some(-47.96875), + Some(-125.77912), + Some(-167.96875), + Some(-263.96875), + Some(-55.96875), + Some(-169.43985), + Some(-167.96875), + Some(-128.24706), + Some(-167.96875), + Some(-166.80313), + Some(-167.96875), + Some(-167.96875), + Some(-167.96875), + Some(-167.96875), + Some(-133.09007), + Some(-167.96875), + Some(-167.96875), + Some(-167.96875), + Some(-39.96875), + Some(-39.96875), + Some(-164.61621), + Some(-262.63724), + Some(-167.96875), + Some(-167.96875), + Some(-267.90018), + Some(-267.80722), + Some(-276.14798), + Some(-167.96875), + Some(-266.18854), + Some(-166.95316), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_nHitBodyPart() { + let prop = ( + "CCSPlayerPawn.m_nHitBodyPart", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + None, + Some(2), + Some(0), + Some(0), + Some(2), + Some(1), + Some(0), + Some(0), + Some(1), + Some(2), + Some(0), + Some(0), + Some(0), + Some(5), + Some(2), + Some(1), + Some(2), + Some(0), + Some(3), + Some(3), + Some(2), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_MoveType() { + let prop = ( + "m_MoveType", + PropColumn { + data: Some(U64(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(0), + None, + None, + None, + None, + None, + None, + Some(0), + None, + None, + None, + None, + None, + None, + Some(0), + Some(0), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_fFlags() { + let prop = ( + "CCSPlayerController.m_fFlags", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_flTimeOfLastInjury() { + let prop = ( + "CCSPlayerPawn.m_flTimeOfLastInjury", + PropColumn { + data: Some(F32(vec![ + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + None, + Some(355.78125), + Some(0.0), + Some(0.0), + Some(373.28125), + Some(373.32813), + Some(0.0), + Some(0.0), + Some(352.03125), + Some(375.32813), + Some(0.0), + Some(0.0), + Some(0.0), + Some(535.7969), + Some(529.4531), + Some(527.15625), + Some(529.46875), + Some(0.0), + Some(532.7969), + Some(532.15625), + Some(538.2656), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_flRecoilIndex() { + let prop = ( + "m_flRecoilIndex", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(0.0), + None, + None, + Some(0.0), + None, + Some(0.0), + Some(0.0), + Some(0.0), + None, + None, + Some(0.0), + Some(0.0), + None, + None, + None, + Some(1.930572), + Some(0.0), + None, + Some(0.0), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_CSPerRoundStats_t_m_iDamage() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iDamage", + PropColumn { + data: Some(I32(vec![ + Some(100), + Some(28), + Some(185), + None, + Some(194), + None, + Some(33), + Some(100), + Some(107), + Some(115), + Some(61), + Some(52), + Some(185), + Some(100), + Some(99), + None, + Some(26), + Some(139), + Some(100), + Some(71), + Some(28), + Some(60), + Some(44), + Some(50), + Some(46), + Some(76), + Some(130), + Some(108), + Some(23), + Some(100), + Some(188), + Some(41), + Some(44), + Some(150), + Some(153), + Some(76), + Some(130), + Some(108), + Some(100), + Some(100), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_vRagdollDamageForce() { + let prop = ( + "CCSPlayerPawn.m_vRagdollDamageForce", + PropColumn { + data: Some(XYZVec(vec![ + None, + Some([-9610.976, 21332.68, 11337.813]), + Some([7039.566, 18674.207, 1310.9368]), + Some([-20683.145, 15521.969, -2697.4182]), + Some([-25677.807, 1769.0138, 3677.0781]), + Some([-2866.7861, -25648.094, 3155.458]), + Some([-5430.6943, 30720.87, -419.36847]), + Some([4164.3174, 19542.664, 861.86615]), + Some([18510.584, -18258.072, -33.348263]), + None, + Some([-21124.611, -11389.467, 175.63977]), + Some([-1726.7971, -31108.934, -1640.9121]), + Some([7496.364, -23256.37, 8885.152]), + Some([-11601.938, -16035.477, -2873.767]), + Some([-11208.161, 21473.85, 12591.308]), + Some([-20624.291, -23337.209, 1858.3392]), + Some([-5430.6943, 30720.87, -419.36847]), + Some([19226.12, 1142.8672, -5389.8203]), + Some([-23706.945, -3664.9272, -741.007]), + Some([-10969.59, 23518.8, 1591.8785]), + Some([-21124.611, -11389.467, 175.63977]), + Some([-16354.684, 12656.852, -3650.8167]), + Some([4053.6904, 23649.143, -534.3961]), + Some([-11601.938, -16035.477, -2873.767]), + Some([-5234.1226, -30757.06, -217.84229]), + Some([15397.523, -18387.809, 897.1388]), + Some([-7462.935, -22706.879, 2168.4565]), + Some([21494.084, 10667.385, -459.76852]), + Some([8644.244, -22377.998, -708.7194]), + Some([-10969.59, 23518.8, 1591.8785]), + Some([23958.57, -1248.9443, -653.4906]), + Some([385.308, 3664.9614, -6844.78]), + Some([1639.9626, -23939.91, -437.4075]), + Some([-29294.576, -1303.0881, -10656.917]), + Some([-13464.551, 24548.348, -290.74048]), + Some([15397.523, -18387.809, 897.1388]), + Some([30393.809, -5101.4565, -4861.2236]), + Some([2015.5789, -23902.805, 770.2814]), + Some([7895.492, -26860.441, -421.86017]), + Some([-19675.791, -3585.4912, -86.97464]), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_steamID() { + let prop = ( + "CCSPlayerController.m_steamID", + PropColumn { + data: Some(U64(vec![ + Some(76561198265366770), + Some(76561198324843075), + Some(76561198118803912), + Some(76561198244754626), + Some(76561198194694750), + Some(76561198073049527), + Some(76561198258044111), + None, + Some(76561198280975787), + Some(76561198202353993), + Some(76561198265366770), + Some(76561198324843075), + Some(76561198118803912), + Some(76561198244754626), + Some(76561198194694750), + Some(76561198073049527), + Some(76561198258044111), + None, + Some(76561198280975787), + Some(76561198202353993), + Some(76561198265366770), + Some(76561198324843075), + Some(76561198118803912), + Some(76561198244754626), + Some(76561198194694750), + Some(76561198073049527), + Some(76561198258044111), + None, + Some(76561198280975787), + Some(76561198202353993), + Some(76561198265366770), + Some(76561198324843075), + Some(76561198118803912), + Some(76561198244754626), + Some(76561198194694750), + Some(76561198073049527), + Some(76561198258044111), + None, + Some(76561198280975787), + Some(76561198202353993), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_nLastConcurrentKilled() { + let prop = ( + "CCSPlayerPawn.m_nLastConcurrentKilled", + PropColumn { + data: Some(I32(vec![ + None, + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + None, + Some(1), + Some(1), + Some(2), + Some(1), + Some(1), + Some(2), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(2), + Some(1), + Some(2), + Some(1), + Some(1), + Some(1), + Some(3), + Some(2), + Some(1), + Some(1), + Some(2), + Some(4), + Some(3), + Some(2), + Some(1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_iInventoryPosition() { + let prop = ( + "m_iInventoryPosition", + PropColumn { + data: Some(U32(vec![ + None, + Some(13), + None, + None, + None, + None, + Some(67), + None, + None, + None, + Some(68), + Some(42), + None, + Some(0), + None, + Some(59), + None, + Some(0), + None, + Some(14), + Some(68), + Some(5), + None, + None, + Some(165), + None, + None, + None, + Some(17), + Some(14), + None, + Some(165), + None, + None, + None, + Some(259), + Some(67), + None, + None, + Some(1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_flCreateTime() { + let prop = ( + "m_flCreateTime", + PropColumn { + data: Some(F32(vec![ + Some(223.32813), + Some(216.92188), + Some(218.46875), + Some(216.92188), + Some(216.92188), + Some(216.92188), + Some(216.92188), + Some(216.92188), + Some(216.92188), + Some(70.765625), + Some(320.0), + Some(321.26563), + Some(319.25), + Some(318.21875), + None, + Some(329.42188), + Some(220.39063), + Some(317.23438), + Some(331.28125), + Some(328.26563), + Some(320.0), + Some(498.6875), + None, + Some(319.25), + Some(503.26563), + None, + Some(502.98438), + None, + Some(499.89063), + Some(328.26563), + Some(570.0781), + Some(567.5781), + Some(686.1094), + Some(683.3125), + Some(683.3125), + Some(564.2031), + Some(683.3125), + Some(683.3125), + Some(683.3125), + Some(564.2031), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_szLastPlaceName() { + let prop = ( + "CCSPlayerPawn.m_szLastPlaceName", + PropColumn { + data: Some(String(vec![ + Some("TSpawn".to_string()), + Some("CTSpawn".to_string()), + Some("TSpawn".to_string()), + Some("TSpawn".to_string()), + Some("CTSpawn".to_string()), + Some("CTSpawn".to_string()), + Some("CTSpawn".to_string()), + Some("TSpawn".to_string()), + Some("CTSpawn".to_string()), + Some("TSpawn".to_string()), + Some("Apartments".to_string()), + Some("Catwalk".to_string()), + Some("Middle".to_string()), + Some("Underpass".to_string()), + Some("Ladder".to_string()), + Some("CTSpawn".to_string()), + Some("CTSpawn".to_string()), + Some("PalaceInterior".to_string()), + Some("Jungle".to_string()), + Some("TopofMid".to_string()), + Some("BombsiteA".to_string()), + Some("CTSpawn".to_string()), + Some("BombsiteA".to_string()), + Some("Jungle".to_string()), + Some("Catwalk".to_string()), + Some("BombsiteA".to_string()), + Some("CTSpawn".to_string()), + Some("BombsiteA".to_string()), + Some("PalaceInterior".to_string()), + Some("PalaceInterior".to_string()), + Some("TSpawn".to_string()), + Some("CTSpawn".to_string()), + Some("TSpawn".to_string()), + Some("TSpawn".to_string()), + Some("CTSpawn".to_string()), + Some("CTSpawn".to_string()), + Some("CTSpawn".to_string()), + Some("TSpawn".to_string()), + Some("CTSpawn".to_string()), + Some("TSpawn".to_string()), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_iTeamNum() { + let prop = ( + "CCSPlayerPawn.m_iTeamNum", + PropColumn { + data: Some(U32(vec![ + Some(2), + None, + Some(2), + Some(2), + None, + None, + None, + Some(2), + None, + Some(2), + Some(2), + None, + Some(2), + Some(2), + None, + None, + None, + Some(2), + None, + Some(2), + Some(2), + None, + Some(2), + Some(2), + None, + None, + None, + Some(2), + None, + Some(2), + Some(2), + None, + Some(2), + Some(2), + None, + None, + None, + Some(2), + None, + Some(2), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CEconItemAttribute_m_iAttributeDefinitionIndex() { + let prop = ( + "CEconItemAttribute.m_iAttributeDefinitionIndex", + PropColumn { + data: Some(U32(vec![ + None, + Some(75), + None, + None, + None, + None, + Some(75), + None, + None, + None, + Some(8), + Some(75), + None, + None, + None, + Some(121), + None, + None, + None, + None, + Some(8), + Some(121), + None, + None, + Some(75), + None, + None, + None, + Some(8), + None, + None, + Some(75), + None, + None, + None, + Some(81), + Some(75), + None, + None, + Some(75), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iPing() { + let prop = ( + "CCSPlayerController.m_iPing", + PropColumn { + data: Some(U32(vec![ + Some(43), + Some(18), + Some(56), + Some(67), + Some(1), + Some(19), + Some(3), + Some(52), + Some(9), + Some(33), + Some(43), + Some(18), + Some(56), + Some(67), + Some(1), + Some(19), + Some(3), + Some(53), + Some(9), + Some(31), + Some(43), + Some(18), + Some(51), + Some(67), + Some(1), + Some(20), + Some(3), + Some(53), + Some(9), + Some(32), + Some(43), + Some(12), + Some(52), + Some(67), + Some(1), + Some(19), + Some(3), + Some(52), + Some(9), + Some(32), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iCompetitiveRankingPredicted_Win() { + let prop = ( + "CCSPlayerController.m_iCompetitiveRankingPredicted_Win", + PropColumn { + data: Some(I32(vec![ + Some(18345), + Some(18265), + Some(10120), + Some(15115), + Some(19012), + Some(16590), + Some(19201), + Some(14167), + Some(18082), + None, + Some(18345), + Some(18265), + Some(10120), + Some(15115), + Some(19012), + Some(16590), + Some(19201), + Some(14167), + Some(18082), + None, + Some(18345), + Some(18265), + Some(10120), + Some(15115), + Some(19012), + Some(16590), + Some(19201), + Some(14167), + Some(18082), + None, + Some(18345), + Some(18265), + Some(10120), + Some(15115), + Some(19012), + Some(16590), + Some(19201), + Some(14167), + Some(18082), + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_bRagdollDamageHeadshot() { + let prop = ( + "CCSPlayerPawn.m_bRagdollDamageHeadshot", + PropColumn { + data: Some(Bool(vec![ + None, + Some(true), + Some(false), + Some(true), + Some(true), + Some(true), + Some(true), + Some(false), + Some(true), + None, + None, + Some(true), + Some(true), + Some(false), + Some(true), + Some(true), + Some(true), + Some(false), + Some(false), + Some(true), + None, + Some(false), + Some(false), + Some(false), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(true), + None, + Some(false), + Some(false), + Some(true), + Some(false), + Some(false), + Some(true), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_MovementServices_m_bDesiresDuck() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_MovementServices.m_bDesiresDuck", + PropColumn { + data: Some(Bool(vec![ + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_fRoundStartTime() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_fRoundStartTime", + PropColumn { + data: Some(F32(vec![ + Some(236.92188), + Some(236.92188), + Some(236.92188), + Some(236.92188), + Some(236.92188), + Some(236.92188), + Some(236.92188), + Some(236.92188), + Some(236.92188), + Some(236.92188), + Some(334.75), + Some(334.75), + Some(334.75), + Some(334.75), + Some(334.75), + Some(334.75), + Some(334.75), + Some(334.75), + Some(334.75), + Some(334.75), + Some(504.0), + Some(504.0), + Some(504.0), + Some(504.0), + Some(504.0), + Some(504.0), + Some(504.0), + Some(504.0), + Some(504.0), + Some(504.0), + Some(703.3125), + Some(703.3125), + Some(703.3125), + Some(703.3125), + Some(703.3125), + Some(703.3125), + Some(703.3125), + Some(703.3125), + Some(703.3125), + Some(703.3125), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_InGameMoneyServices_m_iCashSpentThisRound() { + let prop = ( + "CCSPlayerController.CCSPlayerController_InGameMoneyServices.m_iCashSpentThisRound", + PropColumn { + data: Some(I32(vec![ + Some(1700), + Some(0), + Some(700), + Some(4000), + Some(0), + Some(0), + Some(0), + Some(4000), + Some(0), + Some(1000), + Some(4100), + Some(5700), + Some(4900), + Some(2550), + Some(1900), + Some(5100), + Some(2800), + Some(1750), + Some(4000), + Some(2900), + Some(700), + Some(700), + Some(1200), + Some(900), + Some(3900), + Some(3900), + Some(4250), + Some(300), + Some(300), + Some(900), + Some(800), + Some(0), + Some(3700), + Some(4900), + Some(0), + Some(0), + Some(0), + Some(6750), + Some(0), + Some(1200), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_flNextSecondaryAttackTickRatio() { + let prop = ( + "m_flNextSecondaryAttackTickRatio", + PropColumn { + data: Some(F32(vec![ + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.5333328), + Some(0.0), + Some(0.26667786), + None, + Some(0.5333328), + Some(0.8666687), + Some(0.0), + Some(0.0), + Some(0.56849414), + Some(0.0), + Some(0.0), + None, + Some(0.3865242), + Some(0.2666626), + None, + Some(0.0), + None, + Some(0.08510375), + Some(0.0), + Some(0.0), + Some(0.5333328), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.93333435), + Some(0.0), + Some(0.0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CBodyComponentBaseAnimGraph_m_nIdealMotionType() { + let prop = ( + "CBodyComponentBaseAnimGraph.m_nIdealMotionType", + PropColumn { + data: Some(I32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(3), + None, + None, + None, + None, + None, + None, + Some(3), + None, + None, + None, + None, + None, + None, + Some(3), + Some(3), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_hOwnerEntity() { + let prop = ( + "m_hOwnerEntity", + PropColumn { + data: Some(U32(vec![ + Some(3522664), + Some(13942893), + None, + Some(1146999), + Some(15466622), + Some(16089222), + Some(9863309), + Some(14352543), + Some(6389962), + Some(2998498), + None, + Some(13942893), + Some(10846322), + Some(1146999), + None, + Some(16089222), + Some(9863309), + Some(14352543), + Some(6389962), + Some(2998498), + None, + Some(13942893), + None, + Some(1146999), + Some(15466622), + None, + Some(9863309), + None, + Some(6389962), + Some(2998498), + Some(3522664), + Some(13942893), + Some(10846322), + Some(1146999), + Some(15466622), + Some(16089222), + Some(9863309), + None, + Some(6389962), + Some(2998498), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_flFlashMaxAlpha() { + let prop = ( + "CCSPlayerPawn.m_flFlashMaxAlpha", + PropColumn { + data: Some(F32(vec![ + None, + Some(255.0), + Some(255.0), + None, + Some(255.0), + None, + Some(255.0), + Some(255.0), + Some(255.0), + None, + None, + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + Some(255.0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iUtilityDamage() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iUtilityDamage", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(9), + Some(52), + Some(0), + Some(0), + Some(0), + Some(0), + Some(26), + Some(0), + Some(0), + Some(0), + Some(9), + Some(52), + Some(61), + Some(85), + Some(7), + Some(0), + Some(26), + Some(28), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_OriginalOwnerXuidLow() { + let prop = ( + "m_OriginalOwnerXuidLow", + PropColumn { + data: Some(U32(vec![ + Some(305101042), + Some(364577347), + None, + Some(284488898), + Some(234429022), + Some(112783799), + Some(297778383), + Some(3754702), + Some(320710059), + Some(242088265), + None, + Some(364577347), + Some(158538184), + Some(284488898), + None, + Some(112783799), + Some(3754702), + Some(3754702), + Some(320710059), + Some(242088265), + None, + Some(364577347), + None, + Some(158538184), + Some(234429022), + None, + Some(297778383), + None, + Some(320710059), + Some(242088265), + Some(297778383), + Some(234429022), + Some(158538184), + Some(284488898), + Some(234429022), + Some(112783799), + Some(297778383), + None, + Some(320710059), + Some(242088265), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_aimPunchAngle() { + let prop = ( + "CCSPlayerPawn.m_aimPunchAngle", + PropColumn { + data: Some(XYZVec(vec![ + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.6257424, 0.0391259, 0.0]), + Some([0.7700784, 0.02841704, 0.0]), + Some([0.0752761, -0.003006973, 0.0]), + Some([-5.096302, 0.34865546, 1.8917837e-6]), + Some([0.6225749, 0.013033606, 0.0]), + Some([-5.0283604, -1.4114164, -2.156072e-6]), + Some([0.19490086, 0.015310853, 0.0]), + Some([0.3671517, 0.028899848, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([-2.304628, -0.09649117, -3.8175546e-8]), + Some([0.13787195, -0.0026435894, 0.0]), + Some([-0.24363059, -0.11250786, -8.143596e-7]), + Some([-0.6233528, 0.00069459085, 4.5761978e-10]), + Some([-1.3367857, -0.12772557, -3.002365e-8]), + Some([-0.9370359, -0.047985114, -6.6237595e-7]), + Some([-2.941906, 0.2179837, 1.5002497e-6]), + Some([-4.5515127, 1.190071, 1.1232146e-6]), + Some([-0.087496266, 0.008882257, 1.797804e-9]), + Some([-0.5217251, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_flSlopeDropOffset() { + let prop = ( + "CCSPlayerPawn.m_flSlopeDropOffset", + PropColumn { + data: Some(F32(vec![ + Some(0.0), + Some(3.3520203), + Some(0.0), + Some(2.9844055), + Some(0.53964233), + Some(3.3246765), + Some(0.60079956), + Some(0.0), + Some(1.8640747), + Some(0.64746094), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(1.4710999), + Some(0.0), + Some(6.1763077), + Some(0.0), + Some(1.3343811), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.64746094), + Some(1.6372375), + Some(0.0), + Some(0.0), + Some(0.441864), + Some(0.60079956), + Some(2.1600342), + Some(0.0), + Some(2.2197876), + Some(2.9844055), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_nInteractsExclude() { + let prop = ( + "CCSPlayerPawn.m_nInteractsExclude", + PropColumn { + data: Some(U64(vec![ + None, + Some(512), + Some(512), + Some(512), + Some(512), + Some(512), + Some(512), + Some(512), + Some(512), + None, + Some(512), + Some(512), + Some(512), + Some(512), + Some(262672), + Some(512), + Some(512), + Some(512), + Some(512), + Some(512), + Some(512), + Some(512), + Some(262672), + Some(512), + Some(512), + Some(262672), + Some(512), + Some(262672), + Some(512), + Some(512), + Some(512), + Some(512), + Some(512), + Some(512), + Some(512), + Some(512), + Some(512), + Some(512), + Some(512), + Some(512), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_weaponMode() { + let prop = ( + "m_weaponMode", + PropColumn { + data: Some(U64(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(0), + None, + None, + None, + Some(0), + None, + None, + None, + Some(1), + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(0), + None, + None, + None, + None, + None, + None, + None, + None, + Some(1), + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_bPawnIsAlive() { + let prop = ( + "CCSPlayerController.m_bPawnIsAlive", + PropColumn { + data: Some(Bool(vec![ + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(false), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(false), + Some(true), + Some(true), + Some(false), + Some(true), + Some(false), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_iShotsFired() { + let prop = ( + "CCSPlayerPawn.m_iShotsFired", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(9), + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(2), + Some(0), + Some(0), + Some(3), + Some(0), + Some(11), + Some(1), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_unActiveQuestId() { + let prop = ( + "CCSPlayerController.m_unActiveQuestId", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_CSPerRoundStats_t_m_iUtilityDamage() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iUtilityDamage", + PropColumn { + data: Some(I32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(52), + None, + None, + None, + None, + Some(26), + None, + None, + None, + Some(9), + Some(52), + Some(44), + Some(36), + None, + None, + Some(26), + None, + None, + None, + Some(9), + Some(52), + Some(44), + Some(36), + None, + None, + Some(26), + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_ubInterpolationFrame() { + let prop = ( + "m_ubInterpolationFrame", + PropColumn { + data: Some(U32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(1), + None, + None, + None, + None, + None, + None, + Some(1), + None, + None, + None, + None, + None, + None, + Some(1), + Some(0), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_fLastShotTime() { + let prop = ( + "m_fLastShotTime", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(194.07813), + None, + None, + None, + Some(373.84375), + None, + None, + Some(372.34375), + None, + Some(375.79688), + Some(380.42188), + Some(535.90625), + None, + None, + Some(535.96875), + Some(537.1875), + None, + None, + None, + Some(538.4375), + Some(530.0), + None, + Some(679.9219), + None, + None, + None, + None, + None, + None, + None, + Some(623.8281), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iPawnLifetimeEnd() { + let prop = ( + "CCSPlayerController.m_iPawnLifetimeEnd", + PropColumn { + data: Some(I32(vec![ + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CBodyComponentBaseAnimGraph_m_cellY() { + let prop = ( + "CBodyComponentBaseAnimGraph.m_cellY", + PropColumn { + data: Some(U32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(32), + None, + None, + None, + None, + None, + None, + Some(32), + None, + None, + None, + None, + None, + None, + Some(32), + Some(32), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CEconItemAttribute_m_iRawValue32() { + let prop = ( + "CEconItemAttribute.m_iRawValue32", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_nNextThinkTick() { + let prop = ( + "m_nNextThinkTick", + PropColumn { + data: Some(U32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(1), + None, + None, + None, + None, + None, + None, + Some(1), + None, + None, + None, + None, + None, + None, + Some(1), + Some(1), + None, + None, + None, + None, + None, + Some(88948), + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iEquipmentValue() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iEquipmentValue", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iPawnLifetimeStart() { + let prop = ( + "CCSPlayerController.m_iPawnLifetimeStart", + PropColumn { + data: Some(I32(vec![ + Some(216), + Some(216), + Some(216), + Some(216), + Some(216), + Some(216), + Some(216), + Some(216), + Some(216), + Some(216), + Some(314), + Some(314), + Some(314), + Some(314), + Some(0), + Some(314), + Some(314), + Some(314), + Some(314), + Some(314), + Some(484), + Some(484), + Some(0), + Some(484), + Some(484), + Some(0), + Some(484), + Some(0), + Some(484), + Some(484), + Some(683), + Some(683), + Some(683), + Some(683), + Some(683), + Some(683), + Some(683), + Some(683), + Some(683), + Some(683), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iPawnArmor() { + let prop = ( + "CCSPlayerController.m_iPawnArmor", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_unPlayerTvControlFlags() { + let prop = ( + "CCSPlayerController.m_unPlayerTvControlFlags", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iCompTeammateColor() { + let prop = ( + "CCSPlayerController.m_iCompTeammateColor", + PropColumn { + data: Some(I32(vec![ + Some(3), + Some(1), + Some(1), + Some(2), + Some(2), + Some(4), + Some(0), + Some(4), + Some(3), + Some(0), + Some(3), + Some(1), + Some(1), + Some(2), + Some(2), + Some(4), + Some(0), + Some(4), + Some(3), + Some(0), + Some(3), + Some(1), + Some(1), + Some(2), + Some(2), + Some(4), + Some(0), + Some(4), + Some(3), + Some(0), + Some(3), + Some(1), + Some(1), + Some(2), + Some(2), + Some(4), + Some(0), + Some(4), + Some(3), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iPendingTeamNum() { + let prop = ( + "CCSPlayerController.m_iPendingTeamNum", + PropColumn { + data: Some(U32(vec![ + None, + Some(3), + None, + None, + Some(3), + Some(3), + Some(3), + None, + Some(3), + None, + None, + Some(3), + None, + None, + Some(3), + Some(3), + Some(3), + None, + Some(3), + None, + None, + Some(3), + None, + None, + Some(3), + Some(3), + Some(3), + None, + Some(3), + None, + None, + Some(3), + None, + None, + Some(3), + Some(3), + Some(3), + None, + Some(3), + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_vDecalForwardAxis() { + let prop = ( + "m_vDecalForwardAxis", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_fMolotovDamageTime() { + let prop = ( + "CCSPlayerPawn.m_fMolotovDamageTime", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(0.0), + Some(0.0), + None, + Some(0.0), + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_MovementServices_m_nLadderSurfacePropIndex() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_MovementServices.m_nLadderSurfacePropIndex", + PropColumn { + data: Some(I32(vec![ + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + Some(-1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_bIsBuyMenuOpen() { + let prop = ( + "CCSPlayerPawn.m_bIsBuyMenuOpen", + PropColumn { + data: Some(Bool(vec![ + Some(false), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_nDisconnectionTick() { + let prop = ( + "CCSPlayerController.m_nDisconnectionTick", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_InGameMoneyServices_m_iStartAccount() { + let prop = ( + "CCSPlayerController.CCSPlayerController_InGameMoneyServices.m_iStartAccount", + PropColumn { + data: Some(I32(vec![ + Some(3650), + Some(1900), + Some(4350), + Some(4050), + Some(2200), + Some(2050), + Some(2050), + Some(4050), + Some(2650), + Some(4150), + Some(4150), + Some(5700), + Some(5850), + Some(2550), + Some(6300), + Some(5550), + Some(4450), + Some(3150), + Some(4200), + Some(3000), + Some(6650), + Some(3300), + Some(3750), + Some(6500), + Some(5800), + Some(4050), + Some(4250), + Some(9050), + Some(2150), + Some(5400), + Some(6950), + Some(1500), + Some(6450), + Some(6500), + Some(3250), + Some(2700), + Some(2000), + Some(6900), + Some(1550), + Some(4200), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iKillReward() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iKillReward", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_ubInterpolationFrame() { + let prop = ( + "CCSPlayerPawn.m_ubInterpolationFrame", + PropColumn { + data: Some(U32(vec![ + Some(3), + Some(3), + Some(1), + Some(3), + Some(1), + Some(3), + Some(1), + Some(3), + Some(3), + Some(3), + Some(1), + Some(1), + Some(3), + Some(1), + Some(3), + Some(1), + Some(3), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(3), + Some(1), + Some(3), + Some(1), + Some(3), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(3), + Some(1), + Some(3), + Some(1), + Some(3), + Some(1), + Some(1), + Some(1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iEnemy3Ks() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iEnemy3Ks", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_vDecalPosition() { + let prop = ( + "CCSPlayerPawn.m_vDecalPosition", + PropColumn { + data: Some(XYZVec(vec![ + Some([-1271.9409, -996.25165, -121.87482]), + Some([-1177.3091, -393.89706, -11.370972]), + Some([-504.80264, -1454.2224, -24.087448]), + Some([-912.3319, -1481.2107, -105.44267]), + Some([-1161.0746, -606.4787, -109.58214]), + Some([-828.7623, -2534.7646, 27.780762]), + Some([-1329.447, -975.2356, -124.65142]), + Some([-1105.1072, -604.2416, -92.25015]), + Some([-803.9081, 10.710815, -107.94034]), + None, + Some([-1281.7133, 771.99084, -78.4]), + Some([-2302.8567, 320.36478, -112.783165]), + Some([-314.79352, -922.4806, -103.29794]), + Some([-992.5512, -770.82446, -215.84972]), + Some([-1182.3367, -394.19177, 3.4436035]), + Some([-859.2573, -2460.5, -29.6559]), + Some([-1329.447, -975.2356, -124.65142]), + Some([369.29617, -1527.9995, -136.44029]), + Some([-797.92896, -895.142, -123.14453]), + Some([-2169.6887, 690.8084, -70.36412]), + Some([-576.4873, -368.66467, -108.3066]), + Some([-2291.2625, 373.48062, -122.94483]), + Some([-693.6147, -1593.5266, -125.98947]), + Some([-730.95447, -1178.6669, -116.54382]), + Some([-723.25714, -22.978605, -74.05778]), + Some([-627.2682, -1325.6891, -110.70767]), + Some([-2332.9026, -290.97577, -117.977135]), + Some([-157.4043, -1945.0631, -124.29493]), + Some([147.05904, -1916.9562, 2.3034515]), + Some([63.547302, -2375.304, 18.088778]), + Some([-616.40906, -1986.2017, -178.4]), + Some([-1308.5262, -1171.368, -50.149086]), + Some([-630.76263, -1662.4001, -144.75473]), + Some([-999.77985, 391.99142, -305.51318]), + Some([-764.8695, -110.90314, -113.249084]), + Some([694.5594, -1563.0651, -208.42299]), + Some([-582.8451, -781.82654, -199.15674]), + Some([-614.638, -1577.8723, -81.12184]), + Some([-778.0574, -1577.9769, -124.16199]), + Some([-616.40906, -1986.2017, -178.4]), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_MovementServices_m_flJumpVel() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flJumpVel", + PropColumn { + data: Some(F32(vec![ + Some(256.23972), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(295.74338), + Some(289.49338), + Some(227.28023), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(275.47427), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(252.05167), + Some(289.49338), + Some(274.70984), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + Some(289.49338), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_bInBuyZone() { + let prop = ( + "CCSPlayerPawn.m_bInBuyZone", + PropColumn { + data: Some(Bool(vec![ + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iMoneySaved() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iMoneySaved", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_iRoundTime() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_iRoundTime", + PropColumn { + data: Some(I32(vec![ + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + Some(115), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iScore() { + let prop = ( + "CCSPlayerController.m_iScore", + PropColumn { + data: Some(I32(vec![ + Some(2), + Some(1), + Some(3), + Some(0), + Some(3), + Some(0), + None, + Some(2), + Some(4), + Some(6), + Some(3), + Some(3), + Some(3), + Some(4), + Some(8), + Some(0), + Some(5), + Some(8), + Some(6), + Some(6), + Some(11), + Some(3), + Some(3), + Some(10), + Some(9), + Some(2), + Some(9), + Some(17), + Some(6), + Some(8), + Some(18), + Some(3), + Some(4), + Some(15), + Some(13), + Some(6), + Some(13), + Some(22), + Some(8), + Some(12), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_timeUntilNextPhaseStarts() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_timeUntilNextPhaseStarts", + PropColumn { + data: None, + num_nones: 40, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_nEntityId() { + let prop = ( + "m_nEntityId", + PropColumn { + data: Some(U32(vec![ + Some(2863005796), + Some(3036479887), + Some(2120941719), + Some(4235690213), + Some(1433075922), + Some(304808084), + Some(2706145503), + Some(1545961596), + Some(2937749601), + Some(1441267959), + Some(1518600463), + Some(263651450), + Some(1014530310), + Some(1158250718), + None, + Some(2453012885), + Some(3180888201), + Some(2863038564), + Some(4231168408), + Some(2700902803), + Some(1518600463), + Some(4231594273), + None, + Some(1014530310), + Some(2891416009), + None, + Some(1300365714), + None, + Some(3346038996), + Some(2700902803), + Some(406749301), + Some(3036545423), + Some(3820749197), + Some(290488640), + Some(1720516840), + Some(1848639916), + Some(205815901), + Some(2891481545), + Some(4041703655), + Some(2618360313), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CBodyComponentBaseAnimGraph_m_vecY() { + let prop = ( + "CBodyComponentBaseAnimGraph.m_vecY", + PropColumn { + data: Some(F32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(0.0), + None, + None, + None, + None, + None, + None, + Some(0.0), + None, + None, + None, + None, + None, + None, + Some(0.0), + Some(0.0), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iEnemiesFlashed() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iEnemiesFlashed", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(2), + Some(2), + Some(0), + Some(0), + Some(1), + Some(0), + Some(0), + Some(0), + Some(0), + Some(3), + Some(4), + Some(2), + Some(0), + Some(1), + Some(1), + Some(0), + Some(2), + Some(0), + Some(2), + Some(5), + Some(4), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iCompetitiveRankingPredicted_Loss() { + let prop = ( + "CCSPlayerController.m_iCompetitiveRankingPredicted_Loss", + PropColumn { + data: Some(I32(vec![ + Some(17823), + Some(18015), + Some(9879), + Some(14895), + Some(18469), + Some(16148), + Some(18631), + Some(13632), + Some(17588), + None, + Some(17823), + Some(18015), + Some(9879), + Some(14895), + Some(18469), + Some(16148), + Some(18631), + Some(13632), + Some(17588), + None, + Some(17823), + Some(18015), + Some(9879), + Some(14895), + Some(18469), + Some(16148), + Some(18631), + Some(13632), + Some(17588), + None, + Some(17823), + Some(18015), + Some(9879), + Some(14895), + Some(18469), + Some(16148), + Some(18631), + Some(13632), + Some(17588), + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_iProgressBarDuration() { + let prop = ( + "CCSPlayerPawn.m_iProgressBarDuration", + PropColumn { + data: Some(I32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(-1), + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(-1), + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(-1), + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_flHitHeading() { + let prop = ( + "CCSPlayerPawn.m_flHitHeading", + PropColumn { + data: Some(F32(vec![ + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + None, + Some(42.779312), + Some(0.0), + Some(0.0), + Some(0.10296631), + Some(2.3213272), + Some(0.0), + Some(0.0), + Some(-43.442574), + Some(1.8940296), + Some(0.0), + Some(0.0), + Some(0.0), + Some(-13.185135), + Some(2.3559723), + Some(14.304581), + Some(15.419861), + Some(0.0), + Some(-160.90855), + Some(2.4393005), + Some(2.0423546), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_InventoryServices_m_nPersonaDataPublicCommendsTeacher() { + let prop = ( + "CCSPlayerController.CCSPlayerController_InventoryServices.m_nPersonaDataPublicCommendsTeacher", + PropColumn { + data: Some(I32(vec![ + Some(44), + Some(12), + Some(43), + Some(164), + Some(28), + Some(16), + Some(22), + Some(13), + Some(39), + Some(41), + Some(44), + Some(12), + Some(43), + Some(164), + Some(28), + Some(16), + Some(22), + Some(13), + Some(39), + Some(41), + Some(44), + Some(12), + Some(43), + Some(164), + Some(28), + Some(16), + Some(22), + Some(13), + Some(39), + Some(41), + Some(44), + Some(12), + Some(43), + Some(164), + Some(28), + Some(16), + Some(22), + Some(13), + Some(39), + Some(41), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_hPawn() { + let prop = ( + "CCSPlayerController.m_hPawn", + PropColumn { + data: Some(U32(vec![ + Some(3522664), + Some(13942893), + Some(10846322), + Some(1146999), + Some(15466622), + Some(16089222), + Some(9863309), + Some(14352543), + Some(6389962), + Some(2998498), + Some(3522664), + Some(13942893), + Some(10846322), + Some(1146999), + Some(15548543), + Some(16089222), + Some(9863309), + Some(14352543), + Some(6389962), + Some(2998498), + Some(3522664), + Some(13942893), + Some(13779057), + Some(1146999), + Some(15466622), + Some(15614085), + Some(9863309), + Some(7274587), + Some(6389962), + Some(2998498), + Some(3522664), + Some(13942893), + Some(10846322), + Some(1146999), + Some(15466622), + Some(16089222), + Some(9863309), + Some(14352543), + Some(6389962), + Some(2998498), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_CSPerRoundStats_t_m_iAssists() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.CSPerRoundStats_t.m_iAssists", + PropColumn { + data: Some(I32(vec![ + None, + Some(1), + Some(1), + None, + Some(1), + None, + None, + None, + None, + None, + Some(1), + Some(1), + Some(1), + None, + Some(1), + None, + Some(1), + None, + None, + None, + Some(1), + Some(1), + Some(1), + None, + Some(1), + None, + Some(1), + Some(1), + None, + None, + Some(1), + Some(1), + Some(1), + None, + Some(1), + Some(1), + Some(1), + Some(2), + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_iState() { + let prop = ( + "m_iState", + PropColumn { + data: Some(U32(vec![ + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + None, + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + None, + Some(2), + Some(2), + None, + Some(2), + None, + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_iMatchStats_RoundResults() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_iMatchStats_RoundResults", + PropColumn { + data: Some(I32(vec![ + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(5), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_bIsWalking() { + let prop = ( + "CCSPlayerPawn.m_bIsWalking", + PropColumn { + data: Some(Bool(vec![ + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + None, + Some(false), + Some(false), + Some(true), + Some(false), + Some(true), + Some(true), + Some(false), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(true), + Some(false), + Some(false), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_nDropTick() { + let prop = ( + "m_nDropTick", + PropColumn { + data: Some(U32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(37836), + None, + None, + None, + None, + None, + None, + Some(51292), + None, + None, + None, + None, + None, + None, + Some(82670), + Some(88756), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_iCompetitiveRankType() { + let prop = ( + "CCSPlayerController.m_iCompetitiveRankType", + PropColumn { + data: Some(I32(vec![ + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + Some(11), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_iNumConsecutiveCTLoses() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_iNumConsecutiveCTLoses", + PropColumn { + data: Some(I32(vec![ + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_bFreezePeriod() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_bFreezePeriod", + PropColumn { + data: Some(Bool(vec![ + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_nFireSequenceStartTimeChange() { + let prop = ( + "m_nFireSequenceStartTimeChange", + PropColumn { + data: Some(I32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(3), + None, + None, + None, + Some(19), + None, + None, + Some(41), + None, + Some(9), + Some(11), + Some(93), + None, + None, + Some(35), + Some(20), + None, + None, + None, + Some(4), + Some(18), + None, + Some(11), + None, + None, + None, + None, + None, + None, + None, + Some(5), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CBodyComponentBaseAnimGraph_m_hParent() { + let prop = ( + "CBodyComponentBaseAnimGraph.m_hParent", + PropColumn { + data: Some(U32(vec![ + Some(3522664), + Some(13942893), + None, + Some(1146999), + Some(15466622), + Some(16089222), + Some(9863309), + Some(14352543), + Some(6389962), + Some(2998498), + None, + Some(13942893), + Some(10846322), + Some(1146999), + None, + Some(16089222), + Some(9863309), + Some(14352543), + Some(6389962), + Some(2998498), + None, + Some(13942893), + None, + Some(1146999), + Some(15466622), + None, + Some(9863309), + None, + Some(6389962), + Some(2998498), + Some(3522664), + Some(13942893), + Some(10846322), + Some(1146999), + Some(15466622), + Some(16089222), + Some(9863309), + None, + Some(6389962), + Some(2998498), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_InventoryServices_m_nPersonaDataPublicCommendsLeader() { + let prop = ( + "CCSPlayerController.CCSPlayerController_InventoryServices.m_nPersonaDataPublicCommendsLeader", + PropColumn { + data: Some(I32(vec![ + Some(42), + Some(13), + Some(38), + Some(158), + Some(30), + Some(20), + Some(24), + Some(13), + Some(42), + Some(43), + Some(42), + Some(13), + Some(38), + Some(158), + Some(30), + Some(20), + Some(24), + Some(13), + Some(42), + Some(43), + Some(42), + Some(13), + Some(38), + Some(158), + Some(30), + Some(20), + Some(24), + Some(13), + Some(42), + Some(43), + Some(42), + Some(13), + Some(38), + Some(158), + Some(30), + Some(20), + Some(24), + Some(13), + Some(42), + Some(43), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_szRagdollDamageWeaponName() { + let prop = ( + "CCSPlayerPawn.m_szRagdollDamageWeaponName", + PropColumn { + data: Some(String(vec![ + None, + Some("glock".to_string()), + Some("hkp2000".to_string()), + Some("hkp2000".to_string()), + Some("glock".to_string()), + Some("p250".to_string()), + Some("deagle".to_string()), + Some("fiveseven".to_string()), + Some("glock".to_string()), + None, + Some("ak47".to_string()), + Some("ak47".to_string()), + Some("mp9".to_string()), + Some("usp_silencer".to_string()), + Some("mac10".to_string()), + Some("ak47".to_string()), + Some("deagle".to_string()), + Some("usp_silencer".to_string()), + Some("ak47".to_string()), + Some("usp_silencer".to_string()), + Some("ak47".to_string()), + Some("mac10".to_string()), + Some("m4a1_silencer".to_string()), + Some("usp_silencer".to_string()), + Some("ak47".to_string()), + Some("ak47".to_string()), + Some("ak47".to_string()), + Some("m4a1_silencer".to_string()), + Some("ak47".to_string()), + Some("usp_silencer".to_string()), + Some("m4a1_silencer".to_string()), + Some("hegrenade".to_string()), + Some("m4a1_silencer".to_string()), + Some("m4a1_silencer".to_string()), + Some("awp".to_string()), + Some("ak47".to_string()), + Some("ak47".to_string()), + Some("m4a1_silencer".to_string()), + Some("awp".to_string()), + Some("p250".to_string()), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_MovementServices_m_flStamina() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flStamina", + PropColumn { + data: Some(F32(vec![ + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(15.22197), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_InventoryServices_m_nPersonaDataPublicCommendsFriendly() { + let prop = ( + "CCSPlayerController.CCSPlayerController_InventoryServices.m_nPersonaDataPublicCommendsFriendly", + PropColumn { + data: Some(I32(vec![ + Some(46), + Some(13), + Some(44), + Some(169), + Some(27), + Some(19), + Some(23), + Some(13), + Some(48), + Some(43), + Some(46), + Some(13), + Some(44), + Some(169), + Some(27), + Some(19), + Some(23), + Some(13), + Some(48), + Some(43), + Some(46), + Some(13), + Some(44), + Some(169), + Some(27), + Some(19), + Some(23), + Some(13), + Some(48), + Some(43), + Some(46), + Some(13), + Some(44), + Some(169), + Some(27), + Some(19), + Some(23), + Some(13), + Some(48), + Some(43), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iNumRoundKillsHeadshots() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iNumRoundKillsHeadshots", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + None, + None, + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(1), + None, + None, + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + None, + None, + None, + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + None, + Some(0), + None, + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_bHasMovedSinceSpawn() { + let prop = ( + "CCSPlayerPawn.m_bHasMovedSinceSpawn", + PropColumn { + data: Some(Bool(vec![ + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(true), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_nEntityId() { + let prop = ( + "CCSPlayerPawn.m_nEntityId", + PropColumn { + data: Some(U32(vec![ + Some(174817384), + Some(3920199789), + Some(4014669938), + Some(237174903), + None, + Some(4025155718), + Some(3006070925), + Some(3048603807), + Some(3535995082), + Some(576422114), + Some(174817384), + Some(3920199789), + Some(4014669938), + Some(237174903), + None, + Some(4025155718), + Some(3006070925), + Some(3048603807), + Some(3535995082), + Some(576422114), + Some(174817384), + Some(3920199789), + Some(4014669938), + Some(237174903), + None, + Some(4025155718), + Some(3006070925), + Some(3048603807), + Some(3535995082), + Some(576422114), + Some(174817384), + Some(3920199789), + Some(4014669938), + Some(237174903), + None, + Some(4025155718), + Some(3006070925), + Some(3048603807), + Some(3535995082), + Some(576422114), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_ItemServices_m_bHasDefuser() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_ItemServices.m_bHasDefuser", + PropColumn { + data: Some(Bool(vec![ + None, + Some(false), + None, + None, + Some(false), + None, + None, + None, + Some(false), + None, + None, + Some(true), + None, + None, + Some(false), + Some(true), + Some(true), + None, + Some(false), + None, + None, + Some(false), + None, + None, + Some(false), + Some(false), + Some(false), + None, + Some(false), + None, + None, + Some(false), + None, + None, + Some(false), + Some(false), + Some(false), + None, + Some(false), + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iDamage() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iDamage", + PropColumn { + data: Some(I32(vec![ + Some(100), + Some(28), + Some(185), + Some(0), + Some(194), + Some(0), + Some(33), + Some(100), + Some(107), + Some(115), + Some(161), + Some(111), + Some(185), + Some(90), + Some(339), + Some(0), + Some(205), + Some(239), + Some(207), + Some(115), + Some(561), + Some(171), + Some(185), + Some(390), + Some(513), + Some(183), + Some(280), + Some(439), + Some(207), + Some(215), + Some(850), + Some(212), + Some(277), + Some(615), + Some(673), + Some(333), + Some(578), + Some(766), + Some(307), + Some(215), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CBodyComponentBaseAnimGraph_m_cellZ() { + let prop = ( + "CBodyComponentBaseAnimGraph.m_cellZ", + PropColumn { + data: Some(U32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(32), + None, + None, + None, + None, + None, + None, + Some(32), + None, + None, + None, + None, + None, + None, + Some(32), + Some(32), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_flGameStartTime() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_flGameStartTime", + PropColumn { + data: Some(F32(vec![ + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + Some(70.765625), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_hPlayerPawn() { + let prop = ( + "CCSPlayerController.m_hPlayerPawn", + PropColumn { + data: Some(U32(vec![ + Some(3522664), + Some(13942893), + Some(10846322), + Some(1146999), + Some(15466622), + Some(16089222), + Some(9863309), + Some(14352543), + Some(6389962), + Some(2998498), + Some(3522664), + Some(13942893), + Some(10846322), + Some(1146999), + Some(15466622), + Some(16089222), + Some(9863309), + Some(14352543), + Some(6389962), + Some(2998498), + Some(3522664), + Some(13942893), + Some(10846322), + Some(1146999), + Some(15466622), + Some(16089222), + Some(9863309), + Some(14352543), + Some(6389962), + Some(2998498), + Some(3522664), + Some(13942893), + Some(10846322), + Some(1146999), + Some(15466622), + Some(16089222), + Some(9863309), + Some(14352543), + Some(6389962), + Some(2998498), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_nEnablePhysics() { + let prop = ( + "CCSPlayerPawn.m_nEnablePhysics", + PropColumn { + data: Some(U32(vec![ + None, + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + None, + Some(3), + Some(3), + Some(3), + Some(3), + Some(2), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(2), + Some(3), + Some(3), + Some(2), + Some(3), + Some(2), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + Some(3), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_aimPunchTickBase() { + let prop = ( + "CCSPlayerPawn.m_aimPunchTickBase", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(22042), + Some(24327), + Some(21769), + Some(24331), + Some(23889), + Some(23821), + Some(23829), + Some(23090), + Some(24140), + Some(24346), + Some(34297), + Some(34438), + Some(34290), + Some(34301), + Some(34379), + Some(33886), + Some(34303), + Some(34099), + Some(34460), + Some(34449), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_fWarmupPeriodStart() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_fWarmupPeriodStart", + PropColumn { + data: Some(F32(vec![ + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + Some(54.765625), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_nRagdollDamageBone() { + let prop = ( + "CCSPlayerPawn.m_nRagdollDamageBone", + PropColumn { + data: Some(I32(vec![ + None, + Some(6), + Some(4), + Some(6), + Some(6), + Some(6), + Some(6), + Some(13), + Some(6), + None, + Some(3), + Some(6), + Some(6), + Some(4), + Some(6), + Some(6), + Some(6), + Some(2), + Some(1), + Some(6), + Some(3), + Some(1), + Some(14), + Some(4), + Some(6), + Some(4), + Some(4), + Some(1), + Some(3), + Some(6), + Some(1), + Some(5), + Some(25), + Some(6), + Some(4), + Some(4), + Some(6), + Some(0), + Some(1), + Some(1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_ActionTrackingServices_m_iObjective() { + let prop = ( + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_iObjective", + PropColumn { + data: Some(I32(vec![ + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(1), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(1), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(1), + Some(0), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_vRagdollServerOrigin() { + let prop = ( + "CCSPlayerPawn.m_vRagdollServerOrigin", + PropColumn { + data: Some(XYZVec(vec![ + None, + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + None, + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([-1187.1215, -391.00195, -55.96875]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([-687.58527, -1591.4546, -167.96875]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([-613.96985, -1326.2135, -167.96875]), + Some([0.0, 0.0, 0.0]), + Some([-146.60188, -1949.172, -167.96875]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_nEnablePhysics() { + let prop = ( + "m_nEnablePhysics", + PropColumn { + data: Some(U32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(0), + None, + None, + None, + None, + None, + None, + Some(0), + None, + None, + None, + None, + None, + None, + Some(0), + Some(0), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_nCollisionFunctionMask() { + let prop = ( + "CCSPlayerPawn.m_nCollisionFunctionMask", + PropColumn { + data: Some(U32(vec![ + None, + Some(55), + Some(55), + Some(55), + Some(55), + Some(55), + Some(55), + Some(55), + Some(55), + None, + Some(55), + Some(55), + Some(55), + Some(55), + Some(61), + Some(55), + Some(55), + Some(55), + Some(55), + Some(55), + Some(55), + Some(55), + Some(61), + Some(55), + Some(55), + Some(61), + Some(55), + Some(61), + Some(55), + Some(55), + Some(55), + Some(55), + Some(55), + Some(55), + Some(55), + Some(55), + Some(55), + Some(55), + Some(55), + Some(55), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_bInReload() { + let prop = ( + "m_bInReload", + PropColumn { + data: Some(Bool(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(false), + None, + None, + Some(false), + None, + Some(false), + Some(false), + Some(false), + None, + None, + Some(false), + Some(true), + None, + None, + None, + None, + Some(false), + None, + Some(false), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_iHealth() { + let prop = ( + "CCSPlayerPawn.m_iHealth", + PropColumn { + data: Some(I32(vec![ + Some(100), + Some(100), + Some(100), + Some(100), + Some(100), + Some(100), + Some(100), + Some(100), + Some(100), + None, + Some(48), + Some(100), + Some(100), + Some(1), + Some(0), + Some(100), + Some(100), + Some(74), + Some(29), + Some(100), + Some(100), + Some(100), + Some(0), + Some(48), + Some(20), + Some(0), + Some(100), + Some(0), + Some(50), + Some(77), + Some(100), + Some(100), + Some(100), + Some(100), + Some(100), + Some(100), + Some(100), + Some(100), + Some(100), + Some(100), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_nHierarchyId() { + let prop = ( + "CCSPlayerPawn.m_nHierarchyId", + PropColumn { + data: Some(U32(vec![ + Some(104), + Some(109), + Some(114), + Some(119), + None, + Some(134), + Some(141), + Some(159), + Some(202), + Some(226), + Some(104), + Some(109), + Some(114), + Some(119), + None, + Some(134), + Some(141), + Some(159), + Some(202), + Some(226), + Some(104), + Some(109), + Some(114), + Some(119), + None, + Some(134), + Some(141), + Some(159), + Some(202), + Some(226), + Some(104), + Some(109), + Some(114), + Some(119), + None, + Some(134), + Some(141), + Some(159), + Some(202), + Some(226), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_MoveType() { + let prop = ( + "CCSPlayerPawn.m_MoveType", + PropColumn { + data: Some(U64(vec![ + None, + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + None, + Some(2), + Some(2), + Some(2), + Some(2), + Some(0), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(0), + Some(2), + Some(2), + Some(0), + Some(2), + Some(0), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_MovementServices_m_nButtonDownMaskPrev() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_MovementServices.m_nButtonDownMaskPrev", + PropColumn { + data: Some(U64(vec![ + Some(0), + Some(0), + Some(8589934592), + Some(34359738384), + Some(8589934600), + Some(8589934600), + Some(8589934592), + Some(8), + Some(8589934592), + Some(0), + Some(66560), + Some(512), + Some(66560), + Some(66048), + Some(0), + Some(66560), + Some(12), + Some(8589934592), + Some(512), + Some(1024), + Some(512), + Some(524), + Some(2), + Some(1024), + Some(1026), + Some(0), + Some(65536), + Some(2), + Some(1025), + Some(65536), + Some(0), + Some(0), + Some(8589934592), + Some(0), + Some(8589934592), + Some(8), + Some(0), + Some(8), + Some(0), + Some(0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_nInteractsAs() { + let prop = ( + "m_nInteractsAs", + PropColumn { + data: Some(U64(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(131265), + None, + None, + None, + None, + None, + None, + Some(131265), + None, + None, + None, + None, + None, + None, + Some(131265), + Some(131265), + None, + None, + None, + None, + None, + None, + None, + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_nRoundsPlayedThisPhase() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_nRoundsPlayedThisPhase", + PropColumn { + data: Some(I32(vec![ + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(2), + Some(4), + Some(4), + Some(4), + Some(4), + Some(4), + Some(4), + Some(4), + Some(4), + Some(4), + Some(4), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + Some(6), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_m_nPawnCharacterDefIndex() { + let prop = ( + "CCSPlayerController.m_nPawnCharacterDefIndex", + PropColumn { + data: Some(U32(vec![ + Some(5036), + Some(5037), + Some(5036), + Some(5036), + Some(5037), + Some(5037), + Some(5037), + Some(5036), + Some(5037), + Some(5036), + Some(5036), + Some(5037), + Some(5036), + Some(5036), + Some(5037), + Some(5037), + Some(5037), + Some(5036), + Some(5037), + Some(5036), + Some(5036), + Some(5037), + Some(5036), + Some(5036), + Some(5037), + Some(5037), + Some(5037), + Some(5036), + Some(5037), + Some(5036), + Some(5036), + Some(5037), + Some(5036), + Some(5036), + Some(5037), + Some(5037), + Some(5037), + Some(5036), + Some(5037), + Some(5036), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_pReserveAmmo() { + let prop = ( + "m_pReserveAmmo", + PropColumn { + data: Some(I32(vec![ + Some(1), + Some(1), + Some(0), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(1), + Some(0), + Some(0), + Some(0), + Some(81), + None, + Some(0), + Some(63), + Some(0), + Some(81), + Some(81), + Some(60), + Some(0), + None, + Some(0), + Some(0), + None, + Some(1), + None, + Some(0), + Some(90), + Some(0), + Some(80), + Some(0), + Some(1), + Some(1), + Some(0), + Some(1), + Some(1), + Some(0), + Some(1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_aimPunchTickFraction() { + let prop = ( + "CCSPlayerPawn.m_aimPunchTickFraction", + PropColumn { + data: Some(F32(vec![ + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + None, + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.9446808), + None, + Some(0.6961353), + Some(0.0), + Some(0.0), + Some(0.56849414), + Some(0.6000004), + Some(0.0), + Some(0.64061844), + Some(0.98652405), + Some(0.6779499), + Some(0.0), + Some(0.47893262), + Some(0.0), + Some(0.48510334), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + Some(0.0), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CBodyComponentBaseAnimGraph_m_nRandomSeedOffset() { + let prop = ( + "CBodyComponentBaseAnimGraph.m_nRandomSeedOffset", + PropColumn { + data: Some(I32(vec![ + Some(23958827), + Some(94238205), + Some(821912157), + Some(-974379763), + Some(-529426837), + Some(-265493256), + Some(-706971072), + Some(19183598), + Some(-826435715), + Some(739735424), + Some(-318294761), + Some(259269252), + Some(368845761), + Some(-518486264), + None, + Some(550904609), + Some(68704265), + Some(636426175), + Some(330607055), + Some(-966642112), + Some(-318294761), + Some(-881717410), + None, + Some(368845761), + Some(-521444696), + None, + Some(-158322847), + None, + Some(-183492278), + Some(-966642112), + Some(149183010), + Some(-98125674), + Some(-818501016), + Some(-32576437), + Some(-3691338), + Some(898728176), + Some(-655850456), + Some(1013750409), + Some(-537760741), + Some(817940211), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_fFlags() { + let prop = ( + "CCSPlayerPawn.m_fFlags", + PropColumn { + data: Some(U32(vec![ + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65664), + Some(65665), + Some(65665), + Some(536936577), + Some(65665), + Some(65667), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(536936577), + Some(65665), + Some(65664), + Some(536936577), + Some(65665), + Some(536936577), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + Some(65665), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_CCSPlayer_WeaponServices_m_iAmmo() { + let prop = ( + "CCSPlayerPawn.CCSPlayer_WeaponServices.m_iAmmo", + PropColumn { + data: Some(U32(vec![ + Some(2), + Some(0), + None, + Some(1), + Some(0), + None, + Some(0), + Some(1), + None, + Some(0), + Some(2), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(2), + Some(0), + Some(1), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(0), + Some(2), + Some(0), + Some(0), + Some(1), + Some(0), + Some(0), + Some(0), + Some(1), + Some(0), + Some(1), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_bWaitForNoAttack() { + let prop = ( + "CCSPlayerPawn.m_bWaitForNoAttack", + PropColumn { + data: Some(Bool(vec![ + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_vHeadConstraintOffset() { + let prop = ( + "CCSPlayerPawn.m_vHeadConstraintOffset", + PropColumn { + data: Some(XYZVec(vec![ + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + None, + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + Some([0.0, 0.0, 0.0]), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerController_CCSPlayerController_InventoryServices_m_rank() { + let prop = ( + "CCSPlayerController.CCSPlayerController_InventoryServices.m_rank", + PropColumn { + data: Some(U64(vec![ + None, + Some(996), + Some(1339), + None, + Some(996), + Some(1030), + Some(923), + Some(969), + None, + Some(1340), + None, + Some(996), + Some(1339), + None, + Some(996), + Some(1030), + Some(923), + Some(969), + None, + Some(1340), + None, + Some(996), + Some(1339), + None, + Some(996), + Some(1030), + Some(923), + Some(969), + None, + Some(1340), + None, + Some(996), + Some(1339), + None, + Some(996), + Some(1030), + Some(923), + Some(969), + None, + Some(1340), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_bWarmupPeriod() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_bWarmupPeriod", + PropColumn { + data: Some(Bool(vec![ + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn m_iClip1() { + let prop = ( + "m_iClip1", + PropColumn { + data: Some(U32(vec![ + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + None, + Some(30), + None, + Some(30), + None, + Some(30), + Some(30), + None, + Some(25), + Some(8), + Some(16), + None, + None, + Some(19), + Some(0), + None, + None, + None, + Some(9), + Some(7), + None, + Some(20), + None, + None, + None, + None, + None, + None, + Some(12), + None, + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_bTeamIntroPeriod() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_bTeamIntroPeriod", + PropColumn { + data: Some(Bool(vec![ + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSPlayerPawn_m_unCurrentEquipmentValue() { + let prop = ( + "CCSPlayerPawn.m_unCurrentEquipmentValue", + PropColumn { + data: Some(U32(vec![ + Some(2400), + Some(200), + Some(700), + Some(4200), + Some(200), + Some(200), + Some(200), + Some(4200), + Some(200), + Some(1000), + Some(4300), + Some(5900), + Some(5100), + Some(2750), + Some(5600), + Some(5300), + Some(5700), + Some(1950), + Some(4200), + Some(3100), + Some(5100), + Some(700), + Some(5100), + Some(5100), + Some(4100), + Some(4100), + Some(4450), + Some(2600), + Some(300), + Some(4200), + Some(5000), + Some(3100), + Some(3900), + Some(5100), + Some(3100), + Some(5300), + Some(200), + Some(6950), + Some(200), + Some(5500), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } + #[test] + fn CCSGameRulesProxy_CCSGameRules_m_bGameRestart() { + let prop = ( + "CCSGameRulesProxy.CCSGameRules.m_bGameRestart", + PropColumn { + data: Some(Bool(vec![ + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + Some(false), + ])), + num_nones: 0, + }, + ); + let prop_id = out.1.name_to_id[prop.0]; + assert_eq!(out.0.df[&prop_id], prop.1); + } +} diff --git a/src/parser/src/entities.rs b/src/parser/src/entities.rs index 97a77672..ab78ef70 100644 --- a/src/parser/src/entities.rs +++ b/src/parser/src/entities.rs @@ -127,6 +127,9 @@ impl<'a> ParserThread<'a> { }; let result = ParserThread::decode(bitreader, decoder, &self.qf_mapper)?; if self.is_debug_mode { + if let Field::Value(v) = f { + self.game_events_counter.insert(v.full_name.to_string()); + } ParserThread::debug_inspect(&result, f); } ParserThread::insert_field(entity, result, field_info); @@ -137,7 +140,9 @@ impl<'a> ParserThread<'a> { Ok(bitreader.decode(&decoder, &qf_map)?) } pub fn debug_inspect(result: &Variant, field: &Field) { - if let Field::Value(v) = field {} + if let Field::Value(v) = field { + // println!("{:?} {:?}", v.full_name, result); + } } pub fn insert_field(entity: &mut Entity, result: Variant, field_info: Option) { if let Some(fi) = field_info { diff --git a/src/parser/src/lib.rs b/src/parser/src/lib.rs index fed1cbc3..12e0e5b8 100644 --- a/src/parser/src/lib.rs +++ b/src/parser/src/lib.rs @@ -1,5 +1,6 @@ pub mod collect_data; pub mod decoder; +pub mod e2e_test; pub mod entities; pub mod entities_utils; pub mod fallbackbytes; diff --git a/src/parser/src/main.rs b/src/parser/src/main.rs index 9eddb90b..af56b317 100644 --- a/src/parser/src/main.rs +++ b/src/parser/src/main.rs @@ -1,12 +1,12 @@ use ahash::AHashMap; use memmap2::MmapOptions; +use parser::e2e_test; use parser::parser_settings::Parser; use parser::parser_settings::ParserInputs; use parser::parser_thread_settings::create_huffman_lookup_table; use std::fs; use std::fs::File; use std::time::Instant; - /* use mimalloc::MiMalloc; #[global_allocator] @@ -21,8 +21,14 @@ use std::alloc::System; #[global_allocator] static GLOBAL: &StatsAlloc = &INSTRUMENTED_SYSTEM; */ + +fn main() { + e2e_test::create_tests(); +} + +/* fn main() { - let wanted_props = vec!["X".to_string()]; + let wanted_props = vec!["yaw".to_string()]; let before = Instant::now(); let dir = fs::read_dir("/home/laiho/Documents/demos/cs2/pov/").unwrap(); let mut c = 0; @@ -51,8 +57,8 @@ fn main() { real_name_to_og_name: AHashMap::default(), wanted_player_props: wanted_props.clone(), wanted_player_props_og_names: wanted_props.clone(), - wanted_events: vec!["player_death".to_string()], - // wanted_events: vec![], + //wanted_events: vec!["player_death".to_string()], + wanted_events: vec![], wanted_other_props: vec![ "CCSTeam.m_iScore".to_string(), "CCSTeam.m_szTeamname".to_string(), @@ -73,16 +79,23 @@ fn main() { }; let mut ds = Parser::new(&settings); - ds.is_multithreadable = true; - // let file = File::open("/home/laiho/Documents/programming/python/map/1.dem").unwrap(); - let file = File::open(path.unwrap().path()).unwrap(); + ds.is_multithreadable = false; + + let file = File::open("/home/laiho/Documents/programming/rust/csnew2/demoparser/test_demo.dem").unwrap(); + // let file = File::open(path.unwrap().path()).unwrap(); let mmap = unsafe { MmapOptions::new().map(&file).unwrap() }; total += mmap.len(); mmap.advise(memmap2::Advice::HugePage).unwrap(); - let _d = ds.parse_demo(&mmap).unwrap(); - // println!("{:?}", d.df); + let d = ds.parse_demo(&mmap).unwrap(); + let mut s: Vec<&String> = d.game_events_counter.iter().collect(); + s.sort(); + + for x in s { + println!("{:?}", x); + } + println!("{:?}", d.df[&2]); println!("TOTAL {:?}", before.elapsed()); } println!("TOTAL {:?}", before.elapsed().as_millis()); @@ -92,3 +105,4 @@ fn main() { // println!("GB/S {:?}", x / 1_000_000_000.0); } +*/ diff --git a/src/parser/src/maps.rs b/src/parser/src/maps.rs index affd9c4a..a14591bc 100644 --- a/src/parser/src/maps.rs +++ b/src/parser/src/maps.rs @@ -1755,6 +1755,12 @@ pub static TYPEHM: phf::Map<&'static str, PropType> = phf_map! { "CCSPlayerController.m_iszPlayerName" => PropType::Controller, "CCSPlayerController.m_steamID" => PropType::Controller, "CCSPlayerController.m_iDesiredFOV" => PropType::Controller, + // new + "CCSPlayerController.CCSPlayerController_ActionTrackingServices.m_unTotalRoundDamageDealt" => PropType::Controller, + "CCSPlayerController.m_bPawnIsAlive" => PropType::Controller, + "CCSPlayerController.m_nPawnCharacterDefIndex" => PropType::Controller, + + "CCSPlayerController.CCSPlayerController_InGameMoneyServices.m_iAccount" => PropType::Controller, "CCSPlayerController.CCSPlayerController_InGameMoneyServices.m_iStartAccount" => PropType::Controller, "CCSPlayerController.CCSPlayerController_InGameMoneyServices.m_iTotalCashSpent" => PropType::Controller, @@ -1897,6 +1903,72 @@ pub static TYPEHM: phf::Map<&'static str, PropType> = phf_map! { "CCSPlayerPawn.m_lifeState" => PropType::Player, "CCSPlayerPawn.m_flLowerBodyYawTarget" => PropType::Player, "CCSPlayerPawn.m_flDeathTime" => PropType::Player, + // New + "CCSPlayerPawn.m_thirdPersonHeading" => PropType::Player, + "CCSPlayerPawn.m_flSlopeDropOffset" => PropType::Player, + "CCSPlayerPawn.m_flSlopeDropHeight" => PropType::Player, + "CCSPlayerPawn.m_vHeadConstraintOffset" => PropType::Player, + "CCSPlayerPawn.m_angEyeAngles" => PropType::Player, + "CCSPlayerPawn.m_fFlags" => PropType::Player, + "CCSPlayerPawn.m_hGroundEntity" => PropType::Player, + "CCSPlayerPawn.CBodyComponentBaseAnimGraph.m_flLastTeleportTime" => PropType::Player, + "CCSPlayerPawn.m_flCreateTime" => PropType::Player, + "CCSPlayerPawn.m_bClientSideRagdoll" => PropType::Player, + "CCSPlayerPawn.m_ubInterpolationFrame" => PropType::Player, + "CCSPlayerPawn.m_nInteractsAs" => PropType::Player, + "CCSPlayerPawn.m_nInteractsWith" => PropType::Player, + "CCSPlayerPawn.m_nInteractsExclude" => PropType::Player, + "CCSPlayerPawn.m_nEntityId" => PropType::Player, + "CCSPlayerPawn.m_nHierarchyId" => PropType::Player, + "CCSPlayerPawn.m_nCollisionFunctionMask" => PropType::Player, + "CCSPlayerPawn.m_vecMaxs" => PropType::Player, + + "CCSPlayerPawn.m_nEnablePhysics" => PropType::Player, + "CCSPlayerPawn.m_nAddDecal" => PropType::Player, + + "CCSPlayerPawn.m_vDecalPosition" => PropType::Player, + "CCSPlayerPawn.m_vDecalForwardAxis" => PropType::Player, + "CCSPlayerPawn.m_vecForce" => PropType::Player, + "CCSPlayerPawn.m_nForceBone" => PropType::Player, + "CCSPlayerPawn.m_bClientRagdoll" => PropType::Player, + "CCSPlayerPawn.CCSPlayer_MovementServices.m_arrForceSubtickMoveWhen" => PropType::Player, + "CCSPlayerPawn.CCSPlayer_MovementServices.m_vecLadderNormal" => PropType::Player, + "CCSPlayerPawn.CCSPlayer_MovementServices.m_nLadderSurfacePropIndex" => PropType::Player, + + "CCSPlayerPawn.CCSPlayer_MovementServices.m_bDesiresDuck" => PropType::Player, + "CCSPlayerPawn.CCSPlayer_MovementServices.m_fStashGrenadeParameterWhen" => PropType::Player, + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flOffsetTickCompleteTime" => PropType::Player, + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flOffsetTickStashedSpeed" => PropType::Player, + "CCSPlayerPawn.CCSPlayer_MovementServices.m_flStamina" => PropType::Player, + "CCSPlayerPawn.m_flEmitSoundTime" => PropType::Player, + "CCSPlayerPawn.m_flHitHeading" => PropType::Player, + "CCSPlayerPawn.m_nHitBodyPart" => PropType::Player, + "CCSPlayerPawn.m_flProgressBarStartTime" => PropType::Player, + "CCSPlayerPawn.m_iProgressBarDuration" => PropType::Player, + "CCSPlayerPawn.m_nLastKillerIndex" => PropType::Player, + "CCSPlayerPawn.m_nLastConcurrentKilled" => PropType::Player, + "CCSPlayerPawn.m_unFreezetimeEndEquipmentValue" => PropType::Player, + "CCSPlayerPawn.m_bKilledByHeadshot" => PropType::Player, + "CCSPlayerPawn.CCSPlayer_BulletServices.m_totalHitsOnServer" => PropType::Player, + + "CCSPlayerPawn.m_aimPunchAngle" => PropType::Player, + "CCSPlayerPawn.m_aimPunchAngleVel"=> PropType::Player, + "CCSPlayerPawn.m_aimPunchTickBase"=> PropType::Player, + "CCSPlayerPawn.m_aimPunchTickFraction"=> PropType::Player, + "CCSPlayerPawn.m_bIsBuyMenuOpen" => PropType::Player, + "CCSPlayerPawn.m_nRagdollDamageBone" => PropType::Player, + "CCSPlayerPawn.m_vRagdollDamageForce" => PropType::Player, + "CCSPlayerPawn.m_vRagdollDamagePosition"=> PropType::Player, + "CCSPlayerPawn.m_szRagdollDamageWeaponName"=> PropType::Player, + "CCSPlayerPawn.m_bRagdollDamageHeadshot"=> PropType::Player, + "CCSPlayerPawn.m_vRagdollServerOrigin"=> PropType::Player, + "CCSPlayerPawn.m_qDeathEyeAngles"=> PropType::Player, + // "CCSPlayerPawn.ViewAngleServerChange_t.nType" => PropType::Player, + // "CCSPlayerPawn.m_vecMaxs" => PropType::Player, + // "CCSPlayerPawn.m_vecMaxs" => PropType::Player, + + + // Custom "X"=> PropType::Custom, "user_id"=> PropType::Custom, @@ -2095,6 +2167,23 @@ pub static TYPEHM: phf::Map<&'static str, PropType> = phf_map! { "m_iClip2"=> PropType::Weapon, "m_pReserveAmmo"=> PropType::Weapon, "m_nViewModelIndex"=> PropType::Weapon, + // new + "m_nDropTick"=> PropType::Weapon, + //"m_nViewModelIndex"=> PropType::Weapon, + //"m_nViewModelIndex"=> PropType::Weapon, + //"m_nViewModelIndex"=> PropType::Weapon, + //"m_nViewModelIndex"=> PropType::Weapon, + //"m_nViewModelIndex"=> PropType::Weapon, + //"m_nViewModelIndex"=> PropType::Weapon, + //"m_nViewModelIndex"=> PropType::Weapon, + //"m_nViewModelIndex"=> PropType::Weapon, + //"m_nViewModelIndex"=> PropType::Weapon, + //"m_nViewModelIndex"=> PropType::Weapon, + //"m_nViewModelIndex"=> PropType::Weapon, + //"m_nViewModelIndex"=> PropType::Weapon, + //"m_nViewModelIndex"=> PropType::Weapon, + + }; diff --git a/src/parser/src/parser.rs b/src/parser/src/parser.rs index 56c9ec11..215848e1 100644 --- a/src/parser/src/parser.rs +++ b/src/parser/src/parser.rs @@ -8,6 +8,7 @@ use crate::parser_settings::ParserInputs; use crate::parser_thread_settings::*; use crate::parser_threads::demo_cmd_type_from_int; use crate::prop_controller::PropController; +use crate::prop_controller::TICK_ID; use crate::read_bits::Bitreader; use crate::read_bytes::read_varint; use crate::read_bytes::ProtoPacketParser; @@ -57,7 +58,6 @@ impl<'a> Parser<'a> { self.ptr = 16; let mut sendtable = None; let mut buf = vec![0_u8; 100_000]; - let mut biggest = 0; loop { let frame_starts_at = self.ptr; @@ -66,8 +66,6 @@ impl<'a> Parser<'a> { let tick = read_varint(outer_bytes, &mut self.ptr)?; let size = read_varint(outer_bytes, &mut self.ptr)?; - biggest = u32::max(size, biggest); - self.tick = tick as i32; // Safety check if self.ptr + size as usize >= outer_bytes.len() { @@ -168,7 +166,11 @@ impl<'a> Parser<'a> { self.wanted_player_props.retain(|x| x != prop); self.prop_controller.prop_infos.retain(|x| &x.prop_name != prop); } - return Ok(self.combine_thread_outputs(&mut vec![x])); + let mut outputs = self.combine_thread_outputs(&mut vec![x]); + if let Some(new_df) = self.rm_unwanted_ticks(&mut outputs.df) { + outputs.df = new_df; + } + Ok(outputs) } fn parse_demo_multithread(&mut self, outer_bytes: &[u8]) -> Result { let outputs: Vec> = self @@ -194,8 +196,40 @@ impl<'a> Parser<'a> { self.wanted_player_props.retain(|x| x != prop); self.prop_controller.prop_infos.retain(|x| &x.prop_name != prop); } - Ok(self.combine_thread_outputs(&mut ok)) + let mut outputs = self.combine_thread_outputs(&mut ok); + if let Some(new_df) = self.rm_unwanted_ticks(&mut outputs.df) { + outputs.df = new_df; + } + Ok(outputs) + } + fn rm_unwanted_ticks(&self, hm: &mut AHashMap) -> Option> { + // Used for removing ticks when velocity is needed + if self.wanted_ticks.is_empty() { + return None; + } + + let mut wanted_indicies = vec![]; + + if let Some(ticks) = hm.get(&TICK_ID) { + if let Some(crate::variants::VarVec::I32(t)) = &ticks.data { + for (idx, val) in t.iter().enumerate() { + if let Some(tick) = val { + if self.wanted_ticks.contains(tick) { + wanted_indicies.push(idx); + } + } + } + } + } + let mut new_df = AHashMap::default(); + for (k, v) in hm { + if let Some(new) = v.slice_to_new(&wanted_indicies) { + new_df.insert(*k, new); + } + } + Some(new_df) } + /* fn parse_demo_multithread_no_rayon(&mut self, outer_bytes: &[u8]) -> Result { use std::thread; diff --git a/src/parser/src/parser_settings.rs b/src/parser/src/parser_settings.rs index b7e02dff..d728aa20 100644 --- a/src/parser/src/parser_settings.rs +++ b/src/parser/src/parser_settings.rs @@ -88,6 +88,8 @@ pub struct Parser<'a> { pub header: AHashMap, pub threads_spawned: u32, pub is_multithreadable: bool, + + pub needs_velocity: bool, } pub fn needs_velocity(props: &[String]) -> bool { for prop in props { @@ -101,6 +103,7 @@ pub fn needs_velocity(props: &[String]) -> bool { impl<'a> Parser<'a> { pub fn new(inputs: &'a ParserInputs<'a>) -> Self { Parser { + needs_velocity: false, added_temp_props: vec![], threads_spawned: 0, is_multithreadable: check_multithreadability(&inputs.wanted_player_props), @@ -115,6 +118,7 @@ impl<'a> Parser<'a> { inputs.wanted_player_props.clone(), inputs.wanted_other_props.clone(), inputs.real_name_to_og_name.clone(), + false, ), prop_controller_is_set: false, cls_by_id: None, diff --git a/src/parser/src/parser_thread_settings.rs b/src/parser/src/parser_thread_settings.rs index 35513c4b..d15e93bb 100644 --- a/src/parser/src/parser_thread_settings.rs +++ b/src/parser/src/parser_thread_settings.rs @@ -135,7 +135,7 @@ impl<'a> ParserThread<'a> { header: None, player_md: self.player_end_data, game_events_counter: self.game_events_counter, - prop_info: PropController::new(vec![], vec![], AHashMap::default()), + prop_info: PropController::new(vec![], vec![], AHashMap::default(), false), projectiles: self.projectile_records, ptr: self.ptr, } diff --git a/src/parser/src/parser_threads.rs b/src/parser/src/parser_threads.rs index d28cc860..eb423e7a 100644 --- a/src/parser/src/parser_threads.rs +++ b/src/parser/src/parser_threads.rs @@ -24,8 +24,10 @@ impl<'a> ParserThread<'a> { loop { let cmd = read_varint(outer_bytes, &mut self.ptr)?; let tick = read_varint(outer_bytes, &mut self.ptr)?; + let size = read_varint(outer_bytes, &mut self.ptr)?; self.tick = tick as i32; + // Safety check if self.ptr + size as usize >= outer_bytes.len() { break; diff --git a/src/parser/src/prop_controller.rs b/src/parser/src/prop_controller.rs index ec2cb032..64000070 100644 --- a/src/parser/src/prop_controller.rs +++ b/src/parser/src/prop_controller.rs @@ -7,18 +7,8 @@ use crate::sendtables::Serializer; use crate::sendtables::ValueField; use ahash::AHashMap; -const WEAPON_NAME_ID: u32 = 1; -const YAW_ID: u32 = 2; -const PITCH_ID: u32 = 3; -pub const TICK_ID: u32 = 4; -pub const STEAMID_ID: u32 = 5; -const NAME_ID: u32 = 6; -pub const PLAYER_X_ID: u32 = 7; -pub const PLAYER_Y_ID: u32 = 8; -pub const PLAYER_Z_ID: u32 = 9; -const BUTTONS_BASEID: u32 = 100000; -const NORMAL_PROP_BASEID: u32 = 1000; - +pub const BUTTONS_BASEID: u32 = 100000; +pub const NORMAL_PROP_BASEID: u32 = 1000; pub const WEAPON_SKIN_ID: u32 = 420420420; pub const WEAPON_ORIGINGAL_OWNER_ID: u32 = 6942000; pub const MY_WEAPONS_OFFSET: u32 = 500000; @@ -32,8 +22,16 @@ pub const VELOCITY_Y_ID: u32 = 100000005; pub const VELOCITY_Z_ID: u32 = 100000006; pub const VELOCITY_ID: u32 = 100000007; pub const USERID_ID: u32 = 100000008; - pub const AGENT_SKIN_ID: u32 = 100000009; +pub const WEAPON_NAME_ID: u32 = 100000010; +pub const YAW_ID: u32 = 100000111; +pub const PITCH_ID: u32 = 100000012; +pub const TICK_ID: u32 = 100000013; +pub const STEAMID_ID: u32 = 100000014; +pub const NAME_ID: u32 = 100000015; +pub const PLAYER_X_ID: u32 = 100000016; +pub const PLAYER_Y_ID: u32 = 100000017; +pub const PLAYER_Z_ID: u32 = 100000018; #[derive(Clone, Debug)] pub struct PropController { @@ -48,6 +46,7 @@ pub struct PropController { pub name_to_special_id: AHashMap, pub wanted_other_props: Vec, pub event_with_velocity: bool, + pub needs_velocity: bool, pub path_to_name: AHashMap<[i32; 7], String>, } @@ -71,6 +70,7 @@ impl PropController { wanted_player_props: Vec, wanted_other_props: Vec, real_name_to_og_name: AHashMap, + needs_velocty: bool, ) -> Self { PropController { id: NORMAL_PROP_BASEID, @@ -85,6 +85,7 @@ impl PropController { real_name_to_og_name: real_name_to_og_name, event_with_velocity: false, path_to_name: AHashMap::default(), + needs_velocity: needs_velocty, } } pub fn set_custom_propinfos(&mut self) { @@ -309,13 +310,13 @@ impl PropController { // are the "same" prop. (they have same path and we want to refer to it with one id not ~20) Some(id) => { f.prop_id = *id as u32; - // self.id_to_name.insert(*id, weap_prop.to_string()); + self.id_to_name.insert(*id, weap_prop.to_string()); self.set_special_ids(&weap_prop, is_grenade_or_weapon, *id); return; } None => { self.name_to_id.insert(weap_prop.to_string(), self.id); - // self.id_to_name.insert(self.id, weap_prop.to_string()); + self.id_to_name.insert(self.id, weap_prop.to_string()); f.prop_id = self.id as u32; self.set_special_ids(&weap_prop, is_grenade_or_weapon, self.id); } @@ -353,6 +354,7 @@ impl PropController { } } pub fn handle_prop(&mut self, full_name: &str, f: &mut ValueField, path: Vec) { + f.full_name = full_name.to_string(); // CAK47.m_iClip1 => ["CAK47", "m_iClip1"] let split_at_dot: Vec<&str> = full_name.split(".").collect(); let is_weapon_prop = (split_at_dot[0].contains("Weapon") || split_at_dot[0].contains("AK")) @@ -397,55 +399,6 @@ impl PropController { self.id += 1; } - fn should_parse(&self, name: &str) -> bool { - if self.wanted_player_props.contains(&"X".to_string()) - || self.wanted_player_props.contains(&"Y".to_string()) - || self.wanted_player_props.contains(&"Z".to_string()) - { - if name.contains("cell") || name.contains("m_vec") { - return true; - } - } - if self.wanted_other_props.contains(&name.to_string()) { - return true; - } - - let always_parse = vec![ - "m_nOwnerId", - "m_iItemDefinitionIndex", - "CCSPlayerPawn.CCSPlayer_MovementServices.m_nButtonDownMaskPrev", - "CCSPlayerPawn.CCSPlayer_WeaponServices.m_hActiveWeapon", - "CCSPlayerPawn.m_iTeamNum", - "CBasePlayerWeapon.m_nOwnerId", - ]; - if self.wanted_player_props.contains(&("yaw").to_string()) - || self.wanted_player_props.contains(&("pitch").to_string()) && name == "CCSPlayerPawn.m_angEyeAngles" - { - return true; - } - if always_parse.contains(&name) { - return true; - } - match TYPEHM.get(name) { - _ => {} - }; - if name.contains("CCSTeam.m_iTeamNum") - || name.contains("CCSPlayerPawn.m_iTeamNum") - || name.contains("CCSPlayerController") - || name.contains("m_hActiveWeapon") - || name.contains("Weapons") - || name.contains("OriginalOwnerXuid") - || name.contains("Flash") - || name.contains("m_lifeState") - || name.contains("m_hMyWeapons") - { - return true; - } - if self.wanted_player_props.contains(&name.to_owned()) { - return true; - } - false - } fn set_special_ids(&mut self, name: &str, is_grenade_or_weapon: bool, id: u32) { if is_grenade_or_weapon { match name { diff --git a/src/parser/src/sendtables.rs b/src/parser/src/sendtables.rs index 7cb44b22..30d83deb 100644 --- a/src/parser/src/sendtables.rs +++ b/src/parser/src/sendtables.rs @@ -76,6 +76,7 @@ impl<'a> Parser<'a> { self.wanted_player_props.clone(), self.wanted_other_props.clone(), self.real_name_to_og_name.clone(), + needs_velocity(&self.wanted_player_props), ); // Quantalized floats have their own helper struct let mut qf_mapper = QfMapper { @@ -270,6 +271,7 @@ pub struct ValueField { pub name: String, pub should_parse: bool, pub prop_id: u32, + pub full_name: String, // pub path: Vec, } #[derive(Debug, Clone)] @@ -318,6 +320,7 @@ impl ValueField { name: name.to_string(), prop_id: 0, should_parse: false, + full_name: "None ".to_string() + name, } } } diff --git a/src/parser/src/variants.rs b/src/parser/src/variants.rs index 809a57de..437cbc96 100644 --- a/src/parser/src/variants.rs +++ b/src/parser/src/variants.rs @@ -25,7 +25,7 @@ pub enum Variant { None, } -#[derive(Debug, Clone)] +#[derive(Debug, Clone, PartialEq)] pub enum VarVec { U32(Vec>), Bool(Vec>), @@ -35,6 +35,8 @@ pub enum VarVec { String(Vec>), StringVec(Vec>), U64Vec(Vec>), + XYVec(Vec>), + XYZVec(Vec>), } impl VarVec { @@ -48,16 +50,19 @@ impl VarVec { Variant::U32(_) => VarVec::U32(vec![]), Variant::StringVec(_) => VarVec::StringVec(vec![]), Variant::U64Vec(_) => VarVec::U64Vec(vec![]), + Variant::VecXY(_) => VarVec::XYVec(vec![]), + Variant::VecXYZ(_) => VarVec::XYZVec(vec![]), _ => panic!("Tried to create propcolumns from: {:?}", item), } } } -#[derive(Debug, Clone)] +#[derive(Debug, Clone, PartialEq)] pub struct PropColumn { pub data: Option, - num_nones: usize, + pub num_nones: usize, } + impl PropColumn { pub fn new() -> Self { PropColumn { @@ -65,7 +70,30 @@ impl PropColumn { num_nones: 0, } } - + pub fn slice_to_new(&self, indicies: &[usize]) -> Option { + let data = match &self.data { + Some(VarVec::Bool(b)) => VarVec::Bool(indicies.iter().map(|x| b[*x]).collect_vec()), + Some(VarVec::I32(b)) => VarVec::I32(indicies.iter().map(|x| b[*x]).collect_vec()), + Some(VarVec::F32(b)) => VarVec::F32(indicies.iter().map(|x| b[*x]).collect_vec()), + Some(VarVec::String(b)) => VarVec::String(indicies.iter().map(|x| b[*x].to_owned()).collect_vec()), + Some(VarVec::U32(b)) => VarVec::U32(indicies.iter().map(|x| b[*x]).collect_vec()), + Some(VarVec::U64(b)) => VarVec::U64(indicies.iter().map(|x| b[*x]).collect_vec()), + Some(VarVec::StringVec(b)) => VarVec::StringVec(indicies.iter().map(|x| b[*x].to_owned()).collect_vec()), + Some(VarVec::U64Vec(b)) => VarVec::U64Vec(indicies.iter().map(|x| b[*x].to_owned()).collect_vec()), + Some(VarVec::XYVec(b)) => VarVec::XYVec(indicies.iter().map(|x| b[*x]).collect_vec()), + Some(VarVec::XYZVec(b)) => VarVec::XYZVec(indicies.iter().map(|x| b[*x]).collect_vec()), + None => { + return Some(PropColumn { + data: None, + num_nones: indicies.len(), + }) + } + }; + Some(PropColumn { + data: Some(data), + num_nones: 0, + }) + } pub fn len(&self) -> usize { match &self.data { Some(VarVec::Bool(b)) => b.len(), @@ -76,6 +104,8 @@ impl PropColumn { Some(VarVec::U64(b)) => b.len(), Some(VarVec::StringVec(b)) => b.len(), Some(VarVec::U64Vec(b)) => b.len(), + Some(VarVec::XYVec(b)) => b.len(), + Some(VarVec::XYZVec(b)) => b.len(), None => self.num_nones, } } @@ -185,6 +215,32 @@ impl PropColumn { panic!("illegal 8"); } }, + Some(VarVec::XYVec(v)) => match &other.data { + Some(VarVec::XYVec(v_other)) => { + v.extend_from_slice(&v_other); + } + None => { + for _ in 0..other.num_nones { + v.push(None); + } + } + _ => { + panic!("illegal 8"); + } + }, + Some(VarVec::XYZVec(v)) => match &other.data { + Some(VarVec::XYZVec(v_other)) => { + v.extend_from_slice(&v_other); + } + None => { + for _ in 0..other.num_nones { + v.push(None); + } + } + _ => { + panic!("illegal 8"); + } + }, None => match &other.data { Some(VarVec::Bool(_inner)) => { @@ -219,6 +275,14 @@ impl PropColumn { self.resolve_vec_type(PropColumn::get_type(&other.data)); self.extend_from(other); } + Some(VarVec::XYVec(_inner)) => { + self.resolve_vec_type(PropColumn::get_type(&other.data)); + self.extend_from(other); + } + Some(VarVec::XYZVec(_inner)) => { + self.resolve_vec_type(PropColumn::get_type(&other.data)); + self.extend_from(other); + } None => { self.num_nones += other.num_nones; } @@ -236,6 +300,8 @@ impl PropColumn { Some(VarVec::U64(_)) => Some(5), Some(VarVec::StringVec(_)) => Some(6), Some(VarVec::U64Vec(_)) => Some(7), + Some(VarVec::XYVec(_)) => Some(8), + Some(VarVec::XYZVec(_)) => Some(9), None => None, } } @@ -328,6 +394,14 @@ impl VarVec { VarVec::U64Vec(f) => f.push(p), _ => {} }, + Some(Variant::VecXY(p)) => match self { + VarVec::XYVec(f) => f.push(Some(p)), + _ => {} + }, + Some(Variant::VecXYZ(p)) => match self { + VarVec::XYZVec(f) => f.push(Some(p)), + _ => {} + }, None => self.push_none(), _ => panic!("bad type for prop: {:?}", item), } @@ -342,6 +416,8 @@ impl VarVec { VarVec::Bool(f) => f.push(None), VarVec::StringVec(f) => f.push(vec![]), VarVec::U64Vec(f) => f.push(vec![]), + VarVec::XYVec(f) => f.push(None), + VarVec::XYZVec(f) => f.push(None), } } } @@ -538,6 +614,14 @@ pub fn soa_to_aos(soa: OutputSerdeHelperStruct) -> Vec hm.insert(prop_info.prop_friendly_name.clone(), Some(Variant::U64Vec(f.clone()))), None => hm.insert(prop_info.prop_friendly_name.clone(), None), }, + Some(VarVec::XYVec(val)) => match val.get(idx) { + Some(Some(f)) => hm.insert(prop_info.prop_friendly_name.clone(), Some(Variant::VecXY(f.clone()))), + _ => hm.insert(prop_info.prop_friendly_name.clone(), None), + }, + Some(VarVec::XYZVec(val)) => match val.get(idx) { + Some(Some(f)) => hm.insert(prop_info.prop_friendly_name.clone(), Some(Variant::VecXYZ(f.clone()))), + _ => hm.insert(prop_info.prop_friendly_name.clone(), None), + }, }; } } @@ -584,6 +668,12 @@ impl Serialize for OutputSerdeHelperStruct { Some(VarVec::StringVec(val)) => { map.serialize_entry(&prop_info.prop_friendly_name, val).unwrap(); } + Some(VarVec::XYVec(val)) => { + map.serialize_entry(&prop_info.prop_friendly_name, val).unwrap(); + } + Some(VarVec::XYZVec(val)) => { + map.serialize_entry(&prop_info.prop_friendly_name, val).unwrap(); + } Some(VarVec::U64Vec(val)) => { let string_sid = val .iter() diff --git a/src/parser/test_demo.dem b/src/parser/test_demo.dem new file mode 100755 index 00000000..e5cc9720 Binary files /dev/null and b/src/parser/test_demo.dem differ