From 743d5f5dc09d8a1ec1a3fde9494cd81b08a21709 Mon Sep 17 00:00:00 2001 From: Finn Hartshorn Date: Wed, 19 Aug 2026 08:36:30 +1000 Subject: [PATCH 1/7] Wholesale-copy detour-testing-framework exclusive content from original tip Files touched by neither feature/egui-overlay-plumbing nor feature/save-logging, copied verbatim from the original 36-commit feature/detour-testing-framework tip (e8ce74f) onto main. Covers the detour validation framework, openzt-instance-manager, and detour test tooling. Shared files (Cargo.lock, openzt/Cargo.toml, openzt-dll/Cargo.toml, openzt.bat, openzt/src/lib.rs, openzt-detour/src/generated.rs) are handled separately. --- .gitignore | 7 +- AGENTS.md | 623 +++++++++++++++++ CLAUDE.md | 475 +------------ Cargo.toml | 1 + config.toml | 2 +- detour.lua | 111 ++++ openzt-detour-macro/src/lib.rs | 88 +++ openzt-detour/Cargo.toml | 6 + openzt-detour/add_validation_macros.py | 166 +++++ openzt-detour/src/lib.rs | 14 +- openzt-instance-manager/README.md | 2 +- openzt-instance-manager/config.toml | 2 +- openzt-instance-manager/install.ps1 | 376 +++++++++++ openzt-instance-manager/src/bin/openzt.rs | 143 +++- openzt-instance-manager/src/client.rs | 47 +- openzt-instance-manager/src/config.rs | 2 +- openzt-instance-manager/src/docker.rs | 184 +++++- openzt-instance-manager/src/instance.rs | 54 +- openzt-instance-manager/src/lib.rs | 2 +- openzt-instance-manager/src/output.rs | 38 +- openzt-instance-manager/src/ports.rs | 8 - openzt-instance-manager/src/routes.rs | 167 ++++- openzt-instance-manager/src/state.rs | 1 + openzt-instance-manager/uninstall.ps1 | 70 ++ openzt/scripts/detour_test_automation.py | 770 ++++++++++++++++++++++ openzt/scripts/detour_test_config.toml | 17 + openzt/src/bfconfigfile.rs | 6 +- openzt/src/bfentitytype.rs | 101 +-- openzt/src/bfregistry.rs | 12 +- openzt/src/capture_ztlog.rs | 2 +- openzt/src/command_console.rs | 18 +- openzt/src/detour_validation.rs | 63 ++ openzt/src/experimental.rs | 48 +- openzt/src/integration_tests/mod.rs | 9 +- openzt/src/logging.rs | 5 + openzt/src/reimplementation_tests/mod.rs | 241 +------ openzt/src/resource_manager/hooks.rs | 76 +-- openzt/src/resource_manager/mod_config.rs | 5 +- openzt/src/roofs.rs | 11 +- openzt/src/scripting.rs | 24 + openzt/src/tui_console.rs | 5 +- openzt/src/util.rs | 2 +- openzt/src/version.rs | 4 +- openzt/src/zthabitatmgr.rs | 9 +- openzt/src/ztmapview.rs | 25 +- openzt/src/ztresearch.rs | 12 +- openzt/src/ztworldmgr.rs | 263 +------- vendor/retour-rs/src/traits.rs | 3 +- 48 files changed, 3092 insertions(+), 1228 deletions(-) create mode 100644 AGENTS.md create mode 100644 detour.lua create mode 100644 openzt-detour/add_validation_macros.py create mode 100644 openzt-instance-manager/install.ps1 create mode 100644 openzt-instance-manager/uninstall.ps1 create mode 100644 openzt/scripts/detour_test_automation.py create mode 100644 openzt/scripts/detour_test_config.toml create mode 100644 openzt/src/detour_validation.rs diff --git a/.gitignore b/.gitignore index eeaa95f..a367586 100644 --- a/.gitignore +++ b/.gitignore @@ -3,4 +3,9 @@ ._target /libs/*/target .idea -.openzt-build-state \ No newline at end of file +.openzt-build-state + +# Reverse-engineering research: decompiles, vtable docs, RE scripts. +# Backed up privately, see private/README.md - never commit to this repo. +/private/ +__pycache__/ \ No newline at end of file diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..36e1775 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,623 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## ⚠️ CRITICAL: ALWAYS USE openzt.bat (Windows) or specific cargo commands (Linux) + +**On Windows**: NEVER use `cargo` directly - ALWAYS use `./openzt.bat` for ANY cargo command (build, check, clippy, test, run, etc.). + +The project uses a specific toolchain and target configuration that is managed by `openzt.bat`. Running `cargo` directly will use the wrong toolchain/target. + +**On Linux**: Batch files do not work. Use specific cargo commands directly: +- Build: `cargo build --manifest-path openzt/Cargo.toml --lib --target=i686-pc-windows-gnu` +- Check: `cargo check --manifest-path openzt/Cargo.toml --lib --target=i686-pc-windows-gnu` +- Clippy: `cargo clippy --manifest-path openzt/Cargo.toml --lib --target=i686-pc-windows-gnu` +- Test: `cargo test --manifest-path openzt/Cargo.toml --lib --target=i686-pc-windows-gnu` + +**⚠️ CRITICAL: ALWAYS specify `--target=i686-pc-windows-gnu` on Linux** - The `thiscall` and `stdcall` ABIs are Windows-specific. Without the target, cargo will use the Linux host target and fail with ABI errors. These errors are expected when cross-compiling and the code will compile correctly on Windows with the proper target specified. + +**Windows Examples:** +- ❌ `cargo check` → ✅ `./openzt.bat check` +- ❌ `cargo build` → ✅ `./openzt.bat build` +- ❌ `cargo clippy` → ✅ `./openzt.bat clippy` +- ❌ `cargo test` → ✅ `./openzt.bat test` + +If `openzt.bat` is missing a command you need, ADD IT to `openzt.bat` rather than running cargo directly. + +## Project Overview + +OpenZT is a DLL injection framework for Zoo Tycoon (2001) written in Rust. It provides mod support, bug fixes, and feature enhancements through function detouring and memory manipulation. + +**Target**: 32-bit Windows (`i686-pc-windows-msvc`) +**Output**: `openzt.dll` (copied to Zoo Tycoon directory and loaded automatically) + +## Critical Rules + +1. **NEVER commit Zoo Tycoon assets, code, configs, or decompiled content** - This is a clean-room reimplementation +2. **ALWAYS USE openzt.bat for building, testing, running or just anything that would usually require use of `cargo`** - If openzt.bat is missing functionality add it rather than running cargo directly +3. **New features start behind `experimental` feature flag** in Cargo.toml +4. **All structs must use `#[repr(C)]`** for memory layout compatibility + +## Development Commands + +**IMPORTANT**: Always use `./openzt.bat` for cargo actions on the openzt crate (build, check, clippy, docs). This ensures correct toolchain selection and target configuration. + +### Build Commands +```bash +# Build only (no game launch) +./openzt.bat build # Debug with command-console +./openzt.bat build --release # Release with command-console +./openzt.bat build --test # Debug test build +./openzt.bat build --test --release # Release test build + +# Build and run +./openzt.bat run # Debug with command-console +./openzt.bat run --release # Release with command-console + +# Extra Cargo args/features go after `--` +./openzt.bat build -- --features egui-overlay +./openzt.bat check -- --features egui-overlay +./openzt.bat run -- --features egui-overlay +./openzt.bat build -- --features egui-overlay --features debug-blit + +# Build and run with --wait flag (waits for game to exit before returning) +./openzt.bat run --wait # Debug, wait for exit +./openzt.bat run --release --wait # Release, wait for exit + +# Integration tests +./openzt.bat integration-tests # Run all integration tests (builds release, displays results) + +# Code quality checks +./openzt.bat check # Run cargo check on openzt +./openzt.bat check -- --features egui-overlay # Required when touching egui overlay code +./openzt.bat clippy # Run cargo clippy on openzt +./openzt.bat test # Run cargo test on openzt + +# Documentation +./openzt.bat docs +``` + +### Lua Console (Runtime Scripting) + +The console executes Lua code directly on the game thread. Connect after OpenZT is running: + +```bash +cd openzt-console && cargo run +``` + +**Example Commands**: +```lua +-- List all available functions +help() + +-- Search for specific functions +help("cash") + +-- Game management +get_date() -- Get current in-game date +add_cash(10000) -- Add $10000 to budget +enable_dev_mode(true) -- Enable developer mode +zoostats() -- Display zoo statistics + +-- Settings +get_setting("AI", "cKeeperMaxTiredness") +set_setting("AI", "cKeeperMaxTiredness", "100") +list_settings() -- List all settings +list_settings("AI") -- List AI settings only + +-- Entity management +get_selected_entity() -- Get selected entity details +sel_type() -- Get selected entity type config +sel_type("-v") -- Verbose entity type info +make_sel(9500) -- Make entity type selectable + +-- World/Habitat info +list_entities() -- List all entities in world +list_exhibits() -- List all exhibits/habitats +get_zt_world_mgr() -- World manager debug info + +-- Expansions +list_expansion() -- List loaded expansions +get_current_expansion() -- Get active expansion +get_members() -- List expansion member sets + +-- Resources +list_resources() -- List BF resource directories +list_openzt_mods() -- List OpenZT mod IDs +get_string(9211) -- Get game string by ID + +-- UI +ui("click_continue") -- Click continue button +continue() -- Shorthand for above +get_buy_tab() -- Get current buy tab +``` + +**Error Handling**: +```lua +-- Functions return (nil, error_string) on failure +result, err = get_string(999999) +if err then + print("Error: " .. err) +else + print("Result: " .. result) +end + +-- Or check for nil +local date = get_date() +if date then + print("Date: " .. date) +end +``` + +**Migration Note**: The old command-style syntax (e.g., `add_cash 1000`) is deprecated. Use Lua function calls (e.g., `add_cash(1000)`) instead. See `MIGRATION_TEMPLATE.md` for details on migrating remaining commands. + +### Creating Console Commands + +Adding new console commands to OpenZT is done using the `lua_fn!` macro in `openzt/src/scripting.rs`. This macro handles function registration, metadata for `help()`, and Lua integration automatically. + +#### Registration Location + +All commands are registered in the `init()` function in `openzt/src/scripting.rs` (around line 136). Add your command at the end of this function, before the closing brace. + +#### Command Patterns + +**No Arguments:** +```rust +lua_fn!("ping", "Test console connectivity", "ping()", || { + Ok("pong".to_string()) +}); +``` + +**Single Argument:** +```rust +lua_fn!("get_string", "Get game string by ID", "get_string(id)", |id: u32| { + Ok(format!("String: {}", id)) +}); +``` + +**Multiple Arguments:** +```rust +lua_fn!("set_setting", "Set a configuration value", "set_setting(section, key, value)", + |section: String, key: String, value: String| { + Ok(format!("Set {}.{} = {}", section, key, value)) + } +); +``` + +**Optional Arguments:** +```rust +lua_fn!("help", "List functions or search by keyword", "help([search_term])", + |search: Option| { + match search { + Some(term) => Ok(format!("Searching for: {}", term)), + None => Ok("All functions:".to_string()), + } + } +); +``` + +#### Return Value Patterns + +**Simple string:** +```rust +Ok("result".to_string()) +``` + +**Tuple (value, error):** +```rust +Ok(("Success message".to_string(), None::)) +// On error: Ok((String::new(), "Error message".to_string())) +``` + +**Unit/void:** +```rust +Ok(()) +``` + +#### Error Handling + +Functions should return errors as a tuple with the error string in the second position: + +```rust +lua_fn!("get_entity", "Get entity by ID", "get_entity(id)", |id: u32| { + match find_entity(id) { + Some(entity) => Ok((entity.name, None::)), + None => Ok((String::new(), format!("Entity {} not found", id))), + } +}); +``` + +In Lua, callers check for errors like: +```lua +result, err = get_entity(123) +if err then + print("Error: " .. err) +else + print("Result: " .. result) +end +``` + +## Architecture Patterns + +### Module Structure +- **Entry point**: `lib.rs` calls `init()` functions behind feature flags +- **Module pattern**: Each feature module has an `init()` function called from `lib.rs` +- **Feature flags**: Defined in `Cargo.toml` - new features use `experimental` flag + +### Memory Management +```rust +// Global state pattern +use once_cell::sync::Lazy; +static GLOBAL_STATE: Lazy> = Lazy::new(|| Mutex::new(MyState::default())); + +// Struct definitions +#[repr(C)] +#[derive(Debug)] +struct GameStruct { + field: u32, +} +``` + +### Function Detouring +```rust +// Detour setup (subtract 0x400000 from Ghidra addresses) +static_detour! { + static MY_DETOUR: unsafe extern "stdcall" fn(u32) -> u32; +} + +// Calling game functions +let game_fn: unsafe extern "stdcall" fn(u32) -> u32 = + std::mem::transmute(0x12345678); // Full address +``` + +### Resource Handling +```rust +// Register resource handlers in init() +resource_manager::add_handler("bfb", Box::new(BfbHandler)); +``` + +## Workspace Structure + +- **`openzt/`**: Main DLL crate with game hooks and features +- **`openzt-console/`**: Socket-based runtime console +- **`openzt-configparser/`**: Custom INI parser for Zoo Tycoon configs +- **`field_accessor_as_string*/`**: Derive macro crates + +## Key Features + +### Core Systems +- **Resource Management**: Custom file loading/modification via `resource_mgr/` +- **String Registry**: Game text injection via `string_registry.rs` +- **Lua Scripting**: Runtime Lua execution on game thread via TCP console (port 8080) +- **Settings**: Enhanced INI configuration loading +- **Expansion Packs**: Custom expansion support + +### Development Features +- **Feature flags**: `default = ["experimental", "ini"]`, `release = []` +- **Conditional compilation**: Most features behind flags for testing +- **Hot-swappable**: DLL can be reloaded during development + +### egui Overlay + +- Enabled with `egui-overlay` and gated by `experimental`; run with `./openzt.bat run -- --features egui-overlay` +- When changing `openzt/src/ui/**` or egui overlay behavior, ALWAYS verify with `./openzt.bat check -- --features egui-overlay` or `./openzt.bat build -- --features egui-overlay`; a plain `./openzt.bat check` does not compile this code. +- UI code lives in `openzt/src/ui/mod.rs`; add/update egui widgets inside the `backend.run_frame(...)` closure. +- Rendering uses `egui-tiny-skia` into a `tiny_skia::Pixmap`, then `openzt/src/ui/blit.rs` uploads it to a click-through layered overlay window with per-pixel alpha. +- Frame timing hooks are in `openzt/src/ui/render_hook.rs`; mouse events come from the subclassed game WndProc in `openzt/src/ui/wndproc.rs`; keyboard events are forwarded from `shortcuts.rs`. +- Use `--features egui-overlay --features debug-blit` only to test the overlay/window upload path with a solid red image. + +### Vanilla UI Layout Notes + +- Vanilla `.lyt` files are INI-like and may repeat keys (`state=`, `button=`, `image=`, `backcolor=`); use `openzt-configparser` vector access (`get_vec`) when order or all values matter. +- `.lyt` `animation=ui/main/pause/pause` points to descriptor `ui/main/pause/pause.ani`, not directly to the binary animation frame. +- In `.ani`, join all `dir*` entries with each `animation` value to get binary animation resources: `dir0=ui`, `dir1=main`, `dir2=pause`, `animation=N` => `ui/main/pause/N`. The matching palette is usually beside the descriptor, e.g. `ui/main/pause/pause.pal`. +- Common button animation states are `N` normal, `H` hover, `S` selected/pressed, and `G` disabled/greyed. Static visual passes usually use `N`; toggle buttons (`state=2048`) may need `S` once real UI state is implemented. +- Respect `layer` ordering and anchors. `x/y` are relative to `anchor` when present; `x=left|center|right` and `y=top|bottom` anchor to the screen/layout. `dynamicheight=1` fillers repeat/extend vertically only; `dynamicwidth=1` fillers repeat/extend horizontally only. + +### Inspecting Vanilla Resource Files + +Vanilla resources ship inside `.ztd` archives (base game: `*.ztd` in the Zoo Tycoon install dir; expansions: `XPACK1\*.ztd`, `XPACK2\*.ztd`; patches: `Updates\*.ztd`, `dupdate\*.ztd`, `dlupdate\*.ztd`). A `.ztd` is just a renamed `.zip` - when a decompile is ambiguous or a struct-field assumption needs ground-truthing, read the real file content directly rather than guessing: + +```python +import zipfile +z = zipfile.ZipFile(r"C:\Program Files (x86)\Microsoft Games\Zoo Tycoon\research.ztd") +print(z.read("research/branres.cfg").decode("latin1")) +``` + +To find which archive holds a given resource path, or to enumerate everything matching a pattern: + +```python +import zipfile, glob +archives = glob.glob(r"C:\Program Files (x86)\Microsoft Games\Zoo Tycoon\**\*.ztd", recursive=True) +for archive in archives: + for name in zipfile.ZipFile(archive).namelist(): + if name.lower().startswith("research/") and name.lower().endswith(".cfg"): + print(archive, name) +``` + +As with `private/resources/decompiles/`, this is for local verification only - never commit extracted vanilla assets/content (see "Critical Rules" above). + +### Inspecting the Vanilla DLL's PE Header (vtables, section layout) + +Confirmed vtable findings (addresses, confirmed slots, and the evidence for each) are written up per-class +in `private/docs/vtables/` - check there before re-deriving a class's vtable from scratch, and add a new file there +once you've confirmed one. + +`private/resources/dll/zoo.dll` is a real 32-bit PE file. When a decompile references a vtable or a raw address and +you need to independently verify it (rather than trust the decompile's naming), read the actual bytes: + +```bash +python3 private/scripts/parse_pe_header.py private/resources/dll/zoo.dll +``` + +prints the image base and section table (name, virtual address, file offset, size) with no dependencies +beyond the Python standard library (`pefile` is not installed in this environment and isn't required). + +To resolve a specific virtual address - e.g. a vtable found via Ghidra's symbol naming convention, which +embeds the address directly (`cls_0x635100__vftable_635100_00635100` -> VA `0x00635100`; usually found by +grepping a class's constructor/destructor decompile for `__vftable_`) - and dump its first N entries as +pointers (i.e. what a vtable's first N slots would look like): + +```bash +python3 private/scripts/parse_pe_header.py private/resources/dll/zoo.dll --va 0x00635100 --dump 20 +``` + +Each resolved pointer can be cross-checked against `openzt-detour/src/generated.rs`'s registered +`FunctionDef` addresses - a real match (e.g. a vtable slot landing exactly on an already-registered +address) is strong independent confirmation both that the vtable address is right and that the slot's +purpose is understood. + +To get a rough sense of how much vtable-shaped data exists in a section overall (useful for scoping how +much of the DLL is still unaccounted for - see `private/docs/vtables/PROGRESS.md`), scan for runs of consecutive +words that each resolve into `.text`: + +```bash +python3 private/scripts/parse_pe_header.py private/resources/dll/zoo.dll --scan-runs .rdata +``` + +This is a mechanical, symbol-free heuristic - it cannot tell where one class's vtable ends and an +adjacently-packed next class's begins, so treat its run lengths as an upper bound on entry count, not a +class count. + +**Do not determine a vtable's length by dumping N entries and eyeballing where the pointers "stop looking +valid."** Multiple classes' vtables are frequently packed back-to-back in `.rdata` with no gap or marker +between them, and every slot on both sides is an equally legitimate `.text` function pointer - a scan like +this has no way to detect that boundary and will silently attribute one class's vtable slots to another +(confirmed the hard way: an initial 10-entry read of `ZTResearchMgr`'s vtable at `0x00635100` turned out to +actually be `ZTResearchMgr`'s real 4-entry vtable immediately followed by all of `ZTMarketingMgr`'s vtable, +which starts, with no gap, at `0x00635110`). The pointer values only reveal something's *wrong* when the +following data happens to not look like a code pointer at all (e.g. a stray float constant, or an address +outside `.text`) - which is not guaranteed, and gave a false sense of confidence in this case since the +first several slots past the true boundary still resolved cleanly into `.text`. + +One candidate approach: grep every decompile for `__vftable_` symbols with a higher address than your target +(`grep -r "__vftable_" private/resources/decompiles/`), then confirm the nearest candidate by finding *that* class's +own constructor directly assigning it (`*this = &cls_0xNNNNNN__vftable_...`), and take the gap between the two +confirmed constructor-assignment addresses as the vtable's size. **This is not reliable either** - it only +proves where the *next known* vtable starts, not that nothing else sits between them. Confirmed the hard way on +`ZTMarketingMgr` (`0x00635110`): the nearest next constructor-confirmed vtable in the available decompiles was +`0x006351a0`, suggesting 36 slots, but several of those "slots" resolved to addresses already registered under +unrelated names in `openzt-detour/src/generated.rs` (mouse/keyboard handling, terraforming) - the gap actually +contains other undecompiled classes' vtables packed in between, not one 36-entry vtable. + +The approach that actually holds up: grep every decompile for **offset-based virtual calls on the global +instance** - patterns like `(**(code**)(*(int*)GLOBAL_X + N))(...)` or `(*(code*)**(undefined4**)GLOBAL_X)(...)` +(`grep -rn "GLOBAL_" private/resources/decompiles/`, then look for calls dereferencing through it). Each hit +is a *positive, load-bearing proof* that offset `N` is a real vtable slot - some other piece of the actual game +code dereferences and calls it - and the call site's arguments/context (e.g. called from `ZTApp_updateSim.c`, +`ZTWorldMgr_save.c`, `ZTWorldMgr_load.c`) often reveal the slot's purpose for free. This is how `ZTMarketingMgr` +was confirmed to have (at least) 4 slots - dtor/update/save/load at offsets `0x0/0x4/0x8/0xc` - matching the +exact same offsets independently confirmed for `ZTResearchMgr`'s vtable via the same technique, strongly +suggesting both implement a shared small "Mgr" interface. + +The limitation: this only proves a **lower bound**. A slot that exists but is never called anywhere in the +available decompiles stays invisible to this method, so "N confirmed slots" means "at least N," not "exactly +N." Treat a raw pointer-dump (`--dump`) past the last confirmed offset only as a sanity check for obviously +wrong data (a stray float constant, an address outside `.text`) or for cross-referencing against +`generated.rs`/named functions to catch "you've walked into another class's vtable" - never as the sole basis +for a boundary claim. + +Once a class's address is confirmed, `parse_pe_header.py` also automates the two mechanical steps that +`private/docs/vtables/*.md` files repeat for every class - use these instead of re-deriving them by hand each session: + +```bash +# Auto-detect a candidate length via the repeating-pointer boundary heuristic (private/docs/vtables/README.md), +# instead of guessing a --dump size and grepping the output for a repeat by hand: +python3 private/scripts/parse_pe_header.py private/resources/dll/zoo.dll --find-length --va 0x0062ea54 + +# Diff a class against its confirmed base and print the three ready-to-paste markdown tables +# (confirmed overrides / new slots / full raw dump) every class doc needs: +python3 private/scripts/parse_pe_header.py private/resources/dll/zoo.dll --diff \ + --va 0x0062ea54 --length 204 --base-va 0x0062ed84 --base-length 204 --base-name ZTStaff +``` + +`--find-length`'s output is still only a *candidate* boundary, not a confirmed one - per the methodology +above, cross-check it against an independently-known class address before treating it as final. `--diff`'s +markdown records every non-matching slot as `*unknown*`; only replace that with a real name/role if you have +independent call-site evidence (a `virt_meth_0xADDR` reference, a cast at a call site) - never guess. + +As with the resource-file inspection above, this is for local verification only - never commit extracted +vanilla binary content. + +## Testing + +### Integration Tests + +OpenZT includes an integration testing framework that runs tests in a live game environment. These tests verify mod loading, patch application, and resource management using the actual game engine. + +**Running Integration Tests**: +```bash +# Run all integration tests (builds release, launches game, displays results automatically) +./openzt.bat integration-tests +``` + +The `integration-tests` command: +- Builds the DLL in release mode with the `integration-tests` feature flag +- Launches Zoo Tycoon and waits for tests to complete +- Displays test results automatically after the game exits +- Shows paths to log files for detailed debugging + +**Checking Test Results**: +```bash +# View the integration test log +cat "C:\Program Files (x86)\Microsoft Games\Zoo Tycoon\openzt_integration_tests.log" + +# View detailed OpenZT logs (patch application, errors, etc.) +cat "C:\Program Files (x86)\Microsoft Games\Zoo Tycoon\openzt.log" +``` + +**Test Output**: +``` +=== OpenZT Integration Tests === + +Running dependency resolution tests... + ✓ test_simple_dependency_chain + ✓ test_circular_dependency_handling + ✓ test_optional_dependency_warning + ... (11 tests) + +Running patch rollback tests... + ✓ test_continue_mode_applies_directly + ✓ test_abort_mode_rolls_back_on_failure + ... (9 tests) + +Running loading order tests... + ✓ test_category_ordering + ✓ test_cross_file_habitat_reference + ... (8 tests) + +Running legacy attributes tests... + ✓ test_legacy_animal_attributes_loaded + ✓ test_legacy_fence_attributes_loaded + ... (24 tests) + +Results: 52 passed, 0 failed +ALL TESTS PASSED +``` + +**Test Categories**: + +1. **Dependency Resolution Tests** (`openzt/src/integration_tests/dependency_resolution.rs`) + - Test simple dependency chains + - Test circular dependency detection and handling + - Test optional dependencies and warnings + - Test `before` dependencies + - Test disabled mods exclusion + - Test validation of dependency violations + +2. **Patch Rollback Tests** (`openzt/src/integration_tests/patch_rollback.rs`) + - Test patch error handling modes (continue, abort, abort_mod) + - Verify shadow resource system for transactional patch application + - Test patch operations (set_key, merge, delete, etc.) + +3. **Loading Order Tests** (`openzt/src/integration_tests/loading_order.rs`) + - Verify deterministic mod definition file loading order + - Test category ordering (NoPatch → Mixed → PatchOnly) + - Verify alphabetical sorting within categories + - Test cross-file habitat/location references in patches + +4. **Legacy Attributes Tests** (`openzt/src/integration_tests/legacy_attributes.rs`) + - Test loading of legacy entity attributes from .cfg files + - Test default subtype assignment (animal, staff, fence, wall) + - Test explicit subtype specification + - Test patch-based legacy attribute substitution + - Test fallback behavior for invalid subtypes + - Test cNameID string ID resolution + +**Creating New Tests**: + +1. Add test functions to appropriate test module: +```rust +pub fn run_all_tests() -> Vec { + vec![ + test_existing_feature(), + test_your_new_feature(), // Add here + ] +} + +fn test_your_new_feature() -> TestResult { + let test_name = "test_your_new_feature"; + + // Setup test data + // ... + + // Perform test operations + // ... + + // Verify results + if expected == actual { + TestResult::pass(test_name) + } else { + TestResult::fail(test_name, format!("Expected {}, got {}", expected, actual)) + } +} +``` + +2. For tests requiring mod resources, use the embedded test mod pattern: +```rust +// In loading_order.rs - embed test TOML files +const DEF_FILE: &str = include_str!("../../resources/test/your-test/defs/test.toml"); + +// Add to create_test_mod_file_map() +file_map.insert( + "defs/test.toml".to_string(), + DEF_FILE.as_bytes().to_vec().into_boxed_slice(), +); +``` + +3. Create test resource files in `openzt/resources/test/your-test/`: +``` +your-test/ +├── meta.toml +└── defs/ + └── test.toml +``` + +**Embedded Test Mod Pattern**: + +Integration tests use an embedded mod approach where test resources are compiled directly into the binary: + +- Test files are embedded using `include_str!()` and `include_bytes!()` +- No ZIP file creation or installation required +- Changes to test resources take effect on next build +- Zero runtime overhead - resources are in memory at compile time + +**Important Notes**: + +- Tests run in a live game environment with initialized memory structures +- The game launches and exits automatically when tests complete +- Use the `--wait` flag to wait for the game to exit before returning control (recommended for automated workflows and CI) +- Test log is always written to `C:\Program Files (x86)\Microsoft Games\Zoo Tycoon\openzt_integration_tests.log` +- Load order tracking is only enabled with `integration-tests` feature flag +- Tests create temporary files (e.g., `animals/test.ai`) for verification +- **Habitat/Location Registration**: Always use the TOML key identifier (e.g., "test_habitat_a"), NOT the display name (e.g., "Test Habitat A") when looking up habitats/locations in tests + +### Game Launch Checks + +The build script automatically checks if Zoo Tycoon is already running before attempting to launch: + +```bash +./openzt.bat run --release + +# If Zoo Tycoon is already running, you'll see: +# ERROR: Zoo Tycoon is already running. +# Please close the existing instance before launching a new one. +``` + +This prevents DLL copy failures due to file locks and ensures clean testing environments. + +### Manual Testing + +For features not covered by integration tests: + +1. Build and run with `./openzt.bat run --release` +2. Verify features work in-game +3. Test console commands if applicable +4. Check for game crashes or memory issues + +## Code Quality + +- Avoid obvious comments that restate code +- Document complex game memory layouts and reverse engineering discoveries +- Use meaningful variable names for game offsets and structures +- Follow existing patterns for detour setup and global state management diff --git a/CLAUDE.md b/CLAUDE.md index 5f2b6a5..eef4bd2 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -1,474 +1 @@ -# CLAUDE.md - -This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. - -## ⚠️ CRITICAL: ALWAYS USE openzt.bat (Windows) or specific cargo commands (Linux) - -**On Windows**: NEVER use `cargo` directly - ALWAYS use `./openzt.bat` for ANY cargo command (build, check, clippy, test, run, etc.). - -The project uses a specific toolchain and target configuration that is managed by `openzt.bat`. Running `cargo` directly will use the wrong toolchain/target. - -**On Linux**: Batch files do not work. Use specific cargo commands directly: -- Build: `cargo build --manifest-path openzt/Cargo.toml --lib --target=i686-pc-windows-gnu` -- Check: `cargo check --manifest-path openzt/Cargo.toml --lib --target=i686-pc-windows-gnu` -- Clippy: `cargo clippy --manifest-path openzt/Cargo.toml --lib --target=i686-pc-windows-gnu` -- Test: `cargo test --manifest-path openzt/Cargo.toml --lib --target=i686-pc-windows-gnu` - -**⚠️ CRITICAL: ALWAYS specify `--target=i686-pc-windows-gnu` on Linux** - The `thiscall` and `stdcall` ABIs are Windows-specific. Without the target, cargo will use the Linux host target and fail with ABI errors. These errors are expected when cross-compiling and the code will compile correctly on Windows with the proper target specified. - -**Windows Examples:** -- ❌ `cargo check` → ✅ `./openzt.bat check` -- ❌ `cargo build` → ✅ `./openzt.bat build` -- ❌ `cargo clippy` → ✅ `./openzt.bat clippy` -- ❌ `cargo test` → ✅ `./openzt.bat test` - -If `openzt.bat` is missing a command you need, ADD IT to `openzt.bat` rather than running cargo directly. - -## Project Overview - -OpenZT is a DLL injection framework for Zoo Tycoon (2001) written in Rust. It provides mod support, bug fixes, and feature enhancements through function detouring and memory manipulation. - -**Target**: 32-bit Windows (`i686-pc-windows-msvc`) -**Output**: `openzt.dll` (copied to Zoo Tycoon directory and loaded automatically) - -## Critical Rules - -1. **NEVER commit Zoo Tycoon assets, code, configs, or decompiled content** - This is a clean-room reimplementation -2. **ALWAYS USE openzt.bat for building, testing, running or just anything that would usually require use of `cargo`** - If openzt.bat is missing functionality add it rather than running cargo directly -3. **New features start behind `experimental` feature flag** in Cargo.toml -4. **All structs must use `#[repr(C)]`** for memory layout compatibility - -## Development Commands - -**IMPORTANT**: Always use `./openzt.bat` for cargo actions on the openzt crate (build, check, clippy, docs). This ensures correct toolchain selection and target configuration. - -### Build Commands -```bash -# Build only (no game launch) -./openzt.bat build # Debug with command-console -./openzt.bat build --release # Release with command-console -./openzt.bat build --test # Debug test build -./openzt.bat build --test --release # Release test build - -# Build and run -./openzt.bat run # Debug with command-console -./openzt.bat run --release # Release with command-console - -# Build and run with --wait flag (waits for game to exit before returning) -./openzt.bat run --wait # Debug, wait for exit -./openzt.bat run --release --wait # Release, wait for exit - -# Integration tests -./openzt.bat integration-tests # Run all integration tests (builds release, displays results) - -# Code quality checks -./openzt.bat check # Run cargo check on openzt -./openzt.bat clippy # Run cargo clippy on openzt -./openzt.bat test # Run cargo test on openzt - -# Documentation -./openzt.bat docs -``` - -### Lua Console (Runtime Scripting) - -The console executes Lua code directly on the game thread. Connect after OpenZT is running: - -```bash -cd openzt-console && cargo run -``` - -**Example Commands**: -```lua --- List all available functions -help() - --- Search for specific functions -help("cash") - --- Game management -get_date() -- Get current in-game date -add_cash(10000) -- Add $10000 to budget -enable_dev_mode(true) -- Enable developer mode -zoostats() -- Display zoo statistics - --- Settings -get_setting("AI", "cKeeperMaxTiredness") -set_setting("AI", "cKeeperMaxTiredness", "100") -list_settings() -- List all settings -list_settings("AI") -- List AI settings only - --- Entity management -get_selected_entity() -- Get selected entity details -sel_type() -- Get selected entity type config -sel_type("-v") -- Verbose entity type info -make_sel(9500) -- Make entity type selectable - --- World/Habitat info -list_entities() -- List all entities in world -list_exhibits() -- List all exhibits/habitats -get_zt_world_mgr() -- World manager debug info - --- Expansions -list_expansion() -- List loaded expansions -get_current_expansion() -- Get active expansion -get_members() -- List expansion member sets - --- Resources -list_resources() -- List BF resource directories -list_openzt_mods() -- List OpenZT mod IDs -get_string(9211) -- Get game string by ID - --- UI -ui("click_continue") -- Click continue button -continue() -- Shorthand for above -get_buy_tab() -- Get current buy tab -``` - -**Error Handling**: -```lua --- Functions return (nil, error_string) on failure -result, err = get_string(999999) -if err then - print("Error: " .. err) -else - print("Result: " .. result) -end - --- Or check for nil -local date = get_date() -if date then - print("Date: " .. date) -end -``` - -**Migration Note**: The old command-style syntax (e.g., `add_cash 1000`) is deprecated. Use Lua function calls (e.g., `add_cash(1000)`) instead. See `MIGRATION_TEMPLATE.md` for details on migrating remaining commands. - -### Creating Console Commands - -Adding new console commands to OpenZT is done using the `lua_fn!` macro in `openzt/src/scripting.rs`. This macro handles function registration, metadata for `help()`, and Lua integration automatically. - -#### Registration Location - -All commands are registered in the `init()` function in `openzt/src/scripting.rs` (around line 136). Add your command at the end of this function, before the closing brace. - -#### Command Patterns - -**No Arguments:** -```rust -lua_fn!("ping", "Test console connectivity", "ping()", || { - Ok("pong".to_string()) -}); -``` - -**Single Argument:** -```rust -lua_fn!("get_string", "Get game string by ID", "get_string(id)", |id: u32| { - Ok(format!("String: {}", id)) -}); -``` - -**Multiple Arguments:** -```rust -lua_fn!("set_setting", "Set a configuration value", "set_setting(section, key, value)", - |section: String, key: String, value: String| { - Ok(format!("Set {}.{} = {}", section, key, value)) - } -); -``` - -**Optional Arguments:** -```rust -lua_fn!("help", "List functions or search by keyword", "help([search_term])", - |search: Option| { - match search { - Some(term) => Ok(format!("Searching for: {}", term)), - None => Ok("All functions:".to_string()), - } - } -); -``` - -#### Return Value Patterns - -**Simple string:** -```rust -Ok("result".to_string()) -``` - -**Tuple (value, error):** -```rust -Ok(("Success message".to_string(), None::)) -// On error: Ok((String::new(), "Error message".to_string())) -``` - -**Unit/void:** -```rust -Ok(()) -``` - -#### Error Handling - -Functions should return errors as a tuple with the error string in the second position: - -```rust -lua_fn!("get_entity", "Get entity by ID", "get_entity(id)", |id: u32| { - match find_entity(id) { - Some(entity) => Ok((entity.name, None::)), - None => Ok((String::new(), format!("Entity {} not found", id))), - } -}); -``` - -In Lua, callers check for errors like: -```lua -result, err = get_entity(123) -if err then - print("Error: " .. err) -else - print("Result: " .. result) -end -``` - -## Architecture Patterns - -### Module Structure -- **Entry point**: `lib.rs` calls `init()` functions behind feature flags -- **Module pattern**: Each feature module has an `init()` function called from `lib.rs` -- **Feature flags**: Defined in `Cargo.toml` - new features use `experimental` flag - -### Memory Management -```rust -// Global state pattern -use once_cell::sync::Lazy; -static GLOBAL_STATE: Lazy> = Lazy::new(|| Mutex::new(MyState::default())); - -// Struct definitions -#[repr(C)] -#[derive(Debug)] -struct GameStruct { - field: u32, -} -``` - -### Function Detouring -```rust -// Detour setup (subtract 0x400000 from Ghidra addresses) -static_detour! { - static MY_DETOUR: unsafe extern "stdcall" fn(u32) -> u32; -} - -// Calling game functions -let game_fn: unsafe extern "stdcall" fn(u32) -> u32 = - std::mem::transmute(0x12345678); // Full address -``` - -### Resource Handling -```rust -// Register resource handlers in init() -resource_manager::add_handler("bfb", Box::new(BfbHandler)); -``` - -## Workspace Structure - -- **`openzt/`**: Main DLL crate with game hooks and features -- **`openzt-console/`**: Socket-based runtime console -- **`openzt-configparser/`**: Custom INI parser for Zoo Tycoon configs -- **`field_accessor_as_string*/`**: Derive macro crates - -## Key Features - -### Core Systems -- **Resource Management**: Custom file loading/modification via `resource_mgr/` -- **String Registry**: Game text injection via `string_registry.rs` -- **Lua Scripting**: Runtime Lua execution on game thread via TCP console (port 8080) -- **Settings**: Enhanced INI configuration loading -- **Expansion Packs**: Custom expansion support - -### Development Features -- **Feature flags**: `default = ["experimental", "ini"]`, `release = []` -- **Conditional compilation**: Most features behind flags for testing -- **Hot-swappable**: DLL can be reloaded during development - -## Testing - -### Integration Tests - -OpenZT includes an integration testing framework that runs tests in a live game environment. These tests verify mod loading, patch application, and resource management using the actual game engine. - -**Running Integration Tests**: -```bash -# Run all integration tests (builds release, launches game, displays results automatically) -./openzt.bat integration-tests -``` - -The `integration-tests` command: -- Builds the DLL in release mode with the `integration-tests` feature flag -- Launches Zoo Tycoon and waits for tests to complete -- Displays test results automatically after the game exits -- Shows paths to log files for detailed debugging - -**Checking Test Results**: -```bash -# View the integration test log -cat "C:\Program Files (x86)\Microsoft Games\Zoo Tycoon\openzt_integration_tests.log" - -# View detailed OpenZT logs (patch application, errors, etc.) -cat "C:\Program Files (x86)\Microsoft Games\Zoo Tycoon\openzt.log" -``` - -**Test Output**: -``` -=== OpenZT Integration Tests === - -Running dependency resolution tests... - ✓ test_simple_dependency_chain - ✓ test_circular_dependency_handling - ✓ test_optional_dependency_warning - ... (11 tests) - -Running patch rollback tests... - ✓ test_continue_mode_applies_directly - ✓ test_abort_mode_rolls_back_on_failure - ... (9 tests) - -Running loading order tests... - ✓ test_category_ordering - ✓ test_cross_file_habitat_reference - ... (8 tests) - -Running legacy attributes tests... - ✓ test_legacy_animal_attributes_loaded - ✓ test_legacy_fence_attributes_loaded - ... (24 tests) - -Results: 52 passed, 0 failed -ALL TESTS PASSED -``` - -**Test Categories**: - -1. **Dependency Resolution Tests** (`openzt/src/integration_tests/dependency_resolution.rs`) - - Test simple dependency chains - - Test circular dependency detection and handling - - Test optional dependencies and warnings - - Test `before` dependencies - - Test disabled mods exclusion - - Test validation of dependency violations - -2. **Patch Rollback Tests** (`openzt/src/integration_tests/patch_rollback.rs`) - - Test patch error handling modes (continue, abort, abort_mod) - - Verify shadow resource system for transactional patch application - - Test patch operations (set_key, merge, delete, etc.) - -3. **Loading Order Tests** (`openzt/src/integration_tests/loading_order.rs`) - - Verify deterministic mod definition file loading order - - Test category ordering (NoPatch → Mixed → PatchOnly) - - Verify alphabetical sorting within categories - - Test cross-file habitat/location references in patches - -4. **Legacy Attributes Tests** (`openzt/src/integration_tests/legacy_attributes.rs`) - - Test loading of legacy entity attributes from .cfg files - - Test default subtype assignment (animal, staff, fence, wall) - - Test explicit subtype specification - - Test patch-based legacy attribute substitution - - Test fallback behavior for invalid subtypes - - Test cNameID string ID resolution - -**Creating New Tests**: - -1. Add test functions to appropriate test module: -```rust -pub fn run_all_tests() -> Vec { - vec![ - test_existing_feature(), - test_your_new_feature(), // Add here - ] -} - -fn test_your_new_feature() -> TestResult { - let test_name = "test_your_new_feature"; - - // Setup test data - // ... - - // Perform test operations - // ... - - // Verify results - if expected == actual { - TestResult::pass(test_name) - } else { - TestResult::fail(test_name, format!("Expected {}, got {}", expected, actual)) - } -} -``` - -2. For tests requiring mod resources, use the embedded test mod pattern: -```rust -// In loading_order.rs - embed test TOML files -const DEF_FILE: &str = include_str!("../../resources/test/your-test/defs/test.toml"); - -// Add to create_test_mod_file_map() -file_map.insert( - "defs/test.toml".to_string(), - DEF_FILE.as_bytes().to_vec().into_boxed_slice(), -); -``` - -3. Create test resource files in `openzt/resources/test/your-test/`: -``` -your-test/ -├── meta.toml -└── defs/ - └── test.toml -``` - -**Embedded Test Mod Pattern**: - -Integration tests use an embedded mod approach where test resources are compiled directly into the binary: - -- Test files are embedded using `include_str!()` and `include_bytes!()` -- No ZIP file creation or installation required -- Changes to test resources take effect on next build -- Zero runtime overhead - resources are in memory at compile time - -**Important Notes**: - -- Tests run in a live game environment with initialized memory structures -- The game launches and exits automatically when tests complete -- Use the `--wait` flag to wait for the game to exit before returning control (recommended for automated workflows and CI) -- Test log is always written to `C:\Program Files (x86)\Microsoft Games\Zoo Tycoon\openzt_integration_tests.log` -- Load order tracking is only enabled with `integration-tests` feature flag -- Tests create temporary files (e.g., `animals/test.ai`) for verification -- **Habitat/Location Registration**: Always use the TOML key identifier (e.g., "test_habitat_a"), NOT the display name (e.g., "Test Habitat A") when looking up habitats/locations in tests - -### Game Launch Checks - -The build script automatically checks if Zoo Tycoon is already running before attempting to launch: - -```bash -./openzt.bat run --release - -# If Zoo Tycoon is already running, you'll see: -# ERROR: Zoo Tycoon is already running. -# Please close the existing instance before launching a new one. -``` - -This prevents DLL copy failures due to file locks and ensures clean testing environments. - -### Manual Testing - -For features not covered by integration tests: - -1. Build and run with `./openzt.bat run --release` -2. Verify features work in-game -3. Test console commands if applicable -4. Check for game crashes or memory issues - -## Code Quality - -- Avoid obvious comments that restate code -- Document complex game memory layouts and reverse engineering discoveries -- Use meaningful variable names for game offsets and structures -- Follow existing patterns for detour setup and global state management +@AGENTS.md \ No newline at end of file diff --git a/Cargo.toml b/Cargo.toml index eb44ec6..d381fb1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -15,6 +15,7 @@ members = [ "openzt-detour", "openzt-dll", "openzt-instance-manager", + "egui-tiny-skia", # vendor "vendor/retour-rs", diff --git a/config.toml b/config.toml index a52c338..35cf2bf 100644 --- a/config.toml +++ b/config.toml @@ -8,7 +8,7 @@ console_start = 8081 console_end = 8181 [docker] -image = "finn/winezt:latest" +image = "finn/wine32-zoo:latest" container_prefix = "openzt-" [instances] diff --git a/detour.lua b/detour.lua new file mode 100644 index 0000000..c8abac9 --- /dev/null +++ b/detour.lua @@ -0,0 +1,111 @@ +-- OpenZT Lua Command Test Script +-- This script tests all migrated console commands +-- Run via: cd openzt-console && cargo run +-- Then execute: dofile("test_lua_commands.lua") + +print("========================================") +print("OpenZT Lua Command Test Suite") +print("========================================\n") + +local passed = 0 +local failed = 0 +local errors = {} + +-- Helper function to test commands +local function test_command(name, func, expected_error) + io.write("Testing " .. name .. "... ") + local status, result, err = pcall(func) + + if not status then + -- Lua error (pcall caught an exception) + failed = failed + 1 + table.insert(errors, {name = name, error = tostring(result)}) + print("FAILED (Lua error: " .. tostring(result) .. ")") + elseif err then + -- Command returned (nil, error_string) + if expected_error then + passed = passed + 1 + print("PASSED (expected error: " .. err .. ")") + else + failed = failed + 1 + table.insert(errors, {name = name, error = err}) + print("FAILED (command error: " .. err .. ")") + end + else + passed = passed + 1 + print("PASSED") + if result then + print(" Result: " .. tostring(result):sub(1, 80)) + end + end +end + +print("\n--- Core Functions ---") +test_command("help()", function() return help() end) +test_command("help('cash')", function() return help("cash") end) +test_command("continue()", function() return continue() end) + +print("\n--- Game Management (ztgamemgr.rs) ---") +test_command("get_date()", function() return get_date() end) +test_command("add_cash(1000)", function() return add_cash(1000) end) +test_command("enable_dev_mode(true)", function() return enable_dev_mode(true) end) +test_command("enable_dev_mode(false)", function() return enable_dev_mode(false) end) +test_command("zoostats()", function() return zoostats() end) + +print("\n--- Settings (settings.rs) ---") +test_command("list_settings()", function() return list_settings() end) +test_command("list_settings('AI')", function() return list_settings("AI") end) +-- Note: These may fail if settings don't exist +test_command("get_setting('AI', 'test')", function() return get_setting("AI", "test") end, true) +test_command("set_setting('AI', 'test', '100')", function() return set_setting("AI", "test", "100") end, true) + +print("\n--- String Registry (string_registry.rs) ---") +test_command("get_string(9211)", function() return get_string(9211) end) +test_command("get_string(999999)", function() return get_string(999999) end, true) + +print("\n--- Entity Types (bfentitytype.rs) ---") +test_command("sel_type()", function() return sel_type() end, true) -- May fail if nothing selected +test_command("make_sel(9500)", function() return make_sel(9500) end, true) -- May fail if not found + +print("\n--- Expansions (expansions.rs) ---") +test_command("list_expansion()", function() return list_expansion() end) +test_command("get_current_expansion()", function() return get_current_expansion() end) +test_command("get_members()", function() return get_members() end) + +print("\n--- Habitats (zthabitatmgr.rs) ---") +test_command("get_zthabitatmgr()", function() return get_zthabitatmgr() end) +test_command("list_exhibits()", function() return list_exhibits() end) + +print("\n--- Terrain (ztadvterrainmgr.rs) ---") +test_command("list_bfterraintypeinfo()", function() return list_bfterraintypeinfo() end) + +print("\n--- Registry (bfregistry.rs) ---") +test_command("list_bf_registry()", function() return list_bf_registry() end) + +print("\n========================================") +print("Test Summary") +print("========================================") +print(string.format("Passed: %d", passed)) +print(string.format("Failed: %d", failed)) +print(string.format("Total: %d", passed + failed)) + +if failed > 0 then + print("\n--- Failed Tests ---") + for i, err in ipairs(errors) do + print(string.format("%d. %s", i, err.name)) + print(" Error: " .. err.error) + end +end + +print("\n========================================") +print("Test complete!") +print("========================================\n") + +-- Return summary +return { + passed = passed, + failed = failed, + total = passed + failed, + errors = errors +} + diff --git a/openzt-detour-macro/src/lib.rs b/openzt-detour-macro/src/lib.rs index 06a1a30..73be4ac 100644 --- a/openzt-detour-macro/src/lib.rs +++ b/openzt-detour-macro/src/lib.rs @@ -108,3 +108,91 @@ fn build_function_type(sig: &syn::Signature) -> proc_macro2::TokenStream { pub fn detour(_attr: TokenStream, input: TokenStream) -> TokenStream { input } + +fn extract_bare_fn_type(ty: &syn::Type) -> Option { + if let syn::Type::Path(p) = ty { + if let Some(seg) = p.path.segments.last() { + if seg.ident == "FunctionDef" { + if let syn::PathArguments::AngleBracketed(args) = &seg.arguments { + if let Some(syn::GenericArgument::Type(syn::Type::BareFn(f))) = args.args.first() { + return Some(f.clone()); + } + } + } + } + } + None +} + +#[proc_macro_attribute] +pub fn validate_detour(attr: TokenStream, input: TokenStream) -> TokenStream { + let name_lit = parse_macro_input!(attr as syn::LitStr); + let name = name_lit.value(); + + let const_item = parse_macro_input!(input as syn::ItemConst); + + let bare_fn = extract_bare_fn_type(&const_item.ty) + .expect("validate_detour: expected FunctionDef type"); + + let const_name = &const_item.ident; + let static_name = Ident::new( + &format!("{}_VALIDATION", const_name), + const_name.span(), + ); + let enable_fn_name = Ident::new( + &format!("enable_{}_validation", const_name.to_string().to_lowercase()), + const_name.span(), + ); + + let abi = &bare_fn.abi; + let unsafety = &bare_fn.unsafety; + + let param_names: Vec = (0..bare_fn.inputs.len()) + .map(|i| Ident::new(&format!("_a{}", i), proc_macro2::Span::call_site())) + .collect(); + let param_types: Vec<&syn::Type> = bare_fn.inputs.iter() + .map(|arg| &arg.ty) + .collect(); + + let return_type = match &bare_fn.output { + syn::ReturnType::Default => quote! { () }, + syn::ReturnType::Type(_, ty) => quote! { #ty }, + }; + + let fn_type = if unsafety.is_some() { + quote! { unsafe #abi fn(#(#param_types),*) -> #return_type } + } else { + quote! { #abi fn(#(#param_types),*) -> #return_type } + }; + + let name_str = name.as_str(); + let expect_msg = format!("Failed to create validation detour for {}", name); + + let output = quote! { + #const_item + + pub(crate) static #static_name: + ::std::sync::LazyLock<::retour::GenericDetour<#fn_type>> + = ::std::sync::LazyLock::new(|| { + #unsafety #abi fn stub(#(#param_names: #param_types),*) -> #return_type { + ::tracing::info!("DETOUR_CALLED: {}", #name_str); + unsafe { #static_name.call(#(#param_names),*) } + } + unsafe { #const_name.detour(stub) } + .expect(#expect_msg) + }); + + pub(crate) fn #enable_fn_name() -> ::retour::Result<()> { + unsafe { #static_name.enable() } + } + + ::inventory::submit! { + crate::ValidationEntry { + name: #name_str, + enable: #enable_fn_name, + } + } + }; + + output.into() +} diff --git a/openzt-detour/Cargo.toml b/openzt-detour/Cargo.toml index 2195e1e..9edb7ce 100644 --- a/openzt-detour/Cargo.toml +++ b/openzt-detour/Cargo.toml @@ -8,3 +8,9 @@ repository.workspace = true [dependencies] retour = {path = "../vendor/retour-rs", version = "0.3.1"} +inventory = { version = "0.3", optional = true } +tracing = { version = "0.1", optional = true } +openzt-detour-macro = { path = "../openzt-detour-macro", version = "0.1.0", optional = true } + +[features] +detour-validation = ["dep:inventory", "dep:tracing", "dep:openzt-detour-macro"] diff --git a/openzt-detour/add_validation_macros.py b/openzt-detour/add_validation_macros.py new file mode 100644 index 0000000..3f0c675 --- /dev/null +++ b/openzt-detour/add_validation_macros.py @@ -0,0 +1,166 @@ +#!/usr/bin/env python3 +""" +Add #[cfg_attr(feature = "detour-validation", validate_detour("module/function"))] +attributes to all FunctionDef constants in generated.rs that don't already have them. + +Usage: + python add_validation_macros.py src/generated.rs --dry-run + python add_validation_macros.py src/generated.rs --in-place + python add_validation_macros.py src/generated.rs --output src/generated_with_validations.rs +""" + +import argparse +import re +import sys +from pathlib import Path + + +def screaming_to_snake(name: str) -> str: + """Convert SCREAMING_SNAKE_CASE to lowercase snake_case.""" + return name.lower() + + +def has_validate_detour_attr(lines: list, idx: int) -> bool: + """Check if a function already has a validate_detour attribute above it.""" + # Look backwards from current position for cfg_attr with validate_detour + i = idx - 1 + while i >= 0: + line = lines[i].strip() + if line.startswith("#[cfg_attr"): + if "validate_detour" in line: + return True + # If it's a different cfg_attr, keep looking + elif not line.startswith("#") and line != "": + # Hit a non-attribute, non-empty line + return False + i -= 1 + return False + + +def add_validation_macros(input_file: str, output_file: str = None, in_place: bool = False, dry_run: bool = False) -> int: + """ + Add validate_detour attributes to all FunctionDef constants that don't already have them. + + Returns the number of macros added. + """ + input_path = Path(input_file) + + if not input_path.exists(): + print(f"Error: Input file '{input_file}' not found", file=sys.stderr) + return 0 + + with open(input_path, 'r', encoding='utf-8') as f: + lines = f.readlines() + + output_lines = [] + current_module = None + macros_added = 0 + line_number = 0 + + function_pattern = re.compile(r'pub\s+const\s+(\w+):\s+FunctionDef<') + module_pattern = re.compile(r'pub\s+mod\s+(\w+)\s+\{') + + for line in lines: + line_number += 1 + + # Check for module declaration + module_match = module_pattern.match(line.strip()) + if module_match: + current_module = module_match.group(1) + output_lines.append(line) + continue + + # Check for function definition + stripped_line = line.strip() + function_match = function_pattern.match(stripped_line) + if function_match and current_module: + function_name = function_match.group(1) + + # Get the leading whitespace (indentation) from the function line + indent_match = re.match(r'^(\s*)', line) + indent = indent_match.group(1) if indent_match else '' + + # Check if it already has a validate_detour attribute + if not has_validate_detour_attr(output_lines, len(output_lines)): + # Generate the attribute with proper indentation + macro_line = f'{indent}#[cfg_attr(feature = "detour-validation", validate_detour("{current_module}/{screaming_to_snake(function_name)}"))]\n' + output_lines.append(macro_line) + macros_added += 1 + if dry_run and macros_added <= 20: + print(f"Would add at line {line_number}: {macro_line.strip()}") + elif macros_added % 100 == 0: + print(f"Added {macros_added} macros so far...", file=sys.stderr) + + output_lines.append(line) + else: + output_lines.append(line) + + if dry_run: + print(f"\nTotal macros that would be added: {macros_added}") + return macros_added + + # Write output + if in_place: + # Create backup + backup_path = input_path.with_suffix(input_path.suffix + '.bak') + with open(backup_path, 'w', encoding='utf-8') as f: + f.writelines(lines) + print(f"Backup created: {backup_path}") + + with open(input_path, 'w', encoding='utf-8') as f: + f.writelines(output_lines) + print(f"Modified {input_file} in place") + elif output_file: + output_path = Path(output_file) + output_path.parent.mkdir(parents=True, exist_ok=True) + with open(output_path, 'w', encoding='utf-8') as f: + f.writelines(output_lines) + print(f"Wrote output to: {output_file}") + else: + print("Error: Must specify --in-place or --output", file=sys.stderr) + return 0 + + print(f"Total macros added: {macros_added}") + return macros_added + + +def main(): + parser = argparse.ArgumentParser( + description='Add validate_detour macros to FunctionDef constants in generated.rs', + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + # Dry run to see what changes + python add_validation_macros.py src/generated.rs --dry-run + + # Apply changes (creates backup) + python add_validation_macros.py src/generated.rs --in-place + + # Write to new file + python add_validation_macros.py src/generated.rs --output src/generated_with_validations.rs + """ + ) + + parser.add_argument('input_file', help='Path to generated.rs file') + parser.add_argument('--in-place', '-i', action='store_true', + help='Modify file in place (creates .bak backup)') + parser.add_argument('--output', '-o', help='Write to a different file') + parser.add_argument('--dry-run', '-d', action='store_true', + help='Show what would change without writing') + + args = parser.parse_args() + + if not args.in_place and not args.output and not args.dry_run: + parser.print_help() + print("\nError: Must specify one of --in-place, --output, or --dry-run", file=sys.stderr) + sys.exit(1) + + if args.in_place and args.output: + print("Error: Cannot specify both --in-place and --output", file=sys.stderr) + sys.exit(1) + + add_validation_macros(args.input_file, args.output, args.in_place, args.dry_run) + + +if __name__ == '__main__': + main() diff --git a/openzt-detour/src/lib.rs b/openzt-detour/src/lib.rs index 17231d3..98a791d 100644 --- a/openzt-detour/src/lib.rs +++ b/openzt-detour/src/lib.rs @@ -3,11 +3,12 @@ use std::marker::PhantomData; use retour::GenericDetour; pub mod generated; -pub mod structs; + +// pub mod structs; pub struct FunctionDef { pub address: u32, - function_type: PhantomData, + pub function_type: PhantomData, } impl FunctionDef @@ -29,3 +30,12 @@ where unsafe { ::retour::Function::from_ptr(self.address as *const ()) } } } + +#[cfg(feature = "detour-validation")] +pub struct ValidationEntry { + pub name: &'static str, + pub enable: fn() -> retour::Result<()>, +} + +#[cfg(feature = "detour-validation")] +inventory::collect!(ValidationEntry); diff --git a/openzt-instance-manager/README.md b/openzt-instance-manager/README.md index 33c8fe9..879ce26 100644 --- a/openzt-instance-manager/README.md +++ b/openzt-instance-manager/README.md @@ -65,7 +65,7 @@ console_start = 18081 console_end = 18181 [docker] -image = "finn/winezt:latest" +image = "finn/wine32-zoo:latest" container_prefix = "openzt-" [instances] diff --git a/openzt-instance-manager/config.toml b/openzt-instance-manager/config.toml index 375e205..2947afe 100644 --- a/openzt-instance-manager/config.toml +++ b/openzt-instance-manager/config.toml @@ -8,7 +8,7 @@ console_start = 18081 console_end = 18181 [docker] -image = "finn/winezt:latest" +image = "finn/wine32-zoo:latest" container_prefix = "openzt-" [instances] diff --git a/openzt-instance-manager/install.ps1 b/openzt-instance-manager/install.ps1 new file mode 100644 index 0000000..775375b --- /dev/null +++ b/openzt-instance-manager/install.ps1 @@ -0,0 +1,376 @@ +# OpenZT Instance Manager Installation Script (Windows) +# This script installs the server and client binaries and sets up a Scheduled Task +# Must be run as Administrator + +param ( + [switch]$ServerOnly, + [switch]$CliOnly, + [switch]$Help +) + +if ($Help) { + Write-Host "Usage: .\install.ps1 [-ServerOnly] [-CliOnly] [-Help]" + Write-Host "" + Write-Host "Options:" + Write-Host " -ServerOnly Install only the server component" + Write-Host " -CliOnly Install only the CLI client" + Write-Host " -Help Show this help message" + Write-Host "" + Write-Host "If no option is specified, both server and CLI will be installed." + exit 0 +} + +# Default: install both +$InstallServer = -not $CliOnly +$InstallCli = -not $ServerOnly + +# Paths +$InstallDir = "$env:ProgramFiles\OpenZT Instance Manager" +$ConfigDir = "$env:ProgramData\openzt-instance-manager" +$ServiceName = "openzt-instance-manager" + +# --- Helpers --- + +function Write-Green($msg) { Write-Host $msg -ForegroundColor Green } +function Write-Yellow($msg) { Write-Host $msg -ForegroundColor Yellow } +function Write-Red($msg) { Write-Host $msg -ForegroundColor Red } + +function Require-Admin { + $principal = [Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent() + if (-not $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) { + Write-Red "Error: This script must be run as Administrator." + Write-Host "Right-click the script and select 'Run as administrator', or run from an elevated PowerShell." + exit 1 + } +} + +function Find-WorkspaceRoot($startDir) { + $dir = $startDir + while ($dir -ne $null) { + $cargoToml = Join-Path $dir "Cargo.toml" + if (Test-Path $cargoToml) { + $content = Get-Content $cargoToml -Raw + if ($content -match '(?m)^\[workspace\]') { + return $dir + } + } + $parent = Split-Path $dir -Parent + if ($parent -eq $dir) { break } + $dir = $parent + } + return $null +} + +# --- Main --- + +Require-Admin + +Write-Green "OpenZT Instance Manager Installer" +Write-Host "==================================" +Write-Host "" + +# Check Docker Desktop +Write-Host "Checking Docker..." +$dockerRunning = $false +try { + $dockerInfo = docker info 2>&1 + if ($LASTEXITCODE -eq 0) { $dockerRunning = $true } +} catch {} + +if (-not $dockerRunning) { + # Try checking for Docker Desktop process as a fallback + $dockerProcess = Get-Process "com.docker.proxy" -ErrorAction SilentlyContinue + if ($dockerProcess) { + $dockerRunning = $true + } +} + +if (-not $dockerRunning) { + Write-Yellow "Warning: Docker Desktop is not running or not installed." + Write-Host "The server requires Docker Desktop to manage Zoo Tycoon instances." + Write-Host "Please install Docker Desktop from: https://www.docker.com/products/docker-desktop/" + Write-Host "" + Write-Yellow "Aborting installation. Start Docker Desktop and re-run this script." + exit 1 +} +Write-Green "Docker is running." +Write-Host "" + +# Check Rust/Cargo +Write-Host "Checking for Rust/Cargo..." +$cargoCmd = Get-Command cargo -ErrorAction SilentlyContinue +if (-not $cargoCmd) { + Write-Red "Error: cargo not found." + Write-Host "" + Write-Host "Rust is required to build the binaries. Please install Rust manually:" + Write-Host " 1. Visit https://rustup.rs" + Write-Host " 2. Download and run rustup-init.exe" + Write-Host " 3. Follow the on-screen instructions (default installation is fine)" + Write-Host " 4. Restart your terminal, then re-run this script" + exit 1 +} +Write-Green "Cargo found: $($cargoCmd.Source)" +Write-Host "" + +# Find workspace root +$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path +$WorkspaceRoot = Find-WorkspaceRoot $ScriptDir + +if ($WorkspaceRoot) { + Write-Green "Found workspace root: $WorkspaceRoot" + Set-Location $WorkspaceRoot +} else { + Write-Yellow "No workspace found; building from: $ScriptDir" + Set-Location $ScriptDir +} + +Write-Host "" +Write-Green "Building binaries..." +Write-Host "Working directory: $(Get-Location)" +Write-Host "" + +if ($InstallServer) { + Write-Host "Building server (openzt-instance-manager)..." + cargo build --release --bin openzt-instance-manager + if ($LASTEXITCODE -ne 0) { + Write-Red "Error: Server build failed." + exit 1 + } +} + +if ($InstallCli) { + Write-Host "Building CLI (openzt)..." + cargo build --release --bin openzt --features cli + if ($LASTEXITCODE -ne 0) { + Write-Red "Error: CLI build failed." + exit 1 + } +} + +# Locate built binaries (workspace root or script dir) +$TargetDir = $null +$CwdTarget = Join-Path (Get-Location) "target\release" +$ScriptTarget = Join-Path $ScriptDir "target\release" + +$checkBin = if ($InstallServer) { "openzt-instance-manager.exe" } else { "openzt.exe" } +if (Test-Path (Join-Path $CwdTarget $checkBin)) { + $TargetDir = $CwdTarget +} elseif (Test-Path (Join-Path $ScriptTarget $checkBin)) { + $TargetDir = $ScriptTarget +} else { + Write-Red "Error: Cannot find built binaries." + Write-Host "Searched in:" + Write-Host " $CwdTarget" + Write-Host " $ScriptTarget" + Write-Host "" + Write-Host "Please check if the build succeeded." + exit 1 +} + +Write-Host "" +Write-Green "Installing binaries from: $TargetDir" + +# Verify binaries +if ($InstallServer -and -not (Test-Path "$TargetDir\openzt-instance-manager.exe")) { + Write-Red "Error: openzt-instance-manager.exe not found in $TargetDir" + exit 1 +} +if ($InstallCli -and -not (Test-Path "$TargetDir\openzt.exe")) { + Write-Red "Error: openzt.exe not found in $TargetDir" + exit 1 +} + +# Stop existing scheduled task if present (must stop BEFORE copying binaries) +if ($InstallServer) { + $existingTask = Get-ScheduledTask -TaskName $ServiceName -ErrorAction SilentlyContinue + if ($existingTask) { + Write-Yellow "Existing scheduled task found; stopping it first..." + Stop-ScheduledTask -TaskName $ServiceName -ErrorAction SilentlyContinue + # Wait a moment for the process to fully stop + Start-Sleep -Seconds 1 + Write-Green "Server stopped." + } +} + +# Create install dir +Write-Host "" +Write-Green "Creating install directory: $InstallDir" +New-Item -ItemType Directory -Path $InstallDir -Force | Out-Null + +# Copy binaries +if ($InstallServer) { + Copy-Item "$TargetDir\openzt-instance-manager.exe" "$InstallDir\" -Force + Write-Green "Installed: $InstallDir\openzt-instance-manager.exe" +} +if ($InstallCli) { + Copy-Item "$TargetDir\openzt.exe" "$InstallDir\" -Force + Write-Green "Installed: $InstallDir\openzt.exe" +} + +# Create config dir +Write-Host "" +Write-Green "Creating config directory: $ConfigDir" +New-Item -ItemType Directory -Path $ConfigDir -Force | Out-Null + +# Copy config.toml +$ConfigSource = $null +if (Test-Path "$ScriptDir\config.toml") { + $ConfigSource = "$ScriptDir\config.toml" +} elseif (Test-Path "config.toml") { + $ConfigSource = (Resolve-Path "config.toml").Path +} + +if ($ConfigSource) { + Copy-Item $ConfigSource "$ConfigDir\config.toml" -Force + Write-Host "Copied config from: $ConfigSource" +} else { + Write-Yellow "Warning: config.toml not found. The server will use defaults." + Write-Yellow "Place your config.toml in: $ConfigDir" +} + +# Add install dir to system PATH (if not already present) +Write-Host "" +Write-Green "Updating system PATH..." +$currentPath = [Environment]::GetEnvironmentVariable("PATH", "Machine") +if ($currentPath -split ";" -contains $InstallDir) { + Write-Host "PATH already contains: $InstallDir (skipped)" +} else { + [Environment]::SetEnvironmentVariable("PATH", "$currentPath;$InstallDir", "Machine") + Write-Green "Added to system PATH: $InstallDir" + Write-Yellow "Note: Open a new terminal for PATH changes to take effect." +} + +if ($InstallServer) { + # Enable Task Scheduler history (disabled by default on Windows) + Write-Host "Enabling Task Scheduler history..." + wevtutil set-log Microsoft-Windows-TaskScheduler/Operational /enabled:true | Out-Null + Write-Green "Task Scheduler history enabled." + + # Create a launcher script. + # Redirects server stdout/stderr to a log file so output is not silently discarded + # when running as a Scheduled Task. Task Scheduler itself handles WorkingDirectory. + Write-Host "" + Write-Green "Creating server launcher script..." + $LauncherPath = "$InstallDir\start-server.ps1" + $launcherContent = @" +# OpenZT Instance Manager - Server Launcher +# Captures stdout/stderr to a log file. Overwritten on each start. +Start-Process `` + -FilePath "$InstallDir\openzt-instance-manager.exe" `` + -WorkingDirectory "$ConfigDir" `` + -RedirectStandardOutput "$ConfigDir\server.log" `` + -RedirectStandardError "$ConfigDir\server-error.log" `` + -NoNewWindow `` + -Wait +"@ + Set-Content -Path $LauncherPath -Value $launcherContent -Encoding UTF8 + Write-Green "Created: $LauncherPath" + + # Remove existing scheduled task registration if present (task already stopped above) + $existingTask = Get-ScheduledTask -TaskName $ServiceName -ErrorAction SilentlyContinue + if ($existingTask) { + Write-Yellow "Removing existing scheduled task registration..." + Unregister-ScheduledTask -TaskName $ServiceName -Confirm:$false + Write-Green "Task removed." + } + + # Register a Scheduled Task. + # Task Scheduler is used instead of a Windows Service because the binary reads + # config.toml from its working directory, and New-ScheduledTaskAction supports + # -WorkingDirectory natively. Windows services have no equivalent for this. + Write-Host "" + Write-Green "Registering Scheduled Task: $ServiceName" + + $action = New-ScheduledTaskAction ` + -Execute "powershell.exe" ` + -Argument "-WindowStyle Hidden -NonInteractive -NoProfile -ExecutionPolicy Bypass -File `"$LauncherPath`"" ` + -WorkingDirectory $ConfigDir + + # Create multiple triggers: at startup and at logon + $trigger1 = New-ScheduledTaskTrigger -AtStartup + $trigger2 = New-ScheduledTaskTrigger -AtLogon + $triggers = @($trigger1, $trigger2) + + $settings = New-ScheduledTaskSettingsSet ` + -ExecutionTimeLimit ([TimeSpan]::Zero) ` + -RestartCount 3 ` + -RestartInterval (New-TimeSpan -Minutes 1) ` + -MultipleInstances IgnoreNew + + $principal = New-ScheduledTaskPrincipal ` + -UserId $env:USERNAME ` + -LogonType Interactive ` + -RunLevel Highest + + Register-ScheduledTask ` + -TaskName $ServiceName ` + -Description "OpenZT Instance Manager API Server" ` + -Action $action ` + -Trigger $triggers ` + -Settings $settings ` + -Principal $principal ` + -Force | Out-Null + + Write-Green "Scheduled task registered: $ServiceName" + + # Start the scheduled task + Write-Host "Starting server..." + Start-ScheduledTask -TaskName $ServiceName + Write-Green "Server started via scheduled task." +} + +# Summary +Write-Host "" +Write-Green "Installation complete!" +Write-Host "" +Write-Host "Binaries installed:" +if ($InstallServer) { Write-Host " - $InstallDir\openzt-instance-manager.exe (server)" } +if ($InstallCli) { Write-Host " - $InstallDir\openzt.exe (client)" } +Write-Host "" + +if ($InstallServer) { + Write-Host "Config directory: $ConfigDir" + Write-Host "" + Write-Host "To start the server:" + Write-Host " Start-ScheduledTask -TaskName $ServiceName" + Write-Host "" + Write-Host "To stop the server:" + Write-Host " Stop-ScheduledTask -TaskName $ServiceName" + Write-Host "" + Write-Host "The task is configured to start automatically at boot." + Write-Host "To disable auto-start:" + Write-Host " Disable-ScheduledTask -TaskName $ServiceName" + Write-Host "" + Write-Host "To check task status:" + Write-Host " Get-ScheduledTask -TaskName $ServiceName" + Write-Host "" + Write-Host "To view server logs:" + Write-Host " Get-Content '$ConfigDir\server.log'" + Write-Host " Get-Content '$ConfigDir\server-error.log'" + Write-Host " (logs are overwritten each time the server starts)" + Write-Host "" + Write-Host "To follow logs in real time:" + Write-Host " Get-Content '$ConfigDir\server.log' -Wait" + Write-Host "" +} + +if ($InstallCli) { + Write-Green "CLI usage examples (open a new terminal first for PATH to take effect):" + Write-Host " openzt health # Check API health" + Write-Host " openzt list # List instances" + Write-Host " openzt create # Create instance" + Write-Host " openzt get # Get instance details" + Write-Host " openzt logs # Get instance logs" + Write-Host " openzt delete # Delete instance" + Write-Host "" + Write-Host "Use 'openzt --help' for more information." + Write-Host "" +} + +if (-not $InstallServer -and $InstallCli) { + Write-Yellow "Note: Only the CLI was installed." + Write-Host "The CLI requires a running server. Make sure the server is installed and running" + Write-Host "on a reachable host, or set the OPENZT_API_URL environment variable:" + Write-Host " `$env:OPENZT_API_URL = 'http://your-server:3000'" + Write-Host "" +} diff --git a/openzt-instance-manager/src/bin/openzt.rs b/openzt-instance-manager/src/bin/openzt.rs index 58c4b44..81a2882 100644 --- a/openzt-instance-manager/src/bin/openzt.rs +++ b/openzt-instance-manager/src/bin/openzt.rs @@ -6,6 +6,8 @@ use std::path::PathBuf; // Conditionally include CLI dependencies #[cfg(feature = "cli")] +use base64::Engine; +#[cfg(feature = "cli")] use openzt_instance_manager::id_resolver::resolve_instance_id; // Conditionally include CLI dependencies @@ -55,6 +57,10 @@ async fn main() -> Result<()> { Commands::Start { id } => cmd_start(&client, &id, output_format).await, Commands::Restart { id } => cmd_restart(&client, &id, output_format).await, Commands::Health {} => cmd_health(&client, output_format).await, + Commands::DetourResults { id } => cmd_detour_results(&client, &id, output_format).await, + Commands::UploadScript { id, script_path } => { + cmd_upload_script(&client, &id, &script_path, output_format).await + } } } @@ -153,6 +159,21 @@ enum Commands { /// Instance ID (full UUID or short prefix) id: String, }, + + /// Show detour validation results for an instance + DetourResults { + /// Instance ID (full UUID or short prefix) + id: String, + }, + + /// Upload a Lua script to a running instance + UploadScript { + /// Instance ID (full UUID or short prefix) + id: String, + + /// Path to the Lua script file + script_path: PathBuf, + }, } #[cfg(feature = "cli")] @@ -161,6 +182,14 @@ struct InstanceConfigArgs { /// CPU limit in cores (e.g., 0.5 = 50%, 2.0 = 2 cores) #[arg(long)] cpulimit: Option, + + /// Comma-separated list of detour names to validate (e.g. bfapp/load_string,bfapp/win_main) + #[arg(long, value_delimiter = ',')] + validate_detours: Vec, + + /// Lua script files to upload to the instance + #[arg(long = "script", value_name = "FILE")] + scripts: Vec, } #[cfg(feature = "cli")] @@ -170,7 +199,7 @@ async fn cmd_create( config_args: InstanceConfigArgs, output_format: openzt_instance_manager::output::OutputFormat, ) -> Result<()> { - use openzt_instance_manager::instance::InstanceConfig; + use openzt_instance_manager::instance::{InstanceConfig, ScriptFile}; use openzt_instance_manager::output::{print_create_result, print_error}; // Check if DLL file exists @@ -179,11 +208,40 @@ async fn cmd_create( std::process::exit(1); } + // Load and encode scripts if provided + let scripts: Vec = config_args + .scripts + .iter() + .map(|path| { + let content = std::fs::read(path) + .map_err(|e| miette!("Failed to read script {}: {}", path.display(), e))?; + let filename = path.file_name() + .and_then(|n| n.to_str()) + .ok_or_else(|| miette!("Invalid script filename"))? + .to_string(); + let content_base64 = base64::prelude::BASE64_STANDARD.encode(&content); + Ok::<_, miette::ErrReport>(ScriptFile { + filename, + content: content_base64, + }) + }) + .collect::, _>>() + .unwrap_or_else(|e| { + print_error(&format!("Failed to load scripts: {}", e)); + std::process::exit(1); + }); + // Build instance config - let instance_config = if config_args.cpulimit.is_some() { + let validate_detours = if config_args.validate_detours.is_empty() { + None + } else { + Some(config_args.validate_detours.clone()) + }; + let instance_config = if config_args.cpulimit.is_some() || validate_detours.is_some() { Some(InstanceConfig { wine_debug_level: None, cpulimit: config_args.cpulimit, + validate_detours, }) } else { None @@ -191,7 +249,7 @@ async fn cmd_create( // Call the API let response = client - .create_instance(dll_path, instance_config) + .create_instance(dll_path, instance_config, scripts) .await .map_err(|e| miette!(e))?; @@ -390,6 +448,85 @@ async fn cmd_health( Ok(()) } +#[cfg(feature = "cli")] +async fn cmd_detour_results( + client: &openzt_instance_manager::client::InstanceClient, + id: &str, + output_format: openzt_instance_manager::output::OutputFormat, +) -> Result<()> { + use openzt_instance_manager::output::{print_detour_results, print_error, print_resolution_error}; + + let resolved_id = match resolve_instance_id(client, id).await { + Ok(resolved) => resolved, + Err(e) => { + print_resolution_error(&e); + std::process::exit(1); + } + }; + + match client.get_detour_results(&resolved_id).await { + Ok(results) => { + let output_json = output_format == openzt_instance_manager::output::OutputFormat::Json; + print_detour_results(&results, output_json); + if !results.passed { + std::process::exit(1); + } + } + Err(e) => { + print_error(&format!("Failed to get detour results: {}", e)); + std::process::exit(1); + } + } + + Ok(()) +} + +#[cfg(feature = "cli")] +async fn cmd_upload_script( + client: &openzt_instance_manager::client::InstanceClient, + id: &str, + script_path: &PathBuf, + output_format: openzt_instance_manager::output::OutputFormat, +) -> Result<()> { + use openzt_instance_manager::output::{print_error, print_resolution_error, print_success}; + + // Check if script file exists + if !script_path.exists() { + print_error(&format!("Script file not found: {}", script_path.display())); + std::process::exit(1); + } + + // Resolve ID (handles both short and full UUIDs) + let resolved_id = match resolve_instance_id(client, id).await { + Ok(resolved) => resolved, + Err(e) => { + print_resolution_error(&e); + std::process::exit(1); + } + }; + + match client.upload_script(&resolved_id, script_path).await { + Ok(response) => { + if output_format != openzt_instance_manager::output::OutputFormat::Json { + print_success(&format!( + "Uploaded script '{}' to instance {}", + response.filename, + &response.instance_id[..8] + )); + println!(" Path: {}", response.path); + } else { + println!("{}", serde_json::to_string_pretty(&response).unwrap()); + } + } + Err(e) => { + print_error(&format!("Failed to upload script: {}", e)); + std::process::exit(1); + } + } + + Ok(()) +} + // Stub for when CLI feature is not enabled #[cfg(not(feature = "cli"))] fn main() { diff --git a/openzt-instance-manager/src/client.rs b/openzt-instance-manager/src/client.rs index 2a8b43c..c65a06a 100644 --- a/openzt-instance-manager/src/client.rs +++ b/openzt-instance-manager/src/client.rs @@ -3,7 +3,7 @@ //! This module provides a convenient async client for interacting with //! the instance manager API endpoints. -use crate::instance::{CreateInstanceResponse, InstanceConfig, InstanceDetails, LogsResponse, InstanceStatusResponse}; +use crate::instance::{CreateInstanceResponse, DetourTestResults, InstanceConfig, InstanceDetails, LogsResponse, InstanceStatusResponse, UploadScriptResponse, ScriptFile}; use anyhow::{anyhow, Context, Result}; use base64::Engine; use futures_util::stream::Stream; @@ -51,6 +51,7 @@ impl InstanceClient { &self, dll_path: &Path, config: Option, + scripts: Vec, ) -> Result { // Read and encode the DLL file let dll_bytes = std::fs::read(dll_path) @@ -61,6 +62,7 @@ impl InstanceClient { let request = serde_json::json!({ "openzt_dll": dll_base64, "config": config, + "scripts": scripts, }); let response = self @@ -199,6 +201,18 @@ impl InstanceClient { self.handle_response(response).await } + /// Get detour validation results for an instance + pub async fn get_detour_results(&self, id: &str) -> Result { + let response = self + .http_client + .get(self.url(&format!("/api/instances/{}/detour-results", id))) + .send() + .await + .with_context(|| format!("Failed to get detour results for instance {}", id))?; + + self.handle_response(response).await + } + /// Restart a running instance pub async fn restart_instance(&self, id: &str) -> Result { let response = self @@ -211,6 +225,37 @@ impl InstanceClient { self.handle_response(response).await } + /// Upload a Lua script to an instance + pub async fn upload_script( + &self, + id: &str, + script_path: &Path, + ) -> Result { + // Read and encode the script file + let script_bytes = std::fs::read(script_path) + .with_context(|| format!("Failed to read script file: {}", script_path.display()))?; + + let script_base64 = base64::prelude::BASE64_STANDARD.encode(&script_bytes); + let filename = script_path.file_name() + .and_then(|n| n.to_str()) + .ok_or_else(|| anyhow!("Invalid script filename"))?; + + let request = serde_json::json!({ + "script_content": script_base64, + "filename": filename, + }); + + let response = self + .http_client + .post(self.url(&format!("/api/instances/{}/scripts", id))) + .json(&request) + .send() + .await + .with_context(|| format!("Failed to upload script to instance {}", id))?; + + self.handle_response(response).await + } + /// Handle a response, extracting the JSON body or returning an error async fn handle_response(&self, response: reqwest::Response) -> Result { let status = response.status(); diff --git a/openzt-instance-manager/src/config.rs b/openzt-instance-manager/src/config.rs index 15ef9c7..76d2fec 100644 --- a/openzt-instance-manager/src/config.rs +++ b/openzt-instance-manager/src/config.rs @@ -132,7 +132,7 @@ fn default_console_end() -> u16 { } fn default_docker_image() -> String { - "finn/winezt:latest".to_string() + "finn/wine32-zoo:latest".to_string() } fn default_container_prefix() -> String { diff --git a/openzt-instance-manager/src/docker.rs b/openzt-instance-manager/src/docker.rs index afdd163..b17cd10 100644 --- a/openzt-instance-manager/src/docker.rs +++ b/openzt-instance-manager/src/docker.rs @@ -4,9 +4,10 @@ use bollard::{ Config as ContainerConfig, CreateContainerOptions, RemoveContainerOptions, StartContainerOptions, StopContainerOptions, RestartContainerOptions, LogsOptions, ListContainersOptions, InspectContainerOptions, LogOutput, + UploadToContainerOptions, }, image::CreateImageOptions, - service::{PortBinding, ContainerSummary, ContainerInspectResponse}, + service::{PortBinding, ContainerSummary, ContainerInspectResponse, Mount, MountTypeEnum}, Docker, }; use chrono::{DateTime, Utc}; @@ -14,6 +15,8 @@ use futures_util::stream::{Stream, StreamExt}; use std::collections::HashMap; use std::io::Write; use std::pin::Pin; +use tokio::fs::File; +use tokio::io::AsyncReadExt; use crate::instance::{AppLogType, InstanceConfig, InstanceStatus}; @@ -72,6 +75,7 @@ impl DockerManager { vnc_port: u16, console_port: u16, dll_path: &str, + scripts_dir: Option<&str>, instance_config: &InstanceConfig, ) -> Result { let options = Some(CreateContainerOptions { @@ -107,20 +111,59 @@ impl DockerManager { if let Some(cpulimit) = instance_config.cpulimit { labels.insert("openzt.cpulimit".to_string(), cpulimit.to_string()); } + if let Some(ref detours) = instance_config.validate_detours { + if !detours.is_empty() { + labels.insert("openzt.validate_detours".to_string(), detours.join(",")); + } + } + + // The path is already in the correct format (Windows path on Windows, Linux path on Linux) + let dll_mount = Mount { + target: Some("/home/wineuser/res-openzt.dll".to_string()), + source: Some(dll_path.to_string()), + typ: Some(MountTypeEnum::BIND), + read_only: Some(true), + ..Default::default() + }; + tracing::debug!("Using mount: source={}, target={}", dll_path, dll_mount.target.as_ref().unwrap()); + + // Build mounts array - start with DLL mount + let mut mounts = vec![dll_mount]; + + // Add scripts mount if directory provided + if let Some(scripts_path) = scripts_dir { + let scripts_mount = Mount { + target: Some("/home/wineuser/scripts".to_string()), + source: Some(scripts_path.to_string()), + typ: Some(MountTypeEnum::BIND), + read_only: Some(true), + ..Default::default() + }; + tracing::debug!( + "Adding scripts mount: {} -> {}", + scripts_path, + scripts_mount.target.as_ref().unwrap() + ); + mounts.push(scripts_mount); + } + + // Build env vars + let mut env_vars = vec!["VNC_SERVER=yes".to_string()]; + if let Some(ref detours) = instance_config.validate_detours && !detours.is_empty() { + env_vars.push(format!("OPENZT_VALIDATE_DETOURS={}", detours.join(","))); + } + + env_vars.push("LIBGL_ALWAYS_SOFTWARE=1".to_string()); // Force software rendering for better compatibility let config = ContainerConfig { image: Some(image.to_string()), hostname: Some(name.to_string()), labels: Some(labels), - env: Some(vec![ - "VNC_SERVER=yes".to_string(), - ]), + env: Some(env_vars), exposed_ports: Some(exposed_ports), host_config: Some(bollard::service::HostConfig { port_bindings: Some(port_bindings), - binds: Some(vec![ - format!("{}:/home/wineuser/.wine/drive_c/Program Files (x86)/Microsoft Games/Zoo Tycoon/res-openzt.dll:ro", dll_path), - ]), + mounts: Some(mounts), ipc_mode: Some("host".to_string()), // CPU limits (equivalent to --cpus=) nano_cpus: instance_config.cpulimit @@ -130,7 +173,8 @@ impl DockerManager { ..Default::default() }; - let result = self.docker.create_container(options, config).await?; + let result = self.docker.create_container(options, config).await + .map_err(|e| anyhow::anyhow!("Docker error: {}", e))?; Ok(result.id) } @@ -394,6 +438,9 @@ impl DockerManager { } /// Write base64-encoded DLL to a temporary file +/// +/// On Windows with WSL2, this copies the file into the WSL2 filesystem +/// to ensure proper bind mount behavior. pub fn write_dll_to_temp(instance_id: &str, dll_base64: &str) -> Result { let dll_bytes = base64::Engine::decode(&base64::prelude::BASE64_STANDARD, dll_base64) .context("Failed to decode base64 DLL")?; @@ -406,24 +453,92 @@ pub fn write_dll_to_temp(instance_id: &str, dll_base64: &str) -> Result return Err(anyhow!("Invalid DLL format: missing MZ header")); } - let temp_path = format!("/tmp/openzt-{}.dll", instance_id); + // Write to temp directory + let mut temp_path = std::env::temp_dir(); + temp_path.push(format!("openzt-{}.dll", instance_id)); let mut file = std::fs::File::create(&temp_path) .context("Failed to create temp DLL file")?; file.write_all(&dll_bytes) .context("Failed to write DLL data")?; - tracing::info!("Wrote DLL to {}", temp_path); - Ok(temp_path) + let temp_path_str = temp_path.to_string_lossy().to_string(); + tracing::info!("Wrote DLL to {}", temp_path_str); + Ok(temp_path_str) } /// Clean up temporary DLL file pub fn cleanup_dll_temp(instance_id: &str) { - let temp_path = format!("/tmp/openzt-{}.dll", instance_id); + let mut temp_path = std::env::temp_dir(); + temp_path.push(format!("openzt-{}.dll", instance_id)); if let Err(e) = std::fs::remove_file(&temp_path) { - tracing::warn!("Failed to remove temp DLL file {}: {}", temp_path, e); + tracing::warn!("Failed to remove temp DLL file {}: {}", temp_path.display(), e); } else { - tracing::info!("Removed temp DLL file {}", temp_path); + tracing::info!("Removed temp DLL file {}", temp_path.display()); + } +} + +/// Get the scripts directory path for an instance +pub fn get_scripts_dir(instance_id: &str) -> std::path::PathBuf { + let mut temp_path = std::env::temp_dir(); + temp_path.push(format!("openzt-scripts-{}", instance_id)); + temp_path +} + +/// Create the scripts directory for an instance +pub fn ensure_scripts_dir(instance_id: &str) -> Result { + let scripts_dir = get_scripts_dir(instance_id); + + if !scripts_dir.exists() { + std::fs::create_dir(&scripts_dir) + .context("Failed to create scripts directory")?; + tracing::info!("Created scripts directory: {}", scripts_dir.display()); + } + + Ok(scripts_dir) +} + +/// Write a single script file to host temp directory +pub fn write_script_to_temp( + instance_id: &str, + filename: &str, + script_content_base64: &str, +) -> Result { + let script_bytes = base64::Engine::decode( + &base64::prelude::BASE64_STANDARD, + script_content_base64 + ).context("Failed to decode base64 script content")?; + + // Validate UTF-8 + let _script_content = String::from_utf8(script_bytes.clone()) + .context("Script content is not valid UTF-8")?; + + let scripts_dir = ensure_scripts_dir(instance_id)?; + let script_path = scripts_dir.join(filename); + + let mut file = std::fs::File::create(&script_path) + .context("Failed to create script file")?; + file.write_all(&script_bytes) + .context("Failed to write script content")?; + + tracing::info!("Wrote script to {}", script_path.display()); + Ok(script_path.to_string_lossy().to_string()) +} + +/// Clean up all script files for an instance +pub fn cleanup_scripts_temp(instance_id: &str) { + let scripts_dir = get_scripts_dir(instance_id); + + if let Err(e) = std::fs::remove_dir_all(&scripts_dir) { + if e.kind() != std::io::ErrorKind::NotFound { + tracing::warn!( + "Failed to remove scripts directory {}: {}", + scripts_dir.display(), + e + ); + } + } else { + tracing::info!("Removed scripts directory {}", scripts_dir.display()); } } @@ -477,12 +592,16 @@ impl DockerManager { let status = self.map_docker_status(&inspect.state.ok_or_else(|| anyhow!("Missing state"))?); let created_at = self.parse_created_timestamp(inspect.created.as_deref().ok_or_else(|| anyhow!("Missing created timestamp"))?)?; - // Extract cpulimit from labels (stored during creation) + // Extract config fields from labels (stored during creation) + let labels = inspect.config.as_ref().and_then(|c| c.labels.as_ref()); let config = InstanceConfig { - cpulimit: inspect.config.as_ref() - .and_then(|c| c.labels.as_ref()) - .and_then(|labels| labels.get("openzt.cpulimit")) + cpulimit: labels + .and_then(|l| l.get("openzt.cpulimit")) .and_then(|s| s.parse::().ok()), + validate_detours: labels + .and_then(|l| l.get("openzt.validate_detours")) + .map(|s| s.split(',').map(String::from).collect::>()) + .filter(|v| !v.is_empty()), ..Default::default() }; @@ -574,6 +693,35 @@ impl DockerManager { .map_err(|e| anyhow!("Invalid timestamp: {}", e)) } + /// Copy a file from host path into container using docker cp + pub async fn cp_to_container( + &self, + container_id: &str, + host_path: &str, + container_path: &str, + ) -> Result<()> { + // Read the file content + let mut file = File::open(host_path).await + .context("Failed to open file for copying")?; + let mut buffer = Vec::new(); + file.read_to_end(&mut buffer).await + .context("Failed to read file content")?; + + // Use bollard's upload to container (this implements docker cp) + let options = Some(UploadToContainerOptions { + path: container_path.to_string(), + ..Default::default() + }); + + self.docker + .upload_to_container(container_id, options, buffer.into()) + .await + .context("Failed to copy file to container")?; + + tracing::info!("Copied {} to container:{}", host_path, container_path); + Ok(()) + } + /// Refresh the status of a single instance by inspecting its container. /// Returns Ok(Some(status)) if the container exists, Ok(None) if the container /// was not found (deleted externally), or Err if Docker communication failed. diff --git a/openzt-instance-manager/src/instance.rs b/openzt-instance-manager/src/instance.rs index b54f548..c53887c 100644 --- a/openzt-instance-manager/src/instance.rs +++ b/openzt-instance-manager/src/instance.rs @@ -10,6 +10,7 @@ pub struct Instance { pub status: InstanceStatus, pub created_at: DateTime, pub config: InstanceConfig, + pub script_files: Vec, // Track script filenames for cleanup } #[derive(Debug, Clone, Serialize, Deserialize)] @@ -38,15 +39,36 @@ pub struct InstanceConfig { pub wine_debug_level: Option, #[serde(skip_serializing_if = "Option::is_none")] pub cpulimit: Option, // CPU cores (e.g., 0.5 = 50%, 2.0 = 2 cores) + #[serde(skip_serializing_if = "Option::is_none")] + pub validate_detours: Option>, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct DetourResult { + pub name: String, + pub called: bool, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct DetourTestResults { + pub instance_id: String, + pub results: Vec, + pub passed: bool, +} + +#[derive(Debug, Clone, Serialize, Deserialize)] +pub struct ScriptFile { + pub filename: String, + pub content: String, // base64-encoded Lua file content } #[derive(Debug, Deserialize)] pub struct CreateInstanceRequest { pub openzt_dll: String, #[serde(default)] - pub mods: Vec, - #[serde(default)] pub config: Option, + #[serde(default)] + pub scripts: Vec, // Scripts to upload at creation time } #[derive(Debug, Serialize, Deserialize)] @@ -100,21 +122,6 @@ impl AppLogType { AppLogType::IntegrationTests => "openzt_integration_tests.log", } } - - pub fn as_str(&self) -> &str { - match self { - AppLogType::Openzt => "openzt", - AppLogType::IntegrationTests => "integration-tests", - } - } - - pub fn from_str(s: &str) -> Option { - match s { - "openzt" => Some(AppLogType::Openzt), - "integration-tests" => Some(AppLogType::IntegrationTests), - _ => None, - } - } } #[derive(Debug, Serialize, Deserialize)] @@ -129,3 +136,16 @@ pub struct InstanceStatusResponse { pub id: String, pub status: String, } + +#[derive(Debug, Deserialize)] +pub struct UploadScriptRequest { + pub script_content: String, // base64-encoded Lua file content + pub filename: String, // script filename (e.g., "detour.lua") +} + +#[derive(Debug, Serialize, Deserialize)] +pub struct UploadScriptResponse { + pub instance_id: String, + pub filename: String, + pub path: String, // Full path where script was uploaded +} diff --git a/openzt-instance-manager/src/lib.rs b/openzt-instance-manager/src/lib.rs index b5c636c..101ec28 100644 --- a/openzt-instance-manager/src/lib.rs +++ b/openzt-instance-manager/src/lib.rs @@ -23,7 +23,7 @@ pub mod output; // Re-export commonly used types for external consumers pub use instance::{ CreateInstanceRequest, CreateInstanceResponse, Instance, InstanceConfig, InstanceDetails, - InstanceStatus, LogsResponse, + InstanceStatus, LogsResponse, ScriptFile, UploadScriptRequest, UploadScriptResponse, }; pub use state::AppState; diff --git a/openzt-instance-manager/src/output.rs b/openzt-instance-manager/src/output.rs index 1bfddba..48e08d8 100644 --- a/openzt-instance-manager/src/output.rs +++ b/openzt-instance-manager/src/output.rs @@ -3,12 +3,13 @@ //! This module provides utilities for formatting and displaying output //! in various formats (table, JSON) with colored terminal output. -use crate::instance::{CreateInstanceResponse, InstanceDetails, LogsResponse}; +use crate::instance::{CreateInstanceResponse, DetourTestResults, InstanceDetails, LogsResponse}; use console::{style, Color}; use tabled::{ settings::{ + object::Columns, object::Rows, - Alignment, Modify, Style, + Alignment, Modify, Style, Width, }, Table, Tabled, }; @@ -171,6 +172,8 @@ fn print_instance_list_table(instances: &[InstanceDetails]) { let mut table = Table::new(rows); table.with(Style::modern()); table.with(Modify::new(Rows::new(1..)).with(Alignment::left())); + // Wrap status column (index 4) to prevent overflow + table.with(Modify::new(Columns::new(4..5)).with(Width::wrap(50))); println!(); println!("{}", table); @@ -198,6 +201,37 @@ pub fn print_logs(logs_response: &LogsResponse, output_json: bool) { } } +/// Print detour validation results +pub fn print_detour_results(results: &DetourTestResults, output_json: bool) { + if output_json { + if let Ok(json) = serde_json::to_string_pretty(results) { + println!("{}", json); + } + return; + } + + println!(); + println!( + " Detour results for instance {}:", + style(&results.instance_id[..8]).fg(Color::Cyan) + ); + println!(); + for result in &results.results { + if result.called { + println!(" {} {}", style("✓ PASS").fg(Color::Green).bold(), result.name); + } else { + println!(" {} {}", style("✗ FAIL").fg(Color::Red).bold(), result.name); + } + } + println!(); + if results.passed { + print_success("ALL PASSED"); + } else { + print_error("FAILED"); + } + println!(); +} + /// Print the result of creating an instance pub fn print_create_result(response: &CreateInstanceResponse, output_json: bool) { if output_json { diff --git a/openzt-instance-manager/src/ports.rs b/openzt-instance-manager/src/ports.rs index c4dfb82..ab652a6 100644 --- a/openzt-instance-manager/src/ports.rs +++ b/openzt-instance-manager/src/ports.rs @@ -60,14 +60,6 @@ impl PortPool { self.release_console(console_port); } - pub fn vnc_available(&self) -> usize { - self.vnc_range.clone().count() - self.allocated_vnc.len() - } - - pub fn console_available(&self) -> usize { - self.console_range.clone().count() - self.allocated_console.len() - } - /// Add an existing VNC port allocation (for recovery) pub fn add_existing_vnc(&mut self, port: u16) -> anyhow::Result<()> { if !self.vnc_range.contains(&port) { diff --git a/openzt-instance-manager/src/routes.rs b/openzt-instance-manager/src/routes.rs index 36d889b..5e4265c 100644 --- a/openzt-instance-manager/src/routes.rs +++ b/openzt-instance-manager/src/routes.rs @@ -1,7 +1,8 @@ use super::{ instance::{ - AppLogType, CreateInstanceRequest, CreateInstanceResponse, Instance, - InstanceDetails, InstanceStatus, LogsResponse, InstanceStatusResponse, + AppLogType, CreateInstanceRequest, CreateInstanceResponse, DetourResult, + DetourTestResults, Instance, InstanceDetails, InstanceStatus, LogsResponse, + InstanceStatusResponse, UploadScriptRequest, UploadScriptResponse, }, state::AppState, }; @@ -34,6 +35,8 @@ pub fn create_router() -> Router>> { .route("/api/instances/{id}/stop", post(stop_instance)) .route("/api/instances/{id}/start", post(start_instance)) .route("/api/instances/{id}/restart", post(restart_instance)) + .route("/api/instances/{id}/detour-results", get(get_detour_results)) + .route("/api/instances/{id}/scripts", post(upload_script)) } async fn health_check() -> &'static str { @@ -65,6 +68,23 @@ async fn create_instance( ApiError::InvalidDll(e.to_string()) })?; + // Write scripts to temp directory if provided + let (scripts_dir, script_filenames) = if !req.scripts.is_empty() { + let dir = super::docker::ensure_scripts_dir(&instance_id) + .map_err(|e| ApiError::Internal(e.to_string()))?; + + let mut filenames = Vec::new(); + for script in &req.scripts { + super::docker::write_script_to_temp(&instance_id, &script.filename, &script.content) + .map_err(|e| ApiError::Internal(e.to_string()))?; + filenames.push(script.filename.clone()); + } + + (Some(dir.to_string_lossy().to_string()), filenames) + } else { + (None, Vec::new()) + }; + // Create instance record let instance = Instance { id: instance_id.clone(), @@ -74,6 +94,7 @@ async fn create_instance( status: InstanceStatus::Creating, created_at: Utc::now(), config: req.config.unwrap_or_default(), + script_files: script_filenames, }; { @@ -89,6 +110,7 @@ async fn create_instance( // Create Docker container (background task) let state_clone = state.clone(); let instance_id_clone = instance_id.clone(); + let scripts_dir_clone = scripts_dir.clone(); tokio::spawn(async move { if let Err(e) = create_container_task( state_clone.clone(), @@ -97,18 +119,26 @@ async fn create_instance( vnc_port, console_port, dll_path.clone(), + scripts_dir_clone, ) .await { - tracing::error!("Failed to create container for instance {}: {}", instance_id_clone, e); + let error_msg = format!("{:?}", e); // Use debug format to show full error chain + tracing::error!("Failed to create container for instance {}:\n{}", instance_id_clone, error_msg); // Clean up temp DLL file super::docker::cleanup_dll_temp(&instance_id_clone); + // Clean up temp script files + super::docker::cleanup_scripts_temp(&instance_id_clone); + // Update instance status to error and release ports let mut state_guard = state_clone.write().await; if let Some(instance) = state_guard.instances.get_mut(&instance_id_clone) { - instance.status = InstanceStatus::Error(e.to_string()); + tracing::info!("Updating instance {} status to Error", instance_id_clone); + instance.status = InstanceStatus::Error(error_msg.clone()); + } else { + tracing::error!("Instance {} not found in state map when trying to set error status", instance_id_clone); } state_guard.port_pool.release_pair(vnc_port, console_port); } @@ -130,6 +160,7 @@ async fn create_container_task( vnc_port: u16, console_port: u16, dll_path: String, + scripts_dir: Option, ) -> anyhow::Result<()> { let docker_manager = super::docker::DockerManager::new()?; @@ -156,7 +187,7 @@ async fn create_container_task( // Create container let container_id = match docker_manager - .create_container(&container_name, &image, vnc_port, console_port, &dll_path, &instance_config) + .create_container(&container_name, &image, vnc_port, console_port, &dll_path, scripts_dir.as_deref(), &instance_config) .await { Ok(id) => id, @@ -216,7 +247,10 @@ async fn list_instances( match docker_manager.refresh_instance_status(container_id).await { Ok(Some(status)) => { if let Some(inst) = state_guard.instances.get_mut(id) { - inst.status = status; + // Don't overwrite Error statuses - they represent permanent failures + if !matches!(inst.status, InstanceStatus::Error(_)) { + inst.status = status; + } } } Ok(None) => { @@ -319,6 +353,9 @@ async fn delete_instance( // Clean up temp DLL file super::docker::cleanup_dll_temp(&id); + // Clean up temp script files + super::docker::cleanup_scripts_temp(&id); + // Remove instance and release ports { let mut state_guard = state.write().await; @@ -572,12 +609,129 @@ async fn restart_instance( })) } +async fn get_detour_results( + State(state): State>>, + Path(id): Path, +) -> Result, ApiError> { + let (container_id, validate_detours) = { + let state_guard = state.read().await; + let instance = state_guard.instances.get(&id).ok_or(ApiError::NotFound)?; + let detours = instance.config.validate_detours.clone().ok_or_else(|| { + ApiError::Internal( + "No detours configured for this instance. Use --validate-detours when creating." + .to_string(), + ) + })?; + if detours.is_empty() { + return Err(ApiError::Internal( + "No detours configured for this instance".to_string(), + )); + } + (instance.container_id.clone(), detours) + }; + + if container_id.is_empty() { + return Err(ApiError::Internal("Container not yet created".to_string())); + } + + let docker_manager = super::docker::DockerManager::new()?; + // Read the full openzt.log (large tail to get everything) + let log_content = docker_manager + .get_app_logs(&container_id, AppLogType::Openzt, 1_000_000) + .await?; + + // Collect all DETOUR_CALLED names from the log. + // Log lines are structured tracing output, e.g.: + // 2026-03-07T04:15:33Z INFO openzt_detour::...: DETOUR_CALLED: ztworldmgr/create + let called: std::collections::HashSet = log_content + .lines() + .filter_map(|line| { + let marker = "DETOUR_CALLED: "; + line.find(marker).map(|pos| line[pos + marker.len()..].trim().to_string()) + }) + .collect(); + + let results: Vec = validate_detours + .iter() + .map(|name| DetourResult { + name: name.clone(), + called: called.contains(name.as_str()), + }) + .collect(); + + let passed = results.iter().all(|r| r.called); + + Ok(Json(DetourTestResults { + instance_id: id, + results, + passed, + })) +} + +async fn upload_script( + State(state): State>>, + Path(id): Path, + Json(req): Json, +) -> Result, ApiError> { + let (container_id, instance_id_full) = { + let state_guard = state.read().await; + let instance = state_guard.instances.get(&id).ok_or(ApiError::NotFound)?; + + if !matches!(instance.status, InstanceStatus::Running) { + return Err(ApiError::BadRequest("Instance must be running to upload scripts".to_string())); + } + + (instance.container_id.clone(), id.clone()) + }; + + if container_id.is_empty() { + return Err(ApiError::Internal("Container not yet created".to_string())); + } + + // Write script to temp + let script_path = super::docker::write_script_to_temp( + &instance_id_full, + &req.filename, + &req.script_content, + ).map_err(|e| ApiError::Internal(e.to_string()))?; + + // Copy to container using docker cp + let zt_scripts_path = "/home/wineuser/.wine/drive_c/Program Files (x86)/Microsoft Games/Zoo Tycoon/scripts"; + let container_path = format!("{}/{}", zt_scripts_path, req.filename); + + let docker_mgr = super::docker::DockerManager::new() + .map_err(|e| ApiError::Internal(e.to_string()))?; + + docker_mgr.cp_to_container(&container_id, &script_path, &container_path) + .await + .map_err(|e| ApiError::Internal(e.to_string()))?; + + // Track for cleanup + { + let mut state_guard = state.write().await; + if let Some(instance) = state_guard.instances.get_mut(&instance_id_full) { + if !instance.script_files.contains(&req.filename) { + instance.script_files.push(req.filename.clone()); + } + } + } + + tracing::info!("Uploaded script {} to instance {}", req.filename, instance_id_full); + + Ok(Json(UploadScriptResponse { + instance_id: instance_id_full, + filename: req.filename, + path: container_path, + })) +} + #[derive(Debug)] pub enum ApiError { NotFound, PortsExhausted, MaxInstancesReached, InvalidDll(String), + BadRequest(String), Internal(String), } @@ -596,6 +750,7 @@ impl IntoResponse for ApiError { (StatusCode::SERVICE_UNAVAILABLE, "Maximum instances reached".to_string()) } ApiError::InvalidDll(msg) => (StatusCode::BAD_REQUEST, msg), + ApiError::BadRequest(msg) => (StatusCode::BAD_REQUEST, msg), ApiError::Internal(msg) => (StatusCode::INTERNAL_SERVER_ERROR, msg), }; diff --git a/openzt-instance-manager/src/state.rs b/openzt-instance-manager/src/state.rs index 6ecebdd..adeda3f 100644 --- a/openzt-instance-manager/src/state.rs +++ b/openzt-instance-manager/src/state.rs @@ -76,6 +76,7 @@ impl AppState { status: info.status, created_at: info.created_at, config: info.config, + script_files: Vec::new(), // Scripts don't persist across restarts }; self.instances.insert(instance_id.to_string(), instance); diff --git a/openzt-instance-manager/uninstall.ps1 b/openzt-instance-manager/uninstall.ps1 new file mode 100644 index 0000000..927d08c --- /dev/null +++ b/openzt-instance-manager/uninstall.ps1 @@ -0,0 +1,70 @@ +# OpenZT Instance Manager Uninstallation Script (Windows) +# Must be run as Administrator + +$InstallDir = "$env:ProgramFiles\OpenZT Instance Manager" +$ConfigDir = "$env:ProgramData\openzt-instance-manager" +$ServiceName = "openzt-instance-manager" + +function Write-Green($msg) { Write-Host $msg -ForegroundColor Green } +function Write-Yellow($msg) { Write-Host $msg -ForegroundColor Yellow } +function Write-Red($msg) { Write-Host $msg -ForegroundColor Red } + +# Require Administrator +$principal = [Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent() +if (-not $principal.IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)) { + Write-Red "Error: This script must be run as Administrator." + Write-Host "Right-click the script and select 'Run as administrator', or run from an elevated PowerShell." + exit 1 +} + +Write-Red "OpenZT Instance Manager Uninstaller" +Write-Host "=====================================" +Write-Host "" + +# Stop and remove scheduled task +$task = Get-ScheduledTask -TaskName $ServiceName -ErrorAction SilentlyContinue +if ($task) { + if ($task.State -eq "Running") { + Write-Yellow "Stopping task: $ServiceName..." + Stop-ScheduledTask -TaskName $ServiceName -ErrorAction SilentlyContinue + } + Write-Yellow "Removing scheduled task: $ServiceName..." + Unregister-ScheduledTask -TaskName $ServiceName -Confirm:$false + Write-Host "Scheduled task removed." +} else { + Write-Host "Scheduled task '$ServiceName' not found (skipped)." +} + +# Remove install directory (binaries) +if (Test-Path $InstallDir) { + Write-Yellow "Removing install directory: $InstallDir..." + Remove-Item -Path $InstallDir -Recurse -Force + Write-Host "Removed: $InstallDir" +} else { + Write-Host "Install directory not found (skipped): $InstallDir" +} + +# Remove install dir from system PATH +Write-Yellow "Updating system PATH..." +$currentPath = [Environment]::GetEnvironmentVariable("PATH", "Machine") +$pathParts = $currentPath -split ";" | Where-Object { $_ -ne $InstallDir -and $_ -ne "" } +$newPath = $pathParts -join ";" +if ($newPath -ne $currentPath) { + [Environment]::SetEnvironmentVariable("PATH", $newPath, "Machine") + Write-Host "Removed from system PATH: $InstallDir" +} else { + Write-Host "PATH entry not found (skipped): $InstallDir" +} + +Write-Host "" +Write-Green "Uninstallation complete!" +Write-Host "" +Write-Host "The following have been removed:" +Write-Host " - $InstallDir (binaries and launcher script)" +Write-Host " - Scheduled Task: $ServiceName" +Write-Host " - PATH entry: $InstallDir" +Write-Host "" +Write-Yellow "Note: Config directory was preserved: $ConfigDir" +Write-Host "To remove it manually, run:" +Write-Host " Remove-Item -Path '$ConfigDir' -Recurse -Force" +Write-Host "" diff --git a/openzt/scripts/detour_test_automation.py b/openzt/scripts/detour_test_automation.py new file mode 100644 index 0000000..8e43d48 --- /dev/null +++ b/openzt/scripts/detour_test_automation.py @@ -0,0 +1,770 @@ +#!/usr/bin/env python3 +""" +Detour Test Automation Script for OpenZT + +This script automates the testing of OpenZT function detours using the +openzt-instance-manager CLI. It parses detours from generated.rs, reads +existing test results from CSV, distributes testing across multiple +endpoints, and records results. + +Result codes: + 0 = Not tested / not yet attempted + 1 = Crashed (detour caused game crash) + 2 = Success (detour called and exited cleanly) + 3 = In use (actively used in openzt source code) + +Usage: + python3 detour_test_automation.py [options] + +Options: + --config PATH Custom config file path + --detour NAME Test single detour (for debugging) + --resume Continue from existing CSV (default) + --fresh Start fresh, ignore existing results + --dry-run Show what would be tested without executing +""" + +import argparse +import base64 +import concurrent.futures +import csv +import datetime +import json +import re +import sys +import time +import urllib.error +import urllib.request +from dataclasses import dataclass +from pathlib import Path +from typing import Dict, List, Optional, Set, Tuple + +# Try to use standard library tomllib (Python 3.11+), fall back to tomli +try: + import tomllib + def load_toml(path): + with open(path, 'rb') as f: + return tomllib.load(f) +except ImportError: + try: + import tomli + def load_toml(path): + with open(path, 'rb') as f: + return tomli.load(f) + except ImportError: + print("Error: No TOML library available.") + print("Install tomli: pip install tomli") + sys.exit(1) + + +def http_request(url: str, method: str = 'GET', data: Optional[dict] = None, timeout: int = 30) -> Tuple[int, dict]: + """ + Make an HTTP request using urllib. + + Returns: + Tuple of (status_code, response_data) + """ + headers = {'Content-Type': 'application/json'} + + if data is not None: + body = json.dumps(data).encode('utf-8') + req = urllib.request.Request(url, data=body, headers=headers, method=method) + else: + req = urllib.request.Request(url, headers=headers, method=method) + + try: + with urllib.request.urlopen(req, timeout=timeout) as response: + response_data = json.load(response) + return response.status, response_data + except urllib.error.HTTPError as e: + # Try to read error response + try: + error_data = json.load(e) + return e.code, error_data + except: + return e.code, {'error': str(e)} + except urllib.error.URLError as e: + return 0, {'error': str(e)} + except Exception as e: + return 0, {'error': str(e)} + + +@dataclass +class Endpoint: + """Represents an openzt-instance-manager endpoint""" + url: str + max_instances: int + active_instances: int = 0 + + def can_allocate(self) -> bool: + return self.active_instances < self.max_instances + + def allocate(self) -> bool: + if self.can_allocate(): + self.active_instances += 1 + return True + return False + + def release(self): + self.active_instances = max(0, self.active_instances - 1) + + +@dataclass +class TestResult: + """Result of a detour test""" + detour_name: str + result: int # 0=not tested, 1=crashed, 2=success, 3=in use (actively used in openzt) + timestamp: str + instance_id: str = "" + + @staticmethod + def from_csv_row(row: Dict[str, str]) -> 'TestResult': + return TestResult( + detour_name=row['detour_name'], + result=int(row['result']), + timestamp=row.get('last_test_timestamp', ''), + instance_id=row.get('instance_id', '') + ) + + def to_csv_row(self) -> Dict[str, str]: + return { + 'detour_name': self.detour_name, + 'result': str(self.result), + 'last_test_timestamp': self.timestamp, + 'instance_id': self.instance_id + } + + @staticmethod + def result_code_to_string(code: int) -> str: + """Convert result code to human-readable string""" + codes = { + 0: "not tested", + 1: "crashed", + 2: "success", + 3: "in use" + } + return codes.get(code, f"unknown({code})") + + +@dataclass +class Config: + """Configuration from TOML file""" + max_parallel_instances: int + dll_path: Path + test_script_path: Path + results_csv_path: Path + endpoints: List[Endpoint] + test_timeout_seconds: int + poll_interval_seconds: int + + @staticmethod + def from_file(path: Path) -> 'Config': + data = load_toml(path) + testing = data['testing'] + execution = data['execution'] + + endpoints = [ + Endpoint(url=e['url'], max_instances=e['max_instances']) + for e in data['endpoints'] + ] + + return Config( + max_parallel_instances=testing['max_parallel_instances'], + dll_path=Path(testing['dll_path']), + test_script_path=Path(testing['test_script_path']), + results_csv_path=Path(testing['results_csv_path']), + endpoints=endpoints, + test_timeout_seconds=execution['test_timeout_seconds'], + poll_interval_seconds=execution['poll_interval_seconds'] + ) + + +class DetourTestAutomation: + """Main automation class for detour testing""" + + def __init__(self, config: Config, dry_run: bool = False): + self.config = config + self.dry_run = dry_run + self.results: Dict[str, TestResult] = {} + + def parse_detours_from_generated_rs(self, file_path: Path) -> Set[str]: + """Extract all detour names from generated.rs""" + pattern = r'#\[cfg_attr\(feature = "detour-validation", validate_detour\("([^"]+)"\)\)\]' + with open(file_path, 'r', encoding='utf-8') as f: + content = f.read() + detours = set(re.findall(pattern, content)) + return detours + + def parse_active_detours_from_source(self, source_dir: Path) -> Set[str]: + """ + Parse openzt source code to find actively used detours. + + Scans for #[detour(...)] patterns and their corresponding + openzt_detour::generated::module::FUNCTION imports to construct + full detour names (module/function). + + Returns: + Set of detour names that are actively used in openzt + """ + active_detours = set() + + # Find all Rust files in openzt/src + rust_files = list(source_dir.rglob('*.rs')) + + for rust_file in rust_files: + try: + with open(rust_file, 'r', encoding='utf-8') as f: + content = f.read() + + # Find all #[detour(FUNCTION_NAME)] patterns + detour_function_pattern = r'#\[detour\(([A-Z_][A-Z0-9_]*)\)\]' + detour_functions = re.findall(detour_function_pattern, content) + + if not detour_functions: + continue + + # Find all openzt_detour imports to determine module names + # Pattern: use openzt_detour::generated::module::{FUNCTION1, FUNCTION2, ...}; + import_pattern = r'use\s+openzt_detour::generated::([a-z_][a-z0-9_]*)::\{([^}]+)\}' + imports = re.findall(import_pattern, content) + + # Build a map of function name -> module name + fn_to_module = {} + for module, functions_str in imports: + # Extract function names (handle trailing commas, whitespace) + functions = [f.strip().rstrip(',') for f in functions_str.split(',')] + for func in functions: + if func: # Skip empty strings + fn_to_module[func] = module + + # Also check for single function imports: use openzt_detour::generated::module::FUNCTION; + single_import_pattern = r'use\s+openzt_detour::generated::([a-z_][a-z0-9_]*)::([A-Z_][A-Z0-9_]*)' + single_imports = re.findall(single_import_pattern, content) + for module, func in single_imports: + fn_to_module[func] = module + + # Match detour functions to their modules + for func in detour_functions: + if func in fn_to_module: + module = fn_to_module[func] + detour_name = f"{module}/{func.lower()}" + active_detours.add(detour_name) + else: + # Function not found in imports - might be in a #[detour_mod] + # Skip for now, these would need more complex parsing + pass + + except Exception as e: + print(f"Warning: Error parsing {rust_file}: {e}") + continue + + return active_detours + + def load_results_from_csv(self) -> Dict[str, TestResult]: + """Load existing test results from CSV""" + results = {} + csv_path = self.config.results_csv_path + + if csv_path.exists(): + with open(csv_path, 'r', newline='', encoding='utf-8') as f: + reader = csv.DictReader(f) + for row in reader: + result = TestResult.from_csv_row(row) + results[result.detour_name] = result + + return results + + def save_results_to_csv(self): + """Save current results to CSV""" + csv_path = self.config.results_csv_path + csv_path.parent.mkdir(parents=True, exist_ok=True) + + with open(csv_path, 'w', newline='', encoding='utf-8') as f: + fieldnames = ['detour_name', 'result', 'last_test_timestamp', 'instance_id'] + writer = csv.DictWriter(f, fieldnames=fieldnames) + writer.writeheader() + + for result in self.results.values(): + writer.writerow(result.to_csv_row()) + + def read_file_as_base64(self, path: Path) -> str: + """Read file and return base64-encoded content""" + with open(path, 'rb') as f: + content = f.read() + return base64.b64encode(content).decode('utf-8') + + def create_instance(self, endpoint: Endpoint, detour_name: str) -> Tuple[bool, str, Optional[str]]: + """ + Create an instance with detour validation enabled. + + Returns: + Tuple of (success, instance_id, error_message) + """ + if self.dry_run: + print(f" [DRY RUN] Would create instance on {endpoint.url} for detour {detour_name}") + return True, "dry-run-id", None + + try: + # Read DLL and Lua script + dll_b64 = self.read_file_as_base64(self.config.dll_path) + script_b64 = self.read_file_as_base64(self.config.test_script_path) + + # Build request body + request_body = { + "openzt_dll": dll_b64, + "config": { + "validate_detours": [detour_name] + }, + "scripts": [ + { + "filename": "auto_test_detours.lua", + "content": script_b64 + } + ] + } + + # Send request + status_code, data = http_request( + f"{endpoint.url}/api/instances", + method='POST', + data=request_body, + timeout=30 + ) + + if status_code == 200: + instance_id = data['instance_id'] + return True, instance_id, None + else: + error_msg = data.get('error', str(data)) if data else 'Unknown error' + return False, "", f"HTTP {status_code}: {error_msg}" + + except Exception as e: + return False, "", str(e) + + def get_instance_status(self, endpoint: Endpoint, instance_id: str) -> Tuple[bool, Optional[str], Optional[str]]: + """ + Get instance status. + + Returns: + Tuple of (success, status, error_message) + """ + if self.dry_run: + return True, "running", None + + try: + status_code, data = http_request( + f"{endpoint.url}/api/instances/{instance_id}", + timeout=10 + ) + + if status_code == 200: + return True, data['status'], None + else: + error_msg = data.get('error', str(data)) if data else 'Unknown error' + return False, None, f"HTTP {status_code}: {error_msg}" + + except Exception as e: + return False, None, str(e) + + def get_detour_results(self, endpoint: Endpoint, instance_id: str) -> Tuple[bool, Optional[dict], Optional[str]]: + """ + Get detour test results. + + Returns: + Tuple of (success, results_dict, error_message) + """ + if self.dry_run: + return True, {"passed": True, "results": [{"name": "test", "called": True}]}, None + + try: + status_code, data = http_request( + f"{endpoint.url}/api/instances/{instance_id}/detour-results", + timeout=10 + ) + + if status_code == 200: + return True, data, None + else: + error_msg = data.get('error', str(data)) if data else 'Unknown error' + return False, None, f"HTTP {status_code}: {error_msg}" + + except Exception as e: + return False, None, str(e) + + def delete_instance(self, endpoint: Endpoint, instance_id: str) -> bool: + """Delete an instance""" + if self.dry_run: + print(f" [DRY RUN] Would delete instance {instance_id}") + return True + + try: + status_code, _ = http_request( + f"{endpoint.url}/api/instances/{instance_id}", + method='DELETE', + timeout=10 + ) + return status_code == 200 or status_code == 404 + except Exception: + return False + + def wait_for_test_completion(self, endpoint: Endpoint, instance_id: str, detour_name: str) -> int: + """ + Wait for test to complete and determine result. + + Returns: + Result code: 0=not called, 1=crashed, 2=success + """ + if self.dry_run: + print(f" [DRY RUN] Would wait for test completion for detour {detour_name}") + return 2 # Assume success in dry run + + start_time = time.time() + timeout = self.config.test_timeout_seconds + interval = self.config.poll_interval_seconds + + while time.time() - start_time < timeout: + # Check instance status + success, status, err = self.get_instance_status(endpoint, instance_id) + if not success: + print(f" Error getting instance status: {err}") + time.sleep(interval) + continue + + # If instance is in error state, it crashed + if status == "error": + print(f" Instance {instance_id} crashed (status: error)") + return 1 # Crashed + + # If instance stopped, check detour results + if status == "stopped": + success, results, err = self.get_detour_results(endpoint, instance_id) + if success and results: + if results.get('passed', False): + # Check if our detour was called + for result in results.get('results', []): + if result.get('name') == detour_name and result.get('called', False): + print(f" Detour {detour_name} was called successfully") + return 2 # Success + + # Detour wasn't called + print(f" Detour {detour_name} was not called") + return 0 # Not called + else: + print(f" Detour validation failed: {results}") + return 0 # Not called + else: + print(f" Error getting detour results: {err}") + return 0 # Not called + + # Still running or creating, wait + time.sleep(interval) + + # Timeout + print(f" Timeout waiting for detour {detour_name}") + return 0 # Not called + + def test_detour(self, detour_name: str, endpoints: List[Endpoint]) -> TestResult: + """ + Test a single detour. + + Args: + detour_name: Name of the detour to test + endpoints: List of available endpoints + + Returns: + TestResult with outcome + """ + # Find available endpoint + endpoint = None + for ep in endpoints: + if ep.allocate(): + endpoint = ep + break + + if endpoint is None: + print(f" No available endpoints for detour {detour_name}") + return TestResult( + detour_name=detour_name, + result=0, + timestamp=datetime.datetime.now(datetime.timezone.utc).isoformat().replace('+00:00', 'Z'), + instance_id="" + ) + + print(f"Testing detour: {detour_name} on {endpoint.url}") + + # Create instance + success, instance_id, err = self.create_instance(endpoint, detour_name) + if not success: + print(f" Failed to create instance: {err}") + endpoint.release() + return TestResult( + detour_name=detour_name, + result=0, + timestamp=datetime.datetime.now(datetime.timezone.utc).isoformat().replace('+00:00', 'Z'), + instance_id="" + ) + + print(f" Created instance: {instance_id}") + + # Wait for test completion + result_code = self.wait_for_test_completion(endpoint, instance_id, detour_name) + + # Delete instance + if self.delete_instance(endpoint, instance_id): + print(f" Deleted instance: {instance_id}") + else: + print(f" Warning: Failed to delete instance {instance_id}") + + # Release endpoint + endpoint.release() + + # Return result + result_str = TestResult.result_code_to_string(result_code) + print(f" Result: {result_str}") + + return TestResult( + detour_name=detour_name, + result=result_code, + timestamp=datetime.datetime.now(datetime.timezone.utc).isoformat().replace('+00:00', 'Z'), + instance_id=instance_id + ) + + def run_tests(self, detours: Set[str], fresh: bool = False, source_dir: Optional[Path] = None): + """ + Run tests for all or specified detours. + + Args: + detours: Set of detour names to test + fresh: If True, ignore existing results + source_dir: Path to openzt source code to find active detours + """ + # Load existing results + if not fresh: + self.results = self.load_results_from_csv() + print(f"Loaded {len(self.results)} existing results from CSV") + else: + self.results = {} + print("Starting fresh (ignoring existing results)") + + # Parse active detours from source if provided + active_detours = set() + if source_dir and source_dir.exists(): + print(f"Parsing active detours from {source_dir}...") + active_detours = self.parse_active_detours_from_source(source_dir) + print(f"Found {len(active_detours)} actively used detours in openzt source") + + # Mark active detours as "in use" (result code 3) + # This updates existing results or adds new ones + timestamp = datetime.datetime.now(datetime.timezone.utc).isoformat().replace('+00:00', 'Z') + for detour in active_detours: + # Only update if not already marked as in use + if detour in self.results: + if self.results[detour].result != 3: + # Update to "in use" but preserve timestamp if it exists + existing = self.results[detour] + self.results[detour] = TestResult( + detour_name=detour, + result=3, # 3 = in use + timestamp=existing.timestamp if existing.timestamp else timestamp, + instance_id=existing.instance_id + ) + else: + # Add new entry for active detour + self.results[detour] = TestResult( + detour_name=detour, + result=3, # 3 = in use + timestamp=timestamp, + instance_id="" + ) + + # Save updated results with active detours + self.save_results_to_csv() + + # Filter out already tested detours (including active detours) + if not fresh: + untested = detours - set(self.results.keys()) + print(f"Found {len(detours)} total detours, {len(untested)} untested (excluding {len(active_detours)} active)") + detours_to_test = untested + else: + detours_to_test = detours + print(f"Testing {len(detours)} detours") + + if self.dry_run: + print("\n[DRY RUN] No actual tests will be executed\n") + + # Track overall progress + total = len(detours_to_test) + completed = 0 + passed = 0 + failed = 0 + crashed = 0 + in_use = len(active_detours) + + # Use ThreadPoolExecutor for parallel execution + max_workers = min(self.config.max_parallel_instances, len(self.config.endpoints)) + + with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor: + # Submit all test jobs + future_to_detour = {} + for detour in sorted(detours_to_test): + future = executor.submit(self.test_detour, detour, self.config.endpoints) + future_to_detour[future] = detour + + # Process completed tests + for future in concurrent.futures.as_completed(future_to_detour): + detour = future_to_detour[future] + try: + result = future.result() + self.results[result.detour_name] = result + completed += 1 + + # Update counters + if result.result == 2: + passed += 1 + elif result.result == 1: + crashed += 1 + else: + failed += 1 + + # Save results after each test + self.save_results_to_csv() + + # Print progress + print(f"\nProgress: {completed}/{total} | " + f"Passed: {passed} | Crashed: {crashed} | Not Called: {failed} | In Use: {in_use}\n") + + except Exception as e: + print(f"Error testing detour {detour}: {e}") + completed += 1 + failed += 1 + + # Print summary + print("\n" + "="*60) + print("TEST SUMMARY") + print("="*60) + print(f"Total detours: {len(detours)}") + print(f"Tested this run: {completed}") + print(f"Passed: {passed}") + print(f"Crashed: {crashed}") + print(f"Not Called: {failed}") + print(f"In Use (active in openzt): {in_use}") + print(f"Results saved to: {self.config.results_csv_path}") + print("="*60) + + # List detours that need investigation + print("\nDetours that crashed (may need fixing):") + crashed_detours = [d for d, r in self.results.items() if r.result == 1] + if crashed_detours: + for detour in sorted(crashed_detours): + print(f" - {detour}") + else: + print(" None") + + print("\nDetours not called (may need specific game actions):") + not_called = [d for d, r in self.results.items() if r.result == 0] + if not_called: + for detour in sorted(not_called)[:20]: # Show first 20 + print(f" - {detour}") + if len(not_called) > 20: + print(f" ... and {len(not_called) - 20} more") + else: + print(" None") + + print("\nDetours actively used in openzt:") + active_list = [d for d, r in self.results.items() if r.result == 3] + if active_list: + for detour in sorted(active_list)[:30]: # Show first 30 + print(f" - {detour}") + if len(active_list) > 30: + print(f" ... and {len(active_list) - 30} more") + else: + print(" None") + + +def main(): + """Main entry point""" + parser = argparse.ArgumentParser( + description="Automated detour testing for OpenZT", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=__doc__ + ) + parser.add_argument( + '--config', + type=Path, + default=Path(__file__).parent / 'detour_test_config.toml', + help='Path to configuration file' + ) + parser.add_argument( + '--detour', + type=str, + help='Test single detour (for debugging)' + ) + parser.add_argument( + '--resume', + action='store_true', + default=True, + help='Continue from existing CSV (default)' + ) + parser.add_argument( + '--fresh', + action='store_true', + help='Start fresh, ignore existing results' + ) + parser.add_argument( + '--dry-run', + action='store_true', + help='Show what would be tested without executing' + ) + + args = parser.parse_args() + + # Load configuration + if not args.config.exists(): + print(f"Error: Config file not found: {args.config}") + sys.exit(1) + + config = Config.from_file(args.config) + + # Validate paths + if not config.dll_path.exists(): + print(f"Error: DLL not found: {config.dll_path}") + print("Please build OpenZT first with: ./openzt.bat build --release") + sys.exit(1) + + if not config.test_script_path.exists(): + print(f"Error: Test script not found: {config.test_script_path}") + sys.exit(1) + + # Create automation instance + automation = DetourTestAutomation(config, dry_run=args.dry_run) + + # Parse detours + generated_rs = Path(__file__).parent.parent.parent / 'openzt-detour' / 'src' / 'generated.rs' + if not generated_rs.exists(): + print(f"Error: generated.rs not found: {generated_rs}") + sys.exit(1) + + all_detours = automation.parse_detours_from_generated_rs(generated_rs) + print(f"Found {len(all_detours)} detours in {generated_rs}") + + # Filter to single detour if specified + if args.detour: + if args.detour in all_detours: + detours_to_test = {args.detour} + else: + print(f"Error: Detour not found: {args.detour}") + print(f"Available detours: {', '.join(sorted(all_detours)[:10])}") + sys.exit(1) + else: + detours_to_test = all_detours + + # Find openzt source directory for parsing active detours + source_dir = Path(__file__).parent.parent / 'src' + + # Run tests + fresh = args.fresh + automation.run_tests(detours_to_test, fresh=fresh, source_dir=source_dir) + + +if __name__ == '__main__': + main() diff --git a/openzt/scripts/detour_test_config.toml b/openzt/scripts/detour_test_config.toml new file mode 100644 index 0000000..0aca438 --- /dev/null +++ b/openzt/scripts/detour_test_config.toml @@ -0,0 +1,17 @@ +# Testing constraints +[testing] +max_parallel_instances = 10 # Maximum instances to test at once +dll_path = "F:/RustroverProjects/openzt/target/i686-pc-windows-msvc/release/openzt.dll" +test_script_path = "F:/RustroverProjects/openzt/openzt/scripts/auto_test_detours.lua" +results_csv_path = "F:/RustroverProjects/openzt/detour_test_results.csv" + +# OpenZT Instance Manager endpoints +# Multiple endpoints allow distributing load across servers +[[endpoints]] +url = "http://localhost:3000" +max_instances = 5 # Max instances this endpoint can support + +# Test execution settings +[execution] +test_timeout_seconds = 180 # Total time to wait for test completion (startup + test + shutdown) +poll_interval_seconds = 5 # How often to check instance/detour status diff --git a/openzt/src/bfconfigfile.rs b/openzt/src/bfconfigfile.rs index cf07209..eb66321 100644 --- a/openzt/src/bfconfigfile.rs +++ b/openzt/src/bfconfigfile.rs @@ -1,7 +1,7 @@ //! `BFConfigFile` is the vanilla base class for anything that loads itself from a `.cfg`-style INI //! block via `getInt`/`getFloat`/`getString`/`getStringList` (e.g. `ZTResearchProgram`, -//! `ZTResearchCategory`, `ZTResearchBranch` - see `resources/decompiles/BFConfigFile_*` and -//! `resources/decompiles/ZTResearch*_load*`). Those classes inherit it directly (`this` gets cast +//! `ZTResearchCategory`, `ZTResearchBranch` - see `private/resources/decompiles/BFConfigFile_*` and +//! `private/resources/decompiles/ZTResearch*_load*`). Those classes inherit it directly (`this` gets cast //! straight to `BFConfigFile*` when calling its methods), so it occupies their first `0xc` bytes. //! //! Only the raw layout is modeled here, not `parse`/`getInt`/etc. themselves - callers that already @@ -9,7 +9,7 @@ use std::fmt; -/// Confirmed via `resources/decompiles/BFConfigFile_BFConfigFile.c`/`_attempt.c`/`_parse.c` and +/// Confirmed via `private/resources/decompiles/BFConfigFile_BFConfigFile.c`/`_attempt.c`/`_parse.c` and /// cross-checked against every `ZTResearch*::load*` function that inherits it. #[derive(Debug, Clone, Copy, Default)] #[repr(C)] diff --git a/openzt/src/bfentitytype.rs b/openzt/src/bfentitytype.rs index 92dfe2c..70682bc 100644 --- a/openzt/src/bfentitytype.rs +++ b/openzt/src/bfentitytype.rs @@ -80,8 +80,9 @@ pub struct BFEntityType { pub bf_config_file_ptr: u32, // 0x080 pad9: [u8; 0x098 - 0x084], // ----------------------- padding: 20 bytes pub zt_type: ZTBoundedString, // 0x098 - pub zt_sub_type: ZTBoundedString, // 0x0A0 - pad10: [u8; 0x0B4 - 0x0A8], // ----------------------- padding: 12 bytes + pub zt_sub_type: ZTBoundedString, // 0x0A4 + pad10: [u8; 0x0B4 - 0x0A8], // ----------------------- padding: 4 bytes + // pad10: [u8; 0x0B4 - 0x0B0], // ----------------------- padding: 4 bytes pub footprintx: i32, // 0x0B4 pub footprinty: i32, // 0x0B8 pub footprintz: i32, // 0x0BC @@ -92,8 +93,6 @@ pub struct BFEntityType { pad11: [u8; 0x100 - 0x0CD], // ----------------------- padding: 51 bytes } -const _: () = assert!(std::mem::size_of::() == 0x100); - impl BFEntityType { // returns the codename of the entity type pub fn get_codename(&self) -> String { @@ -767,8 +766,6 @@ pub struct BFUnitType { pad2: [u8; 0x144 - 0x138], // ----------------------- padding: 16 bytes } -const _: () = assert!(std::mem::size_of::() == 0x144); - impl EntityType for BFUnitType { fn print_config_integers(&self) -> String { format!( @@ -830,29 +827,7 @@ pub struct ZTUnitType { pub skip_trick_chance: i32, // 0x184 } -const _: () = assert!(std::mem::size_of::() == 0x188); - impl ZTUnitType { - /// Confirmed real vtable VA for `ZTUnitType` in zoo.exe (see `private/docs/vtables/ZTUnitType.md`). - /// `ZTUnitType` overrides `BFEntityType`'s `+0x1c` slot with a different function (confirmed by - /// the vtable diff docs), so fixtures must use this class's own vtable, not `BFEntityType`'s - /// - see `ztunit-ztanimal-footprint-crash-investigation.md`. - const VTABLE_PTR: u32 = 0x0062e404; - - /// Test-only fixture: a zero-filled `ZTUnitType` with a real vtable pointer, needed because - /// `ZTUnit::getFootprint` virtually dispatches through `entity_type`'s vtable (not its own) in - /// its `use_map_footprint=true` branch. `mem::zeroed()` is otherwise safe: every other field is - /// an integer/bool/byte-array. - pub fn new_for_test(footprint: IVec3, map_footprint: i32) -> Self { - let mut entity_type: ZTUnitType = unsafe { std::mem::zeroed() }; - entity_type.bfunit_type.bfentitytype.vtable = Self::VTABLE_PTR; - entity_type.bfunit_type.bfentitytype.footprintx = footprint.x; - entity_type.bfunit_type.bfentitytype.footprinty = footprint.y; - entity_type.bfunit_type.bfentitytype.footprintz = footprint.z; - entity_type.map_footprint = map_footprint; - entity_type - } - pub fn get_list_name(&self) -> String { let obj_ptr = self as *const ZTUnitType as u32; get_string_from_memory(get_from_memory::(obj_ptr + 0x168)) @@ -1166,8 +1141,6 @@ pub struct ZTAnimalType { pub egg_footprint: IVec3, // 0x410 } -const _: () = assert!(std::mem::size_of::() == 0x41c); - impl EntityType for ZTAnimalType { fn print_config_integers(&self) -> String { format!("{}\ncBoxFootprintX: {}\ncBoxFootprintY: {}\ncBoxFootprintZ: {}\ncFamily: {}\ncGenus: {}\ncHabitat: {}\ncLocation: {}\ncEra: {}\ncBreathThreshold: {}\ncBreathIncrement: {}\ncHungerThreshold: {}\ncHungryHealthChange: {}\ncHungerIncrement: {}\ncFoodUnitValue: {}\ncKeeperFoodUnitsEaten: {}\ncNeededFood: {}\ncNoFoodChange: {}\ncInitialHappiness: {}\ncMaxHits: {}\ncPctHits: {}\ncMaxEnergy: {}\ncMaxDirty: {}\ncMinDirty: {}\ncSickChange: {}\ncOtherAnimalSickChange: {}\ncSickChance: {}\ncSickRandomChance: {}\ncCrowd: {}\ncCrowdHappinessChange: {}\ncZapHappinessChange: {}\ncCaptivity: {}\ncReproductionChance: {}\ncReproductionInterval: {}\ncMatingType: {}\ncOffspring: {}\ncKeeperFrequency: {}\ncNotEnoughKeepersChange: {}\ncSocial: {}\ncHabitatSize: {}\ncNumberAnimalsMin: {}\ncNumberAnimalsMax: {}\ncNumberMinChange: {}\ncNumberMaxChange: {}\ncHabitatPreference: {}\ncBabyBornChange: {}\ncEnergyIncrement: {}\ncEnergyThreshold: {}\ncDirtyIncrement: {}\ncDirtyThreshold: {}\ncSickTime: {}\ncBabyToAdult: {}\ncOtherFood: {}\ncTreePref: {}\ncRockPref: {}\ncSpacePref: {}\ncElevationPref: {}\ncDepthMin: {}\ncDepthMax: {}\ncDepthChange: {}\ncSalinityChange: {}\ncSalinityHealthChange: {}\ncHappyReproduceThreshold: {}\ncBuildingUseChance: {}\ncNoMateChange: {}\ncTimeDeath: {}\ncDeathChance: {}\ncDirtChance: {}\ncWaterNeeded: {}\ncUnderwaterNeeded: {}\ncLandNeeded: {}\ncEnterWaterChance: {}\ncEnterTankChance: {}\ncEnterLandChance: {}\ncDrinkWaterChance: {}\ncChaseAnimalChance: {}\ncClimbsCliffs: {}\ncBashStrength: {}\ncAttractiveness: {}\ncKeeperFoodType: {}\ncIsClimber: {}\ncIsJumper: {}\ncSmallZoodoo: {}\ncDinoZoodoo: {}\ncGiantZoodoo: {}\ncIsSpecialAnimal: {}\ncNeedShelter: {}\ncNeedToys: {}\ncBabiesAttack: {}\n EggFootprintX: {}\ncEggFootprintY: {}\ncEggFootprintZ: {}\n", @@ -1279,25 +1252,6 @@ impl EntityType for ZTAnimalType { } } -impl ZTAnimalType { - /// Confirmed real vtable VA for `ZTAnimalType` in zoo.exe (see `private/docs/vtables/ZTAnimalType.md`). - /// See `ZTUnitType::VTABLE_PTR` for why the type's own vtable is required, not `BFEntityType`'s. - const VTABLE_PTR: u32 = 0x00630268; - - /// Test-only fixture, see `ZTUnitType::new_for_test`. - pub fn new_for_test(footprint: IVec3, map_footprint: i32, box_footprint: IVec3, egg_footprint: IVec3) -> Self { - let mut entity_type: ZTAnimalType = unsafe { std::mem::zeroed() }; - entity_type.ztunit_type.bfunit_type.bfentitytype.vtable = Self::VTABLE_PTR; - entity_type.ztunit_type.bfunit_type.bfentitytype.footprintx = footprint.x; - entity_type.ztunit_type.bfunit_type.bfentitytype.footprinty = footprint.y; - entity_type.ztunit_type.bfunit_type.bfentitytype.footprintz = footprint.z; - entity_type.ztunit_type.map_footprint = map_footprint; - entity_type.box_footprint = box_footprint; - entity_type.egg_footprint = egg_footprint; - entity_type - } -} - impl Deref for ZTAnimalType { type Target = ZTUnitType; @@ -2069,52 +2023,3 @@ pub fn command_make_sel(args: Vec<&str>) -> Result { Ok(format!("Entity type {} is now selectable", entity_type.bfentitytype.get_type_name())) } } - -#[cfg(test)] -mod tests { - use super::*; - - // Explicit list (not derived from the enum) so it visibly needs updating when a - // variant is added and the match arm in `FromStr` is forgotten. - const ZT_ENTITY_TYPE_CLASS_CASES: &[(ZTEntityTypeClass, &str)] = &[ - (ZTEntityTypeClass::Animal, "animal"), - (ZTEntityTypeClass::Ambient, "ambient"), - (ZTEntityTypeClass::Guest, "guest"), - (ZTEntityTypeClass::Fence, "fence"), - (ZTEntityTypeClass::TourGuide, "tourguide"), - (ZTEntityTypeClass::Building, "building"), - (ZTEntityTypeClass::Scenery, "scenery"), - (ZTEntityTypeClass::Food, "food"), - (ZTEntityTypeClass::TankFilter, "tankfilter"), - (ZTEntityTypeClass::Path, "path"), - (ZTEntityTypeClass::Rubble, "rubble"), - (ZTEntityTypeClass::TankWall, "tankwall"), - (ZTEntityTypeClass::Keeper, "keeper"), - (ZTEntityTypeClass::MaintenanceWorker, "maintenanceworker"), - (ZTEntityTypeClass::Drt, "drt"), - (ZTEntityTypeClass::BFOverlay, "bfoverlay"), - (ZTEntityTypeClass::BFUnit, "bfunit"), - (ZTEntityTypeClass::ZTUnit, "ztunit"), - (ZTEntityTypeClass::Staff, "staff"), - (ZTEntityTypeClass::BFEntity, "bfentity"), - ]; - - #[test] - fn test_zt_entity_type_class_from_str_round_trip() { - for (variant, s) in ZT_ENTITY_TYPE_CLASS_CASES { - assert_eq!(s.parse::().unwrap(), *variant, "failed to parse '{}'", s); - } - } - - #[test] - fn test_zt_entity_type_class_from_str_case_insensitive() { - assert_eq!("Animal".parse::().unwrap(), ZTEntityTypeClass::Animal); - assert_eq!("ANIMAL".parse::().unwrap(), ZTEntityTypeClass::Animal); - assert_eq!("aNiMaL".parse::().unwrap(), ZTEntityTypeClass::Animal); - } - - #[test] - fn test_zt_entity_type_class_from_str_unknown_is_err() { - assert!("not_a_real_entity_type_class".parse::().is_err()); - } -} diff --git a/openzt/src/bfregistry.rs b/openzt/src/bfregistry.rs index 36863bd..4b176b4 100644 --- a/openzt/src/bfregistry.rs +++ b/openzt/src/bfregistry.rs @@ -4,7 +4,7 @@ use openzt_detour_macro::detour_mod; use std::sync::LazyLock; use tracing::info; -use crate::{command_console::CommandError, lua_fn, util::get_from_memory}; +use crate::{command_console::CommandError, lua_fn, util::{get_from_memory, MemAddr}}; static BF_REGISTRY: LazyLock>> = LazyLock::new(|| Mutex::new(HashMap::new())); @@ -21,9 +21,9 @@ pub fn list_registry() -> Result { Ok(string_array.join("\n")) } -pub fn add_to_registry(key: &String, value: u32) { +pub fn add_to_registry(key: &String, value: impl MemAddr) { let mut data_mutex = BF_REGISTRY.lock().unwrap(); - data_mutex.insert(key.to_string(), value); + data_mutex.insert(key.to_string(), value.as_u32()); } pub fn get_from_registry(key: String) -> Option { @@ -65,19 +65,19 @@ mod zoo_bf_registry { use openzt_detour::generated::uielement::REGISTERIT as UIELEMENT_REGISTERIT; #[detour(PTR_GET)] - unsafe extern "thiscall" fn prt_get(_this_prt: u32, class_name: u32, _param_2: bool) -> u32 { + unsafe extern "thiscall" fn prt_get(_this_prt: *const u32, class_name: *const i8, _param_2: bool) -> u32 { get_from_registry(get_string_from_memory(get_from_memory::(class_name))).unwrap() } #[detour(BFMGR_REGISTERIT)] - unsafe extern "cdecl" fn add_to_bfregistry(param_1: u32, param_2: u32) -> u32 { + unsafe extern "cdecl" fn add_to_bfregistry(param_1: *const u32, param_2: *const u32) -> u32 { let param_1_string = get_string_from_memory(get_from_memory::(param_1)); add_to_registry(¶m_1_string, param_2); 0x638001 } #[detour(UIELEMENT_REGISTERIT)] - unsafe extern "cdecl" fn add_to_bfregistry_ui(param_1: u32, param_2: u32) -> u32 { + unsafe extern "cdecl" fn add_to_bfregistry_ui(param_1: *const u32, param_2: *const u32) -> u32 { let param_1_string = get_string_from_memory(get_from_memory::(param_1)); add_to_registry(¶m_1_string, param_2); 0x638001 diff --git a/openzt/src/capture_ztlog.rs b/openzt/src/capture_ztlog.rs index f109635..6b722c8 100644 --- a/openzt/src/capture_ztlog.rs +++ b/openzt/src/capture_ztlog.rs @@ -45,7 +45,7 @@ mod zoo_logging { use openzt_detour::generated::bflog::LOG_MESSAGE; #[detour(LOG_MESSAGE)] - unsafe extern "cdecl" fn zoo_log_func(source_file: u32, line_number: i32, level: i32, _param_4: i8, _param_5: i32, _param_6: i32, log_message: u32) { + unsafe extern "cdecl" fn zoo_log_func(source_file: *const i8, line_number: i32, level: i32, _param_4: i8, _param_5: i32, _param_6: u32, log_message: *const u8) { let source_file_string = get_string_from_memory(source_file); let log_message_string = get_string_from_memory(log_message); log_from_zt(&source_file_string, line_number, level, &log_message_string); diff --git a/openzt/src/command_console.rs b/openzt/src/command_console.rs index 279dff3..665e407 100644 --- a/openzt/src/command_console.rs +++ b/openzt/src/command_console.rs @@ -78,7 +78,7 @@ pub mod zoo_console { use super::call_next_command; #[detour(UPDATE_SIM)] - unsafe extern "thiscall" fn zoo_zt_app_update_game(_this_ptr: u32, param_2: i32) { + unsafe extern "thiscall" fn zoo_zt_app_update_game(_this_ptr: *const u32, param_2: i32) { call_next_command(); unsafe { UPDATE_SIM_DETOUR.call(_this_ptr, param_2) } } @@ -125,6 +125,13 @@ pub fn call_next_command() { #[cfg(feature = "tui")] tui_console::add_command_output(result.clone()); + // Log command output if enabled in config or when detour-validation is active + let config = crate::resource_manager::mod_config::get_openzt_config(); + let should_log = cfg!(feature = "detour-validation") || config.logging.log_command_output; + if should_log { + info!("Command result: {}", result); + } + let mut result_mutex = COMMAND_RESULTS.lock().unwrap(); result_mutex.push(result); } @@ -189,6 +196,15 @@ pub fn start_server() { info!("Listening on {}...", listen_addr); + // Auto-load detour test script if detour-validation is enabled + #[cfg(all(feature = "detour-validation", feature = "command-console"))] + { + match crate::scripting::load_lua_file("scripts/detour.lua") { + Ok(msg) => info!("Detour script loaded: {}", msg), + Err(e) => info!("Detour script loading failed: {}", e), + } + } + for stream in listener.incoming() { match stream { Ok(stream) => { diff --git a/openzt/src/detour_validation.rs b/openzt/src/detour_validation.rs new file mode 100644 index 0000000..008c741 --- /dev/null +++ b/openzt/src/detour_validation.rs @@ -0,0 +1,63 @@ +//! Detour validation: logs when annotated game functions are called. +//! +//! To add a new function: annotate its FunctionDef const in +//! openzt-detour/src/generated.rs with: +//! #[cfg_attr(feature = "detour-validation", validate_detour("module/fn"))] +//! +//! Then rebuild and run: +//! ./openzt.bat validate-detours module/fn +//! ./openzt.bat validate-detours all + +use openzt_detour_macro::detour_mod; + +#[detour_mod] +mod detours_validation { + + use openzt_detour::generated::ztui::EXIT_APP; + + #[detour(EXIT_APP)] + unsafe extern "stdcall" fn exit_app() { + tracing::info!("OPENZT_CLEAN_SHUTDOWN"); + unsafe { EXIT_APP_DETOUR.call() }; + } +} + +fn write_shutdown_marker() { + use std::io::Write; + let path = crate::util::get_base_path().join("openzt.log"); + if let Ok(mut file) = std::fs::OpenOptions::new().append(true).open(path) { + let _ = writeln!(file, "OPENZT_CLEAN_SHUTDOWN"); + } +} + +pub fn init(enabled: &[&str]) { + use std::panic::AssertUnwindSafe; + + match std::panic::catch_unwind(AssertUnwindSafe(|| unsafe { detours_validation::init_detours() })) { + Ok(Ok(())) => tracing::info!("Clean shutdown marker detour enabled"), + Ok(Err(e)) => tracing::error!("Failed to enable clean shutdown marker detour: {}", e), + Err(_) => tracing::error!("Panic enabling clean shutdown marker detour; address may be wrong"), + } + + let enable_all = enabled.iter().any(|&s| s == "all"); + + for entry in inventory::iter::() { + if !enable_all && !enabled.contains(&entry.name) { + continue; + } + match std::panic::catch_unwind(AssertUnwindSafe(entry.enable)) { + Ok(Ok(())) => + tracing::info!("Validation detour enabled: {}", entry.name), + Ok(Err(e)) => + tracing::error!( + "Failed to enable validation detour '{}': {}. \ + Possible: already hooked by main codebase.", entry.name, e + ), + Err(_) => + tracing::error!( + "Panic enabling validation detour '{}'. \ + Address in generated.rs is likely wrong.", entry.name + ), + } + } +} diff --git a/openzt/src/experimental.rs b/openzt/src/experimental.rs index 8120ebe..a007caf 100644 --- a/openzt/src/experimental.rs +++ b/openzt/src/experimental.rs @@ -10,23 +10,51 @@ use tracing::info; #[detour_mod] pub mod zoo_experimental { - use openzt_detour::generated::bfuimgr::DISPLAY_MESSAGE_0; + use std::marker::PhantomData; + + use openzt_detour::{FunctionDef, generated::bfuimgr::DISPLAY_MESSAGE_0, generated::ztscenerytype::GET_HELP_ID}; use tracing::info; + use crate::util::{Addr, get_from_memory}; - // use crate::{ - // bfregistry::{add_to_registry, get_from_registry}, - // util::{get_from_memory, get_string_from_memory}, - // }; + + // uint __thiscall FUN_0061c95c(void *this,char **param_1) + const ZTSHOWSCRIPTSTATE_SAVE: FunctionDef u8> = FunctionDef{address: 0x0061c95c, function_type: PhantomData}; + + #[detour(ZTSHOWSCRIPTSTATE_SAVE)] + unsafe extern "thiscall" fn zt_show_script_state(_this_ptr: u32, param_1: u32) -> u8 { + info!("FUN_0061c95c called with params: {:#x}, {:#x}", _this_ptr, param_1); + let result = unsafe { ZTSHOWSCRIPTSTATE_SAVE_DETOUR.call(_this_ptr, param_1) }; + info!("FUN_0061c95c called with params: {:#x}, {:#x} -> {}", _this_ptr, param_1, result); + result + } #[detour(DISPLAY_MESSAGE_0)] - unsafe extern "thiscall" fn prt_get(_this_prt: u32, param_1: u32, param_2: i32, param_3: u32, param_4: u32, param_5: bool, param_6: bool) { + unsafe extern "thiscall" fn prt_get(_this_prt: *const u32, param_1: u32, param_2: i32, param_3: *const u32, param_4: *const u32, param_5: bool, param_6: bool) { info!( "BFUIMgr::displayMessage called with params: {}, {}, {}, {}, {}, {}", - param_1, param_2, param_3, param_4, param_5, param_6 + param_1, param_2, Addr::of(param_3), Addr::of(param_4), param_5, param_6 ); unsafe { DISPLAY_MESSAGE_0_DETOUR.call(_this_prt, param_1, param_2, param_3, param_4, param_5, param_6) }; } + #[detour(GET_HELP_ID)] + unsafe extern "thiscall" fn get_help_id(_this_ptr: *const u32) -> u32 { + // Log this pointer in hex + info!("GET_HELP_ID called, this: {:#x}", _this_ptr as u32); + + // Read what this pointer points to (first u32 value at that address) + let this_value = get_from_memory::(_this_ptr); + info!(" this points to: {:#x}", this_value); + + // Call original function + let result = unsafe { GET_HELP_ID_DETOUR.call(_this_ptr) }; + + // Log return value in both hex and decimal + info!(" returned: {:#x} ({})", result, result); + + result + } + // // 0x431c3e : void __thiscall FUN_00431c3e(void *this,int *param_1,int *param_2,char param_3,int **param_4) // #[hook(unsafe extern "thiscall" FUN_00431c3e, offset = 0x00031c3e)] // fn fun_00431c3e(_this: u32, param_1: u32, param_2: u32, param_3: u8, param_4: u32) { @@ -52,7 +80,7 @@ pub mod zoo_experimental { } pub fn init() { - if let Err(e) = unsafe { zoo_experimental::init_detours() } { - info!("Error initialising experimental detours: {}", e); - }; + // if let Err(e) = unsafe { zoo_experimental::init_detours() } { + // info!("Error initialising experimental detours: {}", e); + // }; } diff --git a/openzt/src/integration_tests/mod.rs b/openzt/src/integration_tests/mod.rs index fb29db5..92ebbdb 100644 --- a/openzt/src/integration_tests/mod.rs +++ b/openzt/src/integration_tests/mod.rs @@ -95,14 +95,9 @@ macro_rules! integration_tests { pub fn init() { #[cfg(target_os = "windows")] { - #[cfg(feature = "tui")] - let tui_config: Option<&crate::tui_console::TuiConfig> = None; - #[cfg(not(feature = "tui"))] - let tui_config = None; - if let Err(e) = crate::logging::init_with_console( &crate::logging::LoggingConfig::default(), - tui_config, + #[cfg(feature = "tui")] None, ) { eprintln!("Failed to initialize logging: {}", e); } @@ -163,7 +158,7 @@ mod detour_zoo_main { use std::io::Write as IoWrite; #[detour(LOAD_LANG_DLLS)] - unsafe extern "thiscall" fn detour_target(_this: u32) -> u32 { + unsafe extern "thiscall" fn detour_target(_this: *const u32) -> u32 { info!("Integration tests starting..."); // Clear load order tracker diff --git a/openzt/src/logging.rs b/openzt/src/logging.rs index 4d411ad..49add33 100644 --- a/openzt/src/logging.rs +++ b/openzt/src/logging.rs @@ -237,6 +237,10 @@ pub struct LoggingConfig { /// Log level (default: Warn) #[serde(default)] pub level: LogLevel, + + /// Log command execution results to openzt.log (default: false, overridden to true when detour-validation enabled) + #[serde(default)] + pub log_command_output: bool, } /// Log level setting for OpenZT logging @@ -270,6 +274,7 @@ impl Default for LoggingConfig { LoggingConfig { log_to_file: true, level: LogLevel::Warn, + log_command_output: false, } } } diff --git a/openzt/src/reimplementation_tests/mod.rs b/openzt/src/reimplementation_tests/mod.rs index b6062d0..e9e57c8 100644 --- a/openzt/src/reimplementation_tests/mod.rs +++ b/openzt/src/reimplementation_tests/mod.rs @@ -17,14 +17,9 @@ mod io_redirect; pub fn init() { #[cfg(target_os = "windows")] { - #[cfg(feature = "tui")] - let tui_config: Option<&crate::tui_console::TuiConfig> = None; - #[cfg(not(feature = "tui"))] - let tui_config = None; - if let Err(e) = crate::logging::init_with_console( &crate::logging::LoggingConfig::default(), - tui_config, + #[cfg(feature = "tui")] None, ) { eprintln!("Failed to initialize logging: {}", e); } @@ -71,19 +66,14 @@ mod detour_zoo_main { #[cfg(target_os = "windows")] use openzt_detour::generated::bfapp::LOAD_LANG_DLLS; - use openzt_detour::generated::bfentity::GET_FOOTPRINT as BFENTITY_GET_FOOTPRINT; use openzt_detour::generated::bftile::GET_LOCAL_ELEVATION; - use openzt_detour::generated::ztanimal::GET_FOOTPRINT as ZTANIMAL_GET_FOOTPRINT; - use openzt_detour::generated::ztunit::GET_FOOTPRINT as ZTUNIT_GET_FOOTPRINT; - use openzt_detour::FunctionDef; use proptest::prelude::*; use tracing::{error, info}; use crate::{ - bfentitytype::{BFEntityType, ZTAnimalType, ZTUnitType}, ztmapview::BFTile, ztresearch::research_save_reimplementation::{self, live_support, SaveRecord}, - ztworldmgr::{BFEntity, IVec3, ZTAnimal, ZTUnit}, + ztworldmgr::IVec3, }; use super::io_redirect; @@ -216,7 +206,7 @@ mod detour_zoo_main { // TODO: Fix this so it works with a crate/mod prefix #[detour(LOAD_LANG_DLLS)] - unsafe extern "thiscall" fn detour_target(_this: u32) -> u32 { + unsafe extern "thiscall" fn detour_target(_this: *const u32) -> u32 { info!("Detour success"); // Read filepath from environment variable with default @@ -252,13 +242,11 @@ mod detour_zoo_main { let result = GET_LOCAL_ELEVATION.original()(&raw const tile as *const u32, &raw const pos as *const u32); assert_eq!( result, - reimplemented_result, - "Failed for pos: {:?}, tile: {:?}, unknown_byte_2: {}, real: {}, reimplemented: {}", + reimplemented_result + 1, + "Failed for pos: {:?}, tile: {:?}, unknown_byte_2: {}", pos, tile, - unknown_byte_2, - result, - reimplemented_result + unknown_byte_2 ); Ok(()) }) { @@ -268,11 +256,7 @@ mod detour_zoo_main { Err(e) => { error!("Proptest failed: {:?}", e); if let proptest::test_runner::TestError::Fail(r, (x, y)) = e { - let pos = IVec3::new(x, y, 0); - let tile = BFTile::new(pos, unknown_byte_2); - let reimplemented_result = tile.get_local_elevation(pos); - let result = GET_LOCAL_ELEVATION.original()(&raw const tile as *const u32, &raw const pos as *const u32); - let failure_line = format!("unknown_byte_2: {}, x: {}, y: {}, real: {}, reimplemented: {}\n", unknown_byte_2, x, y, result, reimplemented_result); + let failure_line = format!("unknown_byte_2: {}, x: {}, y: {}\n", unknown_byte_2, x, y); if let Some(ref mut log_file) = failure_log { if let Err(write_err) = log_file.write_all(failure_line.as_bytes()) { @@ -299,10 +283,6 @@ mod detour_zoo_main { } } - fail_flag |= run_bfentity_get_footprint_tests(&mut failure_log); - fail_flag |= run_ztunit_get_footprint_tests(&mut failure_log); - fail_flag |= run_ztanimal_get_footprint_tests(&mut failure_log); - // ZTRESEARCHMGR_SAVE: compares the real ZTResearchMgr::save's captured output against // research_save_reimplementation::serialize(&snapshot_mgr(mgr)) for generated synthetic trees. { @@ -403,215 +383,8 @@ mod detour_zoo_main { } if fail_flag { - error!("Proptest failed for some cases, check the failure log at: {}", failure_log_path); std::process::exit(1); } std::process::exit(0); } - - fn write_success_line(failure_log: &mut Option, test_name: &str) { - let success_line = format!("Test Passed {}\n", test_name); - if let Some(log_file) = failure_log { - if let Err(write_err) = log_file.write_all(success_line.as_bytes()) { - error!("Failed to write to failure log: {}", write_err); - } - } - } - - /// Calls the real GET_FOOTPRINT function at `entity_ptr` and reads the `IVec3` it writes back. - fn call_original_get_footprint( - original: FunctionDef *const u32>, - entity_ptr: *const u32, - use_map_footprint: bool, - ) -> IVec3 { - let mut result = IVec3::default(); - unsafe { - (original.original())(entity_ptr, &raw mut result as *const u32, use_map_footprint); - } - result - } - - fn run_bfentity_get_footprint_tests(failure_log: &mut Option) -> bool { - let runner_config = ProptestConfig { - failure_persistence: Some(Box::new(super::NoopFailurePersistence)), - ..ProptestConfig::default() - }; - let mut runner = proptest::test_runner::TestRunner::new(runner_config); - let test_name = "BFENTITY_GET_FOOTPRINT"; - let mut fail_flag = false; - - match runner.run( - &(-1000i32..1000i32, -1000i32..1000i32, -1000i32..1000i32, -8i32..8i32, proptest::bool::ANY), - |(fx, fy, fz, rotation, use_map_footprint)| { - let mut entity_type: BFEntityType = unsafe { std::mem::zeroed() }; - entity_type.footprintx = fx; - entity_type.footprinty = fy; - entity_type.footprintz = fz; - - let entity = BFEntity::new_for_test(&raw const entity_type as u32, rotation, 0); - - let reimplemented_result = entity.get_footprint(use_map_footprint); - let real_result = call_original_get_footprint(BFENTITY_GET_FOOTPRINT, &raw const entity as *const u32, use_map_footprint); - - assert_eq!( - (real_result.x, real_result.y, real_result.z), - (reimplemented_result.x, reimplemented_result.y, reimplemented_result.z), - "BFEntity::get_footprint mismatch: fx={}, fy={}, fz={}, rotation={}, use_map_footprint={}, real={:?}, reimplemented={:?}", - fx, fy, fz, rotation, use_map_footprint, real_result, reimplemented_result - ); - Ok(()) - }, - ) { - Ok(_) => { - info!("Proptest passed for {}", test_name); - write_success_line(failure_log, test_name); - } - Err(e) => { - error!("Proptest failed: {:?}", e); - if let proptest::test_runner::TestError::Fail(r, (fx, fy, fz, rotation, use_map_footprint)) = e { - let failure_line = format!( - "{}: fx={}, fy={}, fz={}, rotation={}, use_map_footprint={}, reason={}\n", - test_name, fx, fy, fz, rotation, use_map_footprint, r - ); - if let Some(log_file) = failure_log { - if let Err(write_err) = log_file.write_all(failure_line.as_bytes()) { - error!("Failed to write to failure log: {}", write_err); - } - } - fail_flag = true; - } - } - } - - fail_flag - } - - /// `ZTUnit::getFootprint`'s `use_map_footprint=true` branch virtual-dispatches through - /// `entity_type`'s vtable (not `this`'s own), so the fixture's `ZTUnitType` needs a real - /// vtable pointer - see `ZTUnitType::new_for_test` / `ztunit-ztanimal-footprint-crash-investigation.md`. - fn run_ztunit_get_footprint_tests(failure_log: &mut Option) -> bool { - let runner_config = ProptestConfig { - failure_persistence: Some(Box::new(super::NoopFailurePersistence)), - ..ProptestConfig::default() - }; - let mut runner = proptest::test_runner::TestRunner::new(runner_config); - let test_name = "ZTUNIT_GET_FOOTPRINT"; - let mut fail_flag = false; - - match runner.run( - &( - -1000i32..1000i32, - -1000i32..1000i32, - -1000i32..1000i32, - -1000i32..1000i32, - -8i32..8i32, - proptest::bool::ANY, - ), - |(fx, fy, fz, map_footprint, rotation, use_map_footprint)| { - let entity_type = ZTUnitType::new_for_test(IVec3::new(fx, fy, fz), map_footprint); - let entity = ZTUnit::new_for_test(&raw const entity_type as u32, rotation, 0); - - let reimplemented_result = entity.get_footprint(use_map_footprint); - let real_result = call_original_get_footprint(ZTUNIT_GET_FOOTPRINT, &raw const entity as *const u32, use_map_footprint); - - assert_eq!( - (real_result.x, real_result.y, real_result.z), - (reimplemented_result.x, reimplemented_result.y, reimplemented_result.z), - "ZTUnit::get_footprint mismatch: fx={}, fy={}, fz={}, map_footprint={}, rotation={}, use_map_footprint={}, real={:?}, reimplemented={:?}", - fx, fy, fz, map_footprint, rotation, use_map_footprint, real_result, reimplemented_result - ); - Ok(()) - }, - ) { - Ok(_) => { - info!("Proptest passed for {}", test_name); - write_success_line(failure_log, test_name); - } - Err(e) => { - error!("Proptest failed: {:?}", e); - if let proptest::test_runner::TestError::Fail(r, (fx, fy, fz, map_footprint, rotation, use_map_footprint)) = e { - let failure_line = format!( - "{}: fx={}, fy={}, fz={}, map_footprint={}, rotation={}, use_map_footprint={}, reason={}\n", - test_name, fx, fy, fz, map_footprint, rotation, use_map_footprint, r - ); - if let Some(log_file) = failure_log { - if let Err(write_err) = log_file.write_all(failure_line.as_bytes()) { - error!("Failed to write to failure log: {}", write_err); - } - } - fail_flag = true; - } - } - } - - fail_flag - } - - /// `ZTAnimal::getFootprint`'s `is_egg`/`is_boxed` branches virtual-dispatch through - /// `entity_type`'s vtable unconditionally (regardless of `use_map_footprint`) - same fixture - /// requirement as `ZTUnit` above. - fn run_ztanimal_get_footprint_tests(failure_log: &mut Option) -> bool { - let runner_config = ProptestConfig { - failure_persistence: Some(Box::new(super::NoopFailurePersistence)), - ..ProptestConfig::default() - }; - let mut runner = proptest::test_runner::TestRunner::new(runner_config); - let test_name = "ZTANIMAL_GET_FOOTPRINT"; - let mut fail_flag = false; - - match runner.run( - &( - (-1000i32..1000i32, -1000i32..1000i32, -1000i32..1000i32), - -1000i32..1000i32, - (-1000i32..1000i32, -1000i32..1000i32, -1000i32..1000i32), - (-1000i32..1000i32, -1000i32..1000i32, -1000i32..1000i32), - -8i32..8i32, - proptest::bool::ANY, - proptest::bool::ANY, - proptest::bool::ANY, - ), - |((fx, fy, fz), map_footprint, box_footprint, egg_footprint, rotation, use_map_footprint, is_egg, is_boxed)| { - let entity_type = ZTAnimalType::new_for_test( - IVec3::new(fx, fy, fz), - map_footprint, - IVec3::new(box_footprint.0, box_footprint.1, box_footprint.2), - IVec3::new(egg_footprint.0, egg_footprint.1, egg_footprint.2), - ); - let entity = ZTAnimal::new_for_test(&raw const entity_type as u32, rotation, 0, is_egg, is_boxed); - - let reimplemented_result = entity.get_footprint(use_map_footprint); - let real_result = call_original_get_footprint(ZTANIMAL_GET_FOOTPRINT, &raw const entity as *const u32, use_map_footprint); - - assert_eq!( - (real_result.x, real_result.y, real_result.z), - (reimplemented_result.x, reimplemented_result.y, reimplemented_result.z), - "ZTAnimal::get_footprint mismatch: is_egg={}, is_boxed={}, rotation={}, use_map_footprint={}, real={:?}, reimplemented={:?}", - is_egg, is_boxed, rotation, use_map_footprint, real_result, reimplemented_result - ); - Ok(()) - }, - ) { - Ok(_) => { - info!("Proptest passed for {}", test_name); - write_success_line(failure_log, test_name); - } - Err(e) => { - error!("Proptest failed: {:?}", e); - if let proptest::test_runner::TestError::Fail(r, ((fx, fy, fz), map_footprint, box_footprint, egg_footprint, rotation, use_map_footprint, is_egg, is_boxed)) = e { - let failure_line = format!( - "{}: fx={}, fy={}, fz={}, map_footprint={}, box_footprint={:?}, egg_footprint={:?}, rotation={}, use_map_footprint={}, is_egg={}, is_boxed={}, reason={}\n", - test_name, fx, fy, fz, map_footprint, box_footprint, egg_footprint, rotation, use_map_footprint, is_egg, is_boxed, r - ); - if let Some(log_file) = failure_log { - if let Err(write_err) = log_file.write_all(failure_line.as_bytes()) { - error!("Failed to write to failure log: {}", write_err); - } - } - fail_flag = true; - } - } - } - - fail_flag - } } diff --git a/openzt/src/resource_manager/hooks.rs b/openzt/src/resource_manager/hooks.rs index a49e9d8..9a0f53c 100644 --- a/openzt/src/resource_manager/hooks.rs +++ b/openzt/src/resource_manager/hooks.rs @@ -36,12 +36,12 @@ mod zoo_resource_mgr { openzt_mods::{discover_mods, get_location_or_habitat_by_id}, validation::{log_validation_result, validate_load_order}, }, - util::{get_ini_path, get_string_from_memory, save_to_memory}, + util::{get_ini_path, get_string_from_memory, save_to_memory, Addr, MemAddr}, }; ///When Zoo Tycoon tries to load a resource we check if it's a resource we've already loaded and return that instead #[detour(ATTEMPT)] - unsafe extern "thiscall" fn zoo_bf_resource_attempt(this_ptr: u32, file_name: u32) -> bool { + unsafe extern "thiscall" fn zoo_bf_resource_attempt(this_ptr: *const u32, file_name: *const i8) -> bool { if bf_resource_inner(this_ptr, file_name) { return true; } @@ -50,7 +50,7 @@ mod zoo_resource_mgr { ///When Zoo Tycoon tries to load a resource we check if it's a resource we've already loaded and return that instead #[detour(PREPARE)] - unsafe extern "thiscall" fn zoo_bf_resource_prepare(this_ptr: u32, file_name: u32) -> bool { + unsafe extern "thiscall" fn zoo_bf_resource_prepare(this_ptr: *const u32, file_name: *const u8) -> bool { if bf_resource_inner(this_ptr, file_name) { return true; } @@ -58,7 +58,7 @@ mod zoo_resource_mgr { unsafe { PREPARE_DETOUR.call(this_ptr, file_name) } } - fn bf_resource_inner(this_ptr: u32, file_name: u32) -> bool { + fn bf_resource_inner(this_ptr: impl MemAddr, file_name: impl MemAddr) -> bool { let mut file_name_string = get_string_from_memory(file_name).to_lowercase(); if file_name_string.starts_with(OPENZT_DIR0) { match parse_openzt_resource_string(file_name_string.clone()) { @@ -134,8 +134,8 @@ mod zoo_resource_mgr { } #[detour(CONSTRUCTOR)] - unsafe extern "thiscall" fn zoo_bf_resource_mgr_constructor(this_ptr: u32) -> u32 { - info!("BFResourceMgr::constructor({:X})", this_ptr); + unsafe extern "thiscall" fn zoo_bf_resource_mgr_constructor(this_ptr: *const u32) -> *const u32 { + info!("BFResourceMgr::constructor({:X})", Addr::of(this_ptr)); let now = Instant::now(); @@ -159,7 +159,7 @@ mod zoo_resource_mgr { info!("Adding mods directory to BFResourceMgr"); if let Ok(mods_path) = CString::new("./mods") { - unsafe { ADD_PATH.original()(this_ptr, mods_path.as_ptr() as u32); } + unsafe { ADD_PATH.original()(this_ptr, mods_path.as_ptr()); } } paths.insert(0, "./mods".to_owned()); @@ -264,7 +264,7 @@ mod zoo_resource_mgr { /// Helper function to handle BFResourcePtr delref operations /// Extracts the filename from the BFResourcePtr and calls deref_resource - fn handle_delref(this_ptr: u32) { + fn handle_delref(this_ptr: impl MemAddr) { use crate::util::{get_from_memory, ZTString}; // Read the BFResourcePtr from memory @@ -279,152 +279,152 @@ mod zoo_resource_mgr { // BFResourcePtr::delref detours (30 different call sites in the game) #[detour(DELREF_0)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_0(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_0(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_1)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_1(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_1(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_2)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_2(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_2(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_3)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_3(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_3(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_4)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_4(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_4(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_5)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_5(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_5(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_6)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_6(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_6(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_7)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_7(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_7(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_8)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_8(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_8(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_9)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_9(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_9(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_10)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_10(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_10(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_11)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_11(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_11(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_12)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_12(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_12(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_13)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_13(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_13(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_14)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_14(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_14(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_15)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_15(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_15(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_16)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_16(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_16(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_17)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_17(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_17(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_18)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_18(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_18(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_19)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_19(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_19(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_20)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_20(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_20(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_21)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_21(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_21(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_22)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_22(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_22(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_23)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_23(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_23(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_24)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_24(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_24(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_25)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_25(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_25(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_26)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_26(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_26(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_27)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_27(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_27(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_28)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_28(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_28(this_ptr: *const u32) { handle_delref(this_ptr); } #[detour(DELREF_29)] - unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_29(this_ptr: u32) { + unsafe extern "thiscall" fn zoo_bf_resource_ptr_delref_29(this_ptr: *const u32) { handle_delref(this_ptr); } diff --git a/openzt/src/resource_manager/mod_config.rs b/openzt/src/resource_manager/mod_config.rs index 763f0e4..f3fcf82 100644 --- a/openzt/src/resource_manager/mod_config.rs +++ b/openzt/src/resource_manager/mod_config.rs @@ -236,7 +236,9 @@ fn load_openzt_config_from_disk() -> OpenZTConfig { }; let logging_complete = if let Some(logging) = toml_value.get("logging") { - logging.get("log_to_file").is_some() && logging.get("level").is_some() + logging.get("log_to_file").is_some() + && logging.get("level").is_some() + && logging.get("log_command_output").is_some() } else { false }; @@ -449,6 +451,7 @@ mod tests { let mut config = LoggingConfig { log_to_file: true, level: LogLevel::Trace, + log_command_output: false, }; assert!(toml::to_string(&config).unwrap().contains("level = \"trace\"")); diff --git a/openzt/src/roofs.rs b/openzt/src/roofs.rs index f537cd0..56f6cd5 100644 --- a/openzt/src/roofs.rs +++ b/openzt/src/roofs.rs @@ -29,24 +29,25 @@ pub mod roof_detours { /// After placing an entity, checks if it's a roof and hides it if needed. /// The second parameter (entity_ptr) is the BFEntity that was just placed. #[detour(PLACE_ENTITY_ON_MAP_1)] - unsafe extern "thiscall" fn place_entity_on_map_detour(_this: u32, entity_ptr: u32, _pos: f32, _rotation: i32) -> u32 { + unsafe extern "thiscall" fn place_entity_on_map_detour(_this: *const u32, entity_ptr: *const u32, _pos: f32, _rotation: i32) -> *const i32 { // Call the original function first to place the entity let result = unsafe { PLACE_ENTITY_ON_MAP_1_DETOUR.call(_this, entity_ptr, _pos, _rotation) }; // Only proceed if placement succeeded and we have a valid entity pointer - if result != 0 && entity_ptr != 0 { + if !result.is_null() && !entity_ptr.is_null() { + let entity_ptr_u32 = entity_ptr as u32; // Check if roofs are currently hidden if runtime_state::get_bool("roofs_hidden") { // Check if this entity has the "roof" tag - if let Some(base) = crate::resource_manager::openzt_mods::extensions::get_entity_base(entity_ptr) { + if let Some(base) = crate::resource_manager::openzt_mods::extensions::get_entity_base(entity_ptr_u32) { let roof_extensions = list_extensions_with_tag("roof"); for ext_key in &roof_extensions { if let Some(record) = get_extension(ext_key) && record.base == base { // This is a roof entity, hide it - let visible_ptr = (entity_ptr + 0x13f) as *mut u8; + let visible_ptr = (entity_ptr_u32 + 0x13f) as *mut u8; unsafe { *visible_ptr = 0 }; - info!("Auto-hid newly placed roof entity: {} (ptr: 0x{:x})", base, entity_ptr); + info!("Auto-hid newly placed roof entity: {} (ptr: 0x{:x})", base, entity_ptr_u32); break; } } diff --git a/openzt/src/scripting.rs b/openzt/src/scripting.rs index 32941bc..91a3d35 100644 --- a/openzt/src/scripting.rs +++ b/openzt/src/scripting.rs @@ -102,6 +102,20 @@ pub fn execute_lua(code: &str) -> Result { } } +/// Loads and executes a Lua file from disk +/// File path is relative to the game's base directory +pub fn load_lua_file(relative_path: &str) -> Result { + let full_path = crate::util::get_base_path().join(relative_path); + + if !full_path.exists() { + return Ok(format!("Script file not found: {}", relative_path)); + } + + std::fs::read_to_string(&full_path) + .map_err(|e| format!("Failed to read file: {}", e)) + .and_then(|contents| execute_lua(&contents)) +} + /// Converts a Lua value to a string representation fn lua_value_to_string(value: &mlua::Value) -> String { match value { @@ -564,4 +578,14 @@ pub fn init() { lua_fn!("ping", "Test console connectivity", "ping()", || { Ok("pong".to_string()) }); + + // Register the dofile() function + lua_fn!( + "dofile", + "Load and execute a Lua file from disk (relative to game directory)", + "dofile(path)", + |path: String| { + load_lua_file(&path).map_err(|e| mlua::Error::external(e)) + } + ); } diff --git a/openzt/src/tui_console.rs b/openzt/src/tui_console.rs index 233e615..5cd9325 100644 --- a/openzt/src/tui_console.rs +++ b/openzt/src/tui_console.rs @@ -555,11 +555,10 @@ fn handle_key_event(key: ratatui::crossterm::event::KeyEvent) { }; state.history_index = new_index; - if let Some(idx) = new_index { - if let Some(cmd) = state.command_history.get(idx) { + if let Some(idx) = new_index + && let Some(cmd) = state.command_history.get(idx) { state.input = cmd.clone(); } - } } KeyCode::Down => { let mut state = GLOBAL_TUI_STATE.lock().unwrap(); diff --git a/openzt/src/util.rs b/openzt/src/util.rs index eda8d21..2827698 100644 --- a/openzt/src/util.rs +++ b/openzt/src/util.rs @@ -126,8 +126,8 @@ pub fn get_string_from_memory_bounded(start: u32, end: u32, buffer_end: u32) -> } pub fn get_string_from_memory(address: impl MemAddr) -> String { - let mut bytes = Vec::new(); let mut char_address = address.as_u32(); + let mut bytes = Vec::new(); while { let byte = get_from_memory::(char_address); byte != 0 diff --git a/openzt/src/version.rs b/openzt/src/version.rs index aa95cb1..c487def 100644 --- a/openzt/src/version.rs +++ b/openzt/src/version.rs @@ -9,11 +9,13 @@ pub fn init() { #[detour_mod] mod bf_version_info { + use std::ffi::c_void; + use crate::util::{get_from_memory, get_string_from_memory, save_string_to_memory, save_to_memory}; use openzt_detour::generated::bfversioninfo::GET_VERSION_STRING; #[detour(GET_VERSION_STRING)] - unsafe extern "cdecl" fn bf_version_info_get_version_string_hook(param_1: u32, param_2: u32, param_3: u32) -> u32 { + unsafe extern "cdecl" fn bf_version_info_get_version_string_hook(param_1: *const i8, param_2: *const c_void, param_3: *const u32) -> u32 { let return_value = unsafe { GET_VERSION_STRING_DETOUR.call(param_1, param_2, param_3) }; let version_string = get_string_from_memory(get_from_memory::(param_2)); let version_length = version_string.len(); diff --git a/openzt/src/zthabitatmgr.rs b/openzt/src/zthabitatmgr.rs index 4560992..7115f90 100644 --- a/openzt/src/zthabitatmgr.rs +++ b/openzt/src/zthabitatmgr.rs @@ -125,15 +125,10 @@ pub struct ZTHabitat { unknown_nt_time: FileTime, // 0x128 pad5: [u8; 0x24], // ----------------------- padding: 36 bytes exhibit_name: ZTBoundedString, // 0x154 - pad6: [u8; 0x24], // ----------------------- padding: 36 bytes - tank_height: u32, // 0x184 // Actual structural tank height (ZTTankExhibit::getTankHeight/setTankHeight); not the field checkTankPlacement compares against, see water_level. - water_level: u32, // 0x188 // Current water level (ZTTankExhibit::getWaterLevel); this is what checkTankPlacement's height comparisons actually use. - pad7: [u8; 0xc], // ----------------------- padding: 12 bytes - is_filled: bool, // 0x198 // Set true by ZTTankExhibit::fill(), false by ZTTankExhibit::drain(). + pad6: [u8; 0x28], // ----------------------- padding: 40 bytes + tank_height: u32, // 0x188 } -const _: () = assert!(std::mem::size_of::() == 0x198); - impl ZTHabitat { const TANK_VTABLE_PTR: u32 = 0x006312bc; pub fn get_gate_tile_in(&self) -> Option { diff --git a/openzt/src/ztmapview.rs b/openzt/src/ztmapview.rs index c0be83d..d4d01c9 100644 --- a/openzt/src/ztmapview.rs +++ b/openzt/src/ztmapview.rs @@ -218,7 +218,7 @@ impl BFTile { pub mod zoo_ztmapview { use tracing::{info, error}; - use crate::util::{get_from_memory, ref_from_memory, save_to_memory}; + use crate::util::{get_from_memory, ref_from_memory}; use crate::ztmapview::{BFTile, ZTMapView}; use crate::ztworldmgr::IVec3; use openzt_detour::generated::bftile::GET_LOCAL_ELEVATION; @@ -233,7 +233,7 @@ pub mod zoo_ztmapview { #[detour(CHECK_TANK_PLACEMENT)] // fn check_tank_placement(ZTMapView *other_this, BFEntity *param_2, BFTile *param_3, int *param_4) unsafe extern "stdcall" fn check_tank_placement(temp_entity_ptr: *const u32, tile: *const u32, response_ptr: *mut u32) -> bool { - let _result = unsafe { CHECK_TANK_PLACEMENT_DETOUR.call(temp_entity_ptr, tile, response_ptr) }; + let result = unsafe { CHECK_TANK_PLACEMENT_DETOUR.call(temp_entity_ptr, tile, response_ptr) }; // let entity = get_from_memory(temp_entity); @@ -247,19 +247,17 @@ pub mod zoo_ztmapview { if zt_result != reimplemented_result.clone() as u32 { error!("ZTMapView::checkTankPlacement mismatch between reimplementation and game result! Reimplementation: {:?}, Game: {:#x}", reimplemented_result, zt_result); } - - if !response_ptr.is_null() { - save_to_memory(response_ptr, reimplemented_result as u32); - } - false } Ok(()) => { if zt_result != 0 { error!("ZTMapView::checkTankPlacement mismatch: reimplementation returned Ok but game returned {:#x}", zt_result); } - true } } + + // info!("ZTMapView::checkTankPlacement {}, {:p} -> {:#x}", result, response_ptr, unsafe{*response_ptr}); + result + // true } // #[hook(unsafe extern "thiscall" BFUIMgr_display_message, offset = 0x0009ccc3)] @@ -331,7 +329,7 @@ impl ZTMapView { return Err(ErrorStringId::ObjectCannotBePlacedInTank); } - if scenery_entity_type.surface && *habitat.water_level() < scenery_entity_type.depth { + if scenery_entity_type.surface && *habitat.tank_height() < scenery_entity_type.depth { return Err(ErrorStringId::ObjectMustBePlacedInADeeperTank); } } @@ -344,15 +342,12 @@ impl ZTMapView { if *animal_entity.is_egg() && !animal_entity_type.underwater { return Err(ErrorStringId::EggsMustBePlacedOnLand); } - if *habitat.water_level() < animal_entity_type.ztunit_type.bfunit_type.depth { + if *habitat.tank_height() < animal_entity_type.ztunit_type.bfunit_type.depth { // TODO: Add an extra message for animals rather than objects return Err(ErrorStringId::ObjectMustBePlacedInADeeperTank); } // TankWithWater check; onlyUnderwater? - if animal_entity_type.underwater - && !animal_entity.is_boxed() - && (!habitat.is_filled() || *habitat.water_level() < 1) - { + if animal_entity_type.underwater && *habitat.tank_height() < 1 { return Err(ErrorStringId::AnimalMustBePlacedInATankWithWater); } } @@ -389,7 +384,7 @@ impl ZTMapView { let tile_entity_type_class = tile_entity.entity_type_class(); if zt_entity_type_class_is(&tile_entity_type_class, &ZTEntityTypeClass::Scenery) { let tile_scenery_type = unsafe { ref_from_memory::(*tile_entity.inner_class_ptr()) }; - if tile_scenery_type.surface { + if !tile_scenery_type.surface { // return Ok(()); // TODO: ZT doesn't set the error message code for this case, but does return false? return Err(ErrorStringId::UnknownError) diff --git a/openzt/src/ztresearch.rs b/openzt/src/ztresearch.rs index 1bdf74e..9f6f870 100644 --- a/openzt/src/ztresearch.rs +++ b/openzt/src/ztresearch.rs @@ -3,8 +3,8 @@ //! (e.g. "Animal Care") is currently working towards, tracking funding and progress, and applying a //! program's effect once it completes. //! -//! Field layouts below are derived from the decompiles in `resources/decompiles/ZTResearch*` and -//! `resources/decompiles/_forceResearch.c` / `_clickResearch.c`. Byte ranges with no decompiled +//! Field layouts below are derived from the decompiles in `private/resources/decompiles/ZTResearch*` and +//! `private/resources/decompiles/_forceResearch.c` / `_clickResearch.c`. Byte ranges with no decompiled //! evidence are left as `padN` placeholders. `ZTResearchMgr`'s layout is additionally confirmed by //! `openzt-detour/src/structs.rs` (size `0x18`). //! @@ -581,7 +581,7 @@ impl ZTResearchBranch { } /// The vanilla "$400 (Min)"-style formatted text for the *currently selected* funding level (per - /// `resources/decompiles/ZTResearchBranch_getFundingText.c`, this always uses + /// `private/resources/decompiles/ZTResearchBranch_getFundingText.c`, this always uses /// `current_funding_level` - there's no way to ask for an arbitrary level's text). Calls into the /// original implementation (money formatting + a `%s`-templated name) rather than reimplementing /// it, since it depends on an unconfirmed scale constant (`DAT_00635040`) that only matters if @@ -693,7 +693,7 @@ impl ZTResearchMgr { } /// Calls the vanilla `ZTResearchMgr::load` - the save-file counterpart to `save()`. Per - /// `resources/decompiles/ZTResearchMgr_load.c`/`.asm`, `load` always starts by resetting every + /// `private/resources/decompiles/ZTResearchMgr_load.c`/`.asm`, `load` always starts by resetting every /// branch's `current_funding_level` to `0`, every category's `enabled` to `1`, and calling /// `ZTResearchProgram::reset()` on every program (which itself zeroes `current_progress` and, for /// `UnlockEntity`/`BuildingUpgrade` effects, calls back into the building/entity managers) - @@ -739,7 +739,7 @@ impl fmt::Display for ZTResearchMgr { } /// Calls the vanilla standalone `forceResearch` cheat-console function - the one the in-game -/// "force research" cheat actually triggers, per `resources/decompiles/_forceResearch.c`. It calls +/// "force research" cheat actually triggers, per `private/resources/decompiles/_forceResearch.c`. It calls /// `ZTResearchMgr::forceResearch(GLOBAL_ZTResearchMgr, false)` (the `continue_program` flag is /// hardcoded `false` here - use `ZTResearchMgr::force_research` directly if you need `true`) and /// then notifies every `ZTWorldMgr` entity of the change, so the world/UI actually refreshes; plain @@ -2030,7 +2030,7 @@ mod research_config_reimplementation { /// Native reimplementation of `ZTResearchMgr::save`/`load`'s save-file persistence format - a small, /// self-describing stream of `(kind, id, value)` tuples capturing each branch's `current_funding_level`, /// each category's `enabled` flag, and each program's `current_progress`. Confirmed byte-for-byte from -/// `resources/decompiles/ZTResearchMgr_save.c` and cross-checked against `ZTResearchMgr_load.c`/`.asm`. +/// `private/resources/decompiles/ZTResearchMgr_save.c` and cross-checked against `ZTResearchMgr_load.c`/`.asm`. /// /// This is **shadow-mode only**: nothing here ever runs during real save/load (`ZTResearchMgr::save`/ /// `load` are not detoured), it exists purely to be exercised by the live proptest-vs-`.original()` diff --git a/openzt/src/ztworldmgr.rs b/openzt/src/ztworldmgr.rs index 34f75ee..a1427a7 100644 --- a/openzt/src/ztworldmgr.rs +++ b/openzt/src/ztworldmgr.rs @@ -3,7 +3,6 @@ use itertools::Itertools; use num_enum::FromPrimitive; use openzt_detour_macro::detour_mod; use std::cmp::max; -use std::mem; use std::str::FromStr; use std::{collections::HashMap, fmt}; use tracing::{error, info}; @@ -162,8 +161,6 @@ pub struct BFEntity { // Full size is 0x154 bytes map_footprint: i32, // 0x150 } -const _: () = assert!(mem::size_of::() == 0x154); - impl fmt::Display for BFEntity { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( @@ -175,16 +172,6 @@ impl fmt::Display for BFEntity { } impl BFEntity { - /// Builds a zero-filled `BFEntity` for tests, with only the fields relevant to - /// pure (globals()-free) logic populated. Mirrors `BFTile::new` in `ztmapview.rs`. - pub fn new_for_test(inner_class_ptr: u32, rotation: i32, map_footprint: i32) -> Self { - let mut entity: BFEntity = unsafe { mem::zeroed() }; - entity.inner_class_ptr = inner_class_ptr; - entity.rotation = rotation; - entity.map_footprint = map_footprint; - entity - } - pub fn entity_type_class(&self) -> ZTEntityTypeClass { ZTEntityTypeClass::from(get_from_memory::(self.inner_class_ptr)) } @@ -267,7 +254,7 @@ impl BFEntity { } pub fn check_avoid_edges(&self, tile: &BFTile) -> bool { - let radius = self.entity_type().avoid_edges as i32 - 1; + let radius = self.entity_type().avoid_edges - 1; if radius < 0 { return false; @@ -280,10 +267,10 @@ impl BFEntity { // Check all tiles in a square of `radius` around the placement tile let world_mgr = globals().ztworldmgr(); - let x_min = tile.pos.x - radius; - let x_max = tile.pos.x + radius; - let y_min = tile.pos.y - radius; - let y_max = tile.pos.y + radius; + let x_min = tile.pos.x - radius as i32; + let x_max = tile.pos.x + radius as i32; + let y_min = tile.pos.y - radius as i32; + let y_max = tile.pos.y + radius as i32; for check_x in x_min..=x_max { for check_y in y_min..=y_max { @@ -312,17 +299,6 @@ pub(crate) struct BFUnit { padding: [u8; 0x214-0x154], // ----- padding: 192 bytes } -const _: () = assert!(mem::size_of::() == 0x214); - -impl BFUnit { - /// Test-only fixture, see `BFEntity::new_for_test`. - pub fn new_for_test(inner_class_ptr: u32, rotation: i32, map_footprint: i32) -> Self { - BFUnit { - base: BFEntity::new_for_test(inner_class_ptr, rotation, map_footprint), - padding: [0; 0x214 - 0x154], - } - } -} impl std::ops::Deref for BFUnit { type Target = BFEntity; @@ -345,16 +321,7 @@ pub(crate) struct ZTUnit { padding: [u8; 0x260-0x214], // ----- padding: 76 bytes } -const _: () = assert!(mem::size_of::() == 0x260); - impl ZTUnit { - /// Test-only fixture, see `BFEntity::new_for_test`. - pub fn new_for_test(inner_class_ptr: u32, rotation: i32, map_footprint: i32) -> Self { - ZTUnit { - base: BFUnit::new_for_test(inner_class_ptr, rotation, map_footprint), - padding: [0; 0x260 - 0x214], - } - } pub fn entity_type(&self) -> &'static ZTUnitType { unsafe { ref_from_memory(self.inner_class_ptr) } @@ -364,10 +331,9 @@ impl ZTUnit { if !use_map_footprint { self.base.get_footprint(use_map_footprint) } else { - let map_footprint = self.entity_type().map_footprint; IVec3 { - x: map_footprint, - y: map_footprint, + x: self.map_footprint as i32, + y: self.map_footprint as i32, z: 0, } } @@ -390,7 +356,7 @@ impl std::ops::DerefMut for ZTUnit { #[derive(Debug, Getters)] #[get = "pub"] #[repr(C)] -pub(crate) struct ZTAnimal { // bytes: 0x3a8 = 936 bytes +pub(crate) struct ZTAnimal { base: ZTUnit, // offset: 0x0000 _pad_0x0260: [u8; 300], food_tile: *const BFTile, // offset: 0x038c @@ -410,18 +376,7 @@ pub(crate) struct ZTAnimal { // bytes: 0x3a8 = 936 bytes mbr_0x3b4: u8, // offset: 0x03b4 } -const _: () = assert!(mem::size_of::() == 0x3a8); - impl ZTAnimal { - /// Test-only fixture, see `BFEntity::new_for_test`. `mem::zeroed()` is safe here since - /// every field is an integer/bool/byte-array/raw-pointer, none of them references or niche types. - pub fn new_for_test(inner_class_ptr: u32, rotation: i32, map_footprint: i32, is_egg: bool, is_boxed: bool) -> Self { - let mut animal: ZTAnimal = unsafe { mem::zeroed() }; - animal.base = ZTUnit::new_for_test(inner_class_ptr, rotation, map_footprint); - animal.is_egg = is_egg; - animal.is_boxed = is_boxed; - animal - } pub fn entity_type(&self) -> &'static ZTAnimalType { unsafe { ref_from_memory(self.inner_class_ptr) } @@ -440,9 +395,9 @@ impl ZTAnimal { }; if self.rotation % 4 == 0 { - IVec3 { x: footprint.x, y: footprint.y, z: footprint.z } - } else { IVec3 { x: footprint.y, y: footprint.x, z: footprint.z } + } else { + IVec3 { x: footprint.x, y: footprint.y, z: footprint.z } } } } @@ -1343,201 +1298,3 @@ pub fn get_entity_type_by_id(id: u32) -> u32 { // struct BFMap { // padding: [u8; 0x5c], // } - -#[cfg(test)] -mod tests { - use super::*; - use crate::bfentitytype::BFEntityType; - - // Explicit list (not derived from the enum) so it visibly needs updating when a - // variant is added and the match arm in `FromStr` is forgotten. - const ZT_ENTITY_CLASS_CASES: &[(ZTEntityClass, &str)] = &[ - (ZTEntityClass::Food, "food"), - (ZTEntityClass::Path, "path"), - (ZTEntityClass::Fences, "fences"), - (ZTEntityClass::Building, "building"), - (ZTEntityClass::Animal, "animal"), - (ZTEntityClass::Guest, "guest"), - (ZTEntityClass::Scenery, "scenery"), - (ZTEntityClass::Keeper, "keeper"), - (ZTEntityClass::MaintenanceWorker, "maintenanceworker"), - (ZTEntityClass::TourGuide, "tourguide"), - (ZTEntityClass::Drt, "drt"), - (ZTEntityClass::Ambient, "ambient"), - (ZTEntityClass::Rubble, "rubble"), - (ZTEntityClass::TankWall, "tankwall"), - (ZTEntityClass::TankFilter, "tankfilter"), - ]; - - #[test] - fn test_zt_entity_class_from_str_round_trip() { - for (variant, s) in ZT_ENTITY_CLASS_CASES { - assert_eq!(s.parse::().unwrap(), *variant, "failed to parse '{}'", s); - } - } - - #[test] - fn test_zt_entity_class_from_str_case_insensitive() { - assert_eq!("Animal".parse::().unwrap(), ZTEntityClass::Animal); - assert_eq!("ANIMAL".parse::().unwrap(), ZTEntityClass::Animal); - assert_eq!("aNiMaL".parse::().unwrap(), ZTEntityClass::Animal); - } - - #[test] - fn test_zt_entity_class_from_str_unknown_is_err() { - assert!("not_a_real_entity_class".parse::().is_err()); - } - - fn entity_type_with_avoid_edges(avoid_edges: u32) -> BFEntityType { - let mut entity_type: BFEntityType = unsafe { mem::zeroed() }; - entity_type.avoid_edges = avoid_edges; - entity_type - } - - #[test] - fn test_check_avoid_edges_zero_always_false() { - let entity_type = entity_type_with_avoid_edges(0); - let entity = BFEntity::new_for_test(&entity_type as *const BFEntityType as u32, 0, 0); - - let mut tile = BFTile::new(IVec3::new(0, 0, 0), 0); - tile.north_fence = 1; - tile.east_fence = 1; - tile.south_fence = 1; - tile.west_fence = 1; - - assert!(!entity.check_avoid_edges(&tile), "avoid_edges == 0 should always return false, regardless of fence state"); - } - - #[test] - fn test_check_avoid_edges_radius_zero_no_fences() { - let entity_type = entity_type_with_avoid_edges(1); - let entity = BFEntity::new_for_test(&entity_type as *const BFEntityType as u32, 0, 0); - - let tile = BFTile::new(IVec3::new(0, 0, 0), 0); - - assert!(!entity.check_avoid_edges(&tile)); - } - - #[test] - fn test_check_avoid_edges_radius_zero_each_fence_direction_triggers() { - let entity_type = entity_type_with_avoid_edges(1); - let entity = BFEntity::new_for_test(&entity_type as *const BFEntityType as u32, 0, 0); - let pos = IVec3::new(0, 0, 0); - - let mut north = BFTile::new(pos, 0); - north.north_fence = 1; - assert!(entity.check_avoid_edges(&north), "north_fence alone should trigger avoid_edges"); - - let mut east = BFTile::new(pos, 0); - east.east_fence = 1; - assert!(entity.check_avoid_edges(&east), "east_fence alone should trigger avoid_edges"); - - let mut south = BFTile::new(pos, 0); - south.south_fence = 1; - assert!(entity.check_avoid_edges(&south), "south_fence alone should trigger avoid_edges"); - - let mut west = BFTile::new(pos, 0); - west.west_fence = 1; - assert!(entity.check_avoid_edges(&west), "west_fence alone should trigger avoid_edges"); - } - - // ZTUnit/ZTAnimal::get_footprint internal-consistency tests. - // - // These pin down our own reimplementation's branch behavior. Most of them can't be compared - // against `.original()` directly (unlike BFEntity's equivalent, see reimplementation_tests/mod.rs) - // because ZTAnimal's is_egg/is_boxed branches unconditionally virtual-dispatch through - // entity_type's vtable; see ztunit-ztanimal-footprint-crash-investigation.md for the confirmed - // root cause and the entity_type fixtures' real vtable pointer. - - fn entity_type_with_footprint(x: i32, y: i32, z: i32) -> BFEntityType { - let mut entity_type: BFEntityType = unsafe { mem::zeroed() }; - entity_type.footprintx = x; - entity_type.footprinty = y; - entity_type.footprintz = z; - entity_type - } - - #[test] - fn test_ztunit_get_footprint_map_footprint_ignores_rotation() { - let entity_type = ZTUnitType::new_for_test(IVec3::default(), 42); - for rotation in [-8, -3, -1, 0, 1, 3, 4, 8] { - let entity = ZTUnit::new_for_test(&entity_type as *const ZTUnitType as u32, rotation, 0); - let footprint = entity.get_footprint(true); - assert_eq!( - (footprint.x, footprint.y, footprint.z), - (42, 42, 0), - "use_map_footprint=true should return {{map_footprint, map_footprint, 0}} regardless of rotation ({})", - rotation - ); - } - } - - #[test] - fn test_ztunit_get_footprint_delegates_to_base_when_not_using_map_footprint() { - let entity_type = entity_type_with_footprint(5, 7, 9); - - let unrotated = ZTUnit::new_for_test(&entity_type as *const BFEntityType as u32, 0, 42); - let footprint = unrotated.get_footprint(false); - assert_eq!((footprint.x, footprint.y, footprint.z), (5, 7, 9)); - - let rotated = ZTUnit::new_for_test(&entity_type as *const BFEntityType as u32, 1, 42); - let footprint = rotated.get_footprint(false); - assert_eq!((footprint.x, footprint.y, footprint.z), (7, 5, 9), "odd rotation should swap x/y, matching BFEntity::get_footprint"); - } - - fn animal_type_with_footprints(egg: IVec3, boxed: IVec3) -> ZTAnimalType { - let mut entity_type: ZTAnimalType = unsafe { mem::zeroed() }; - entity_type.egg_footprint = egg; - entity_type.box_footprint = boxed; - entity_type - } - - #[test] - fn test_ztanimal_get_footprint_delegates_to_base_when_not_egg_or_boxed() { - let entity_type = entity_type_with_footprint(5, 7, 9); - let entity = ZTAnimal::new_for_test(&entity_type as *const BFEntityType as u32, 1, 0, false, false); - - let footprint = entity.get_footprint(false); - assert_eq!( - (footprint.x, footprint.y, footprint.z), - (7, 5, 9), - "is_egg=false, is_boxed=false should delegate through ZTUnit/BFEntity::get_footprint" - ); - } - - #[test] - fn test_ztanimal_get_footprint_egg_uses_egg_footprint_with_rotation_swap() { - let entity_type = animal_type_with_footprints(IVec3::new(11, 22, 33), IVec3::new(99, 98, 97)); - - // Same swap direction as BFEntity::get_footprint's: rotation % 4 == 0 leaves x/y unswapped, - // any other rotation swaps them. Confirmed live against the real ZTAnimal::getFootprint - - // see ztunit-ztanimal-footprint-crash-investigation.md. - let unrotated = ZTAnimal::new_for_test(&entity_type as *const ZTAnimalType as u32, 0, 0, true, false); - let footprint = unrotated.get_footprint(false); - assert_eq!((footprint.x, footprint.y, footprint.z), (11, 22, 33)); - - let rotated = ZTAnimal::new_for_test(&entity_type as *const ZTAnimalType as u32, 1, 0, true, false); - let footprint = rotated.get_footprint(false); - assert_eq!((footprint.x, footprint.y, footprint.z), (22, 11, 33)); - } - - #[test] - fn test_ztanimal_get_footprint_boxed_uses_box_footprint() { - let entity_type = animal_type_with_footprints(IVec3::new(11, 22, 33), IVec3::new(99, 98, 97)); - - let entity = ZTAnimal::new_for_test(&entity_type as *const ZTAnimalType as u32, 0, 0, false, true); - let footprint = entity.get_footprint(false); - assert_eq!((footprint.x, footprint.y, footprint.z), (99, 98, 97)); - } - - #[test] - fn test_ztanimal_get_footprint_egg_and_boxed_prefers_egg() { - // Deliberate tie-break: the code checks `is_egg` before `is_boxed`, so when both are set - // egg_footprint wins. Distinct egg/box values here make a regression to box_footprint visible. - let entity_type = animal_type_with_footprints(IVec3::new(11, 22, 33), IVec3::new(99, 98, 97)); - - let entity = ZTAnimal::new_for_test(&entity_type as *const ZTAnimalType as u32, 0, 0, true, true); - let footprint = entity.get_footprint(false); - assert_eq!((footprint.x, footprint.y, footprint.z), (11, 22, 33), "is_egg=true, is_boxed=true should prefer egg_footprint"); - } -} diff --git a/vendor/retour-rs/src/traits.rs b/vendor/retour-rs/src/traits.rs index 2d8cb33..bfff922 100644 --- a/vendor/retour-rs/src/traits.rs +++ b/vendor/retour-rs/src/traits.rs @@ -26,5 +26,6 @@ unsafe impl HookableWith for T {} impl_hookable! { __arg_0: A, __arg_1: B, __arg_2: C, __arg_3: D, __arg_4: E, __arg_5: F, __arg_6: G, - __arg_7: H, __arg_8: I, __arg_9: J, __arg_10: K, __arg_11: L, __arg_12: M, __arg_13: N + __arg_7: H, __arg_8: I, __arg_9: J, __arg_10: K, __arg_11: L, __arg_12: M, __arg_13: N, + __arg_14: O, __arg_15: P, __arg_16: Q, __arg_17: R } From dd449f710e608a38e3c79b0559600024e9d59a66 Mon Sep 17 00:00:00 2001 From: Finn Hartshorn Date: Wed, 19 Aug 2026 08:43:25 +1000 Subject: [PATCH 2/7] Hand-resolve shared files for detour-testing-framework-only content openzt/src/lib.rs, openzt.bat, openzt/Cargo.toml, openzt-dll/Cargo.toml, and openzt-detour/src/generated.rs are also touched by feature/egui-overlay-plumbing and/or feature/save-logging. Since this branch must not depend on those branches, each file's detour-testing content was hand-extracted: - lib.rs: detour_validation module + OPENZT_VALIDATE_DETOURS env var init, plus two unrelated fixes (load_lang_dlls signature, collapsible_if cleanup). Excludes save_logging/cursors/ui modules. - openzt.bat: --no-pause global flag infrastructure and validate-detours command. Excludes egui's test-egui-tiny-skia addition. - openzt/Cargo.toml, openzt-dll/Cargo.toml: detour-validation feature and inventory dependency only. Excludes egui deps/features and unrelated toml/nt-time version bumps. - generated.rs: every entry gets detour-testing's validate_detour annotation. For the ~49 entries whose pointer type egui or save-logging retyped, the type is reverted to main's original so this branch carries only the annotation, not their retyping work. 11 entries (new SAVE hooks, including a whole new ztshowscriptstate module) that save-logging added from scratch are dropped entirely since they aren't detour-testing's content. --- openzt-detour/src/generated.rs | 6166 +++++++++++++++++++++++--------- openzt-dll/Cargo.toml | 1 + openzt.bat | 156 +- openzt/Cargo.toml | 2 + openzt/src/lib.rs | 24 +- 5 files changed, 4591 insertions(+), 1758 deletions(-) diff --git a/openzt-detour/src/generated.rs b/openzt-detour/src/generated.rs index a8d23e9..21b6c8f 100644 --- a/openzt-detour/src/generated.rs +++ b/openzt-detour/src/generated.rs @@ -4,61 +4,94 @@ #![allow(clippy::type_complexity)] use std::marker::PhantomData; +use core::ffi::c_void; use crate::FunctionDef; +#[cfg(feature = "detour-validation")] +use openzt_detour_macro::validate_detour; + // AI_cls_0x404fd6 class functions pub mod ai_cls_0x404fd6 { use super::*; - pub const FIND: FunctionDef = FunctionDef{address: 0x004031b1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ai_cls_0x404fd6/find"))] + pub const FIND: FunctionDef = FunctionDef{address: 0x004031b1, function_type: PhantomData}; } // Ambients class functions pub mod ambients { use super::*; - pub const AMBIENTS: FunctionDef = FunctionDef{address: 0x0041e930, function_type: PhantomData}; - pub const PLAY: FunctionDef = FunctionDef{address: 0x0043f445, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004495a3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ambients/ambients"))] + pub const AMBIENTS: FunctionDef = FunctionDef{address: 0x0041e930, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ambients/play"))] + pub const PLAY: FunctionDef = FunctionDef{address: 0x0043f445, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ambients/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004495a3, function_type: PhantomData}; } // AmbientsGroup class functions pub mod ambientsgroup { use super::*; - pub const PLAY: FunctionDef = FunctionDef{address: 0x0043f4d5, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0045067e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ambientsgroup/play"))] + pub const PLAY: FunctionDef = FunctionDef{address: 0x0043f4d5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ambientsgroup/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0045067e, function_type: PhantomData}; } // BFAIMgr class functions pub mod bfaimgr { use super::*; - pub const F_MOVE_SLOW_F: FunctionDef u32> = FunctionDef{address: 0x00436606, function_type: PhantomData}; - pub const EXECUTE_CALL: FunctionDef u32> = FunctionDef{address: 0x00437ccd, function_type: PhantomData}; - pub const F_RANDOM_WALK: FunctionDef u32> = FunctionDef{address: 0x0043d948, function_type: PhantomData}; - pub const F_PLAY_SET: FunctionDef u32> = FunctionDef{address: 0x0043ddc1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_move_slow_f"))] + pub const F_MOVE_SLOW_F: FunctionDef u32> = FunctionDef{address: 0x00436606, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/execute_call"))] + pub const EXECUTE_CALL: FunctionDef u32> = FunctionDef{address: 0x00437ccd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_random_walk"))] + pub const F_RANDOM_WALK: FunctionDef u32> = FunctionDef{address: 0x0043d948, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_play_set"))] + pub const F_PLAY_SET: FunctionDef u32> = FunctionDef{address: 0x0043ddc1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047b081, function_type: PhantomData}; - pub const F_MOVE_MEDIUM_F: FunctionDef u32> = FunctionDef{address: 0x004a31de, function_type: PhantomData}; - pub const F_MOVE_FAST_F: FunctionDef u32> = FunctionDef{address: 0x004a5310, function_type: PhantomData}; - pub const BFAIMGR: FunctionDef u32> = FunctionDef{address: 0x0050374b, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00525e90, function_type: PhantomData}; - pub const INIT_AIPARAMS: FunctionDef = FunctionDef{address: 0x005267ec, function_type: PhantomData}; - pub const GET_PATH: FunctionDef = FunctionDef{address: 0x0052d8e8, function_type: PhantomData}; - pub const F_PLAY_SPECIAL: FunctionDef u32> = FunctionDef{address: 0x00588f7e, function_type: PhantomData}; - pub const F_PLAY_SET_TERRAIN_F: FunctionDef u32> = FunctionDef{address: 0x00601d2d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_move_medium_f"))] + pub const F_MOVE_MEDIUM_F: FunctionDef u32> = FunctionDef{address: 0x004a31de, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_move_fast_f"))] + pub const F_MOVE_FAST_F: FunctionDef u32> = FunctionDef{address: 0x004a5310, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/bfaimgr"))] + pub const BFAIMGR: FunctionDef *const u32> = FunctionDef{address: 0x0050374b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00525e90, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/init_aiparams"))] + pub const INIT_AIPARAMS: FunctionDef u32> = FunctionDef{address: 0x005267ec, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/get_path"))] + pub const GET_PATH: FunctionDef = FunctionDef{address: 0x0052d8e8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_play_special"))] + pub const F_PLAY_SPECIAL: FunctionDef u32> = FunctionDef{address: 0x00588f7e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_move_entity_special_f"))] + pub const F_MOVE_ENTITY_SPECIAL_F: FunctionDef u32> = FunctionDef{address: 0x00601aa5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_move_entity_delta_f"))] + pub const F_MOVE_ENTITY_DELTA_F: FunctionDef u32> = FunctionDef{address: 0x00601b73, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_play_set_terrain_f"))] + pub const F_PLAY_SET_TERRAIN_F: FunctionDef u32> = FunctionDef{address: 0x00601d2d, function_type: PhantomData}; } // BFAnimCache class functions pub mod bfanimcache { use super::*; - pub const FIND_ANIM: FunctionDef u32> = FunctionDef{address: 0x00401fdd, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00419e91, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfanimcache/find_anim"))] + pub const FIND_ANIM: FunctionDef *const i8> = FunctionDef{address: 0x00401fdd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfanimcache/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00419e91, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfanimcache/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x0052812e, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x005283f4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfanimcache/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const i32> = FunctionDef{address: 0x005283f4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfanimcache/instantiate"))] pub const INSTANTIATE: FunctionDef u32> = FunctionDef{address: 0x00528447, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfanimcache/unload_anims"))] pub const UNLOAD_ANIMS: FunctionDef = FunctionDef{address: 0x0061ca3b, function_type: PhantomData}; } @@ -66,35 +99,59 @@ pub mod bfanimcache { pub mod bfapp { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/load_string"))] pub const LOAD_STRING: FunctionDef u32> = FunctionDef{address: 0x00404e0a, function_type: PhantomData}; - pub const HANDLE_MESSAGES: FunctionDef i32> = FunctionDef{address: 0x00418f4f, function_type: PhantomData}; - pub const WIN_MAIN: FunctionDef i32> = FunctionDef{address: 0x0041a8bc, function_type: PhantomData}; - pub const BUILD_STRING: FunctionDef u32> = FunctionDef{address: 0x0041ca7f, function_type: PhantomData}; - pub const GET_INSTALLED_EXPANSION: FunctionDef u32> = FunctionDef{address: 0x004ab32c, function_type: PhantomData}; - pub const LOAD_USER_RESOURCE: FunctionDef u32> = FunctionDef{address: 0x004f029d, function_type: PhantomData}; - pub const FIND_INSTANCE: FunctionDef = FunctionDef{address: 0x005337e6, function_type: PhantomData}; - pub const INIT_INSTANCE: FunctionDef bool> = FunctionDef{address: 0x005340ba, function_type: PhantomData}; - pub const LOAD_LANG_DLLS: FunctionDef u32> = FunctionDef{address: 0x00537333, function_type: PhantomData}; - pub const INIT_WINDOW_CLASS: FunctionDef = FunctionDef{address: 0x005376bb, function_type: PhantomData}; - pub const REGISTER_CLASS: FunctionDef bool> = FunctionDef{address: 0x005378f6, function_type: PhantomData}; - pub const STORE_TYPEDATA: FunctionDef = FunctionDef{address: 0x0053797b, function_type: PhantomData}; - pub const CREATE_WINDOW_CLASS: FunctionDef = FunctionDef{address: 0x00537b37, function_type: PhantomData}; - pub const LOAD_RES_DLLS: FunctionDef u32> = FunctionDef{address: 0x00537ee3, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x005784f8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/handle_messages"))] + pub const HANDLE_MESSAGES: FunctionDef u32> = FunctionDef{address: 0x00418f4f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/win_main"))] + pub const WIN_MAIN: FunctionDef i32> = FunctionDef{address: 0x0041a8bc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/build_string"))] + pub const BUILD_STRING: FunctionDef *const u32> = FunctionDef{address: 0x0041ca7f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/get_installed_expansion"))] + pub const GET_INSTALLED_EXPANSION: FunctionDef u32> = FunctionDef{address: 0x004ab32c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/load_user_resource"))] + pub const LOAD_USER_RESOURCE: FunctionDef u32> = FunctionDef{address: 0x004f029d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/find_instance"))] + pub const FIND_INSTANCE: FunctionDef bool> = FunctionDef{address: 0x005337e6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/init_instance"))] + pub const INIT_INSTANCE: FunctionDef bool> = FunctionDef{address: 0x005340ba, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/load_lang_dlls"))] + pub const LOAD_LANG_DLLS: FunctionDef u32> = FunctionDef{address: 0x00537333, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/init_window_class"))] + pub const INIT_WINDOW_CLASS: FunctionDef bool> = FunctionDef{address: 0x005376bb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/register_class"))] + pub const REGISTER_CLASS: FunctionDef bool> = FunctionDef{address: 0x005378f6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/store_typedata"))] + pub const STORE_TYPEDATA: FunctionDef = FunctionDef{address: 0x0053797b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/create_window_class"))] + pub const CREATE_WINDOW_CLASS: FunctionDef = FunctionDef{address: 0x00537b37, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/load_res_dlls"))] + pub const LOAD_RES_DLLS: FunctionDef u32> = FunctionDef{address: 0x00537ee3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x005784f8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/exit_override"))] pub const EXIT_OVERRIDE: FunctionDef = FunctionDef{address: 0x0057de3e, function_type: PhantomData}; - pub const BFAPP_0: FunctionDef u32> = FunctionDef{address: 0x00587641, function_type: PhantomData}; - pub const DESTROY_WINDOW_CLASS: FunctionDef = FunctionDef{address: 0x00587661, function_type: PhantomData}; - pub const GET_SCREEN_CENTER: FunctionDef = FunctionDef{address: 0x005fd367, function_type: PhantomData}; - pub const BFAPP_1: FunctionDef u32> = FunctionDef{address: 0x005fd382, function_type: PhantomData}; - pub const LOAD_TYPEDATA: FunctionDef = FunctionDef{address: 0x005fd3a0, function_type: PhantomData}; - pub const TOGGLE_CURSORS: FunctionDef = FunctionDef{address: 0x005fd3d1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/bfapp_0"))] + pub const BFAPP_0: FunctionDef *const u32> = FunctionDef{address: 0x00587641, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/destroy_window_class"))] + pub const DESTROY_WINDOW_CLASS: FunctionDef = FunctionDef{address: 0x00587661, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/get_screen_center"))] + pub const GET_SCREEN_CENTER: FunctionDef = FunctionDef{address: 0x005fd367, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/bfapp_1"))] + pub const BFAPP_1: FunctionDef *const u32> = FunctionDef{address: 0x005fd382, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/load_typedata"))] + pub const LOAD_TYPEDATA: FunctionDef = FunctionDef{address: 0x005fd3a0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/toggle_cursors"))] + pub const TOGGLE_CURSORS: FunctionDef = FunctionDef{address: 0x005fd3d1, function_type: PhantomData}; } // BFBSCall class functions pub mod bfbscall { use super::*; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004109fe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfbscall/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004109fe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfbscall/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x004781e9, function_type: PhantomData}; } @@ -102,18 +159,25 @@ pub mod bfbscall { pub mod bfbehaviorset { use super::*; - pub const EXECUTE_0: FunctionDef = FunctionDef{address: 0x00435e57, function_type: PhantomData}; - pub const EXECUTE_CHILD: FunctionDef u32> = FunctionDef{address: 0x0043745f, function_type: PhantomData}; - pub const INIT_CHILD: FunctionDef u32> = FunctionDef{address: 0x0043de4f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfbehaviorset/execute_0"))] + pub const EXECUTE_0: FunctionDef = FunctionDef{address: 0x00435e57, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfbehaviorset/execute_child"))] + pub const EXECUTE_CHILD: FunctionDef u32> = FunctionDef{address: 0x0043745f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfbehaviorset/init_child"))] + pub const INIT_CHILD: FunctionDef u32> = FunctionDef{address: 0x0043de4f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfbehaviorset/execute_1"))] pub const EXECUTE_1: FunctionDef = FunctionDef{address: 0x0043e7fc, function_type: PhantomData}; - pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x0044fb77, function_type: PhantomData}; - pub const SET_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004551cb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfbehaviorset/load"))] + pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x0044fb77, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfbehaviorset/set_entity"))] + pub const SET_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x004551cb, function_type: PhantomData}; } // BFCPUSPEED class functions pub mod bfcpuspeed { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("bfcpuspeed/get_cpuspeed"))] pub const GET_CPUSPEED: FunctionDef u32> = FunctionDef{address: 0x00533be4, function_type: PhantomData}; } @@ -121,174 +185,301 @@ pub mod bfcpuspeed { pub mod bfcategory { use super::*; - pub const GET_VALUE: FunctionDef u32> = FunctionDef{address: 0x00410ec0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfcategory/get_value"))] + pub const GET_VALUE: FunctionDef *const i32> = FunctionDef{address: 0x00410ec0, function_type: PhantomData}; } // BFCogGoal class functions pub mod bfcoggoal { use super::*; - pub const SET_TILE: FunctionDef = FunctionDef{address: 0x0041300b, function_type: PhantomData}; - pub const SET_IDSUB: FunctionDef = FunctionDef{address: 0x0041308d, function_type: PhantomData}; - pub const SET_TILE_SUB: FunctionDef = FunctionDef{address: 0x004131c8, function_type: PhantomData}; - pub const CLEAR_TARGET_SUB: FunctionDef = FunctionDef{address: 0x004131f9, function_type: PhantomData}; - pub const SET_TARGET_POS: FunctionDef = FunctionDef{address: 0x00413c2b, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00454aaf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfcoggoal/set_tile"))] + pub const SET_TILE: FunctionDef = FunctionDef{address: 0x0041300b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfcoggoal/set_idsub"))] + pub const SET_IDSUB: FunctionDef = FunctionDef{address: 0x0041308d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfcoggoal/set_tile_sub"))] + pub const SET_TILE_SUB: FunctionDef = FunctionDef{address: 0x004131c8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfcoggoal/clear_target_sub"))] + pub const CLEAR_TARGET_SUB: FunctionDef = FunctionDef{address: 0x004131f9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfcoggoal/set_target_pos"))] + pub const SET_TARGET_POS: FunctionDef = FunctionDef{address: 0x00413c2b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfcoggoal/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00454aaf, function_type: PhantomData}; } // BFConfigFile class functions pub mod bfconfigfile { use super::*; - pub const GET_STRING_0: FunctionDef u32> = FunctionDef{address: 0x00404c52, function_type: PhantomData}; - pub const GET_STRING_LIST_PTR: FunctionDef u8> = FunctionDef{address: 0x00405223, function_type: PhantomData}; - pub const GET_STRING_LIST: FunctionDef u32> = FunctionDef{address: 0x00405463, function_type: PhantomData}; - pub const GET_STRING_1: FunctionDef bool> = FunctionDef{address: 0x004098c1, function_type: PhantomData}; - pub const ATTEMPT_0: FunctionDef = FunctionDef{address: 0x00409ac0, function_type: PhantomData}; - pub const GET_INT: FunctionDef u32> = FunctionDef{address: 0x00409c14, function_type: PhantomData}; - pub const GET_KEYS: FunctionDef u32> = FunctionDef{address: 0x00409cf3, function_type: PhantomData}; - pub const RELEASE: FunctionDef = FunctionDef{address: 0x0040a5bc, function_type: PhantomData}; - pub const PARSE: FunctionDef bool> = FunctionDef{address: 0x0040ade7, function_type: PhantomData}; - pub const ATTEMPT_1: FunctionDef u32> = FunctionDef{address: 0x0040aeda, function_type: PhantomData}; - pub const ADD_KEY_VAL: FunctionDef = FunctionDef{address: 0x0040af4f, function_type: PhantomData}; - pub const ADD_BLOCK: FunctionDef u32> = FunctionDef{address: 0x0040b540, function_type: PhantomData}; - pub const GET_INT_LIST: FunctionDef u32> = FunctionDef{address: 0x004aabb8, function_type: PhantomData}; - pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x004aaf2d, function_type: PhantomData}; - pub const GET_FLOAT: FunctionDef u32> = FunctionDef{address: 0x004b37c3, function_type: PhantomData}; - pub const GET_BLOCKS: FunctionDef u32> = FunctionDef{address: 0x004b435e, function_type: PhantomData}; - pub const CONSTRUCTOR_0: FunctionDef u32> = FunctionDef{address: 0x004b4516, function_type: PhantomData}; - pub const CONSTRUCTOR_1: FunctionDef u32> = FunctionDef{address: 0x004d56f9, function_type: PhantomData}; - pub const CONSTRUCTOR_2: FunctionDef u32> = FunctionDef{address: 0x005fed91, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_string_0"))] + pub const GET_STRING_0: FunctionDef *const i32> = FunctionDef{address: 0x00404c52, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_string_list_ptr"))] + pub const GET_STRING_LIST_PTR: FunctionDef u8> = FunctionDef{address: 0x00405223, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_string_list"))] + pub const GET_STRING_LIST: FunctionDef *const u32> = FunctionDef{address: 0x00405463, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_string_1"))] + pub const GET_STRING_1: FunctionDef bool> = FunctionDef{address: 0x004098c1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/attempt_0"))] + pub const ATTEMPT_0: FunctionDef = FunctionDef{address: 0x00409ac0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_int"))] + pub const GET_INT: FunctionDef u32> = FunctionDef{address: 0x00409c14, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_keys"))] + pub const GET_KEYS: FunctionDef *const u32> = FunctionDef{address: 0x00409cf3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/release"))] + pub const RELEASE: FunctionDef = FunctionDef{address: 0x0040a5bc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/parse"))] + pub const PARSE: FunctionDef bool> = FunctionDef{address: 0x0040ade7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/attempt_1"))] + pub const ATTEMPT_1: FunctionDef u32> = FunctionDef{address: 0x0040aeda, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/add_key_val"))] + pub const ADD_KEY_VAL: FunctionDef = FunctionDef{address: 0x0040af4f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/add_block"))] + pub const ADD_BLOCK: FunctionDef *const u32> = FunctionDef{address: 0x0040b540, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_int_list"))] + pub const GET_INT_LIST: FunctionDef *const u32> = FunctionDef{address: 0x004aabb8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/acquire"))] + pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x004aaf2d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_float"))] + pub const GET_FLOAT: FunctionDef u32> = FunctionDef{address: 0x004b37c3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_blocks"))] + pub const GET_BLOCKS: FunctionDef *const u32> = FunctionDef{address: 0x004b435e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/constructor_0"))] + pub const CONSTRUCTOR_0: FunctionDef *const u32> = FunctionDef{address: 0x004b4516, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/constructor_1"))] + pub const CONSTRUCTOR_1: FunctionDef *const i32> = FunctionDef{address: 0x004d56f9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/constructor_2"))] + pub const CONSTRUCTOR_2: FunctionDef *const u32> = FunctionDef{address: 0x005fed91, function_type: PhantomData}; } // BFConfigStringTable class functions pub mod bfconfigstringtable { use super::*; - pub const DEL_STRING: FunctionDef = FunctionDef{address: 0x0040a6ad, function_type: PhantomData}; - pub const ADD_STRING: FunctionDef u32> = FunctionDef{address: 0x0040ae55, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigstringtable/del_string"))] + pub const DEL_STRING: FunctionDef = FunctionDef{address: 0x0040a6ad, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigstringtable/add_string"))] + pub const ADD_STRING: FunctionDef u32> = FunctionDef{address: 0x0040ae55, function_type: PhantomData}; } // BFDiagnostic class functions pub mod bfdiagnostic { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("bfdiagnostic/get_cpuspeed"))] pub const GET_CPUSPEED: FunctionDef u32> = FunctionDef{address: 0x00533a62, function_type: PhantomData}; - pub const GET_MEMORY: FunctionDef i32> = FunctionDef{address: 0x005368c0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfdiagnostic/get_memory"))] + pub const GET_MEMORY: FunctionDef u32> = FunctionDef{address: 0x005368c0, function_type: PhantomData}; } // BFEntity class functions pub mod bfentity { use super::*; - pub const INIT_AMBIENT_ANIMS: FunctionDef = FunctionDef{address: 0x00401115, function_type: PhantomData}; - pub const GET_TILE: FunctionDef i32> = FunctionDef{address: 0x0040f8ac, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/init_ambient_anims"))] + pub const INIT_AMBIENT_ANIMS: FunctionDef = FunctionDef{address: 0x00401115, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_tile"))] + pub const GET_TILE: FunctionDef i32> = FunctionDef{address: 0x0040f8ac, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_footprint"))] pub const GET_FOOTPRINT: FunctionDef *const u32> = FunctionDef{address: 0x0040f916, function_type: PhantomData}; - pub const IS_WALKABLE: FunctionDef = FunctionDef{address: 0x0040fbbd, function_type: PhantomData}; - pub const DIR_TO_SET: FunctionDef u32> = FunctionDef{address: 0x0040ff43, function_type: PhantomData}; - pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x0040ffc2, function_type: PhantomData}; - pub const SET_WORLD_POS: FunctionDef = FunctionDef{address: 0x00410141, function_type: PhantomData}; - pub const SET_DRAW_DITHERED: FunctionDef = FunctionDef{address: 0x0041028c, function_type: PhantomData}; - pub const INIT_AFTER_LOAD: FunctionDef = FunctionDef{address: 0x00410cb0, function_type: PhantomData}; - pub const FIND_ANIM: FunctionDef = FunctionDef{address: 0x00410ffe, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00412693, function_type: PhantomData}; - pub const INIT: FunctionDef i32> = FunctionDef{address: 0x0041281b, function_type: PhantomData}; - pub const INIT_STATUS_VARS: FunctionDef u32> = FunctionDef{address: 0x004128e0, function_type: PhantomData}; - pub const GET_GRID_POS: FunctionDef u32> = FunctionDef{address: 0x0041426f, function_type: PhantomData}; - pub const IS_WALKABLE_BY: FunctionDef = FunctionDef{address: 0x004147fd, function_type: PhantomData}; - pub const CHECK_AVOID_EDGES: FunctionDef u32> = FunctionDef{address: 0x004149e6, function_type: PhantomData}; - pub const BFENTITY_0: FunctionDef u32> = FunctionDef{address: 0x0041df2e, function_type: PhantomData}; - pub const SET_IS_REMOVED: FunctionDef = FunctionDef{address: 0x0041e0d9, function_type: PhantomData}; - pub const SET_VISIBLE: FunctionDef = FunctionDef{address: 0x0041e0f0, function_type: PhantomData}; - pub const IS_REMOVED_UNDO: FunctionDef = FunctionDef{address: 0x0041e1b5, function_type: PhantomData}; - pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x0041e84f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/is_walkable"))] + pub const IS_WALKABLE: FunctionDef u32> = FunctionDef{address: 0x0040fbbd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/dir_to_set"))] + pub const DIR_TO_SET: FunctionDef u32> = FunctionDef{address: 0x0040ff43, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/validate_position"))] + pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x0040ffc2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_world_pos"))] + pub const SET_WORLD_POS: FunctionDef = FunctionDef{address: 0x00410141, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_draw_dithered"))] + pub const SET_DRAW_DITHERED: FunctionDef = FunctionDef{address: 0x0041028c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/init_after_load"))] + pub const INIT_AFTER_LOAD: FunctionDef u8> = FunctionDef{address: 0x00410cb0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/find_anim"))] + pub const FIND_ANIM: FunctionDef = FunctionDef{address: 0x00410ffe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00412693, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/init"))] + pub const INIT: FunctionDef i32> = FunctionDef{address: 0x0041281b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/init_status_vars"))] + pub const INIT_STATUS_VARS: FunctionDef u32> = FunctionDef{address: 0x004128e0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_grid_pos"))] + pub const GET_GRID_POS: FunctionDef *const i32> = FunctionDef{address: 0x0041426f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/is_walkable_by"))] + pub const IS_WALKABLE_BY: FunctionDef = FunctionDef{address: 0x004147fd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/check_avoid_edges"))] + pub const CHECK_AVOID_EDGES: FunctionDef u32> = FunctionDef{address: 0x004149e6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/bfentity_0"))] + pub const BFENTITY_0: FunctionDef *const u32> = FunctionDef{address: 0x0041df2e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_is_removed"))] + pub const SET_IS_REMOVED: FunctionDef = FunctionDef{address: 0x0041e0d9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_visible"))] + pub const SET_VISIBLE: FunctionDef = FunctionDef{address: 0x0041e0f0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/is_removed_undo"))] + pub const IS_REMOVED_UNDO: FunctionDef u8> = FunctionDef{address: 0x0041e1b5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/create_name"))] + pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x0041e84f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_blocking_rect"))] pub const GET_BLOCKING_RECT: FunctionDef *const u32> = FunctionDef{address: 0x0042721a, function_type: PhantomData}; - pub const GET_PLACEMENT_FOOTPRINT: FunctionDef = FunctionDef{address: 0x004272d4, function_type: PhantomData}; - pub const CLEAR_BS: FunctionDef u32> = FunctionDef{address: 0x004274de, function_type: PhantomData}; - pub const CLEAR_QUEUE: FunctionDef = FunctionDef{address: 0x004275bb, function_type: PhantomData}; - pub const GET_INSIDE_POS: FunctionDef u32> = FunctionDef{address: 0x0042b875, function_type: PhantomData}; - pub const REPLACE_COLORS: FunctionDef = FunctionDef{address: 0x00432fc7, function_type: PhantomData}; - pub const DRAW_0: FunctionDef = FunctionDef{address: 0x00432ff4, function_type: PhantomData}; - pub const GET_SHADOW_TILE: FunctionDef = FunctionDef{address: 0x00433d31, function_type: PhantomData}; - pub const GET_COLOR_REP_INFO: FunctionDef i32> = FunctionDef{address: 0x00433fbd, function_type: PhantomData}; - pub const UPDATE_ANIMATION: FunctionDef = FunctionDef{address: 0x00434899, function_type: PhantomData}; - pub const IS_REMOVED: FunctionDef = FunctionDef{address: 0x004348b0, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0043494e, function_type: PhantomData}; - pub const SET_STOP_AT_END: FunctionDef = FunctionDef{address: 0x00434aca, function_type: PhantomData}; - pub const SET_BS: FunctionDef u32> = FunctionDef{address: 0x0043c6c5, function_type: PhantomData}; - pub const DRAW_SHADOW: FunctionDef = FunctionDef{address: 0x0043f81c, function_type: PhantomData}; - pub const GET_UNDERWATER_SECTION_ANIM: FunctionDef i32> = FunctionDef{address: 0x0043fd53, function_type: PhantomData}; - pub const SET_DIRECTION: FunctionDef = FunctionDef{address: 0x004403ea, function_type: PhantomData}; - pub const GET_ICON_ZOOM: FunctionDef = FunctionDef{address: 0x004440cc, function_type: PhantomData}; - pub const VERIFY_SHAPE: FunctionDef = FunctionDef{address: 0x00446995, function_type: PhantomData}; - pub const SET_NAME: FunctionDef = FunctionDef{address: 0x00449215, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044f866, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_placement_footprint"))] + pub const GET_PLACEMENT_FOOTPRINT: FunctionDef = FunctionDef{address: 0x004272d4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/clear_bs"))] + pub const CLEAR_BS: FunctionDef u32> = FunctionDef{address: 0x004274de, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/clear_queue"))] + pub const CLEAR_QUEUE: FunctionDef = FunctionDef{address: 0x004275bb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_inside_pos"))] + pub const GET_INSIDE_POS: FunctionDef *const u32> = FunctionDef{address: 0x0042b875, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/replace_colors"))] + pub const REPLACE_COLORS: FunctionDef = FunctionDef{address: 0x00432fc7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/draw_0"))] + pub const DRAW_0: FunctionDef = FunctionDef{address: 0x00432ff4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_shadow_tile"))] + pub const GET_SHADOW_TILE: FunctionDef i32> = FunctionDef{address: 0x00433d31, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_color_rep_info"))] + pub const GET_COLOR_REP_INFO: FunctionDef i32> = FunctionDef{address: 0x00433fbd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/update_animation"))] + pub const UPDATE_ANIMATION: FunctionDef = FunctionDef{address: 0x00434899, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/is_removed"))] + pub const IS_REMOVED: FunctionDef u8> = FunctionDef{address: 0x004348b0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0043494e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_stop_at_end"))] + pub const SET_STOP_AT_END: FunctionDef = FunctionDef{address: 0x00434aca, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_bs"))] + pub const SET_BS: FunctionDef u32> = FunctionDef{address: 0x0043c6c5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/draw_shadow"))] + pub const DRAW_SHADOW: FunctionDef = FunctionDef{address: 0x0043f81c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_underwater_section_anim"))] + pub const GET_UNDERWATER_SECTION_ANIM: FunctionDef i32> = FunctionDef{address: 0x0043fd53, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_direction"))] + pub const SET_DIRECTION: FunctionDef = FunctionDef{address: 0x004403ea, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_icon_zoom"))] + pub const GET_ICON_ZOOM: FunctionDef u32> = FunctionDef{address: 0x004440cc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/verify_shape"))] + pub const VERIFY_SHAPE: FunctionDef u8> = FunctionDef{address: 0x00446995, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_name"))] + pub const SET_NAME: FunctionDef = FunctionDef{address: 0x00449215, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044f866, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00477998, function_type: PhantomData}; - pub const FORCE_ANIM: FunctionDef = FunctionDef{address: 0x00485580, function_type: PhantomData}; - pub const MORPH: FunctionDef = FunctionDef{address: 0x004865c4, function_type: PhantomData}; - pub const CALC_SHADOW_WORLD_POSITION: FunctionDef = FunctionDef{address: 0x00492def, function_type: PhantomData}; - pub const DRAW_UNDERWATER_SECTION: FunctionDef = FunctionDef{address: 0x00496b99, function_type: PhantomData}; - pub const GET_HEIGHT: FunctionDef = FunctionDef{address: 0x00498d30, function_type: PhantomData}; - pub const SET_BSNEW: FunctionDef u32> = FunctionDef{address: 0x004a7e94, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/force_anim"))] + pub const FORCE_ANIM: FunctionDef u32> = FunctionDef{address: 0x00485580, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/morph"))] + pub const MORPH: FunctionDef = FunctionDef{address: 0x004865c4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/calc_shadow_world_position"))] + pub const CALC_SHADOW_WORLD_POSITION: FunctionDef = FunctionDef{address: 0x00492def, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/draw_underwater_section"))] + pub const DRAW_UNDERWATER_SECTION: FunctionDef = FunctionDef{address: 0x00496b99, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_height"))] + pub const GET_HEIGHT: FunctionDef u32> = FunctionDef{address: 0x00498d30, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_bsnew"))] + pub const SET_BSNEW: FunctionDef u32> = FunctionDef{address: 0x004a7e94, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/is_on_tile"))] pub const IS_ON_TILE: FunctionDef bool> = FunctionDef{address: 0x004e16f1, function_type: PhantomData}; - pub const DRAW_SELECTION_GRAPHIC: FunctionDef = FunctionDef{address: 0x004ed85d, function_type: PhantomData}; - pub const SET_SELECTED: FunctionDef = FunctionDef{address: 0x004ee29a, function_type: PhantomData}; - pub const SEND_EVENT_0: FunctionDef = FunctionDef{address: 0x004f2bd5, function_type: PhantomData}; - pub const ADD_TO_MAP: FunctionDef = FunctionDef{address: 0x004f421f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/draw_selection_graphic"))] + pub const DRAW_SELECTION_GRAPHIC: FunctionDef = FunctionDef{address: 0x004ed85d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_selected"))] + pub const SET_SELECTED: FunctionDef = FunctionDef{address: 0x004ee29a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/send_event_0"))] + pub const SEND_EVENT_0: FunctionDef = FunctionDef{address: 0x004f2bd5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/add_to_map"))] + pub const ADD_TO_MAP: FunctionDef = FunctionDef{address: 0x004f421f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_blocking_rect_virt_ztpath"))] pub const GET_BLOCKING_RECT_VIRT_ZTPATH: FunctionDef *const u32> = FunctionDef{address: 0x004fbbee, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/destroy_selection_graphics"))] pub const DESTROY_SELECTION_GRAPHICS: FunctionDef = FunctionDef{address: 0x005028c5, function_type: PhantomData}; - pub const SNAP_TO_GRID: FunctionDef = FunctionDef{address: 0x00505763, function_type: PhantomData}; - pub const SEND_EVENT_1: FunctionDef = FunctionDef{address: 0x0059df63, function_type: PhantomData}; - pub const GET_DEPTH: FunctionDef = FunctionDef{address: 0x005af392, function_type: PhantomData}; - pub const GET_IDLE_ANIM: FunctionDef = FunctionDef{address: 0x005ff91c, function_type: PhantomData}; - pub const GET_ICON_ANIM: FunctionDef = FunctionDef{address: 0x005ff92b, function_type: PhantomData}; - pub const IS_SNAP_TO_GROUND: FunctionDef = FunctionDef{address: 0x005ff936, function_type: PhantomData}; - pub const BFENTITY_1: FunctionDef u32> = FunctionDef{address: 0x005ff93d, function_type: PhantomData}; - pub const DRAW_1: FunctionDef = FunctionDef{address: 0x005ff95b, function_type: PhantomData}; - pub const DRAW_AIINFO: FunctionDef = FunctionDef{address: 0x005ff9e8, function_type: PhantomData}; - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x005ff9eb, function_type: PhantomData}; - pub const GET_EVENTS: FunctionDef = FunctionDef{address: 0x005ffa19, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/snap_to_grid"))] + pub const SNAP_TO_GRID: FunctionDef = FunctionDef{address: 0x00505763, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/send_event_1"))] + pub const SEND_EVENT_1: FunctionDef = FunctionDef{address: 0x0059df63, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_depth"))] + pub const GET_DEPTH: FunctionDef u32> = FunctionDef{address: 0x005af392, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_idle_anim"))] + pub const GET_IDLE_ANIM: FunctionDef u32> = FunctionDef{address: 0x005ff91c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_icon_anim"))] + pub const GET_ICON_ANIM: FunctionDef = FunctionDef{address: 0x005ff92b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/is_snap_to_ground"))] + pub const IS_SNAP_TO_GROUND: FunctionDef u8> = FunctionDef{address: 0x005ff936, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/bfentity_1"))] + pub const BFENTITY_1: FunctionDef *const u32> = FunctionDef{address: 0x005ff93d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/draw_1"))] + pub const DRAW_1: FunctionDef = FunctionDef{address: 0x005ff95b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/draw_aiinfo"))] + pub const DRAW_AIINFO: FunctionDef = FunctionDef{address: 0x005ff9e8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x005ff9eb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_events"))] + pub const GET_EVENTS: FunctionDef = FunctionDef{address: 0x005ffa19, function_type: PhantomData}; } // BFEntityType class functions pub mod bfentitytype { use super::*; - pub const FIND_ANIM: FunctionDef u32> = FunctionDef{address: 0x00402062, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/find_anim"))] + pub const FIND_ANIM: FunctionDef *const i8> = FunctionDef{address: 0x00402062, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/is_user_type_id"))] pub const IS_USER_TYPE_ID: FunctionDef u32> = FunctionDef{address: 0x00404cb4, function_type: PhantomData}; - pub const IS_USER_TYPE: FunctionDef = FunctionDef{address: 0x004055e2, function_type: PhantomData}; - pub const GET_BASE_ANIM: FunctionDef u32> = FunctionDef{address: 0x00412ac4, function_type: PhantomData}; - pub const FIND_SOUND: FunctionDef u32> = FunctionDef{address: 0x0044084b, function_type: PhantomData}; - pub const LOAD_DATA: FunctionDef u32> = FunctionDef{address: 0x004b456c, function_type: PhantomData}; - pub const LOAD_SOUNDS: FunctionDef u32> = FunctionDef{address: 0x004b473f, function_type: PhantomData}; - pub const GET_INT: FunctionDef u32> = FunctionDef{address: 0x004b4803, function_type: PhantomData}; - pub const GET_STRING: FunctionDef u32> = FunctionDef{address: 0x004b486c, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004b4903, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b4c2a, function_type: PhantomData}; - pub const LOAD_COLOR_REP_INFO: FunctionDef u32> = FunctionDef{address: 0x004bb159, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004be045, function_type: PhantomData}; - pub const SET_TYPE: FunctionDef = FunctionDef{address: 0x004be24e, function_type: PhantomData}; - pub const CHECK_TYPE: FunctionDef u32> = FunctionDef{address: 0x004be3ec, function_type: PhantomData}; - pub const NUM_ICONS: FunctionDef = FunctionDef{address: 0x004e9e68, function_type: PhantomData}; - pub const GET_ICON_NAME: FunctionDef u32> = FunctionDef{address: 0x004e9e74, function_type: PhantomData}; - pub const GET_UNIT_COUNT: FunctionDef i32> = FunctionDef{address: 0x004f6cc5, function_type: PhantomData}; - pub const BFENTITY_TYPE: FunctionDef u32> = FunctionDef{address: 0x00500783, function_type: PhantomData}; - pub const UNLOAD_DATA: FunctionDef = FunctionDef{address: 0x005008bb, function_type: PhantomData}; - pub const UNLOAD_ANIMATIONS: FunctionDef = FunctionDef{address: 0x005008e7, function_type: PhantomData}; - pub const UNLOAD_SOUNDS: FunctionDef = FunctionDef{address: 0x005008fe, function_type: PhantomData}; - pub const LOAD_USER_DATA: FunctionDef u32> = FunctionDef{address: 0x00597337, function_type: PhantomData}; - pub const SET_AVAILABLE: FunctionDef = FunctionDef{address: 0x005a111d, function_type: PhantomData}; - pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x005fe1c8, function_type: PhantomData}; - pub const GET_USER_DATA: FunctionDef u32> = FunctionDef{address: 0x005fe1ea, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/is_user_type"))] + pub const IS_USER_TYPE: FunctionDef = FunctionDef{address: 0x004055e2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_base_anim"))] + pub const GET_BASE_ANIM: FunctionDef *const i8> = FunctionDef{address: 0x00412ac4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/find_sound"))] + pub const FIND_SOUND: FunctionDef *const i32> = FunctionDef{address: 0x0044084b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/load_data"))] + pub const LOAD_DATA: FunctionDef u32> = FunctionDef{address: 0x004b456c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/load_sounds"))] + pub const LOAD_SOUNDS: FunctionDef u32> = FunctionDef{address: 0x004b473f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_int"))] + pub const GET_INT: FunctionDef u32> = FunctionDef{address: 0x004b4803, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_string"))] + pub const GET_STRING: FunctionDef u32> = FunctionDef{address: 0x004b486c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/load_characteristics_0"))] + pub const LOAD_CHARACTERISTICS_0: FunctionDef *const i16> = FunctionDef{address: 0x004b4903, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/load_characteristics_1"))] + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b4c2a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/load_color_rep_info"))] + pub const LOAD_COLOR_REP_INFO: FunctionDef u32> = FunctionDef{address: 0x004bb159, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004be045, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/set_type"))] + pub const SET_TYPE: FunctionDef = FunctionDef{address: 0x004be24e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/check_type"))] + pub const CHECK_TYPE: FunctionDef u32> = FunctionDef{address: 0x004be3ec, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/num_icons"))] + pub const NUM_ICONS: FunctionDef i32> = FunctionDef{address: 0x004e9e68, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_icon_name"))] + pub const GET_ICON_NAME: FunctionDef u32> = FunctionDef{address: 0x004e9e74, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_unit_count"))] + pub const GET_UNIT_COUNT: FunctionDef i32> = FunctionDef{address: 0x004f6cc5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/bfentity_type"))] + pub const BFENTITY_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x00500783, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/unload_data"))] + pub const UNLOAD_DATA: FunctionDef = FunctionDef{address: 0x005008bb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/unload_animations"))] + pub const UNLOAD_ANIMATIONS: FunctionDef = FunctionDef{address: 0x005008e7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/unload_sounds"))] + pub const UNLOAD_SOUNDS: FunctionDef = FunctionDef{address: 0x005008fe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/load_user_data"))] + pub const LOAD_USER_DATA: FunctionDef u32> = FunctionDef{address: 0x00597337, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/set_available"))] + pub const SET_AVAILABLE: FunctionDef = FunctionDef{address: 0x005a111d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x005fe1c8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_user_data"))] + pub const GET_USER_DATA: FunctionDef *const i32> = FunctionDef{address: 0x005fe1ea, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_base_user_id"))] pub const GET_BASE_USER_ID: FunctionDef i32> = FunctionDef{address: 0x005fe25c, function_type: PhantomData}; - pub const GET_USER_DATA_INDEX: FunctionDef = FunctionDef{address: 0x005fe27a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_user_data_index"))] + pub const GET_USER_DATA_INDEX: FunctionDef u8> = FunctionDef{address: 0x005fe27a, function_type: PhantomData}; } // BFEvent class functions pub mod bfevent { use super::*; - pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x00485f08, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfevent/load"))] + pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x00485f08, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfevent/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0060182e, function_type: PhantomData}; } @@ -296,7 +487,9 @@ pub mod bfevent { pub mod bfeventinfo { use super::*; - pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x00485e31, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfeventinfo/load"))] + pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x00485e31, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfeventinfo/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00601768, function_type: PhantomData}; } @@ -304,114 +497,175 @@ pub mod bfeventinfo { pub mod bfeventmgr { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("bfeventmgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047afa5, function_type: PhantomData}; - pub const INIT: FunctionDef u32> = FunctionDef{address: 0x00525f3e, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0052603f, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00594d17, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfeventmgr/init"))] + pub const INIT: FunctionDef u32> = FunctionDef{address: 0x00525f3e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfeventmgr/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0052603f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfeventmgr/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00594d17, function_type: PhantomData}; } // BFFont class functions pub mod bffont { use super::*; - pub const CREATE: FunctionDef u32> = FunctionDef{address: 0x00510102, function_type: PhantomData}; - pub const BFFONT: FunctionDef u32> = FunctionDef{address: 0x00620bfa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bffont/create"))] + pub const CREATE: FunctionDef u32> = FunctionDef{address: 0x00510102, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bffont/bffont"))] + pub const BFFONT: FunctionDef *const u32> = FunctionDef{address: 0x00620bfa, function_type: PhantomData}; } // BFFontCache class functions pub mod bffontcache { use super::*; - pub const REMOVE_FONT: FunctionDef = FunctionDef{address: 0x005032a6, function_type: PhantomData}; - pub const GET_FONT: FunctionDef u32> = FunctionDef{address: 0x00510001, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bffontcache/remove_font"))] + pub const REMOVE_FONT: FunctionDef = FunctionDef{address: 0x005032a6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bffontcache/get_font"))] + pub const GET_FONT: FunctionDef *const i32> = FunctionDef{address: 0x00510001, function_type: PhantomData}; } // BFFontDescription class functions pub mod bffontdescription { use super::*; - pub const GET_HEIGHT_0: FunctionDef i32> = FunctionDef{address: 0x00418d4a, function_type: PhantomData}; - pub const RELEASE: FunctionDef = FunctionDef{address: 0x0050241b, function_type: PhantomData}; - pub const GET_AVG_CHAR_WIDTH_0: FunctionDef i32> = FunctionDef{address: 0x00510668, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bffontdescription/get_height_0"))] + pub const GET_HEIGHT_0: FunctionDef i32> = FunctionDef{address: 0x00418d4a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bffontdescription/release"))] + pub const RELEASE: FunctionDef = FunctionDef{address: 0x0050241b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bffontdescription/get_avg_char_width_0"))] + pub const GET_AVG_CHAR_WIDTH_0: FunctionDef i32> = FunctionDef{address: 0x00510668, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bffontdescription/get_height_1"))] pub const GET_HEIGHT_1: FunctionDef u32> = FunctionDef{address: 0x00511c74, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bffontdescription/get_avg_char_width_1"))] pub const GET_AVG_CHAR_WIDTH_1: FunctionDef u32> = FunctionDef{address: 0x00511cc2, function_type: PhantomData}; - pub const CREATE: FunctionDef u32> = FunctionDef{address: 0x00511d39, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bffontdescription/create"))] + pub const CREATE: FunctionDef *const i16> = FunctionDef{address: 0x00511d39, function_type: PhantomData}; } // BFGameApp class functions pub mod bfgameapp { use super::*; - pub const GET_GRAPHICS: FunctionDef = FunctionDef{address: 0x00401380, function_type: PhantomData}; - pub const HANDLE_MESSAGES: FunctionDef i32> = FunctionDef{address: 0x00418f97, function_type: PhantomData}; - pub const DO_EACH_LOOP: FunctionDef = FunctionDef{address: 0x0041a5ff, function_type: PhantomData}; - pub const RESTART_GRAPHICS_MGR: FunctionDef u32> = FunctionDef{address: 0x004ca9a4, function_type: PhantomData}; - pub const TOGGLE_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d603b, function_type: PhantomData}; - pub const RESIZE_APP: FunctionDef u32> = FunctionDef{address: 0x004d6ce5, function_type: PhantomData}; - pub const INIT_INSTANCE_0: FunctionDef u32> = FunctionDef{address: 0x00533552, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x005786fb, function_type: PhantomData}; - pub const GET_SOUND: FunctionDef = FunctionDef{address: 0x0057d5e1, function_type: PhantomData}; - pub const EXIT_OVERRIDE: FunctionDef = FunctionDef{address: 0x0057de27, function_type: PhantomData}; - pub const BFGAME_APP: FunctionDef u32> = FunctionDef{address: 0x00604487, function_type: PhantomData}; - pub const INIT_INSTANCE_1: FunctionDef = FunctionDef{address: 0x00620686, function_type: PhantomData}; - pub const GET_UPDATE_TIME: FunctionDef = FunctionDef{address: 0x0062069f, function_type: PhantomData}; - pub const INIT_INSTANCE_2: FunctionDef = FunctionDef{address: 0x006206a3, function_type: PhantomData}; - pub const LOAD_TYPEDATA: FunctionDef = FunctionDef{address: 0x006206d4, function_type: PhantomData}; - pub const GET_UPDATE_HANDLER: FunctionDef u32> = FunctionDef{address: 0x00620708, function_type: PhantomData}; - pub const INC_SIM_SPEED: FunctionDef = FunctionDef{address: 0x00620745, function_type: PhantomData}; - pub const DEC_SIM_SPEED: FunctionDef = FunctionDef{address: 0x00620762, function_type: PhantomData}; - pub const RESET_SIM_SPEED: FunctionDef = FunctionDef{address: 0x00620792, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/get_graphics"))] + pub const GET_GRAPHICS: FunctionDef u32> = FunctionDef{address: 0x00401380, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/handle_messages"))] + pub const HANDLE_MESSAGES: FunctionDef u32> = FunctionDef{address: 0x00418f97, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/do_each_loop"))] + pub const DO_EACH_LOOP: FunctionDef = FunctionDef{address: 0x0041a5ff, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/restart_graphics_mgr"))] + pub const RESTART_GRAPHICS_MGR: FunctionDef u32> = FunctionDef{address: 0x004ca9a4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/toggle_fullscreen"))] + pub const TOGGLE_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d603b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/resize_app"))] + pub const RESIZE_APP: FunctionDef u32> = FunctionDef{address: 0x004d6ce5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/init_instance_0"))] + pub const INIT_INSTANCE_0: FunctionDef u32> = FunctionDef{address: 0x00533552, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x005786fb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/get_sound"))] + pub const GET_SOUND: FunctionDef *const u32> = FunctionDef{address: 0x0057d5e1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/exit_override"))] + pub const EXIT_OVERRIDE: FunctionDef = FunctionDef{address: 0x0057de27, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/bfgame_app"))] + pub const BFGAME_APP: FunctionDef *const u32> = FunctionDef{address: 0x00604487, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/init_instance_1"))] + pub const INIT_INSTANCE_1: FunctionDef = FunctionDef{address: 0x00620686, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/get_update_time"))] + pub const GET_UPDATE_TIME: FunctionDef u32> = FunctionDef{address: 0x0062069f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/init_instance_2"))] + pub const INIT_INSTANCE_2: FunctionDef = FunctionDef{address: 0x006206a3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/load_typedata"))] + pub const LOAD_TYPEDATA: FunctionDef = FunctionDef{address: 0x006206d4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/get_update_handler"))] + pub const GET_UPDATE_HANDLER: FunctionDef *const u32> = FunctionDef{address: 0x00620708, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/inc_sim_speed"))] + pub const INC_SIM_SPEED: FunctionDef = FunctionDef{address: 0x00620745, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/dec_sim_speed"))] + pub const DEC_SIM_SPEED: FunctionDef = FunctionDef{address: 0x00620762, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/reset_sim_speed"))] + pub const RESET_SIM_SPEED: FunctionDef = FunctionDef{address: 0x00620792, function_type: PhantomData}; } // BFGameMgr class functions pub mod bfgamemgr { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgamemgr/update_sim"))] + pub const UPDATE_SIM: FunctionDef = FunctionDef{address: 0x0043529d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgamemgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047aca5, function_type: PhantomData}; - pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x00594cba, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgamemgr/bfgame_mgr"))] + pub const BFGAME_MGR: FunctionDef *const u32> = FunctionDef{address: 0x0057d7f5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgamemgr/set_new_game_defaults"))] + pub const SET_NEW_GAME_DEFAULTS: FunctionDef = FunctionDef{address: 0x00591a50, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgamemgr/load"))] + pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x00594cba, function_type: PhantomData}; } // BFGoal class functions pub mod bfgoal { use super::*; - pub const SET_GOAL_TILE: FunctionDef = FunctionDef{address: 0x0042224d, function_type: PhantomData}; - pub const GET_TYPE: FunctionDef = FunctionDef{address: 0x004781e5, function_type: PhantomData}; - pub const BFGOAL: FunctionDef u32> = FunctionDef{address: 0x004a4da2, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004a4e37, function_type: PhantomData}; - pub const SET_GOAL_TARGET_POS: FunctionDef = FunctionDef{address: 0x004a722c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgoal/set_goal_tile"))] + pub const SET_GOAL_TILE: FunctionDef = FunctionDef{address: 0x0042224d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgoal/get_type"))] + pub const GET_TYPE: FunctionDef u32> = FunctionDef{address: 0x004781e5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgoal/bfgoal"))] + pub const BFGOAL: FunctionDef *const u32> = FunctionDef{address: 0x004a4da2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgoal/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004a4e37, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgoal/set_goal_target_pos"))] + pub const SET_GOAL_TARGET_POS: FunctionDef = FunctionDef{address: 0x004a722c, function_type: PhantomData}; } // BFGoalFactory class functions pub mod bfgoalfactory { use super::*; - pub const CREATE_0: FunctionDef u32> = FunctionDef{address: 0x00413acd, function_type: PhantomData}; - pub const CREATE_1: FunctionDef u32> = FunctionDef{address: 0x00413ba8, function_type: PhantomData}; - pub const CONSTRUCTOR_0: FunctionDef u32> = FunctionDef{address: 0x00502904, function_type: PhantomData}; - pub const BFGOAL_FACTORY: FunctionDef = FunctionDef{address: 0x0050290b, function_type: PhantomData}; - pub const CONSTRUCTOR_1: FunctionDef u32> = FunctionDef{address: 0x00502915, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgoalfactory/create_0"))] + pub const CREATE_0: FunctionDef *const u32> = FunctionDef{address: 0x00413acd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgoalfactory/create_1"))] + pub const CREATE_1: FunctionDef *const u32> = FunctionDef{address: 0x00413ba8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgoalfactory/constructor_0"))] + pub const CONSTRUCTOR_0: FunctionDef *const u32> = FunctionDef{address: 0x00502904, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgoalfactory/bfgoal_factory"))] + pub const BFGOAL_FACTORY: FunctionDef = FunctionDef{address: 0x0050290b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfgoalfactory/constructor_1"))] + pub const CONSTRUCTOR_1: FunctionDef *const u32> = FunctionDef{address: 0x00502915, function_type: PhantomData}; } // BFIniFile class functions pub mod bfinifile { use super::*; - pub const READ: FunctionDef u32> = FunctionDef{address: 0x0041b55d, function_type: PhantomData}; - pub const WRITE: FunctionDef = FunctionDef{address: 0x004b298d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfinifile/read"))] + pub const READ: FunctionDef u32> = FunctionDef{address: 0x0041b55d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfinifile/write"))] + pub const WRITE: FunctionDef = FunctionDef{address: 0x004b298d, function_type: PhantomData}; } // BFLog class functions pub mod bflog { use super::*; - pub const LOG_MESSAGE: FunctionDef = FunctionDef{address: 0x00401363, function_type: PhantomData}; - pub const CONSTRUCTOR_0: FunctionDef = FunctionDef{address: 0x00401386, function_type: PhantomData}; - pub const CONSTRUCTOR_1: FunctionDef = FunctionDef{address: 0x0040514d, function_type: PhantomData}; - pub const FORMAT_LOG_MESSAGE: FunctionDef u32> = FunctionDef{address: 0x0040667d, function_type: PhantomData}; - pub const PROCESS_LOG_OPTIONS: FunctionDef = FunctionDef{address: 0x0052b94a, function_type: PhantomData}; - pub const WRITE_LOG_MESSAGE: FunctionDef = FunctionDef{address: 0x0052b9a2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bflog/log_message"))] + pub const LOG_MESSAGE: FunctionDef = FunctionDef{address: 0x00401363, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bflog/constructor_0"))] + pub const CONSTRUCTOR_0: FunctionDef = FunctionDef{address: 0x00401386, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bflog/constructor_1"))] + pub const CONSTRUCTOR_1: FunctionDef = FunctionDef{address: 0x0040514d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bflog/format_log_message"))] + pub const FORMAT_LOG_MESSAGE: FunctionDef u32> = FunctionDef{address: 0x0040667d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bflog/process_log_options"))] + pub const PROCESS_LOG_OPTIONS: FunctionDef = FunctionDef{address: 0x0052b94a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bflog/write_log_message"))] + pub const WRITE_LOG_MESSAGE: FunctionDef = FunctionDef{address: 0x0052b9a2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bflog/set_log_level"))] pub const SET_LOG_LEVEL: FunctionDef = FunctionDef{address: 0x0052ba7b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bflog/write_log_to_file"))] pub const WRITE_LOG_TO_FILE: FunctionDef = FunctionDef{address: 0x006033ba, function_type: PhantomData}; } @@ -419,121 +673,215 @@ pub mod bflog { pub mod bfmap { use super::*; - pub const WORLD_TO_VIRTUAL_0: FunctionDef = FunctionDef{address: 0x0040f041, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/world_to_virtual_0"))] + pub const WORLD_TO_VIRTUAL_0: FunctionDef = FunctionDef{address: 0x0040f041, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/tile_to_world"))] pub const TILE_TO_WORLD: FunctionDef *const i32> = FunctionDef{address: 0x0040f26c, function_type: PhantomData}; - pub const GET_NEIGHBOR_0: FunctionDef u32> = FunctionDef{address: 0x0040fa92, function_type: PhantomData}; - pub const GET_HEIGHT_ABOVE_TERRAIN: FunctionDef i32> = FunctionDef{address: 0x00410183, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_neighbor_0"))] + pub const GET_NEIGHBOR_0: FunctionDef u32> = FunctionDef{address: 0x0040fa92, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_height_above_terrain"))] + pub const GET_HEIGHT_ABOVE_TERRAIN: FunctionDef i32> = FunctionDef{address: 0x00410183, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_direction_0"))] pub const GET_DIRECTION_0: FunctionDef i32> = FunctionDef{address: 0x00411654, function_type: PhantomData}; - pub const GET_DIRECTION_1: FunctionDef i32> = FunctionDef{address: 0x004116a9, function_type: PhantomData}; - pub const DISTANCE_CARTESIAN: FunctionDef i32> = FunctionDef{address: 0x0041180a, function_type: PhantomData}; - pub const VALIDATE_NOT_BLOCKED: FunctionDef u32> = FunctionDef{address: 0x00413f43, function_type: PhantomData}; - pub const VALIDATE: FunctionDef u32> = FunctionDef{address: 0x004140c6, function_type: PhantomData}; - pub const GET_NEIGHBORS: FunctionDef u32> = FunctionDef{address: 0x004171a1, function_type: PhantomData}; - pub const GET_NEAREST_DIRECTION: FunctionDef u64> = FunctionDef{address: 0x00426c39, function_type: PhantomData}; - pub const GET_PROPER_DIRECTION: FunctionDef u32> = FunctionDef{address: 0x0042b79a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_direction_1"))] + pub const GET_DIRECTION_1: FunctionDef i32> = FunctionDef{address: 0x004116a9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/distance_cartesian"))] + pub const DISTANCE_CARTESIAN: FunctionDef i32> = FunctionDef{address: 0x0041180a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/add_unit"))] + pub const ADD_UNIT: FunctionDef u32> = FunctionDef{address: 0x004137df, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/validate_not_blocked"))] + pub const VALIDATE_NOT_BLOCKED: FunctionDef u32> = FunctionDef{address: 0x00413f43, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/validate"))] + pub const VALIDATE: FunctionDef u32> = FunctionDef{address: 0x004140c6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_neighbors"))] + pub const GET_NEIGHBORS: FunctionDef *const u32> = FunctionDef{address: 0x004171a1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_nearest_direction_0"))] + pub const GET_NEAREST_DIRECTION_0: FunctionDef u64> = FunctionDef{address: 0x00426c39, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_proper_direction"))] + pub const GET_PROPER_DIRECTION: FunctionDef *const c_void> = FunctionDef{address: 0x0042b79a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_neighbor_1"))] pub const GET_NEIGHBOR_1: FunctionDef u32> = FunctionDef{address: 0x00432236, function_type: PhantomData}; - pub const DRAW: FunctionDef = FunctionDef{address: 0x00432dcd, function_type: PhantomData}; - pub const GET_TURNING_DIRECTION: FunctionDef i32> = FunctionDef{address: 0x0043a28c, function_type: PhantomData}; - pub const WORLD_TO_VIRTUAL_1: FunctionDef = FunctionDef{address: 0x004402ed, function_type: PhantomData}; - pub const VIRTUAL_TO_WORLD: FunctionDef = FunctionDef{address: 0x004441ab, function_type: PhantomData}; - pub const SET_SELECTION: FunctionDef = FunctionDef{address: 0x004446f9, function_type: PhantomData}; - pub const GET_SELECTION: FunctionDef = FunctionDef{address: 0x004447e5, function_type: PhantomData}; - pub const ADD_EDGE: FunctionDef u32> = FunctionDef{address: 0x0044d4f8, function_type: PhantomData}; - pub const SAVE_TILE_TERRAIN: FunctionDef = FunctionDef{address: 0x00459245, function_type: PhantomData}; - pub const ADJUST_CELL: FunctionDef u32> = FunctionDef{address: 0x0045d935, function_type: PhantomData}; - pub const ADJUST_CELL_HEIGHT: FunctionDef = FunctionDef{address: 0x0045e04e, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004625af, function_type: PhantomData}; - pub const RESTORE_TERRAIN: FunctionDef = FunctionDef{address: 0x00482978, function_type: PhantomData}; - pub const COPY_FULL_TO_SINGLE_TILE_TERRAIN: FunctionDef = FunctionDef{address: 0x00488fc7, function_type: PhantomData}; - pub const GET_CHANGED_ELEVATIONS: FunctionDef u32> = FunctionDef{address: 0x004891d3, function_type: PhantomData}; - pub const SET_HEIGHT_ABOVE_TERRAIN: FunctionDef = FunctionDef{address: 0x00492a9f, function_type: PhantomData}; - pub const DRAW_SORTER_ENTITY: FunctionDef = FunctionDef{address: 0x004a7272, function_type: PhantomData}; - pub const MOVE_ENTITY: FunctionDef = FunctionDef{address: 0x004a746a, function_type: PhantomData}; - pub const COMPUTE_TILES: FunctionDef = FunctionDef{address: 0x004af165, function_type: PhantomData}; - pub const SET_ZOOM: FunctionDef = FunctionDef{address: 0x004af19c, function_type: PhantomData}; - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6b83, function_type: PhantomData}; - pub const SET_MAP_DIMENSIONS: FunctionDef = FunctionDef{address: 0x004c84d3, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004c8782, function_type: PhantomData}; - pub const UPDATE_TERRAIN_COST: FunctionDef f32> = FunctionDef{address: 0x004d9c0f, function_type: PhantomData}; - pub const GET_TERRAIN_PAINT_COST: FunctionDef f32> = FunctionDef{address: 0x004dc8a4, function_type: PhantomData}; - pub const ADD_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004f3e7d, function_type: PhantomData}; - pub const CAN_PAINT: FunctionDef u32> = FunctionDef{address: 0x004f8f0b, function_type: PhantomData}; - pub const PAINT_CELL: FunctionDef u32> = FunctionDef{address: 0x004f8fd8, function_type: PhantomData}; - pub const REMOVE_ENTITY: FunctionDef = FunctionDef{address: 0x004fe639, function_type: PhantomData}; - pub const REMOVE_EDGE: FunctionDef = FunctionDef{address: 0x004ffdd8, function_type: PhantomData}; - pub const VALIDATE_NEIGHBORS: FunctionDef u32> = FunctionDef{address: 0x0052d76a, function_type: PhantomData}; - pub const VALIDATE_TILES: FunctionDef = FunctionDef{address: 0x005b302a, function_type: PhantomData}; - pub const CLEAR_TILE_TERRAIN: FunctionDef = FunctionDef{address: 0x005b342e, function_type: PhantomData}; - pub const GET_ALL_NEIGHBORS: FunctionDef u32> = FunctionDef{address: 0x005b3835, function_type: PhantomData}; - pub const CLEAR_SAVED_PATH: FunctionDef = FunctionDef{address: 0x00600414, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/draw"))] + pub const DRAW: FunctionDef = FunctionDef{address: 0x00432dcd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_selection_for_drawing"))] + pub const GET_SELECTION_FOR_DRAWING: FunctionDef = FunctionDef{address: 0x00432e32, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_turning_direction"))] + pub const GET_TURNING_DIRECTION: FunctionDef i32> = FunctionDef{address: 0x0043a28c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/world_to_virtual_1"))] + pub const WORLD_TO_VIRTUAL_1: FunctionDef = FunctionDef{address: 0x004402ed, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_nearest_direction_1"))] + pub const GET_NEAREST_DIRECTION_1: FunctionDef u64> = FunctionDef{address: 0x00440b46, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/virtual_to_world"))] + pub const VIRTUAL_TO_WORLD: FunctionDef = FunctionDef{address: 0x004441ab, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/set_selection"))] + pub const SET_SELECTION: FunctionDef = FunctionDef{address: 0x004446f9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_selection"))] + pub const GET_SELECTION: FunctionDef = FunctionDef{address: 0x004447e5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/add_edge"))] + pub const ADD_EDGE: FunctionDef u32> = FunctionDef{address: 0x0044d4f8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/save_tile_terrain"))] + pub const SAVE_TILE_TERRAIN: FunctionDef = FunctionDef{address: 0x00459245, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/adjust_cell"))] + pub const ADJUST_CELL: FunctionDef u32> = FunctionDef{address: 0x0045d935, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/adjust_cell_height"))] + pub const ADJUST_CELL_HEIGHT: FunctionDef = FunctionDef{address: 0x0045e04e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/tile_in_selection"))] + pub const TILE_IN_SELECTION: FunctionDef i32> = FunctionDef{address: 0x0045e3c0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004625af, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/adjust_left_neighbors"))] + pub const ADJUST_LEFT_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00481fa1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/adjust_top_neighbors"))] + pub const ADJUST_TOP_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00482050, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/adjust_bottom_neighbors"))] + pub const ADJUST_BOTTOM_NEIGHBORS: FunctionDef = FunctionDef{address: 0x004820ff, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/adjust_right_neighbors"))] + pub const ADJUST_RIGHT_NEIGHBORS: FunctionDef = FunctionDef{address: 0x004822ab, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/restore_terrain"))] + pub const RESTORE_TERRAIN: FunctionDef = FunctionDef{address: 0x00482978, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/copy_full_to_single_tile_terrain"))] + pub const COPY_FULL_TO_SINGLE_TILE_TERRAIN: FunctionDef = FunctionDef{address: 0x00488fc7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_changed_elevations"))] + pub const GET_CHANGED_ELEVATIONS: FunctionDef *const u32> = FunctionDef{address: 0x004891d3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/set_height_above_terrain"))] + pub const SET_HEIGHT_ABOVE_TERRAIN: FunctionDef = FunctionDef{address: 0x00492a9f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/draw_sorter_entity"))] + pub const DRAW_SORTER_ENTITY: FunctionDef = FunctionDef{address: 0x004a7272, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/move_entity"))] + pub const MOVE_ENTITY: FunctionDef = FunctionDef{address: 0x004a746a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/compute_tiles"))] + pub const COMPUTE_TILES: FunctionDef = FunctionDef{address: 0x004af165, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/set_zoom"))] + pub const SET_ZOOM: FunctionDef = FunctionDef{address: 0x004af19c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/clear"))] + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6b83, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/set_map_dimensions"))] + pub const SET_MAP_DIMENSIONS: FunctionDef = FunctionDef{address: 0x004c84d3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004c8782, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/update_terrain_cost"))] + pub const UPDATE_TERRAIN_COST: FunctionDef f32> = FunctionDef{address: 0x004d9c0f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_terrain_paint_cost"))] + pub const GET_TERRAIN_PAINT_COST: FunctionDef f32> = FunctionDef{address: 0x004dc8a4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/add_entity"))] + pub const ADD_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004f3e7d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/can_paint"))] + pub const CAN_PAINT: FunctionDef u32> = FunctionDef{address: 0x004f8f0b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/paint_cell"))] + pub const PAINT_CELL: FunctionDef u32> = FunctionDef{address: 0x004f8fd8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/add_shadow"))] + pub const ADD_SHADOW: FunctionDef u32> = FunctionDef{address: 0x004fc088, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/remove_entity"))] + pub const REMOVE_ENTITY: FunctionDef = FunctionDef{address: 0x004fe639, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/remove_edge"))] + pub const REMOVE_EDGE: FunctionDef = FunctionDef{address: 0x004ffdd8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/validate_neighbors"))] + pub const VALIDATE_NEIGHBORS: FunctionDef u32> = FunctionDef{address: 0x0052d76a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/validate_tiles"))] + pub const VALIDATE_TILES: FunctionDef = FunctionDef{address: 0x005b302a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/clear_tile_terrain"))] + pub const CLEAR_TILE_TERRAIN: FunctionDef = FunctionDef{address: 0x005b342e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_all_neighbors"))] + pub const GET_ALL_NEIGHBORS: FunctionDef *const u32> = FunctionDef{address: 0x005b3835, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/clear_saved_path"))] + pub const CLEAR_SAVED_PATH: FunctionDef = FunctionDef{address: 0x00600414, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/move_entity_delta"))] + pub const MOVE_ENTITY_DELTA: FunctionDef = FunctionDef{address: 0x006005c3, function_type: PhantomData}; } // BFMgr class functions pub mod bfmgr { use super::*; - pub const LOOKUP: FunctionDef u32> = FunctionDef{address: 0x004bdd7a, function_type: PhantomData}; - pub const CREATE_MANAGER: FunctionDef u32> = FunctionDef{address: 0x004bdd91, function_type: PhantomData}; - pub const REGISTERIT: FunctionDef u32> = FunctionDef{address: 0x005770e5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmgr/lookup"))] + pub const LOOKUP: FunctionDef u32> = FunctionDef{address: 0x004bdd7a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmgr/create_manager"))] + pub const CREATE_MANAGER: FunctionDef u32> = FunctionDef{address: 0x004bdd91, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmgr/registerit"))] + pub const REGISTERIT: FunctionDef u32> = FunctionDef{address: 0x005770e5, function_type: PhantomData}; } // BFMoveMod class functions pub mod bfmovemod { use super::*; - pub const BFMOVE_MOD: FunctionDef u32> = FunctionDef{address: 0x004f9be0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfmovemod/bfmove_mod"))] + pub const BFMOVE_MOD: FunctionDef *const u32> = FunctionDef{address: 0x004f9be0, function_type: PhantomData}; } // BFOldSubGoal class functions pub mod bfoldsubgoal { use super::*; - pub const UNKNOWN_METHOD: FunctionDef u32> = FunctionDef{address: 0x00413a43, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfoldsubgoal/unknown_method"))] + pub const UNKNOWN_METHOD: FunctionDef *const u32> = FunctionDef{address: 0x00413a43, function_type: PhantomData}; } // BFOverlay class functions pub mod bfoverlay { use super::*; - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x00420565, function_type: PhantomData}; - pub const BFOVERLAY_0: FunctionDef u32> = FunctionDef{address: 0x00420589, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0045024d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlay/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x00420565, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlay/bfoverlay_0"))] + pub const BFOVERLAY_0: FunctionDef *const u32> = FunctionDef{address: 0x00420589, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlay/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0045024d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlay/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047a7ee, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004fc391, function_type: PhantomData}; - pub const ADD_TO_MAP: FunctionDef = FunctionDef{address: 0x004fc3cd, function_type: PhantomData}; - pub const BFOVERLAY_1: FunctionDef u32> = FunctionDef{address: 0x00624292, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlay/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004fc391, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlay/add_to_map"))] + pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x004fc3cd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlay/bfoverlay_1"))] + pub const BFOVERLAY_1: FunctionDef *const u32> = FunctionDef{address: 0x00624292, function_type: PhantomData}; } // BFOverlayType class functions pub mod bfoverlaytype { use super::*; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051cd5e, function_type: PhantomData}; - pub const BFOVERLAY_TYPE: FunctionDef u32> = FunctionDef{address: 0x0057cc7a, function_type: PhantomData}; - pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x00624270, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlaytype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051cd5e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlaytype/bfoverlay_type"))] + pub const BFOVERLAY_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x0057cc7a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlaytype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x00624270, function_type: PhantomData}; } // BFPathFinder class functions pub mod bfpathfinder { use super::*; - pub const CLEAR_LISTS: FunctionDef = FunctionDef{address: 0x0041194a, function_type: PhantomData}; - pub const MAKE_ID: FunctionDef = FunctionDef{address: 0x00411a56, function_type: PhantomData}; - pub const FIND_PATH: FunctionDef u32> = FunctionDef{address: 0x00414d3f, function_type: PhantomData}; - pub const VALIDATE: FunctionDef = FunctionDef{address: 0x00414fef, function_type: PhantomData}; - pub const ESTIMATE: FunctionDef f32> = FunctionDef{address: 0x00415247, function_type: PhantomData}; - pub const COST: FunctionDef f32> = FunctionDef{address: 0x004153e3, function_type: PhantomData}; - pub const SET_NODE_MAX: FunctionDef = FunctionDef{address: 0x004c680d, function_type: PhantomData}; - pub const BFPATH_FINDER: FunctionDef u32> = FunctionDef{address: 0x00503905, function_type: PhantomData}; - pub const INIT: FunctionDef = FunctionDef{address: 0x005265a6, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0052669c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/clear_lists"))] + pub const CLEAR_LISTS: FunctionDef = FunctionDef{address: 0x0041194a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/make_id"))] + pub const MAKE_ID: FunctionDef = FunctionDef{address: 0x00411a56, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/find_path"))] + pub const FIND_PATH: FunctionDef u32> = FunctionDef{address: 0x00414d3f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/validate"))] + pub const VALIDATE: FunctionDef u32> = FunctionDef{address: 0x00414fef, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/estimate"))] + pub const ESTIMATE: FunctionDef f32> = FunctionDef{address: 0x00415247, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/cost"))] + pub const COST: FunctionDef f32> = FunctionDef{address: 0x004153e3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/set_node_max"))] + pub const SET_NODE_MAX: FunctionDef = FunctionDef{address: 0x004c680d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/bfpath_finder"))] + pub const BFPATH_FINDER: FunctionDef *const u32> = FunctionDef{address: 0x00503905, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/init"))] + pub const INIT: FunctionDef = FunctionDef{address: 0x005265a6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0052669c, function_type: PhantomData}; } // BFPathFinderInfo class functions pub mod bfpathfinderinfo { use super::*; - pub const INIT: FunctionDef u32> = FunctionDef{address: 0x0052609a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinderinfo/init"))] + pub const INIT: FunctionDef u32> = FunctionDef{address: 0x0052609a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinderinfo/get"))] pub const GET: FunctionDef u32> = FunctionDef{address: 0x00526573, function_type: PhantomData}; } @@ -541,64 +889,111 @@ pub mod bfpathfinderinfo { pub mod bfregistry { use super::*; - pub const GET: FunctionDef u32> = FunctionDef{address: 0x004bdca9, function_type: PhantomData}; - pub const FIND: FunctionDef u32> = FunctionDef{address: 0x004bdcbf, function_type: PhantomData}; - pub const PTR_GET: FunctionDef u32> = FunctionDef{address: 0x004bdd22, function_type: PhantomData}; - pub const REG: FunctionDef u32> = FunctionDef{address: 0x0057766f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfregistry/get"))] + pub const GET: FunctionDef *const u32> = FunctionDef{address: 0x004bdca9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfregistry/find"))] + pub const FIND: FunctionDef u32> = FunctionDef{address: 0x004bdcbf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfregistry/ptr_get"))] + pub const PTR_GET: FunctionDef u32> = FunctionDef{address: 0x004bdd22, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfregistry/reg"))] + pub const REG: FunctionDef u32> = FunctionDef{address: 0x0057766f, function_type: PhantomData}; } // BFResource class functions pub mod bfresource { use super::*; - pub const RELEASE_0: FunctionDef = FunctionDef{address: 0x00402e14, function_type: PhantomData}; - pub const SET_HANDLE_0: FunctionDef = FunctionDef{address: 0x00402e1d, function_type: PhantomData}; - pub const ATTEMPT: FunctionDef bool> = FunctionDef{address: 0x00403891, function_type: PhantomData}; - pub const SET_HANDLE_1: FunctionDef = FunctionDef{address: 0x004038af, function_type: PhantomData}; - pub const PREPARE: FunctionDef bool> = FunctionDef{address: 0x004047f4, function_type: PhantomData}; - pub const SET_HANDLE_2: FunctionDef = FunctionDef{address: 0x00404812, function_type: PhantomData}; - pub const RELEASE_1: FunctionDef = FunctionDef{address: 0x0040bc8a, function_type: PhantomData}; - pub const SET_HANDLE_3: FunctionDef = FunctionDef{address: 0x0040bc93, function_type: PhantomData}; - pub const CREATE_MEMORY: FunctionDef = FunctionDef{address: 0x004ad366, function_type: PhantomData}; - pub const FIND_0: FunctionDef u32> = FunctionDef{address: 0x004b41f2, function_type: PhantomData}; - pub const FIND_1: FunctionDef u32> = FunctionDef{address: 0x004bf910, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/release_0"))] + pub const RELEASE_0: FunctionDef = FunctionDef{address: 0x00402e14, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/set_handle_0"))] + pub const SET_HANDLE_0: FunctionDef = FunctionDef{address: 0x00402e1d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/attempt"))] + pub const ATTEMPT: FunctionDef bool> = FunctionDef{address: 0x00403891, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/set_handle_1"))] + pub const SET_HANDLE_1: FunctionDef = FunctionDef{address: 0x004038af, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/prepare"))] + pub const PREPARE: FunctionDef bool> = FunctionDef{address: 0x004047f4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/set_handle_2"))] + pub const SET_HANDLE_2: FunctionDef = FunctionDef{address: 0x00404812, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/release_1"))] + pub const RELEASE_1: FunctionDef = FunctionDef{address: 0x004072b0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/set_handle_3"))] + pub const SET_HANDLE_3: FunctionDef = FunctionDef{address: 0x004072b9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/set_handle_4"))] + pub const SET_HANDLE_4: FunctionDef = FunctionDef{address: 0x00407306, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/release_2"))] + pub const RELEASE_2: FunctionDef = FunctionDef{address: 0x0040bc8a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/set_handle_5"))] + pub const SET_HANDLE_5: FunctionDef = FunctionDef{address: 0x0040bc93, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/create_memory"))] + pub const CREATE_MEMORY: FunctionDef = FunctionDef{address: 0x004ad366, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/find_0"))] + pub const FIND_0: FunctionDef *const c_void> = FunctionDef{address: 0x004b41f2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/find_1"))] + pub const FIND_1: FunctionDef *const c_void> = FunctionDef{address: 0x004bf910, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/shutdown"))] pub const SHUTDOWN: FunctionDef = FunctionDef{address: 0x0057e084, function_type: PhantomData}; - pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x005fed7c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/acquire"))] + pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x005fed7c, function_type: PhantomData}; } // BFResourceDir class functions pub mod bfresourcedir { use super::*; - pub const FIND_FILE: FunctionDef u32> = FunctionDef{address: 0x00403a59, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00403b82, function_type: PhantomData}; - pub const PREPARE: FunctionDef u32> = FunctionDef{address: 0x00404926, function_type: PhantomData}; - pub const VALID: FunctionDef = FunctionDef{address: 0x00404fc8, function_type: PhantomData}; - pub const FIND_0: FunctionDef u32> = FunctionDef{address: 0x004b9e9f, function_type: PhantomData}; - pub const FIND_1: FunctionDef u32> = FunctionDef{address: 0x004bfc2f, function_type: PhantomData}; - pub const BFRESOURCE_DIR_0: FunctionDef u32> = FunctionDef{address: 0x004cbe92, function_type: PhantomData}; - pub const BFRESOURCE_DIR_1: FunctionDef u32> = FunctionDef{address: 0x004cbff4, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00529464, function_type: PhantomData}; - pub const TREE_SEARCH: FunctionDef u32> = FunctionDef{address: 0x00529796, function_type: PhantomData}; - pub const NAME: FunctionDef = FunctionDef{address: 0x006030a0, function_type: PhantomData}; - pub const INDEX: FunctionDef u32> = FunctionDef{address: 0x006030a4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/find_file"))] + pub const FIND_FILE: FunctionDef *const u8> = FunctionDef{address: 0x00403a59, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00403b82, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/prepare"))] + pub const PREPARE: FunctionDef u32> = FunctionDef{address: 0x00404926, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/valid"))] + pub const VALID: FunctionDef u8> = FunctionDef{address: 0x00404fc8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/find_0"))] + pub const FIND_0: FunctionDef *const i32> = FunctionDef{address: 0x004b9e9f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/find_1"))] + pub const FIND_1: FunctionDef *const i32> = FunctionDef{address: 0x004bfc2f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/bfresource_dir_0"))] + pub const BFRESOURCE_DIR_0: FunctionDef *const u32> = FunctionDef{address: 0x004cbe92, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/bfresource_dir_1"))] + pub const BFRESOURCE_DIR_1: FunctionDef *const u32> = FunctionDef{address: 0x004cbff4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00529464, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/tree_search"))] + pub const TREE_SEARCH: FunctionDef *const c_void> = FunctionDef{address: 0x00529796, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/name"))] + pub const NAME: FunctionDef u32> = FunctionDef{address: 0x006030a0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/index"))] + pub const INDEX: FunctionDef *const u32> = FunctionDef{address: 0x006030a4, function_type: PhantomData}; } // BFResourceMgr class functions pub mod bfresourcemgr { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/get"))] pub const GET: FunctionDef u32> = FunctionDef{address: 0x00402e76, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00403817, function_type: PhantomData}; - pub const GET_RESOURCE_PTR: FunctionDef i32> = FunctionDef{address: 0x004038f5, function_type: PhantomData}; - pub const MAKE_NAME: FunctionDef u32> = FunctionDef{address: 0x00403993, function_type: PhantomData}; - pub const PREPARE: FunctionDef u32> = FunctionDef{address: 0x00404855, function_type: PhantomData}; - pub const CREATE_MEMORY: FunctionDef u32> = FunctionDef{address: 0x004ad2fc, function_type: PhantomData}; - pub const FIND_0: FunctionDef u32> = FunctionDef{address: 0x004b9a40, function_type: PhantomData}; - pub const FIND_1: FunctionDef u32> = FunctionDef{address: 0x004bf92b, function_type: PhantomData}; - pub const ADD_PATH: FunctionDef u32> = FunctionDef{address: 0x0052870b, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0052903f, function_type: PhantomData}; - pub const SHUTDOWN: FunctionDef = FunctionDef{address: 0x0057e0c4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00403817, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/get_resource_ptr"))] + pub const GET_RESOURCE_PTR: FunctionDef i32> = FunctionDef{address: 0x004038f5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/make_name"))] + pub const MAKE_NAME: FunctionDef u32> = FunctionDef{address: 0x00403993, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/prepare"))] + pub const PREPARE: FunctionDef u32> = FunctionDef{address: 0x00404855, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/create_memory"))] + pub const CREATE_MEMORY: FunctionDef *const u32> = FunctionDef{address: 0x004ad2fc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/find_0"))] + pub const FIND_0: FunctionDef *const c_void> = FunctionDef{address: 0x004b9a40, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/find_1"))] + pub const FIND_1: FunctionDef *const c_void> = FunctionDef{address: 0x004bf92b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/add_path"))] + pub const ADD_PATH: FunctionDef u32> = FunctionDef{address: 0x0052870b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0052903f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/shutdown"))] + pub const SHUTDOWN: FunctionDef = FunctionDef{address: 0x0057e0c4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/bfresource_mgr"))] pub const BFRESOURCE_MGR: FunctionDef = FunctionDef{address: 0x0057e827, function_type: PhantomData}; } @@ -606,69 +1001,121 @@ pub mod bfresourcemgr { pub mod bfresourceptr { use super::*; - pub const DELREF_0: FunctionDef = FunctionDef{address: 0x00402e47, function_type: PhantomData}; - pub const DELREF_1: FunctionDef = FunctionDef{address: 0x00402e5e, function_type: PhantomData}; - pub const DELREF_2: FunctionDef = FunctionDef{address: 0x00402e6a, function_type: PhantomData}; - pub const DEALLOCATE: FunctionDef = FunctionDef{address: 0x00402ec7, function_type: PhantomData}; - pub const DELREF_3: FunctionDef = FunctionDef{address: 0x00402f76, function_type: PhantomData}; - pub const DELREF_4: FunctionDef = FunctionDef{address: 0x004038d9, function_type: PhantomData}; - pub const ALLOCATE: FunctionDef = FunctionDef{address: 0x004043f4, function_type: PhantomData}; - pub const DELREF_5: FunctionDef = FunctionDef{address: 0x0040483c, function_type: PhantomData}; - pub const DELREF_6: FunctionDef = FunctionDef{address: 0x00406b87, function_type: PhantomData}; - pub const DELREF_7: FunctionDef = FunctionDef{address: 0x004072e3, function_type: PhantomData}; - pub const DELREF_8: FunctionDef = FunctionDef{address: 0x00407330, function_type: PhantomData}; - pub const DELREF_9: FunctionDef = FunctionDef{address: 0x00409b55, function_type: PhantomData}; - pub const DELREF_10: FunctionDef = FunctionDef{address: 0x0040bcbd, function_type: PhantomData}; - pub const DELREF_11: FunctionDef = FunctionDef{address: 0x0040c4bf, function_type: PhantomData}; - pub const DELREF_12: FunctionDef = FunctionDef{address: 0x0041e62e, function_type: PhantomData}; - pub const DELREF_13: FunctionDef = FunctionDef{address: 0x004aba16, function_type: PhantomData}; - pub const DELREF_14: FunctionDef = FunctionDef{address: 0x004abaef, function_type: PhantomData}; - pub const DELREF_15: FunctionDef = FunctionDef{address: 0x004abc8f, function_type: PhantomData}; - pub const DELREF_16: FunctionDef = FunctionDef{address: 0x004ac016, function_type: PhantomData}; - pub const DELREF_17: FunctionDef = FunctionDef{address: 0x004ac060, function_type: PhantomData}; - pub const DELREF_18: FunctionDef = FunctionDef{address: 0x004ad053, function_type: PhantomData}; - pub const DELREF_19: FunctionDef = FunctionDef{address: 0x004ad3bd, function_type: PhantomData}; - pub const DELREF_20: FunctionDef = FunctionDef{address: 0x004b31c3, function_type: PhantomData}; - pub const DELREF_21: FunctionDef = FunctionDef{address: 0x004c6755, function_type: PhantomData}; - pub const DELREF_22: FunctionDef = FunctionDef{address: 0x004c67c9, function_type: PhantomData}; - pub const DELREF_23: FunctionDef = FunctionDef{address: 0x00501628, function_type: PhantomData}; - pub const DELREF_24: FunctionDef = FunctionDef{address: 0x00503e66, function_type: PhantomData}; - pub const DELREF_25: FunctionDef = FunctionDef{address: 0x00503eb0, function_type: PhantomData}; - pub const DELREF_26: FunctionDef = FunctionDef{address: 0x00504054, function_type: PhantomData}; - pub const DELREF_27: FunctionDef = FunctionDef{address: 0x0050409e, function_type: PhantomData}; - pub const DELREF_28: FunctionDef = FunctionDef{address: 0x005041ca, function_type: PhantomData}; - pub const DELREF_29: FunctionDef = FunctionDef{address: 0x00504214, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_0"))] + pub const DELREF_0: FunctionDef = FunctionDef{address: 0x00402e47, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_1"))] + pub const DELREF_1: FunctionDef = FunctionDef{address: 0x00402e5e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_2"))] + pub const DELREF_2: FunctionDef = FunctionDef{address: 0x00402e6a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/deallocate"))] + pub const DEALLOCATE: FunctionDef = FunctionDef{address: 0x00402ec7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_3"))] + pub const DELREF_3: FunctionDef = FunctionDef{address: 0x00402f76, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_4"))] + pub const DELREF_4: FunctionDef = FunctionDef{address: 0x004038d9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/allocate"))] + pub const ALLOCATE: FunctionDef = FunctionDef{address: 0x004043f4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_5"))] + pub const DELREF_5: FunctionDef = FunctionDef{address: 0x0040483c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_6"))] + pub const DELREF_6: FunctionDef = FunctionDef{address: 0x00406b87, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_7"))] + pub const DELREF_7: FunctionDef = FunctionDef{address: 0x004072e3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_8"))] + pub const DELREF_8: FunctionDef = FunctionDef{address: 0x00407330, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_9"))] + pub const DELREF_9: FunctionDef = FunctionDef{address: 0x00409b55, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_10"))] + pub const DELREF_10: FunctionDef = FunctionDef{address: 0x0040bcbd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_11"))] + pub const DELREF_11: FunctionDef = FunctionDef{address: 0x0040c4bf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_12"))] + pub const DELREF_12: FunctionDef = FunctionDef{address: 0x0041e62e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_13"))] + pub const DELREF_13: FunctionDef = FunctionDef{address: 0x004aba16, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_14"))] + pub const DELREF_14: FunctionDef = FunctionDef{address: 0x004abaef, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_15"))] + pub const DELREF_15: FunctionDef = FunctionDef{address: 0x004abc8f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_16"))] + pub const DELREF_16: FunctionDef = FunctionDef{address: 0x004ac016, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_17"))] + pub const DELREF_17: FunctionDef = FunctionDef{address: 0x004ac060, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_18"))] + pub const DELREF_18: FunctionDef = FunctionDef{address: 0x004ad053, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_19"))] + pub const DELREF_19: FunctionDef = FunctionDef{address: 0x004ad3bd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_20"))] + pub const DELREF_20: FunctionDef = FunctionDef{address: 0x004b31c3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_21"))] + pub const DELREF_21: FunctionDef = FunctionDef{address: 0x004c6755, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_22"))] + pub const DELREF_22: FunctionDef = FunctionDef{address: 0x004c67c9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_23"))] + pub const DELREF_23: FunctionDef = FunctionDef{address: 0x00501628, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_24"))] + pub const DELREF_24: FunctionDef = FunctionDef{address: 0x00503e66, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_25"))] + pub const DELREF_25: FunctionDef = FunctionDef{address: 0x00503eb0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_26"))] + pub const DELREF_26: FunctionDef = FunctionDef{address: 0x00504054, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_27"))] + pub const DELREF_27: FunctionDef = FunctionDef{address: 0x0050409e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_28"))] + pub const DELREF_28: FunctionDef = FunctionDef{address: 0x005041ca, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_29"))] + pub const DELREF_29: FunctionDef = FunctionDef{address: 0x00504214, function_type: PhantomData}; } // BFResourceZip class functions pub mod bfresourcezip { use super::*; - pub const FIND_OFFSET: FunctionDef i32> = FunctionDef{address: 0x00403a1c, function_type: PhantomData}; - pub const LOAD: FunctionDef = FunctionDef{address: 0x00403b43, function_type: PhantomData}; - pub const PREPARE: FunctionDef u32> = FunctionDef{address: 0x004048da, function_type: PhantomData}; - pub const FIND_0: FunctionDef u32> = FunctionDef{address: 0x004b9b73, function_type: PhantomData}; - pub const FIND_1: FunctionDef u32> = FunctionDef{address: 0x004bf9fb, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00528ac1, function_type: PhantomData}; - pub const VALID: FunctionDef = FunctionDef{address: 0x00528f94, function_type: PhantomData}; - pub const BFRESOURCE_ZIP_0: FunctionDef u32> = FunctionDef{address: 0x0057e21f, function_type: PhantomData}; - pub const BFRESOURCE_ZIP_1: FunctionDef u32> = FunctionDef{address: 0x0057e351, function_type: PhantomData}; - pub const INDEX: FunctionDef u32> = FunctionDef{address: 0x00602f65, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/find_offset"))] + pub const FIND_OFFSET: FunctionDef i32> = FunctionDef{address: 0x00403a1c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/load"))] + pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x00403b43, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/prepare"))] + pub const PREPARE: FunctionDef u32> = FunctionDef{address: 0x004048da, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/find_0"))] + pub const FIND_0: FunctionDef *const i32> = FunctionDef{address: 0x004b9b73, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/find_1"))] + pub const FIND_1: FunctionDef *const i32> = FunctionDef{address: 0x004bf9fb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00528ac1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/valid"))] + pub const VALID: FunctionDef bool> = FunctionDef{address: 0x00528f94, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/bfresource_zip_0"))] + pub const BFRESOURCE_ZIP_0: FunctionDef *const u32> = FunctionDef{address: 0x0057e21f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/bfresource_zip_1"))] + pub const BFRESOURCE_ZIP_1: FunctionDef *const u32> = FunctionDef{address: 0x0057e351, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/index"))] + pub const INDEX: FunctionDef *const i32> = FunctionDef{address: 0x00602f65, function_type: PhantomData}; } // BFScenarioMgr class functions pub mod bfscenariomgr { use super::*; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00435a48, function_type: PhantomData}; - pub const GET_EXPANSION_ID: FunctionDef u32> = FunctionDef{address: 0x00453530, function_type: PhantomData}; - pub const END_SCENARIO: FunctionDef u32> = FunctionDef{address: 0x0048a726, function_type: PhantomData}; - pub const BFSCENARIO_MGR: FunctionDef u32> = FunctionDef{address: 0x00504e6a, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0052428d, function_type: PhantomData}; - pub const GET_CROWD_AMBIENTS_NAME: FunctionDef u32> = FunctionDef{address: 0x00592632, function_type: PhantomData}; - pub const GET_WORLD_AMBIENTS_NAME: FunctionDef u32> = FunctionDef{address: 0x00592659, function_type: PhantomData}; - pub const GET_CROWD_CONFIG_NAME: FunctionDef u32> = FunctionDef{address: 0x00592680, function_type: PhantomData}; - pub const GET_WORLD_CONFIG_NAME: FunctionDef u32> = FunctionDef{address: 0x005926a7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00435a48, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/get_expansion_id"))] + pub const GET_EXPANSION_ID: FunctionDef u32> = FunctionDef{address: 0x00453530, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/end_scenario"))] + pub const END_SCENARIO: FunctionDef u32> = FunctionDef{address: 0x0048a726, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/bfscenario_mgr"))] + pub const BFSCENARIO_MGR: FunctionDef *const u32> = FunctionDef{address: 0x00504e6a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0052428d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/get_crowd_ambients_name"))] + pub const GET_CROWD_AMBIENTS_NAME: FunctionDef *const u8> = FunctionDef{address: 0x00592632, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/get_world_ambients_name"))] + pub const GET_WORLD_AMBIENTS_NAME: FunctionDef *const u8> = FunctionDef{address: 0x00592659, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/get_crowd_config_name"))] + pub const GET_CROWD_CONFIG_NAME: FunctionDef *const u8> = FunctionDef{address: 0x00592680, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/get_world_config_name"))] + pub const GET_WORLD_CONFIG_NAME: FunctionDef *const u8> = FunctionDef{address: 0x005926a7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/unlock_all_scenarios"))] pub const UNLOCK_ALL_SCENARIOS: FunctionDef = FunctionDef{address: 0x006000d3, function_type: PhantomData}; } @@ -676,174 +1123,315 @@ pub mod bfscenariomgr { pub mod bfterrainimage { use super::*; - pub const COMPUTE_IMAGE_SIZE: FunctionDef = FunctionDef{address: 0x004aee5a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfterrainimage/compute_image_size"))] + pub const COMPUTE_IMAGE_SIZE: FunctionDef = FunctionDef{address: 0x004aee5a, function_type: PhantomData}; } // BFTerrainMgr class functions pub mod bfterrainmgr { use super::*; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0052560a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfterrainmgr/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0052560a, function_type: PhantomData}; } // BFTerrainTypeInfo class functions pub mod bfterraintypeinfo { use super::*; - pub const INITIALIZE: FunctionDef u32> = FunctionDef{address: 0x00523c58, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfterraintypeinfo/initialize"))] + pub const INITIALIZE: FunctionDef *const i16> = FunctionDef{address: 0x00523c58, function_type: PhantomData}; } // BFText class functions pub mod bftext { use super::*; - pub const LENGTH_IN_CHARACTERS: FunctionDef = FunctionDef{address: 0x00418ccf, function_type: PhantomData}; - pub const CONVERT_TO_BYTES: FunctionDef = FunctionDef{address: 0x004ec1e3, function_type: PhantomData}; - pub const SUBSTR: FunctionDef u32> = FunctionDef{address: 0x004ec280, function_type: PhantomData}; - pub const ERASE: FunctionDef u32> = FunctionDef{address: 0x006242b0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftext/length_in_bytes"))] + pub const LENGTH_IN_BYTES: FunctionDef i32> = FunctionDef{address: 0x00401523, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftext/length_in_characters"))] + pub const LENGTH_IN_CHARACTERS: FunctionDef = FunctionDef{address: 0x00418ccf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftext/convert_to_bytes"))] + pub const CONVERT_TO_BYTES: FunctionDef = FunctionDef{address: 0x004ec1e3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftext/substr"))] + pub const SUBSTR: FunctionDef *const i16> = FunctionDef{address: 0x004ec280, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftext/erase"))] + pub const ERASE: FunctionDef *const i32> = FunctionDef{address: 0x006242b0, function_type: PhantomData}; } // BFTile class functions pub mod bftile { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/get_local_elevation"))] pub const GET_LOCAL_ELEVATION: FunctionDef i32> = FunctionDef{address: 0x0040f24d, function_type: PhantomData}; - pub const GET_CORNER_ELEVATION: FunctionDef i32> = FunctionDef{address: 0x0040f4f9, function_type: PhantomData}; - pub const IS_IN_ZOO: FunctionDef u32> = FunctionDef{address: 0x0040fb8d, function_type: PhantomData}; - pub const VALIDATE_POSITIONS: FunctionDef = FunctionDef{address: 0x0044a0bf, function_type: PhantomData}; - pub const GET_MAX_ELEVATION: FunctionDef i32> = FunctionDef{address: 0x0045d8b5, function_type: PhantomData}; - pub const CAN_CHANGE_ELEVATION: FunctionDef = FunctionDef{address: 0x0045d92d, function_type: PhantomData}; - pub const CAN_CHANGE_SHAPE: FunctionDef u32> = FunctionDef{address: 0x0045e028, function_type: PhantomData}; - pub const RAISE: FunctionDef = FunctionDef{address: 0x0045e416, function_type: PhantomData}; - pub const LOWER: FunctionDef = FunctionDef{address: 0x0045e70f, function_type: PhantomData}; - pub const GET_MIN_ELEVATION: FunctionDef i32> = FunctionDef{address: 0x00492d80, function_type: PhantomData}; - pub const SNAP_TO_EDGE: FunctionDef = FunctionDef{address: 0x0049336d, function_type: PhantomData}; - pub const CALCULATE_SHAPE: FunctionDef = FunctionDef{address: 0x004aea12, function_type: PhantomData}; - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6964, function_type: PhantomData}; - pub const REMOVE_ALL_EDGES: FunctionDef = FunctionDef{address: 0x004c6a17, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004c864e, function_type: PhantomData}; - pub const REMOVE_EDGE: FunctionDef u32> = FunctionDef{address: 0x004f165b, function_type: PhantomData}; - pub const SET_TERRAIN_TYPE: FunctionDef = FunctionDef{address: 0x004f17e0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/get_corner_elevation"))] + pub const GET_CORNER_ELEVATION: FunctionDef i32> = FunctionDef{address: 0x0040f4f9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/is_in_zoo"))] + pub const IS_IN_ZOO: FunctionDef u32> = FunctionDef{address: 0x0040fb8d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/add_unit"))] + pub const ADD_UNIT: FunctionDef = FunctionDef{address: 0x00410b0f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/validate_positions"))] + pub const VALIDATE_POSITIONS: FunctionDef = FunctionDef{address: 0x0044a0bf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/get_max_elevation"))] + pub const GET_MAX_ELEVATION: FunctionDef i32> = FunctionDef{address: 0x0045d8b5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/can_change_elevation"))] + pub const CAN_CHANGE_ELEVATION: FunctionDef = FunctionDef{address: 0x0045d92d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/can_change_shape"))] + pub const CAN_CHANGE_SHAPE: FunctionDef u32> = FunctionDef{address: 0x0045e028, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/raise"))] + pub const RAISE: FunctionDef = FunctionDef{address: 0x0045e416, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/lower"))] + pub const LOWER: FunctionDef = FunctionDef{address: 0x0045e70f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/adjust_corner"))] + pub const ADJUST_CORNER: FunctionDef u32> = FunctionDef{address: 0x0048235a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/set_corner_elevation"))] + pub const SET_CORNER_ELEVATION: FunctionDef u32> = FunctionDef{address: 0x00482485, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/get_min_elevation"))] + pub const GET_MIN_ELEVATION: FunctionDef i32> = FunctionDef{address: 0x00492d80, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/snap_to_edge"))] + pub const SNAP_TO_EDGE: FunctionDef = FunctionDef{address: 0x0049336d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/calculate_shape"))] + pub const CALCULATE_SHAPE: FunctionDef = FunctionDef{address: 0x004aea12, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/clear"))] + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6964, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/remove_all_edges"))] + pub const REMOVE_ALL_EDGES: FunctionDef = FunctionDef{address: 0x004c6a17, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004c864e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/remove_edge"))] + pub const REMOVE_EDGE: FunctionDef u32> = FunctionDef{address: 0x004f165b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bftile/set_terrain_type"))] + pub const SET_TERRAIN_TYPE: FunctionDef = FunctionDef{address: 0x004f17e0, function_type: PhantomData}; } // BFUIMgr class functions pub mod bfuimgr { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/get_element_0"))] pub const GET_ELEMENT_0: FunctionDef u32> = FunctionDef{address: 0x0040157d, function_type: PhantomData}; - pub const SET_CONTROL_FORE_COLOR: FunctionDef = FunctionDef{address: 0x0040ee08, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/set_control_fore_color"))] + pub const SET_CONTROL_FORE_COLOR: FunctionDef = FunctionDef{address: 0x0040ee08, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/set_cursor"))] pub const SET_CURSOR: FunctionDef = FunctionDef{address: 0x00418e81, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/hide_busy_cursor"))] pub const HIDE_BUSY_CURSOR: FunctionDef = FunctionDef{address: 0x00418f2f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/show_busy_cursor"))] pub const SHOW_BUSY_CURSOR: FunctionDef = FunctionDef{address: 0x00418f43, function_type: PhantomData}; - pub const DRAW: FunctionDef u32> = FunctionDef{address: 0x004193d8, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a16b, function_type: PhantomData}; - pub const PREPARE_TO_HIDE_ELEMENT: FunctionDef = FunctionDef{address: 0x0041ac35, function_type: PhantomData}; - pub const REMOVE_TIMER_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x0041ad6a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/draw"))] + pub const DRAW: FunctionDef u32> = FunctionDef{address: 0x004193d8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a16b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/prepare_to_hide_element"))] + pub const PREPARE_TO_HIDE_ELEMENT: FunctionDef = FunctionDef{address: 0x0041ac35, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/remove_timer_element"))] + pub const REMOVE_TIMER_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x0041ad6a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/display_help_0"))] pub const DISPLAY_HELP_0: FunctionDef = FunctionDef{address: 0x0041b100, function_type: PhantomData}; - pub const HANDLE_MESSAGES: FunctionDef i32> = FunctionDef{address: 0x00441d7b, function_type: PhantomData}; - pub const GET_ELEMENT_1: FunctionDef u32> = FunctionDef{address: 0x0044232b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/handle_messages"))] + pub const HANDLE_MESSAGES: FunctionDef i32> = FunctionDef{address: 0x00441d7b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/get_element_1"))] + pub const GET_ELEMENT_1: FunctionDef *const c_void> = FunctionDef{address: 0x0044232b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/get_max_tooltip_width"))] pub const GET_MAX_TOOLTIP_WIDTH: FunctionDef u32> = FunctionDef{address: 0x00442d19, function_type: PhantomData}; - pub const FOCUS_CONTROL: FunctionDef = FunctionDef{address: 0x0044316b, function_type: PhantomData}; - pub const CAPTURE_ELEMENT: FunctionDef = FunctionDef{address: 0x00443560, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/focus_control"))] + pub const FOCUS_CONTROL: FunctionDef = FunctionDef{address: 0x0044316b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/capture_element"))] + pub const CAPTURE_ELEMENT: FunctionDef = FunctionDef{address: 0x00443560, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/deselect_element"))] pub const DESELECT_ELEMENT: FunctionDef = FunctionDef{address: 0x00443dd0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/enable_element"))] pub const ENABLE_ELEMENT: FunctionDef = FunctionDef{address: 0x00443e3e, function_type: PhantomData}; - pub const TRANSLATE_KEY: FunctionDef u32> = FunctionDef{address: 0x0046bbd3, function_type: PhantomData}; - pub const DISPLAY_MESSAGE_0: FunctionDef = FunctionDef{address: 0x0049ccc3, function_type: PhantomData}; - pub const DISPLAY_MESSAGE_1: FunctionDef = FunctionDef{address: 0x0049cec0, function_type: PhantomData}; - pub const SHOW_LAST_DIALOG: FunctionDef = FunctionDef{address: 0x004a09cc, function_type: PhantomData}; - pub const HIDE_PERSISTENT_TEXT: FunctionDef = FunctionDef{address: 0x004b28df, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/translate_key"))] + pub const TRANSLATE_KEY: FunctionDef *const i8> = FunctionDef{address: 0x0046bbd3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/display_message_0"))] + pub const DISPLAY_MESSAGE_0: FunctionDef = FunctionDef{address: 0x0049ccc3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/display_message_1"))] + pub const DISPLAY_MESSAGE_1: FunctionDef = FunctionDef{address: 0x0049cec0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/show_last_dialog"))] + pub const SHOW_LAST_DIALOG: FunctionDef = FunctionDef{address: 0x004a09cc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/hide_persistent_text"))] + pub const HIDE_PERSISTENT_TEXT: FunctionDef = FunctionDef{address: 0x004b28df, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/destroy_cursors"))] pub const DESTROY_CURSORS: FunctionDef = FunctionDef{address: 0x004b2caa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/clear_messages"))] pub const CLEAR_MESSAGES: FunctionDef = FunctionDef{address: 0x004c6d10, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/select_element"))] pub const SELECT_ELEMENT: FunctionDef = FunctionDef{address: 0x004c7794, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/init_cursors"))] pub const INIT_CURSORS: FunctionDef = FunctionDef{address: 0x004d4118, function_type: PhantomData}; - pub const RESIZE: FunctionDef u32> = FunctionDef{address: 0x004d41f4, function_type: PhantomData}; - pub const RELOAD: FunctionDef u32> = FunctionDef{address: 0x004d594b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/resize"))] + pub const RESIZE: FunctionDef u32> = FunctionDef{address: 0x004d41f4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/reload"))] + pub const RELOAD: FunctionDef u32> = FunctionDef{address: 0x004d594b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/reset_element_cursor"))] pub const RESET_ELEMENT_CURSOR: FunctionDef = FunctionDef{address: 0x004d5bea, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/disable_element"))] pub const DISABLE_ELEMENT: FunctionDef = FunctionDef{address: 0x004df425, function_type: PhantomData}; - pub const REMOVE_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004e0965, function_type: PhantomData}; - pub const DELETE_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004e0e21, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/remove_element"))] + pub const REMOVE_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004e0965, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/delete_element"))] + pub const DELETE_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004e0e21, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/display_help_1"))] pub const DISPLAY_HELP_1: FunctionDef = FunctionDef{address: 0x004fb613, function_type: PhantomData}; - pub const CONFIRM_DIALOG_0: FunctionDef u32> = FunctionDef{address: 0x004ff63c, function_type: PhantomData}; - pub const CONFIRM_DIALOG_1: FunctionDef u32> = FunctionDef{address: 0x004fff2c, function_type: PhantomData}; - pub const DELETE_ALL_ELEMENTS_0: FunctionDef u32> = FunctionDef{address: 0x0050214c, function_type: PhantomData}; - pub const STOP: FunctionDef = FunctionDef{address: 0x005021bb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/confirm_dialog_0"))] + pub const CONFIRM_DIALOG_0: FunctionDef u32> = FunctionDef{address: 0x004ff63c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/confirm_dialog_1"))] + pub const CONFIRM_DIALOG_1: FunctionDef u32> = FunctionDef{address: 0x004fff2c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/delete_all_elements_0"))] + pub const DELETE_ALL_ELEMENTS_0: FunctionDef u32> = FunctionDef{address: 0x0050214c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/stop"))] + pub const STOP: FunctionDef = FunctionDef{address: 0x005021bb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/delete_all_elements_1"))] pub const DELETE_ALL_ELEMENTS_1: FunctionDef u32> = FunctionDef{address: 0x00502796, function_type: PhantomData}; - pub const RELEASE_SOUNDS: FunctionDef = FunctionDef{address: 0x0050342a, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00511054, function_type: PhantomData}; - pub const SET_BUILTIN_CALLBACK: FunctionDef = FunctionDef{address: 0x00517d55, function_type: PhantomData}; - pub const SET_HELP_CONTROL: FunctionDef = FunctionDef{address: 0x00519cc4, function_type: PhantomData}; - pub const START: FunctionDef u32> = FunctionDef{address: 0x0051e3b8, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00539a66, function_type: PhantomData}; - pub const CONFIGURE_AND_SHOW_DIALOG: FunctionDef u32> = FunctionDef{address: 0x005a1b15, function_type: PhantomData}; - pub const BFUIMGR_0: FunctionDef u32> = FunctionDef{address: 0x00620515, function_type: PhantomData}; - pub const BFUIMGR_1: FunctionDef u32> = FunctionDef{address: 0x006207b1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/release_sounds"))] + pub const RELEASE_SOUNDS: FunctionDef = FunctionDef{address: 0x0050342a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00511054, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/set_builtin_callback"))] + pub const SET_BUILTIN_CALLBACK: FunctionDef = FunctionDef{address: 0x00517d55, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/set_help_control"))] + pub const SET_HELP_CONTROL: FunctionDef = FunctionDef{address: 0x00519cc4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/start"))] + pub const START: FunctionDef u32> = FunctionDef{address: 0x0051e3b8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00539a66, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/configure_and_show_dialog"))] + pub const CONFIGURE_AND_SHOW_DIALOG: FunctionDef *const i16> = FunctionDef{address: 0x005a1b15, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/bfuimgr_0"))] + pub const BFUIMGR_0: FunctionDef *const u32> = FunctionDef{address: 0x00620515, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/bfuimgr_1"))] + pub const BFUIMGR_1: FunctionDef *const u32> = FunctionDef{address: 0x006207b1, function_type: PhantomData}; } // BFUnit class functions pub mod bfunit { use super::*; - pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x004102fc, function_type: PhantomData}; - pub const GET_IDLE_ANIM: FunctionDef i32> = FunctionDef{address: 0x004133d6, function_type: PhantomData}; - pub const IS_SAME_TILE: FunctionDef = FunctionDef{address: 0x00414530, function_type: PhantomData}; - pub const GET_PATH_COST: FunctionDef u32> = FunctionDef{address: 0x0041456c, function_type: PhantomData}; - pub const IS_MAX_COST_FOR_ALL: FunctionDef u32> = FunctionDef{address: 0x004146d4, function_type: PhantomData}; - pub const IDLE: FunctionDef = FunctionDef{address: 0x00421eb7, function_type: PhantomData}; - pub const GO_TO_DEST_0: FunctionDef u32> = FunctionDef{address: 0x00422072, function_type: PhantomData}; - pub const GO_TO_DEST_1: FunctionDef u32> = FunctionDef{address: 0x00422127, function_type: PhantomData}; - pub const GET_PATH: FunctionDef u32> = FunctionDef{address: 0x004221c3, function_type: PhantomData}; - pub const LISTEN_0: FunctionDef = FunctionDef{address: 0x00423c03, function_type: PhantomData}; - pub const GET_EVENTS_0: FunctionDef = FunctionDef{address: 0x00423cee, function_type: PhantomData}; - pub const FACE_TOWARD_TILE: FunctionDef = FunctionDef{address: 0x00426d1a, function_type: PhantomData}; - pub const FACE_TOWARD_ENTITY: FunctionDef = FunctionDef{address: 0x00426d4d, function_type: PhantomData}; - pub const GET_AIINFO_ON: FunctionDef = FunctionDef{address: 0x0043358f, function_type: PhantomData}; - pub const GET_EVENTS_1: FunctionDef = FunctionDef{address: 0x00434a04, function_type: PhantomData}; - pub const UPDATE_ANIMATION: FunctionDef = FunctionDef{address: 0x00435bbe, function_type: PhantomData}; - pub const UPDATE_POSITION: FunctionDef = FunctionDef{address: 0x00435bf8, function_type: PhantomData}; - pub const GET_EVENTS_2: FunctionDef = FunctionDef{address: 0x00435cdb, function_type: PhantomData}; - pub const LISTEN_1: FunctionDef = FunctionDef{address: 0x00435cf1, function_type: PhantomData}; - pub const RUN_BEHAVIOR_SET: FunctionDef = FunctionDef{address: 0x00435cfb, function_type: PhantomData}; - pub const UPDATE_SUB_GOALS: FunctionDef = FunctionDef{address: 0x00436161, function_type: PhantomData}; - pub const GET_DEST_TILE: FunctionDef i32> = FunctionDef{address: 0x00436323, function_type: PhantomData}; - pub const SET_MOVING: FunctionDef = FunctionDef{address: 0x0043e5a5, function_type: PhantomData}; - pub const STOP: FunctionDef = FunctionDef{address: 0x0043e642, function_type: PhantomData}; - pub const GET_EVENTS_3: FunctionDef = FunctionDef{address: 0x0043f40d, function_type: PhantomData}; - pub const CLEANUP_EVENTS: FunctionDef = FunctionDef{address: 0x0043f4a0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/validate_position"))] + pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x004102fc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/add_to_map"))] + pub const ADD_TO_MAP: FunctionDef = FunctionDef{address: 0x00412cdc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_idle_anim"))] + pub const GET_IDLE_ANIM: FunctionDef i32> = FunctionDef{address: 0x004133d6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/is_same_tile"))] + pub const IS_SAME_TILE: FunctionDef u8> = FunctionDef{address: 0x00414530, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_path_cost"))] + pub const GET_PATH_COST: FunctionDef u32> = FunctionDef{address: 0x0041456c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/is_max_cost_for_all"))] + pub const IS_MAX_COST_FOR_ALL: FunctionDef u32> = FunctionDef{address: 0x004146d4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/idle"))] + pub const IDLE: FunctionDef = FunctionDef{address: 0x00421eb7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/go_to_dest_0"))] + pub const GO_TO_DEST_0: FunctionDef u32> = FunctionDef{address: 0x00422072, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/go_to_dest_1"))] + pub const GO_TO_DEST_1: FunctionDef u32> = FunctionDef{address: 0x00422127, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_path"))] + pub const GET_PATH: FunctionDef u32> = FunctionDef{address: 0x004221c3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/listen_0"))] + pub const LISTEN_0: FunctionDef = FunctionDef{address: 0x00423c03, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_events_0"))] + pub const GET_EVENTS_0: FunctionDef = FunctionDef{address: 0x00423cee, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/face_toward_tile"))] + pub const FACE_TOWARD_TILE: FunctionDef = FunctionDef{address: 0x00426d1a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/face_toward_entity"))] + pub const FACE_TOWARD_ENTITY: FunctionDef = FunctionDef{address: 0x00426d4d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x00427873, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_aiinfo_on"))] + pub const GET_AIINFO_ON: FunctionDef u32> = FunctionDef{address: 0x0043358f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_events_1"))] + pub const GET_EVENTS_1: FunctionDef = FunctionDef{address: 0x00434a04, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/update_animation"))] + pub const UPDATE_ANIMATION: FunctionDef = FunctionDef{address: 0x00435bbe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/update_position"))] + pub const UPDATE_POSITION: FunctionDef = FunctionDef{address: 0x00435bf8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_events_2"))] + pub const GET_EVENTS_2: FunctionDef = FunctionDef{address: 0x00435cdb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/listen_1"))] + pub const LISTEN_1: FunctionDef = FunctionDef{address: 0x00435cf1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/run_behavior_set"))] + pub const RUN_BEHAVIOR_SET: FunctionDef = FunctionDef{address: 0x00435cfb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/update_sub_goals"))] + pub const UPDATE_SUB_GOALS: FunctionDef = FunctionDef{address: 0x00436161, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_dest_tile"))] + pub const GET_DEST_TILE: FunctionDef i32> = FunctionDef{address: 0x00436323, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/set_moving"))] + pub const SET_MOVING: FunctionDef = FunctionDef{address: 0x0043e5a5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/stop"))] + pub const STOP: FunctionDef = FunctionDef{address: 0x0043e642, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_events_3"))] + pub const GET_EVENTS_3: FunctionDef = FunctionDef{address: 0x0043f40d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/cleanup_events"))] + pub const CLEANUP_EVENTS: FunctionDef = FunctionDef{address: 0x0043f4a0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/is_non_path_steep"))] pub const IS_NON_PATH_STEEP: FunctionDef u32> = FunctionDef{address: 0x0044045e, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004547cc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004547cc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00478252, function_type: PhantomData}; - pub const SET_HEIGHT_ABOVE_TERRAIN: FunctionDef = FunctionDef{address: 0x00492a51, function_type: PhantomData}; - pub const CHECK_ELEVATION: FunctionDef bool> = FunctionDef{address: 0x00493e1c, function_type: PhantomData}; - pub const SET_DEST_TILE: FunctionDef = FunctionDef{address: 0x004a7a90, function_type: PhantomData}; - pub const SET_SELECTED: FunctionDef = FunctionDef{address: 0x004ee4a4, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004f568c, function_type: PhantomData}; - pub const BFUNIT: FunctionDef u32> = FunctionDef{address: 0x004f9c33, function_type: PhantomData}; - pub const SEND_EVENT: FunctionDef = FunctionDef{address: 0x0059def9, function_type: PhantomData}; - pub const GET_COST: FunctionDef u32> = FunctionDef{address: 0x0060238f, function_type: PhantomData}; - pub const GET_TERRAIN_COST: FunctionDef i32> = FunctionDef{address: 0x006023ac, function_type: PhantomData}; - pub const DRAW_AIINFO: FunctionDef = FunctionDef{address: 0x00602481, function_type: PhantomData}; - pub const MORPH: FunctionDef = FunctionDef{address: 0x00602929, function_type: PhantomData}; - pub const GET_HEIGHT_ABOVE_TERRAIN: FunctionDef = FunctionDef{address: 0x00602c74, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/set_world_dest"))] + pub const SET_WORLD_DEST: FunctionDef = FunctionDef{address: 0x0048bf55, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/set_height_above_terrain"))] + pub const SET_HEIGHT_ABOVE_TERRAIN: FunctionDef = FunctionDef{address: 0x00492a51, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/check_elevation"))] + pub const CHECK_ELEVATION: FunctionDef bool> = FunctionDef{address: 0x00493e1c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_next_pos"))] + pub const GET_NEXT_POS: FunctionDef = FunctionDef{address: 0x00499be7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/set_dest_tile"))] + pub const SET_DEST_TILE: FunctionDef = FunctionDef{address: 0x004a7a90, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/set_selected"))] + pub const SET_SELECTED: FunctionDef = FunctionDef{address: 0x004ee4a4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004f568c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/bfunit"))] + pub const BFUNIT: FunctionDef *const u32> = FunctionDef{address: 0x004f9c33, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/send_event"))] + pub const SEND_EVENT: FunctionDef = FunctionDef{address: 0x0059def9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_cost"))] + pub const GET_COST: FunctionDef u32> = FunctionDef{address: 0x0060238f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_terrain_cost"))] + pub const GET_TERRAIN_COST: FunctionDef i32> = FunctionDef{address: 0x006023ac, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/draw_aiinfo"))] + pub const DRAW_AIINFO: FunctionDef = FunctionDef{address: 0x00602481, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/morph"))] + pub const MORPH: FunctionDef = FunctionDef{address: 0x00602929, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_height_above_terrain"))] + pub const GET_HEIGHT_ABOVE_TERRAIN: FunctionDef = FunctionDef{address: 0x00602c74, function_type: PhantomData}; } // BFUnitType class functions pub mod bfunittype { use super::*; - pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004b5de3, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b5faf, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004be68c, function_type: PhantomData}; - pub const BFUNIT_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x00500b5b, function_type: PhantomData}; - pub const BFUNIT_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x00500bda, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunittype/set_idle_animation"))] + pub const SET_IDLE_ANIMATION: FunctionDef u32> = FunctionDef{address: 0x004b551d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunittype/load_characteristics_0"))] + pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004b5de3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunittype/load_characteristics_1"))] + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b5faf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunittype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004be68c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunittype/bfunit_type_0"))] + pub const BFUNIT_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x00500b5b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunittype/bfunit_type_1"))] + pub const BFUNIT_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x00500bda, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfunittype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x005ffe36, function_type: PhantomData}; } // BFVersionInfo class functions pub mod bfversioninfo { use super::*; - pub const GET_VERSION_STRING: FunctionDef u32> = FunctionDef{address: 0x004bdfd4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfversioninfo/get_version_string"))] + pub const GET_VERSION_STRING: FunctionDef u32> = FunctionDef{address: 0x004bdfd4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfversioninfo/init_instance"))] pub const INIT_INSTANCE: FunctionDef u32> = FunctionDef{address: 0x005356ad, function_type: PhantomData}; - pub const EXIT_INSTANCE_0: FunctionDef = FunctionDef{address: 0x0057e05d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfversioninfo/exit_instance_0"))] + pub const EXIT_INSTANCE_0: FunctionDef = FunctionDef{address: 0x0057e05d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfversioninfo/exit_instance_1"))] pub const EXIT_INSTANCE_1: FunctionDef = FunctionDef{address: 0x0057e0b3, function_type: PhantomData}; } @@ -851,14 +1439,23 @@ pub mod bfversioninfo { pub mod bfwindow { use super::*; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x004d60a8, function_type: PhantomData}; - pub const SHOW: FunctionDef bool> = FunctionDef{address: 0x004d60ff, function_type: PhantomData}; - pub const RESIZE: FunctionDef = FunctionDef{address: 0x004d6141, function_type: PhantomData}; - pub const CENTER: FunctionDef = FunctionDef{address: 0x004d61db, function_type: PhantomData}; - pub const CHANGE_STYLE: FunctionDef u32> = FunctionDef{address: 0x004d62b3, function_type: PhantomData}; - pub const STYLE_POPUP: FunctionDef = FunctionDef{address: 0x004d641d, function_type: PhantomData}; - pub const STYLE_FIXED: FunctionDef = FunctionDef{address: 0x0052f150, function_type: PhantomData}; - pub const POINTER: FunctionDef bool> = FunctionDef{address: 0x005336d5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x004d60a8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/show"))] + pub const SHOW: FunctionDef bool> = FunctionDef{address: 0x004d60ff, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/resize"))] + pub const RESIZE: FunctionDef = FunctionDef{address: 0x004d6141, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/center"))] + pub const CENTER: FunctionDef = FunctionDef{address: 0x004d61db, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/change_style"))] + pub const CHANGE_STYLE: FunctionDef u32> = FunctionDef{address: 0x004d62b3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/style_popup"))] + pub const STYLE_POPUP: FunctionDef = FunctionDef{address: 0x004d641d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/style_fixed"))] + pub const STYLE_FIXED: FunctionDef = FunctionDef{address: 0x0052f150, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/pointer"))] + pub const POINTER: FunctionDef bool> = FunctionDef{address: 0x005336d5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/attach"))] pub const ATTACH: FunctionDef bool> = FunctionDef{address: 0x00536486, function_type: PhantomData}; } @@ -866,63 +1463,125 @@ pub mod bfwindow { pub mod bfwindowclass { use super::*; - pub const CREATE_WINDOW_0: FunctionDef = FunctionDef{address: 0x005362a4, function_type: PhantomData}; - pub const CREATE_WINDOW_1: FunctionDef u32> = FunctionDef{address: 0x005364ea, function_type: PhantomData}; - pub const MAKE_ICON: FunctionDef = FunctionDef{address: 0x005379c1, function_type: PhantomData}; - pub const CONSTRUCTOR_0: FunctionDef u32> = FunctionDef{address: 0x005379f6, function_type: PhantomData}; - pub const CONSTRUCTOR_1: FunctionDef u32> = FunctionDef{address: 0x00578c6f, function_type: PhantomData}; - pub const UNREGISTER_CLASS: FunctionDef bool> = FunctionDef{address: 0x00587672, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfwindowclass/create_window_0"))] + pub const CREATE_WINDOW_0: FunctionDef = FunctionDef{address: 0x005362a4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfwindowclass/create_window_1"))] + pub const CREATE_WINDOW_1: FunctionDef *const u32> = FunctionDef{address: 0x005364ea, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfwindowclass/make_icon"))] + pub const MAKE_ICON: FunctionDef bool> = FunctionDef{address: 0x005379c1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfwindowclass/constructor_0"))] + pub const CONSTRUCTOR_0: FunctionDef *const u32> = FunctionDef{address: 0x005379f6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfwindowclass/constructor_1"))] + pub const CONSTRUCTOR_1: FunctionDef *const u32> = FunctionDef{address: 0x00578c6f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfwindowclass/unregister_class"))] + pub const UNREGISTER_CLASS: FunctionDef bool> = FunctionDef{address: 0x00587672, function_type: PhantomData}; } // BFWorldMgr class functions pub mod bfworldmgr { use super::*; - pub const VERIFY_ENTITY_0: FunctionDef = FunctionDef{address: 0x00443ffa, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044f280, function_type: PhantomData}; - pub const INIT_UNLOCKED_ENTITIES: FunctionDef = FunctionDef{address: 0x004533bc, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0046285b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/verify_entity_0"))] + pub const VERIFY_ENTITY_0: FunctionDef u8> = FunctionDef{address: 0x00443ffa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044f280, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/init_unlocked_entities"))] + pub const INIT_UNLOCKED_ENTITIES: FunctionDef = FunctionDef{address: 0x004533bc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0046285b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00477b4e, function_type: PhantomData}; - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6b18, function_type: PhantomData}; - pub const UNLOCK_ENTITY: FunctionDef = FunctionDef{address: 0x00598cdc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/clear"))] + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6b18, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/unlock_entity"))] + pub const UNLOCK_ENTITY: FunctionDef = FunctionDef{address: 0x00598cdc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/verify_entity_1"))] pub const VERIFY_ENTITY_1: FunctionDef = FunctionDef{address: 0x005b66c4, function_type: PhantomData}; } +// DX8Sound class functions +pub mod dx8sound { + use super::*; + + #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00407010, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/set_volume"))] + pub const SET_VOLUME: FunctionDef = FunctionDef{address: 0x0040757b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/bring_alive"))] + pub const BRING_ALIVE: FunctionDef u32> = FunctionDef{address: 0x0041c488, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/get_sound_resource"))] + pub const GET_SOUND_RESOURCE: FunctionDef u32> = FunctionDef{address: 0x0041c514, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/play_0"))] + pub const PLAY_0: FunctionDef = FunctionDef{address: 0x00440764, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/update_position"))] + pub const UPDATE_POSITION: FunctionDef = FunctionDef{address: 0x0044153b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/play_looped_0"))] + pub const PLAY_LOOPED_0: FunctionDef = FunctionDef{address: 0x00441797, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/play_1"))] + pub const PLAY_1: FunctionDef = FunctionDef{address: 0x0044369a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/play_looped_1"))] + pub const PLAY_LOOPED_1: FunctionDef = FunctionDef{address: 0x004fc592, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/play_2"))] + pub const PLAY_2: FunctionDef = FunctionDef{address: 0x0061fd4c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/play_looped_2"))] + pub const PLAY_LOOPED_2: FunctionDef = FunctionDef{address: 0x0061fe0e, function_type: PhantomData}; +} + // GXCanvas class functions pub mod gxcanvas { use super::*; - pub const GET_DC: FunctionDef u32> = FunctionDef{address: 0x004014c8, function_type: PhantomData}; - pub const RELEASE_DC: FunctionDef u32> = FunctionDef{address: 0x004014f5, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004050f7, function_type: PhantomData}; - pub const CLEAR: FunctionDef u32> = FunctionDef{address: 0x00405792, function_type: PhantomData}; - pub const GET_PIXEL: FunctionDef u32> = FunctionDef{address: 0x0040710e, function_type: PhantomData}; - pub const SET_COLOR_KEY: FunctionDef u32> = FunctionDef{address: 0x004071cd, function_type: PhantomData}; - pub const DRAW_CLIPPED: FunctionDef u32> = FunctionDef{address: 0x0041981c, function_type: PhantomData}; - pub const STRING: FunctionDef u32> = FunctionDef{address: 0x004b189d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/get_dc"))] + pub const GET_DC: FunctionDef *const i32> = FunctionDef{address: 0x004014c8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/release_dc"))] + pub const RELEASE_DC: FunctionDef u32> = FunctionDef{address: 0x004014f5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004050f7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/clear"))] + pub const CLEAR: FunctionDef u32> = FunctionDef{address: 0x00405792, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/get_pixel"))] + pub const GET_PIXEL: FunctionDef u32> = FunctionDef{address: 0x0040710e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/set_color_key"))] + pub const SET_COLOR_KEY: FunctionDef u32> = FunctionDef{address: 0x004071cd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/draw_clipped"))] + pub const DRAW_CLIPPED: FunctionDef u32> = FunctionDef{address: 0x0041981c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/string"))] + pub const STRING: FunctionDef u32> = FunctionDef{address: 0x004b189d, function_type: PhantomData}; } // GXDynamicLLE class functions pub mod gxdynamiclle { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("gxdynamiclle/clear"))] pub const CLEAR: FunctionDef = FunctionDef{address: 0x004abfd6, function_type: PhantomData}; - pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x004aca7f, function_type: PhantomData}; - pub const BUILD: FunctionDef = FunctionDef{address: 0x004acdda, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxdynamiclle/load"))] + pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x004aca7f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxdynamiclle/build"))] + pub const BUILD: FunctionDef = FunctionDef{address: 0x004acdda, function_type: PhantomData}; } // GXGraphicsMgr class functions pub mod gxgraphicsmgr { use super::*; - pub const LOAD_PALETTE_MAP: FunctionDef i32> = FunctionDef{address: 0x00403600, function_type: PhantomData}; - pub const CREATE_UISURFACE_0: FunctionDef u32> = FunctionDef{address: 0x0041b98c, function_type: PhantomData}; - pub const CREATE_UISURFACE_1: FunctionDef u32> = FunctionDef{address: 0x0041ba54, function_type: PhantomData}; - pub const COPY_PALETTE_MAP: FunctionDef i32> = FunctionDef{address: 0x004abcac, function_type: PhantomData}; - pub const TOGGLE_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d5fc6, function_type: PhantomData}; - pub const START: FunctionDef u32> = FunctionDef{address: 0x004d6c59, function_type: PhantomData}; - pub const INITIALIZE: FunctionDef = FunctionDef{address: 0x00533e4b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/load_palette_map"))] + pub const LOAD_PALETTE_MAP: FunctionDef i32> = FunctionDef{address: 0x00403600, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/create_uisurface_0"))] + pub const CREATE_UISURFACE_0: FunctionDef *const u32> = FunctionDef{address: 0x0041b98c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/create_uisurface_1"))] + pub const CREATE_UISURFACE_1: FunctionDef u32> = FunctionDef{address: 0x0041ba54, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/copy_palette_map"))] + pub const COPY_PALETTE_MAP: FunctionDef i32> = FunctionDef{address: 0x004abcac, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/toggle_fullscreen"))] + pub const TOGGLE_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d5fc6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/start"))] + pub const START: FunctionDef u32> = FunctionDef{address: 0x004d6c59, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/initialize"))] + pub const INITIALIZE: FunctionDef = FunctionDef{address: 0x00533e4b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/destroy"))] pub const DESTROY: FunctionDef = FunctionDef{address: 0x0057de67, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/gxgraphics_mgr"))] pub const GXGRAPHICS_MGR: FunctionDef = FunctionDef{address: 0x0057de8e, function_type: PhantomData}; } @@ -930,952 +1589,1619 @@ pub mod gxgraphicsmgr { pub mod gximage { use super::*; - pub const DRAW: FunctionDef u32> = FunctionDef{address: 0x0061f0c8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gximage/draw"))] + pub const DRAW: FunctionDef u32> = FunctionDef{address: 0x0061f0c8, function_type: PhantomData}; } // GXImageBMP class functions pub mod gximagebmp { use super::*; - pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x005234da, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gximagebmp/attempt"))] + pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x005234da, function_type: PhantomData}; } // GXImageTGA class functions pub mod gximagetga { use super::*; - pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x004b32a7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gximagetga/attempt"))] + pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x004b32a7, function_type: PhantomData}; } // GXLLE class functions pub mod gxlle { use super::*; - pub const DRAW_DITHER: FunctionDef u32> = FunctionDef{address: 0x0047c948, function_type: PhantomData}; - pub const COMPRESS: FunctionDef u32> = FunctionDef{address: 0x004ad3d6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxlle/draw_dither"))] + pub const DRAW_DITHER: FunctionDef u32> = FunctionDef{address: 0x0047c948, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxlle/compress"))] + pub const COMPRESS: FunctionDef *const u32> = FunctionDef{address: 0x004ad3d6, function_type: PhantomData}; } // GXLLEAnim class functions pub mod gxlleanim { use super::*; - pub const RELEASE: FunctionDef = FunctionDef{address: 0x00402f13, function_type: PhantomData}; - pub const PREPARE: FunctionDef bool> = FunctionDef{address: 0x0040bbc1, function_type: PhantomData}; - pub const GXLLEANIM: FunctionDef = FunctionDef{address: 0x0040bc77, function_type: PhantomData}; - pub const ATTEMPT: FunctionDef bool> = FunctionDef{address: 0x00411e21, function_type: PhantomData}; - pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x00411eb8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanim/release"))] + pub const RELEASE: FunctionDef = FunctionDef{address: 0x00402f13, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanim/prepare"))] + pub const PREPARE: FunctionDef bool> = FunctionDef{address: 0x0040bbc1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanim/gxlleanim"))] + pub const GXLLEANIM: FunctionDef = FunctionDef{address: 0x0040bc77, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanim/attempt"))] + pub const ATTEMPT: FunctionDef bool> = FunctionDef{address: 0x00411e21, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanim/acquire"))] + pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x00411eb8, function_type: PhantomData}; } // GXLLEAnimSet class functions pub mod gxlleanimset { use super::*; - pub const RELEASE_0: FunctionDef = FunctionDef{address: 0x004069d0, function_type: PhantomData}; - pub const ATTEMPT_0: FunctionDef bool> = FunctionDef{address: 0x00406a22, function_type: PhantomData}; - pub const RELEASE_1: FunctionDef = FunctionDef{address: 0x00406b0e, function_type: PhantomData}; - pub const ATTEMPT_1: FunctionDef bool> = FunctionDef{address: 0x0040b967, function_type: PhantomData}; - pub const DATA_SIZE: FunctionDef i32> = FunctionDef{address: 0x0040bf92, function_type: PhantomData}; - pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x004bddbc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanimset/release_0"))] + pub const RELEASE_0: FunctionDef = FunctionDef{address: 0x004069d0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanimset/attempt_0"))] + pub const ATTEMPT_0: FunctionDef bool> = FunctionDef{address: 0x00406a22, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanimset/release_1"))] + pub const RELEASE_1: FunctionDef = FunctionDef{address: 0x00406b0e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanimset/attempt_1"))] + pub const ATTEMPT_1: FunctionDef bool> = FunctionDef{address: 0x0040b967, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanimset/data_size"))] + pub const DATA_SIZE: FunctionDef i32> = FunctionDef{address: 0x0040bf92, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanimset/acquire"))] + pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x004bddbc, function_type: PhantomData}; } // GXMixer class functions pub mod gxmixer { use super::*; - pub const GET_ANIM_SET: FunctionDef u32> = FunctionDef{address: 0x004010e7, function_type: PhantomData}; - pub const SET_SET: FunctionDef = FunctionDef{address: 0x0040165f, function_type: PhantomData}; - pub const SET_BASE_0: FunctionDef = FunctionDef{address: 0x0040de33, function_type: PhantomData}; - pub const TOTAL_CLEAR: FunctionDef = FunctionDef{address: 0x0040df80, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0040e214, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0040e420, function_type: PhantomData}; - pub const SET_BASE_1: FunctionDef = FunctionDef{address: 0x0040e6c1, function_type: PhantomData}; - pub const GET_ANIM: FunctionDef u32> = FunctionDef{address: 0x00411fed, function_type: PhantomData}; - pub const DRAW: FunctionDef = FunctionDef{address: 0x004325a9, function_type: PhantomData}; - pub const SET_TIME: FunctionDef = FunctionDef{address: 0x004340e1, function_type: PhantomData}; - pub const CLEAR_ALL: FunctionDef = FunctionDef{address: 0x004b1e62, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/get_anim_set"))] + pub const GET_ANIM_SET: FunctionDef u32> = FunctionDef{address: 0x004010e7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/set_set"))] + pub const SET_SET: FunctionDef = FunctionDef{address: 0x0040165f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/set_base_0"))] + pub const SET_BASE_0: FunctionDef = FunctionDef{address: 0x0040de33, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/total_clear"))] + pub const TOTAL_CLEAR: FunctionDef = FunctionDef{address: 0x0040df80, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0040e214, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0040e420, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/set_base_1"))] + pub const SET_BASE_1: FunctionDef = FunctionDef{address: 0x0040e6c1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/get_anim"))] + pub const GET_ANIM: FunctionDef *const c_void> = FunctionDef{address: 0x00411fed, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/draw"))] + pub const DRAW: FunctionDef = FunctionDef{address: 0x004325a9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/set_time"))] + pub const SET_TIME: FunctionDef = FunctionDef{address: 0x004340e1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/clear_all"))] + pub const CLEAR_ALL: FunctionDef = FunctionDef{address: 0x004b1e62, function_type: PhantomData}; } // GXMixerLink class functions pub mod gxmixerlink { use super::*; - pub const GXMIXER_LINK: FunctionDef = FunctionDef{address: 0x004016c7, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0040de05, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxmixerlink/gxmixer_link"))] + pub const GXMIXER_LINK: FunctionDef = FunctionDef{address: 0x004016c7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxmixerlink/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0040de05, function_type: PhantomData}; } // GXPalette class functions pub mod gxpalette { use super::*; - pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x004abb26, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxpalette/attempt"))] + pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x004abb26, function_type: PhantomData}; } // GXPaletteMap class functions pub mod gxpalettemap { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("gxpalettemap/copy_colors"))] pub const COPY_COLORS: FunctionDef = FunctionDef{address: 0x00433f66, function_type: PhantomData}; - pub const RELEASE: FunctionDef = FunctionDef{address: 0x004ab9b0, function_type: PhantomData}; - pub const ATTEMPT: FunctionDef = FunctionDef{address: 0x004aba2d, function_type: PhantomData}; - pub const SET_PIXEL_FORMAT_0: FunctionDef = FunctionDef{address: 0x004abb05, function_type: PhantomData}; - pub const SET_PIXEL_FORMAT_1: FunctionDef = FunctionDef{address: 0x004abb84, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxpalettemap/release"))] + pub const RELEASE: FunctionDef = FunctionDef{address: 0x004ab9b0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxpalettemap/attempt"))] + pub const ATTEMPT: FunctionDef = FunctionDef{address: 0x004aba2d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxpalettemap/set_pixel_format_0"))] + pub const SET_PIXEL_FORMAT_0: FunctionDef = FunctionDef{address: 0x004abb05, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxpalettemap/set_pixel_format_1"))] + pub const SET_PIXEL_FORMAT_1: FunctionDef = FunctionDef{address: 0x004abb84, function_type: PhantomData}; } // GXVideoManager class functions pub mod gxvideomanager { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/flip"))] pub const FLIP: FunctionDef bool> = FunctionDef{address: 0x004013bf, function_type: PhantomData}; - pub const CREATE_SURFACE: FunctionDef u32> = FunctionDef{address: 0x0041ba74, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/create_surface"))] + pub const CREATE_SURFACE: FunctionDef *const c_void> = FunctionDef{address: 0x0041ba74, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/flip_to_gdi"))] pub const FLIP_TO_GDI: FunctionDef = FunctionDef{address: 0x004cc682, function_type: PhantomData}; - pub const SWITCH_MODE: FunctionDef = FunctionDef{address: 0x004d601e, function_type: PhantomData}; - pub const START: FunctionDef u32> = FunctionDef{address: 0x004d64ab, function_type: PhantomData}; - pub const RELEASE_SURFACES: FunctionDef = FunctionDef{address: 0x004d67a2, function_type: PhantomData}; - pub const SETUP_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d6894, function_type: PhantomData}; - pub const CREATE_FLIPPING_CHAIN: FunctionDef u32> = FunctionDef{address: 0x004d6ae1, function_type: PhantomData}; - pub const SETUP_WINDOWED: FunctionDef u32> = FunctionDef{address: 0x0052f1d0, function_type: PhantomData}; - pub const CREATE_BLT_SURFACES: FunctionDef u32> = FunctionDef{address: 0x0052f2a6, function_type: PhantomData}; - pub const CREATE_DIRECT_DRAW: FunctionDef u32> = FunctionDef{address: 0x00533d0a, function_type: PhantomData}; - pub const INITIALIZE: FunctionDef u32> = FunctionDef{address: 0x00533db5, function_type: PhantomData}; - pub const STOP: FunctionDef = FunctionDef{address: 0x0057df69, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/switch_mode"))] + pub const SWITCH_MODE: FunctionDef = FunctionDef{address: 0x004d601e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/start"))] + pub const START: FunctionDef u32> = FunctionDef{address: 0x004d64ab, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/release_surfaces"))] + pub const RELEASE_SURFACES: FunctionDef = FunctionDef{address: 0x004d67a2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/setup_fullscreen"))] + pub const SETUP_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d6894, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/create_flipping_chain"))] + pub const CREATE_FLIPPING_CHAIN: FunctionDef u32> = FunctionDef{address: 0x004d6ae1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/setup_windowed"))] + pub const SETUP_WINDOWED: FunctionDef u32> = FunctionDef{address: 0x0052f1d0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/create_blt_surfaces"))] + pub const CREATE_BLT_SURFACES: FunctionDef u32> = FunctionDef{address: 0x0052f2a6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/create_direct_draw"))] + pub const CREATE_DIRECT_DRAW: FunctionDef u32> = FunctionDef{address: 0x00533d0a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/initialize"))] + pub const INITIALIZE: FunctionDef u32> = FunctionDef{address: 0x00533db5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/stop"))] + pub const STOP: FunctionDef = FunctionDef{address: 0x0057df69, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/gxvideo_manager"))] pub const GXVIDEO_MANAGER: FunctionDef = FunctionDef{address: 0x0057dfc7, function_type: PhantomData}; - pub const RELEASE_DIRECT_DRAW: FunctionDef = FunctionDef{address: 0x0057e01e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/release_direct_draw"))] + pub const RELEASE_DIRECT_DRAW: FunctionDef = FunctionDef{address: 0x0057e01e, function_type: PhantomData}; } // HTTPCallbackInterface class functions pub mod httpcallbackinterface { use super::*; - pub const CHECK_COMPLETED: FunctionDef = FunctionDef{address: 0x0059f93f, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00626b1d, function_type: PhantomData}; - pub const NOTIFY_DONE: FunctionDef = FunctionDef{address: 0x00626b35, function_type: PhantomData}; - pub const CHECK_ERROR: FunctionDef u32> = FunctionDef{address: 0x00626b4f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("httpcallbackinterface/check_completed"))] + pub const CHECK_COMPLETED: FunctionDef u8> = FunctionDef{address: 0x0059f93f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("httpcallbackinterface/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00626b1d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("httpcallbackinterface/notify_done"))] + pub const NOTIFY_DONE: FunctionDef = FunctionDef{address: 0x00626b35, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("httpcallbackinterface/check_error"))] + pub const CHECK_ERROR: FunctionDef u32> = FunctionDef{address: 0x00626b4f, function_type: PhantomData}; } // HTTPUtil class functions pub mod httputil { use super::*; - pub const PARSE_URL: FunctionDef = FunctionDef{address: 0x00627585, function_type: PhantomData}; - pub const INIT_SOCKET: FunctionDef u32> = FunctionDef{address: 0x00627699, function_type: PhantomData}; - pub const SEND_STRING: FunctionDef u32> = FunctionDef{address: 0x00627775, function_type: PhantomData}; - pub const GET_HTTPMEMORY: FunctionDef u32> = FunctionDef{address: 0x006277ea, function_type: PhantomData}; - pub const GET_HTTPFILE: FunctionDef u32> = FunctionDef{address: 0x00627a17, function_type: PhantomData}; - pub const RE_GET_FILE: FunctionDef u32> = FunctionDef{address: 0x00627c0c, function_type: PhantomData}; - pub const SEND_HTTPGET: FunctionDef u32> = FunctionDef{address: 0x00627c5d, function_type: PhantomData}; - pub const READ_HTTPTO_MEMORY: FunctionDef u32> = FunctionDef{address: 0x00627cc4, function_type: PhantomData}; - pub const READ_HTTPTO_FILE: FunctionDef u32> = FunctionDef{address: 0x00627ef2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("httputil/parse_url"))] + pub const PARSE_URL: FunctionDef = FunctionDef{address: 0x00627585, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("httputil/init_socket"))] + pub const INIT_SOCKET: FunctionDef u32> = FunctionDef{address: 0x00627699, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("httputil/send_string"))] + pub const SEND_STRING: FunctionDef u32> = FunctionDef{address: 0x00627775, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("httputil/get_httpmemory"))] + pub const GET_HTTPMEMORY: FunctionDef u32> = FunctionDef{address: 0x006277ea, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("httputil/get_httpfile"))] + pub const GET_HTTPFILE: FunctionDef u32> = FunctionDef{address: 0x00627a17, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("httputil/re_get_file"))] + pub const RE_GET_FILE: FunctionDef u32> = FunctionDef{address: 0x00627c0c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("httputil/send_httpget"))] + pub const SEND_HTTPGET: FunctionDef u32> = FunctionDef{address: 0x00627c5d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("httputil/read_httpto_memory"))] + pub const READ_HTTPTO_MEMORY: FunctionDef *const i16> = FunctionDef{address: 0x00627cc4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("httputil/read_httpto_file"))] + pub const READ_HTTPTO_FILE: FunctionDef u32> = FunctionDef{address: 0x00627ef2, function_type: PhantomData}; } // IScroller class functions pub mod iscroller { use super::*; - pub const INIT_SB: FunctionDef = FunctionDef{address: 0x004d4971, function_type: PhantomData}; - pub const LOAD_SB: FunctionDef u32> = FunctionDef{address: 0x00510ba2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("iscroller/init_sb"))] + pub const INIT_SB: FunctionDef = FunctionDef{address: 0x004d4971, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("iscroller/load_sb"))] + pub const LOAD_SB: FunctionDef u32> = FunctionDef{address: 0x00510ba2, function_type: PhantomData}; } // MenuMusicHandler class functions pub mod menumusichandler { use super::*; - pub const START_FADE: FunctionDef = FunctionDef{address: 0x00592570, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("menumusichandler/start_fade"))] + pub const START_FADE: FunctionDef = FunctionDef{address: 0x00592570, function_type: PhantomData}; } // SNDSoundResource class functions pub mod sndsoundresource { use super::*; - pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x0061ff52, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresource/release"))] + pub const RELEASE: FunctionDef = FunctionDef{address: 0x004072fa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresource/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0041c571, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresource/sndsound_resource"))] + pub const SNDSOUND_RESOURCE: FunctionDef *const u32> = FunctionDef{address: 0x0041e5e3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresource/attempt"))] + pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x0061ff52, function_type: PhantomData}; } // SNDSoundResourceWAV class functions pub mod sndsoundresourcewav { use super::*; - pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x0041c4c2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresourcewav/release"))] + pub const RELEASE: FunctionDef = FunctionDef{address: 0x004072a3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresourcewav/release_inner"))] + pub const RELEASE_INNER: FunctionDef = FunctionDef{address: 0x004072f0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresourcewav/attempt"))] + pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x0041c4c2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresourcewav/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0041c58a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresourcewav/sndsound_resource_wav"))] + pub const SNDSOUND_RESOURCE_WAV: FunctionDef *const u32> = FunctionDef{address: 0x0041e63d, function_type: PhantomData}; } // Sorter class functions pub mod sorter { use super::*; - pub const INSERT_MAP: FunctionDef = FunctionDef{address: 0x00431c3e, function_type: PhantomData}; - pub const POINT_IN_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004333c2, function_type: PhantomData}; - pub const SET_MAP: FunctionDef = FunctionDef{address: 0x0044afe0, function_type: PhantomData}; - pub const ACQUIRE_ANIS: FunctionDef = FunctionDef{address: 0x00461609, function_type: PhantomData}; - pub const DRAW_TANK1: FunctionDef = FunctionDef{address: 0x004cd3a8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("sorter/insert_map"))] + pub const INSERT_MAP: FunctionDef = FunctionDef{address: 0x00431c3e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("sorter/point_in_entity"))] + pub const POINT_IN_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004333c2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("sorter/set_map"))] + pub const SET_MAP: FunctionDef = FunctionDef{address: 0x0044afe0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("sorter/acquire_anis"))] + pub const ACQUIRE_ANIS: FunctionDef = FunctionDef{address: 0x00461609, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("sorter/draw_tank1"))] + pub const DRAW_TANK1: FunctionDef = FunctionDef{address: 0x004cd3a8, function_type: PhantomData}; } // SoundGroup class functions pub mod soundgroup { use super::*; - pub const PLAY: FunctionDef u32> = FunctionDef{address: 0x0043f513, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("soundgroup/play"))] + pub const PLAY: FunctionDef u32> = FunctionDef{address: 0x0043f513, function_type: PhantomData}; } // UIBarGraphRenderer class functions pub mod uibargraphrenderer { use super::*; - pub const RENDER_GRAPH_0: FunctionDef = FunctionDef{address: 0x0053211d, function_type: PhantomData}; - pub const POINT_TO_GRAPH_POS: FunctionDef = FunctionDef{address: 0x005324c5, function_type: PhantomData}; - pub const RENDER_XLABELS: FunctionDef = FunctionDef{address: 0x005325f5, function_type: PhantomData}; - pub const RENDER_GRAPH_1: FunctionDef = FunctionDef{address: 0x006239d9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uibargraphrenderer/render_graph_0"))] + pub const RENDER_GRAPH_0: FunctionDef = FunctionDef{address: 0x0053211d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uibargraphrenderer/point_to_graph_pos"))] + pub const POINT_TO_GRAPH_POS: FunctionDef = FunctionDef{address: 0x005324c5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uibargraphrenderer/render_xlabels"))] + pub const RENDER_XLABELS: FunctionDef = FunctionDef{address: 0x005325f5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uibargraphrenderer/render_graph_1"))] + pub const RENDER_GRAPH_1: FunctionDef = FunctionDef{address: 0x006239d9, function_type: PhantomData}; } // UIButton class functions pub mod uibutton { use super::*; - pub const VALIDATE_SELECTED_BUTTON: FunctionDef u32> = FunctionDef{address: 0x004179de, function_type: PhantomData}; - pub const DRAW: FunctionDef = FunctionDef{address: 0x004197a0, function_type: PhantomData}; - pub const LOAD: FunctionDef = FunctionDef{address: 0x004d35ab, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004e9989, function_type: PhantomData}; - pub const COPY: FunctionDef u32> = FunctionDef{address: 0x004e99ee, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uibutton/validate_selected_button"))] + pub const VALIDATE_SELECTED_BUTTON: FunctionDef *const i32> = FunctionDef{address: 0x004179de, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uibutton/draw"))] + pub const DRAW: FunctionDef = FunctionDef{address: 0x004197a0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uibutton/load"))] + pub const LOAD: FunctionDef = FunctionDef{address: 0x004d35ab, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uibutton/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004e9989, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uibutton/copy"))] + pub const COPY: FunctionDef *const u32> = FunctionDef{address: 0x004e99ee, function_type: PhantomData}; } // UICallbackMgr class functions pub mod uicallbackmgr { use super::*; - pub const DO_ACTION: FunctionDef = FunctionDef{address: 0x0041ab24, function_type: PhantomData}; - pub const STOP: FunctionDef = FunctionDef{address: 0x004f1daf, function_type: PhantomData}; - pub const ADD_ACTION: FunctionDef = FunctionDef{address: 0x00512687, function_type: PhantomData}; - pub const START: FunctionDef = FunctionDef{address: 0x0051f409, function_type: PhantomData}; - pub const ADD_GLOBAL_TRIGGER: FunctionDef = FunctionDef{address: 0x0058ec81, function_type: PhantomData}; - pub const REMOVE_ACTION: FunctionDef = FunctionDef{address: 0x00620891, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicallbackmgr/do_action"))] + pub const DO_ACTION: FunctionDef = FunctionDef{address: 0x0041ab24, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicallbackmgr/stop"))] + pub const STOP: FunctionDef = FunctionDef{address: 0x004f1daf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicallbackmgr/add_action"))] + pub const ADD_ACTION: FunctionDef = FunctionDef{address: 0x00512687, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicallbackmgr/start"))] + pub const START: FunctionDef u8> = FunctionDef{address: 0x0051f409, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicallbackmgr/add_global_trigger"))] + pub const ADD_GLOBAL_TRIGGER: FunctionDef = FunctionDef{address: 0x0058ec81, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicallbackmgr/remove_action"))] + pub const REMOVE_ACTION: FunctionDef = FunctionDef{address: 0x00620891, function_type: PhantomData}; } // UIControl class functions pub mod uicontrol { use super::*; - pub const GET_DC: FunctionDef u32> = FunctionDef{address: 0x0040e969, function_type: PhantomData}; - pub const RELEASE_DC: FunctionDef = FunctionDef{address: 0x0040e9cd, function_type: PhantomData}; - pub const SET_TEXT_0: FunctionDef = FunctionDef{address: 0x0040eabf, function_type: PhantomData}; - pub const UILOAD_ANIMATION: FunctionDef bool> = FunctionDef{address: 0x004176ce, function_type: PhantomData}; - pub const USE_TOOLTIP_ID: FunctionDef = FunctionDef{address: 0x00418a49, function_type: PhantomData}; - pub const DRAW: FunctionDef = FunctionDef{address: 0x004195ae, function_type: PhantomData}; - pub const RENDER: FunctionDef = FunctionDef{address: 0x0041a808, function_type: PhantomData}; - pub const SHOW: FunctionDef = FunctionDef{address: 0x0041acbb, function_type: PhantomData}; - pub const SET_TEXT_1: FunctionDef = FunctionDef{address: 0x0041afb5, function_type: PhantomData}; - pub const FILL_CANVASES: FunctionDef u32> = FunctionDef{address: 0x0041bce8, function_type: PhantomData}; - pub const DYNAMIC_RENDER: FunctionDef = FunctionDef{address: 0x004328ae, function_type: PhantomData}; - pub const HIT_TEST: FunctionDef i8> = FunctionDef{address: 0x004420b2, function_type: PhantomData}; - pub const HANDLE_MOUSE_MOVE: FunctionDef u32> = FunctionDef{address: 0x00442493, function_type: PhantomData}; - pub const SELECT_TRIGGER: FunctionDef = FunctionDef{address: 0x00443365, function_type: PhantomData}; - pub const HANDLE_LEFT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004435b9, function_type: PhantomData}; - pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x0044361a, function_type: PhantomData}; - pub const DESELECT_TRIGGER: FunctionDef = FunctionDef{address: 0x004438dd, function_type: PhantomData}; - pub const SET_IMAGE_0: FunctionDef = FunctionDef{address: 0x004b1a32, function_type: PhantomData}; - pub const SET_ANIMATION: FunctionDef = FunctionDef{address: 0x004b1aa0, function_type: PhantomData}; - pub const USE_ANIMATION: FunctionDef = FunctionDef{address: 0x004b1f89, function_type: PhantomData}; - pub const ADD_IMAGE_NAME: FunctionDef = FunctionDef{address: 0x004d2b40, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d32c9, function_type: PhantomData}; - pub const ADJUST_DIMENSIONS: FunctionDef u32> = FunctionDef{address: 0x004d483e, function_type: PhantomData}; - pub const INIT: FunctionDef u32> = FunctionDef{address: 0x004d4909, function_type: PhantomData}; - pub const UICONTROL: FunctionDef u32> = FunctionDef{address: 0x004e0996, function_type: PhantomData}; - pub const CONSTRUCTOR_0: FunctionDef u32> = FunctionDef{address: 0x004e95ea, function_type: PhantomData}; - pub const CONSTRUCTOR_1: FunctionDef u32> = FunctionDef{address: 0x0050fe83, function_type: PhantomData}; - pub const GET_TEXT: FunctionDef = FunctionDef{address: 0x0058c4aa, function_type: PhantomData}; - pub const SET_IMAGE_1: FunctionDef = FunctionDef{address: 0x00620b61, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/hide"))] + pub const HIDE: FunctionDef = FunctionDef{address: 0x004018d5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/get_dc"))] + pub const GET_DC: FunctionDef *const u32> = FunctionDef{address: 0x0040e969, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/release_dc"))] + pub const RELEASE_DC: FunctionDef = FunctionDef{address: 0x0040e9cd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/set_text_0"))] + pub const SET_TEXT_0: FunctionDef = FunctionDef{address: 0x0040eabf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/uiload_animation"))] + pub const UILOAD_ANIMATION: FunctionDef bool> = FunctionDef{address: 0x004176ce, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/use_tooltip_id"))] + pub const USE_TOOLTIP_ID: FunctionDef = FunctionDef{address: 0x00418a49, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/draw"))] + pub const DRAW: FunctionDef = FunctionDef{address: 0x004195ae, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/render"))] + pub const RENDER: FunctionDef = FunctionDef{address: 0x0041a808, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/show"))] + pub const SHOW: FunctionDef = FunctionDef{address: 0x0041acbb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/set_text_1"))] + pub const SET_TEXT_1: FunctionDef = FunctionDef{address: 0x0041afb5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/fill_canvases"))] + pub const FILL_CANVASES: FunctionDef u32> = FunctionDef{address: 0x0041bce8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/dynamic_render"))] + pub const DYNAMIC_RENDER: FunctionDef = FunctionDef{address: 0x004328ae, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/hit_test"))] + pub const HIT_TEST: FunctionDef i8> = FunctionDef{address: 0x004420b2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/handle_mouse_move"))] + pub const HANDLE_MOUSE_MOVE: FunctionDef u32> = FunctionDef{address: 0x00442493, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/select_trigger"))] + pub const SELECT_TRIGGER: FunctionDef = FunctionDef{address: 0x00443365, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/handle_left_button_up"))] + pub const HANDLE_LEFT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004435b9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/handle_left_button_down"))] + pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x0044361a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/deselect_trigger"))] + pub const DESELECT_TRIGGER: FunctionDef = FunctionDef{address: 0x004438dd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/set_image_0"))] + pub const SET_IMAGE_0: FunctionDef = FunctionDef{address: 0x004b1a32, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/set_animation"))] + pub const SET_ANIMATION: FunctionDef = FunctionDef{address: 0x004b1aa0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/use_animation"))] + pub const USE_ANIMATION: FunctionDef = FunctionDef{address: 0x004b1f89, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/add_image_name"))] + pub const ADD_IMAGE_NAME: FunctionDef = FunctionDef{address: 0x004d2b40, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d32c9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/adjust_dimensions"))] + pub const ADJUST_DIMENSIONS: FunctionDef u32> = FunctionDef{address: 0x004d483e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/init"))] + pub const INIT: FunctionDef u32> = FunctionDef{address: 0x004d4909, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/uicontrol"))] + pub const UICONTROL: FunctionDef *const u32> = FunctionDef{address: 0x004e0996, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/constructor_0"))] + pub const CONSTRUCTOR_0: FunctionDef *const u32> = FunctionDef{address: 0x004e95ea, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/constructor_1"))] + pub const CONSTRUCTOR_1: FunctionDef *const u32> = FunctionDef{address: 0x0050fe83, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/get_text"))] + pub const GET_TEXT: FunctionDef u32> = FunctionDef{address: 0x0058c4aa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/set_image_1"))] + pub const SET_IMAGE_1: FunctionDef = FunctionDef{address: 0x00620b61, function_type: PhantomData}; +} + +// UIEditableText class functions +pub mod uieditabletext { + use super::*; + + #[cfg_attr(feature = "detour-validation", validate_detour("uieditabletext/handle_char"))] + pub const HANDLE_CHAR: FunctionDef u32> = FunctionDef{address: 0x0046c7d9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uieditabletext/init_cursors"))] + pub const INIT_CURSORS: FunctionDef = FunctionDef{address: 0x004d41be, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uieditabletext/handle_mouse_move"))] + pub const HANDLE_MOUSE_MOVE: FunctionDef u32> = FunctionDef{address: 0x0058c652, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uieditabletext/handle_left_button_down"))] + pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x00620224, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uieditabletext/find_character"))] + pub const FIND_CHARACTER: FunctionDef i32> = FunctionDef{address: 0x006202dd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uieditabletext/find_text_width"))] + pub const FIND_TEXT_WIDTH: FunctionDef i32> = FunctionDef{address: 0x00620487, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uieditabletext/find_char_width"))] + pub const FIND_CHAR_WIDTH: FunctionDef = FunctionDef{address: 0x006204bf, function_type: PhantomData}; } // UIElement class functions pub mod uielement { use super::*; - pub const SET_FLAG: FunctionDef = FunctionDef{address: 0x004014ac, function_type: PhantomData}; - pub const DIRTY: FunctionDef = FunctionDef{address: 0x00401802, function_type: PhantomData}; - pub const HIDE: FunctionDef = FunctionDef{address: 0x004018c6, function_type: PhantomData}; - pub const GET_ELEMENT_0: FunctionDef = FunctionDef{address: 0x0040760c, function_type: PhantomData}; - pub const SORT: FunctionDef = FunctionDef{address: 0x0040eab5, function_type: PhantomData}; - pub const LOAD_STATE: FunctionDef = FunctionDef{address: 0x0041215f, function_type: PhantomData}; - pub const GET_SCREEN_POS: FunctionDef = FunctionDef{address: 0x00418c5f, function_type: PhantomData}; - pub const ENABLE: FunctionDef = FunctionDef{address: 0x0041914b, function_type: PhantomData}; - pub const DISABLE: FunctionDef = FunctionDef{address: 0x00419191, function_type: PhantomData}; - pub const SHOW: FunctionDef = FunctionDef{address: 0x0041ac49, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041adf1, function_type: PhantomData}; - pub const HANDLE_DOUBLE_CLICK: FunctionDef = FunctionDef{address: 0x0041eabe, function_type: PhantomData}; - pub const HANDLE_MIDDLE_BUTTON_DOWN: FunctionDef = FunctionDef{address: 0x00429d0f, function_type: PhantomData}; - pub const GET_ELEMENT_1: FunctionDef u32> = FunctionDef{address: 0x004422fd, function_type: PhantomData}; - pub const UNHIGHLIGHT: FunctionDef = FunctionDef{address: 0x00442562, function_type: PhantomData}; - pub const HIGHLIGHT: FunctionDef = FunctionDef{address: 0x004425ac, function_type: PhantomData}; - pub const UNFOCUS: FunctionDef = FunctionDef{address: 0x004431f6, function_type: PhantomData}; - pub const FOCUS: FunctionDef = FunctionDef{address: 0x00443235, function_type: PhantomData}; - pub const DESELECT: FunctionDef = FunctionDef{address: 0x004433d8, function_type: PhantomData}; - pub const SELECT: FunctionDef = FunctionDef{address: 0x00443414, function_type: PhantomData}; - pub const HANDLE_LEFT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004435a8, function_type: PhantomData}; - pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x0044360a, function_type: PhantomData}; - pub const SET_TOOLTIP_ID: FunctionDef = FunctionDef{address: 0x00443bfc, function_type: PhantomData}; - pub const SET_LAYOUT: FunctionDef = FunctionDef{address: 0x004b203f, function_type: PhantomData}; - pub const RELOAD: FunctionDef = FunctionDef{address: 0x004d5777, function_type: PhantomData}; - pub const HANDLE_MOUSE_WHEEL: FunctionDef u32> = FunctionDef{address: 0x004de381, function_type: PhantomData}; - pub const SET_ALIAS_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004ffb8b, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0050f8e7, function_type: PhantomData}; - pub const REGISTERIT: FunctionDef u32> = FunctionDef{address: 0x005774bf, function_type: PhantomData}; - pub const SET_GLOBAL_GRAYED: FunctionDef = FunctionDef{address: 0x005a0d64, function_type: PhantomData}; - pub const HANDLE_KEY_DOWN: FunctionDef = FunctionDef{address: 0x00606ce7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/set_flag"))] + pub const SET_FLAG: FunctionDef = FunctionDef{address: 0x004014ac, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/dirty"))] + pub const DIRTY: FunctionDef = FunctionDef{address: 0x00401802, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/hide"))] + pub const HIDE: FunctionDef = FunctionDef{address: 0x004018c6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/get_element_0"))] + pub const GET_ELEMENT_0: FunctionDef u32> = FunctionDef{address: 0x0040760c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/sort"))] + pub const SORT: FunctionDef = FunctionDef{address: 0x0040eab5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/load_state"))] + pub const LOAD_STATE: FunctionDef u8> = FunctionDef{address: 0x0041215f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/get_screen_pos"))] + pub const GET_SCREEN_POS: FunctionDef = FunctionDef{address: 0x00418c5f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/enable"))] + pub const ENABLE: FunctionDef = FunctionDef{address: 0x0041914b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/disable"))] + pub const DISABLE: FunctionDef = FunctionDef{address: 0x00419191, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/show"))] + pub const SHOW: FunctionDef = FunctionDef{address: 0x0041ac49, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041adf1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/handle_double_click"))] + pub const HANDLE_DOUBLE_CLICK: FunctionDef = FunctionDef{address: 0x0041eabe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/handle_middle_button_down"))] + pub const HANDLE_MIDDLE_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x00429d0f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/set_cursor"))] + pub const SET_CURSOR: FunctionDef = FunctionDef{address: 0x00432346, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/get_element_1"))] + pub const GET_ELEMENT_1: FunctionDef *const i32> = FunctionDef{address: 0x004422fd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/unhighlight"))] + pub const UNHIGHLIGHT: FunctionDef = FunctionDef{address: 0x00442562, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/highlight"))] + pub const HIGHLIGHT: FunctionDef = FunctionDef{address: 0x004425ac, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/unfocus"))] + pub const UNFOCUS: FunctionDef = FunctionDef{address: 0x004431f6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/focus"))] + pub const FOCUS: FunctionDef = FunctionDef{address: 0x00443235, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/deselect"))] + pub const DESELECT: FunctionDef = FunctionDef{address: 0x004433d8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/select"))] + pub const SELECT: FunctionDef = FunctionDef{address: 0x00443414, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/handle_left_button_up"))] + pub const HANDLE_LEFT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004435a8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/handle_left_button_down"))] + pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x0044360a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/set_tooltip_id"))] + pub const SET_TOOLTIP_ID: FunctionDef = FunctionDef{address: 0x00443bfc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/set_layout"))] + pub const SET_LAYOUT: FunctionDef = FunctionDef{address: 0x004b203f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/reload"))] + pub const RELOAD: FunctionDef u8> = FunctionDef{address: 0x004d5777, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/handle_mouse_wheel"))] + pub const HANDLE_MOUSE_WHEEL: FunctionDef u32> = FunctionDef{address: 0x004de381, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/set_alias_element"))] + pub const SET_ALIAS_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004ffb8b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0050f8e7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/registerit"))] + pub const REGISTERIT: FunctionDef u32> = FunctionDef{address: 0x005774bf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/set_global_grayed"))] + pub const SET_GLOBAL_GRAYED: FunctionDef = FunctionDef{address: 0x005a0d64, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uielement/handle_key_down"))] + pub const HANDLE_KEY_DOWN: FunctionDef u32> = FunctionDef{address: 0x00606ce7, function_type: PhantomData}; } // UIGraphRenderer class functions pub mod uigraphrenderer { use super::*; - pub const CALC_DISPLAY_RANGES: FunctionDef = FunctionDef{address: 0x0052f46b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uigraphrenderer/calc_display_ranges"))] + pub const CALC_DISPLAY_RANGES: FunctionDef = FunctionDef{address: 0x0052f46b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uigraphrenderer/round_up_max"))] pub const ROUND_UP_MAX: FunctionDef i32> = FunctionDef{address: 0x0052fe2d, function_type: PhantomData}; - pub const RENDER: FunctionDef = FunctionDef{address: 0x00531dbd, function_type: PhantomData}; - pub const RENDER_POINT_LABEL: FunctionDef = FunctionDef{address: 0x00531ec5, function_type: PhantomData}; - pub const RENDER_LABELS: FunctionDef = FunctionDef{address: 0x005325da, function_type: PhantomData}; - pub const RENDER_AXIS_LINES: FunctionDef = FunctionDef{address: 0x005328f4, function_type: PhantomData}; - pub const RENDER_YLABELS: FunctionDef = FunctionDef{address: 0x0053296d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uigraphrenderer/render"))] + pub const RENDER: FunctionDef = FunctionDef{address: 0x00531dbd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uigraphrenderer/render_point_label"))] + pub const RENDER_POINT_LABEL: FunctionDef = FunctionDef{address: 0x00531ec5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uigraphrenderer/render_labels"))] + pub const RENDER_LABELS: FunctionDef = FunctionDef{address: 0x005325da, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uigraphrenderer/render_axis_lines"))] + pub const RENDER_AXIS_LINES: FunctionDef = FunctionDef{address: 0x005328f4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uigraphrenderer/render_ylabels"))] + pub const RENDER_YLABELS: FunctionDef = FunctionDef{address: 0x0053296d, function_type: PhantomData}; } // UIImage class functions pub mod uiimage { use super::*; - pub const RENDER: FunctionDef = FunctionDef{address: 0x00443cbf, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d3509, function_type: PhantomData}; - pub const UIIMAGE: FunctionDef u32> = FunctionDef{address: 0x0050295e, function_type: PhantomData}; - pub const CREATE: FunctionDef u32> = FunctionDef{address: 0x00606fd2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiimage/render"))] + pub const RENDER: FunctionDef = FunctionDef{address: 0x00443cbf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiimage/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d3509, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiimage/uiimage"))] + pub const UIIMAGE: FunctionDef *const u32> = FunctionDef{address: 0x0050295e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiimage/create"))] + pub const CREATE: FunctionDef *const u32> = FunctionDef{address: 0x00606fd2, function_type: PhantomData}; } // UIImageSet class functions pub mod uiimageset { use super::*; - pub const SET_STATUS: FunctionDef = FunctionDef{address: 0x004f1b13, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiimageset/set_status"))] + pub const SET_STATUS: FunctionDef = FunctionDef{address: 0x004f1b13, function_type: PhantomData}; } // UILayout class functions pub mod uilayout { use super::*; - pub const DRAW: FunctionDef = FunctionDef{address: 0x0041952b, function_type: PhantomData}; - pub const REMOVE_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x0041ae42, function_type: PhantomData}; - pub const BRING_TO_FRONT: FunctionDef = FunctionDef{address: 0x0041aeb1, function_type: PhantomData}; - pub const SHOW: FunctionDef = FunctionDef{address: 0x004b1b86, function_type: PhantomData}; - pub const ADD_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004b206c, function_type: PhantomData}; - pub const LOAD_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x0050f61a, function_type: PhantomData}; - pub const HANDLE_LEFT_BUTTON_UP: FunctionDef = FunctionDef{address: 0x0058c88e, function_type: PhantomData}; - pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x0058c8b4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/draw"))] + pub const DRAW: FunctionDef = FunctionDef{address: 0x0041952b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/remove_element"))] + pub const REMOVE_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x0041ae42, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/bring_to_front"))] + pub const BRING_TO_FRONT: FunctionDef = FunctionDef{address: 0x0041aeb1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/hide"))] + pub const HIDE: FunctionDef = FunctionDef{address: 0x00443b70, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/show"))] + pub const SHOW: FunctionDef = FunctionDef{address: 0x004b1b86, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/add_element"))] + pub const ADD_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004b206c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/load_element"))] + pub const LOAD_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x0050f61a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/handle_left_button_up"))] + pub const HANDLE_LEFT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x0058c88e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/handle_left_button_down"))] + pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x0058c8b4, function_type: PhantomData}; } // UIListBox class functions pub mod uilistbox { use super::*; - pub const RECALC_SCROLL_BAR: FunctionDef = FunctionDef{address: 0x00417645, function_type: PhantomData}; - pub const ABSOLUTE_SCROLL: FunctionDef = FunctionDef{address: 0x00417695, function_type: PhantomData}; - pub const LOCAL_RENDER: FunctionDef = FunctionDef{address: 0x00417a8e, function_type: PhantomData}; - pub const ADD_STRING_0: FunctionDef = FunctionDef{address: 0x00417f79, function_type: PhantomData}; - pub const ITEM_NOW_VISIBLE: FunctionDef = FunctionDef{address: 0x00418372, function_type: PhantomData}; - pub const ADD_STRING_1: FunctionDef u32> = FunctionDef{address: 0x00418504, function_type: PhantomData}; - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004188de, function_type: PhantomData}; - pub const SET_SELECTED: FunctionDef = FunctionDef{address: 0x004189e8, function_type: PhantomData}; - pub const SHOW: FunctionDef = FunctionDef{address: 0x00418a71, function_type: PhantomData}; - pub const SET_ITEM_VISIBLE: FunctionDef = FunctionDef{address: 0x00418bfb, function_type: PhantomData}; - pub const GET_ITEM: FunctionDef u32> = FunctionDef{address: 0x0041ee59, function_type: PhantomData}; - pub const LOAD: FunctionDef = FunctionDef{address: 0x004d393f, function_type: PhantomData}; - pub const ABSOLUTE_TO_VISIBLE: FunctionDef i32> = FunctionDef{address: 0x004ed6d2, function_type: PhantomData}; - pub const RESTORE_STATE: FunctionDef = FunctionDef{address: 0x004ef81c, function_type: PhantomData}; - pub const ADD_STRING_2: FunctionDef u32> = FunctionDef{address: 0x004f0331, function_type: PhantomData}; - pub const GET_ITEM_STRING: FunctionDef u32> = FunctionDef{address: 0x004f05b2, function_type: PhantomData}; - pub const ITEM_NOW_INVISIBLE: FunctionDef = FunctionDef{address: 0x004f984e, function_type: PhantomData}; - pub const REMOVE_STRING: FunctionDef u32> = FunctionDef{address: 0x004f9908, function_type: PhantomData}; - pub const INCREMENT: FunctionDef u32> = FunctionDef{address: 0x004f9ffa, function_type: PhantomData}; - pub const SET_ITEM_STRING: FunctionDef = FunctionDef{address: 0x005aecdc, function_type: PhantomData}; - pub const IS_ITEM_SELECTED: FunctionDef u32> = FunctionDef{address: 0x00622dcb, function_type: PhantomData}; - pub const FIND_ITEM_ABSOLUTE_ID: FunctionDef i32> = FunctionDef{address: 0x00622e92, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/recalc_scroll_bar"))] + pub const RECALC_SCROLL_BAR: FunctionDef = FunctionDef{address: 0x00417645, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/absolute_scroll"))] + pub const ABSOLUTE_SCROLL: FunctionDef = FunctionDef{address: 0x00417695, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/local_render"))] + pub const LOCAL_RENDER: FunctionDef = FunctionDef{address: 0x00417a8e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/add_string_0"))] + pub const ADD_STRING_0: FunctionDef = FunctionDef{address: 0x00417f79, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/item_now_visible"))] + pub const ITEM_NOW_VISIBLE: FunctionDef = FunctionDef{address: 0x00418372, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/add_string_1"))] + pub const ADD_STRING_1: FunctionDef *const c_void> = FunctionDef{address: 0x00418504, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/clear"))] + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004188de, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/set_selected"))] + pub const SET_SELECTED: FunctionDef = FunctionDef{address: 0x004189e8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/show"))] + pub const SHOW: FunctionDef = FunctionDef{address: 0x00418a71, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/set_item_visible"))] + pub const SET_ITEM_VISIBLE: FunctionDef = FunctionDef{address: 0x00418bfb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/get_item"))] + pub const GET_ITEM: FunctionDef u32> = FunctionDef{address: 0x0041ee59, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/hide"))] + pub const HIDE: FunctionDef = FunctionDef{address: 0x00443b9e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d393f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/render"))] + pub const RENDER: FunctionDef = FunctionDef{address: 0x004ec999, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/absolute_to_visible"))] + pub const ABSOLUTE_TO_VISIBLE: FunctionDef i32> = FunctionDef{address: 0x004ed6d2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/restore_state"))] + pub const RESTORE_STATE: FunctionDef = FunctionDef{address: 0x004ef81c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/add_string_2"))] + pub const ADD_STRING_2: FunctionDef u32> = FunctionDef{address: 0x004f0331, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/get_item_string"))] + pub const GET_ITEM_STRING: FunctionDef *const i16> = FunctionDef{address: 0x004f05b2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/item_now_invisible"))] + pub const ITEM_NOW_INVISIBLE: FunctionDef = FunctionDef{address: 0x004f984e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/remove_string"))] + pub const REMOVE_STRING: FunctionDef u32> = FunctionDef{address: 0x004f9908, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/increment"))] + pub const INCREMENT: FunctionDef u32> = FunctionDef{address: 0x004f9ffa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/scroll"))] + pub const SCROLL: FunctionDef u32> = FunctionDef{address: 0x0053337e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/set_item_string"))] + pub const SET_ITEM_STRING: FunctionDef = FunctionDef{address: 0x005aecdc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/set_item_icon"))] + pub const SET_ITEM_ICON: FunctionDef = FunctionDef{address: 0x005aed6d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/is_item_selected"))] + pub const IS_ITEM_SELECTED: FunctionDef u32> = FunctionDef{address: 0x00622dcb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/find_item_absolute_id"))] + pub const FIND_ITEM_ABSOLUTE_ID: FunctionDef i32> = FunctionDef{address: 0x00622e92, function_type: PhantomData}; } // UIListBoxEntry class functions pub mod uilistboxentry { use super::*; - pub const CALC_SIZE: FunctionDef = FunctionDef{address: 0x00417c8c, function_type: PhantomData}; - pub const SET_NORMAL_ICON: FunctionDef = FunctionDef{address: 0x00417e94, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004181f7, function_type: PhantomData}; - pub const SET_SELECTED_ICON: FunctionDef = FunctionDef{address: 0x0047098b, function_type: PhantomData}; - pub const SET_GRAYED_ICON: FunctionDef = FunctionDef{address: 0x00474c26, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxentry/calc_size"))] + pub const CALC_SIZE: FunctionDef = FunctionDef{address: 0x00417c8c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxentry/set_normal_icon"))] + pub const SET_NORMAL_ICON: FunctionDef = FunctionDef{address: 0x00417e94, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxentry/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const i32> = FunctionDef{address: 0x004181f7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxentry/set_selected_icon"))] + pub const SET_SELECTED_ICON: FunctionDef = FunctionDef{address: 0x0047098b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxentry/set_grayed_icon"))] + pub const SET_GRAYED_ICON: FunctionDef = FunctionDef{address: 0x00474c26, function_type: PhantomData}; } // UIListBoxItem class functions pub mod uilistboxitem { use super::*; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00418000, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/find_entry"))] + pub const FIND_ENTRY: FunctionDef *const i32> = FunctionDef{address: 0x00417c59, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00418000, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/calc_size"))] pub const CALC_SIZE: FunctionDef = FunctionDef{address: 0x0041848c, function_type: PhantomData}; - pub const SET_JUSTIFY: FunctionDef = FunctionDef{address: 0x004185f6, function_type: PhantomData}; - pub const RENDER_TEXT_ENTRIES: FunctionDef = FunctionDef{address: 0x004ecba7, function_type: PhantomData}; - pub const RENDER_ICON_ENTRIES: FunctionDef = FunctionDef{address: 0x004ece25, function_type: PhantomData}; - pub const GET_STRING: FunctionDef u32> = FunctionDef{address: 0x004f0571, function_type: PhantomData}; - pub const ADD_ENTRY: FunctionDef = FunctionDef{address: 0x00531863, function_type: PhantomData}; - pub const DISABLE: FunctionDef = FunctionDef{address: 0x0058f57c, function_type: PhantomData}; - pub const SET_STRING: FunctionDef = FunctionDef{address: 0x005aebf5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/set_justify"))] + pub const SET_JUSTIFY: FunctionDef = FunctionDef{address: 0x004185f6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/render_text_entries"))] + pub const RENDER_TEXT_ENTRIES: FunctionDef = FunctionDef{address: 0x004ecba7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/render_icon_entries"))] + pub const RENDER_ICON_ENTRIES: FunctionDef = FunctionDef{address: 0x004ece25, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/get_string"))] + pub const GET_STRING: FunctionDef *const i32> = FunctionDef{address: 0x004f0571, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/add_entry"))] + pub const ADD_ENTRY: FunctionDef = FunctionDef{address: 0x00531863, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/disable"))] + pub const DISABLE: FunctionDef = FunctionDef{address: 0x0058f57c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/set_string"))] + pub const SET_STRING: FunctionDef = FunctionDef{address: 0x005aebf5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/set_normal_icon"))] + pub const SET_NORMAL_ICON: FunctionDef = FunctionDef{address: 0x005aed23, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/set_selected_icon"))] + pub const SET_SELECTED_ICON: FunctionDef = FunctionDef{address: 0x00622b75, function_type: PhantomData}; } // UIMessageQueue class functions pub mod uimessagequeue { use super::*; - pub const DRAW: FunctionDef = FunctionDef{address: 0x004197fc, function_type: PhantomData}; - pub const ADD_MESSAGE: FunctionDef u32> = FunctionDef{address: 0x0049cd46, function_type: PhantomData}; - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6d4e, function_type: PhantomData}; - pub const RENDER: FunctionDef = FunctionDef{address: 0x004fad0f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uimessagequeue/draw"))] + pub const DRAW: FunctionDef = FunctionDef{address: 0x004197fc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uimessagequeue/add_message"))] + pub const ADD_MESSAGE: FunctionDef u32> = FunctionDef{address: 0x0049cd46, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uimessagequeue/clear"))] + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6d4e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uimessagequeue/render"))] + pub const RENDER: FunctionDef = FunctionDef{address: 0x004fad0f, function_type: PhantomData}; } // UIPointGraphRenderer class functions pub mod uipointgraphrenderer { use super::*; - pub const RENDER_GRAPH: FunctionDef = FunctionDef{address: 0x00623eb8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uipointgraphrenderer/render_graph"))] + pub const RENDER_GRAPH: FunctionDef = FunctionDef{address: 0x00623eb8, function_type: PhantomData}; } // UIRadioSet class functions pub mod uiradioset { use super::*; - pub const SELECT_BUTTON: FunctionDef = FunctionDef{address: 0x004438fb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiradioset/select_button"))] + pub const SELECT_BUTTON: FunctionDef = FunctionDef{address: 0x004438fb, function_type: PhantomData}; } // UIScrollBar class functions pub mod uiscrollbar { use super::*; - pub const RECALC_THUMB_POSITION: FunctionDef = FunctionDef{address: 0x0041755a, function_type: PhantomData}; - pub const RENDER: FunctionDef = FunctionDef{address: 0x004b22a2, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00511212, function_type: PhantomData}; - pub const COPY: FunctionDef u32> = FunctionDef{address: 0x00620636, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollbar/recalc_thumb_position"))] + pub const RECALC_THUMB_POSITION: FunctionDef = FunctionDef{address: 0x0041755a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollbar/render"))] + pub const RENDER: FunctionDef = FunctionDef{address: 0x004b22a2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollbar/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00511212, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollbar/copy"))] + pub const COPY: FunctionDef *const u32> = FunctionDef{address: 0x00620636, function_type: PhantomData}; } // UIScrollingRegion class functions pub mod uiscrollingregion { use super::*; - pub const COPY: FunctionDef u32> = FunctionDef{address: 0x004010e1, function_type: PhantomData}; - pub const HIDE: FunctionDef = FunctionDef{address: 0x00443981, function_type: PhantomData}; - pub const LOAD: FunctionDef = FunctionDef{address: 0x004d3e23, function_type: PhantomData}; - pub const INIT: FunctionDef u32> = FunctionDef{address: 0x004d4c85, function_type: PhantomData}; - pub const CLEAR_SELECTION: FunctionDef = FunctionDef{address: 0x004df638, function_type: PhantomData}; - pub const DEPOPULATE: FunctionDef u32> = FunctionDef{address: 0x004e0cd1, function_type: PhantomData}; - pub const POPULATE: FunctionDef u32> = FunctionDef{address: 0x004e90c2, function_type: PhantomData}; - pub const SHOW: FunctionDef = FunctionDef{address: 0x004ea015, function_type: PhantomData}; - pub const UISCROLLING_REGION_0: FunctionDef u32> = FunctionDef{address: 0x00502fe5, function_type: PhantomData}; - pub const UISCROLLING_REGION_1: FunctionDef u32> = FunctionDef{address: 0x00503003, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x005125d8, function_type: PhantomData}; - pub const HANDLE_CHAR: FunctionDef = FunctionDef{address: 0x00622ef8, function_type: PhantomData}; - pub const SELECT_NEXT_BUTTON: FunctionDef = FunctionDef{address: 0x00622f18, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/vf_return0"))] + pub const VF_RETURN0: FunctionDef u32> = FunctionDef{address: 0x004010e1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/hide"))] + pub const HIDE: FunctionDef = FunctionDef{address: 0x00443981, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d3e23, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/init"))] + pub const INIT: FunctionDef u32> = FunctionDef{address: 0x004d4c85, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/clear_selection"))] + pub const CLEAR_SELECTION: FunctionDef = FunctionDef{address: 0x004df638, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/depopulate"))] + pub const DEPOPULATE: FunctionDef u32> = FunctionDef{address: 0x004e0cd1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/populate"))] + pub const POPULATE: FunctionDef u32> = FunctionDef{address: 0x004e90c2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/show"))] + pub const SHOW: FunctionDef = FunctionDef{address: 0x004ea015, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/uiscrolling_region_0"))] + pub const UISCROLLING_REGION_0: FunctionDef *const u32> = FunctionDef{address: 0x00502fe5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/uiscrolling_region_1"))] + pub const UISCROLLING_REGION_1: FunctionDef *const u32> = FunctionDef{address: 0x00503003, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x005125d8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/handle_char"))] + pub const HANDLE_CHAR: FunctionDef u32> = FunctionDef{address: 0x00622ef8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/select_next_button"))] + pub const SELECT_NEXT_BUTTON: FunctionDef = FunctionDef{address: 0x00622f18, function_type: PhantomData}; } // UIStatusImage class functions pub mod uistatusimage { use super::*; - pub const SET_STATUS: FunctionDef = FunctionDef{address: 0x0041cefc, function_type: PhantomData}; - pub const CLEAR_FOR_LOAD: FunctionDef = FunctionDef{address: 0x004d3de0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uistatusimage/set_status"))] + pub const SET_STATUS: FunctionDef = FunctionDef{address: 0x0041cefc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uistatusimage/clear_for_load"))] + pub const CLEAR_FOR_LOAD: FunctionDef = FunctionDef{address: 0x004d3de0, function_type: PhantomData}; } // UIText class functions pub mod uitext { use super::*; - pub const RECALC_SCROLL_BAR: FunctionDef = FunctionDef{address: 0x0040eaa0, function_type: PhantomData}; - pub const RENDER: FunctionDef = FunctionDef{address: 0x0041a476, function_type: PhantomData}; - pub const FIT_TO_TEXT: FunctionDef = FunctionDef{address: 0x0041b0bb, function_type: PhantomData}; - pub const SET_SCROLL_BAR: FunctionDef = FunctionDef{address: 0x004d4c5d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uitext/set_text"))] + pub const SET_TEXT: FunctionDef *const u32> = FunctionDef{address: 0x0040495e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uitext/recalc_scroll_bar"))] + pub const RECALC_SCROLL_BAR: FunctionDef = FunctionDef{address: 0x0040eaa0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uitext/render"))] + pub const RENDER: FunctionDef = FunctionDef{address: 0x0041a476, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uitext/fit_to_text"))] + pub const FIT_TO_TEXT: FunctionDef = FunctionDef{address: 0x0041b0bb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uitext/set_scroll_bar"))] + pub const SET_SCROLL_BAR: FunctionDef = FunctionDef{address: 0x004d4c5d, function_type: PhantomData}; } // UIView class functions pub mod uiview { use super::*; - pub const CONSTRUCTOR_0: FunctionDef u32> = FunctionDef{address: 0x0052059c, function_type: PhantomData}; - pub const COPY: FunctionDef u32> = FunctionDef{address: 0x0060a8d2, function_type: PhantomData}; - pub const CONSTRUCTOR_1: FunctionDef u32> = FunctionDef{address: 0x00620a90, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiview/constructor_0"))] + pub const CONSTRUCTOR_0: FunctionDef *const u32> = FunctionDef{address: 0x0052059c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiview/copy"))] + pub const COPY: FunctionDef *const u32> = FunctionDef{address: 0x0060a8d2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("uiview/constructor_1"))] + pub const CONSTRUCTOR_1: FunctionDef *const u32> = FunctionDef{address: 0x00620a90, function_type: PhantomData}; } // UpdateHandler class functions pub mod updatehandler { use super::*; - pub const PARSE_INDEX_0: FunctionDef = FunctionDef{address: 0x004ab2f7, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00624e20, function_type: PhantomData}; - pub const PRUNE_UPDATE_GROUPS: FunctionDef = FunctionDef{address: 0x00624fb6, function_type: PhantomData}; - pub const DESTINATION_FROM_URL: FunctionDef u32> = FunctionDef{address: 0x0062534b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/parse_index_0"))] + pub const PARSE_INDEX_0: FunctionDef = FunctionDef{address: 0x004ab2f7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00624e20, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/prune_update_groups"))] + pub const PRUNE_UPDATE_GROUPS: FunctionDef = FunctionDef{address: 0x00624fb6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/destination_from_url"))] + pub const DESTINATION_FROM_URL: FunctionDef *const u32> = FunctionDef{address: 0x0062534b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/is_item_downloaded"))] pub const IS_ITEM_DOWNLOADED: FunctionDef u32> = FunctionDef{address: 0x006256d2, function_type: PhantomData}; - pub const FINALIZE_UPDATES: FunctionDef = FunctionDef{address: 0x00625907, function_type: PhantomData}; - pub const MOVE_FILE_FROM_TMP: FunctionDef = FunctionDef{address: 0x00625a9b, function_type: PhantomData}; - pub const PARSE_INDEX_1: FunctionDef = FunctionDef{address: 0x00625d13, function_type: PhantomData}; - pub const START_INDEX_DOWNLOAD: FunctionDef = FunctionDef{address: 0x00626205, function_type: PhantomData}; - pub const START_DOWNLOAD: FunctionDef = FunctionDef{address: 0x00626247, function_type: PhantomData}; - pub const DOWNLOAD_FILE_GROUP: FunctionDef = FunctionDef{address: 0x00626350, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/finalize_updates"))] + pub const FINALIZE_UPDATES: FunctionDef = FunctionDef{address: 0x00625907, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/move_file_from_tmp"))] + pub const MOVE_FILE_FROM_TMP: FunctionDef = FunctionDef{address: 0x00625a9b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/parse_index_1"))] + pub const PARSE_INDEX_1: FunctionDef = FunctionDef{address: 0x00625d13, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/start_index_download"))] + pub const START_INDEX_DOWNLOAD: FunctionDef = FunctionDef{address: 0x00626205, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/start_download"))] + pub const START_DOWNLOAD: FunctionDef = FunctionDef{address: 0x00626247, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/download_file_group"))] + pub const DOWNLOAD_FILE_GROUP: FunctionDef = FunctionDef{address: 0x00626350, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/delete_bad_files"))] pub const DELETE_BAD_FILES: FunctionDef = FunctionDef{address: 0x006264bb, function_type: PhantomData}; - pub const NOTIFY_DONE: FunctionDef = FunctionDef{address: 0x006265c3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/cancel_download"))] + pub const CANCEL_DOWNLOAD: FunctionDef = FunctionDef{address: 0x006265a0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/notify_done"))] + pub const NOTIFY_DONE: FunctionDef = FunctionDef{address: 0x006265c3, function_type: PhantomData}; } // ZLibControl class functions pub mod zlibcontrol { use super::*; - pub const GET_BUFFER: FunctionDef = FunctionDef{address: 0x0040782e, function_type: PhantomData}; - pub const DECOMPRESS: FunctionDef u32> = FunctionDef{address: 0x00408c1f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zlibcontrol/get_buffer"))] + pub const GET_BUFFER: FunctionDef = FunctionDef{address: 0x0040782e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zlibcontrol/decompress"))] + pub const DECOMPRESS: FunctionDef u32> = FunctionDef{address: 0x00408c1f, function_type: PhantomData}; } // ZTAIMgr class functions pub mod ztaimgr { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_guest_routine_f"))] pub const F_GUEST_ROUTINE_F: FunctionDef = FunctionDef{address: 0x004224f5, function_type: PhantomData}; - pub const F_FACE_TOWARD_FOOD: FunctionDef u32> = FunctionDef{address: 0x0042662c, function_type: PhantomData}; - pub const F_FACE_TOWARD_FOOD_F: FunctionDef = FunctionDef{address: 0x00426665, function_type: PhantomData}; - pub const F_FACE_TOWARD_TARGET: FunctionDef u32> = FunctionDef{address: 0x00426e50, function_type: PhantomData}; - pub const F_FACE_TOWARD_TARGET_F: FunctionDef = FunctionDef{address: 0x00426ed9, function_type: PhantomData}; - pub const F_PLAY_SET_TERRAIN_F: FunctionDef u32> = FunctionDef{address: 0x004314d6, function_type: PhantomData}; - pub const EXECUTE_CALL: FunctionDef = FunctionDef{address: 0x00436065, function_type: PhantomData}; - pub const F_EXIT_BUILDING: FunctionDef = FunctionDef{address: 0x004a7744, function_type: PhantomData}; - pub const F_EXIT_BUILDING_F: FunctionDef = FunctionDef{address: 0x004a777e, function_type: PhantomData}; - pub const F_KEEPER_ROUTINE_F: FunctionDef = FunctionDef{address: 0x004a8763, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_face_toward_food"))] + pub const F_FACE_TOWARD_FOOD: FunctionDef u32> = FunctionDef{address: 0x0042662c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_face_toward_food_f"))] + pub const F_FACE_TOWARD_FOOD_F: FunctionDef = FunctionDef{address: 0x00426665, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_face_toward_target"))] + pub const F_FACE_TOWARD_TARGET: FunctionDef u32> = FunctionDef{address: 0x00426e50, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_face_toward_target_f"))] + pub const F_FACE_TOWARD_TARGET_F: FunctionDef = FunctionDef{address: 0x00426ed9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_play_set_terrain_f"))] + pub const F_PLAY_SET_TERRAIN_F: FunctionDef u32> = FunctionDef{address: 0x004314d6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/execute_call"))] + pub const EXECUTE_CALL: FunctionDef = FunctionDef{address: 0x00436065, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_exit_building"))] + pub const F_EXIT_BUILDING: FunctionDef = FunctionDef{address: 0x004a7744, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_exit_building_f"))] + pub const F_EXIT_BUILDING_F: FunctionDef = FunctionDef{address: 0x004a777e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_keeper_routine_f"))] + pub const F_KEEPER_ROUTINE_F: FunctionDef = FunctionDef{address: 0x004a8763, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_maint_routine_f"))] pub const F_MAINT_ROUTINE_F: FunctionDef = FunctionDef{address: 0x004a945f, function_type: PhantomData}; - pub const ZTAIMGR: FunctionDef u32> = FunctionDef{address: 0x00503857, function_type: PhantomData}; - pub const F_SHOW_PREDATOR: FunctionDef u32> = FunctionDef{address: 0x0050e6fa, function_type: PhantomData}; - pub const F_SHOW_PREDATOR_F: FunctionDef = FunctionDef{address: 0x0050e764, function_type: PhantomData}; - pub const F_HIDE_PREDATOR_F: FunctionDef = FunctionDef{address: 0x0050e879, function_type: PhantomData}; - pub const CREATE: FunctionDef = FunctionDef{address: 0x00525961, function_type: PhantomData}; - pub const INIT_AIPARAMS: FunctionDef = FunctionDef{address: 0x0052599f, function_type: PhantomData}; - pub const F_CAUGHT_PREY: FunctionDef u32> = FunctionDef{address: 0x00588c2d, function_type: PhantomData}; - pub const F_DUST_BALL: FunctionDef u32> = FunctionDef{address: 0x00588d47, function_type: PhantomData}; - pub const F_DUST_BALL_F: FunctionDef = FunctionDef{address: 0x00588f69, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/ztaimgr"))] + pub const ZTAIMGR: FunctionDef *const u32> = FunctionDef{address: 0x00503857, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_show_predator"))] + pub const F_SHOW_PREDATOR: FunctionDef u32> = FunctionDef{address: 0x0050e6fa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_show_predator_f"))] + pub const F_SHOW_PREDATOR_F: FunctionDef = FunctionDef{address: 0x0050e764, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_hide_predator_f"))] + pub const F_HIDE_PREDATOR_F: FunctionDef = FunctionDef{address: 0x0050e879, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/create"))] + pub const CREATE: FunctionDef u32> = FunctionDef{address: 0x00525961, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/init_aiparams"))] + pub const INIT_AIPARAMS: FunctionDef u32> = FunctionDef{address: 0x0052599f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_caught_prey"))] + pub const F_CAUGHT_PREY: FunctionDef u32> = FunctionDef{address: 0x00588c2d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_dust_ball"))] + pub const F_DUST_BALL: FunctionDef u32> = FunctionDef{address: 0x00588d47, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_dust_ball_f"))] + pub const F_DUST_BALL_F: FunctionDef = FunctionDef{address: 0x00588f69, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_guide_routine_f"))] pub const F_GUIDE_ROUTINE_F: FunctionDef = FunctionDef{address: 0x0058a998, function_type: PhantomData}; - pub const F_CAUGHT_PREY_F: FunctionDef = FunctionDef{address: 0x005a593f, function_type: PhantomData}; - pub const F_TARGET_BUILDING_F: FunctionDef u32> = FunctionDef{address: 0x005a5b71, function_type: PhantomData}; - pub const F_END_TRICK_F: FunctionDef = FunctionDef{address: 0x005a6a22, function_type: PhantomData}; - pub const F_ENTER_BUILDING_F: FunctionDef = FunctionDef{address: 0x005ad42c, function_type: PhantomData}; - pub const F_PLAY_SET_TANK_F: FunctionDef u32> = FunctionDef{address: 0x005b2be5, function_type: PhantomData}; - pub const F_SPRAY_F: FunctionDef = FunctionDef{address: 0x0060caad, function_type: PhantomData}; - pub const F_HATCH_F: FunctionDef = FunctionDef{address: 0x0060cacb, function_type: PhantomData}; - pub const F_HATCH: FunctionDef u32> = FunctionDef{address: 0x0060cae0, function_type: PhantomData}; - pub const F_KILL_PREY_F: FunctionDef = FunctionDef{address: 0x0060cb25, function_type: PhantomData}; - pub const F_KILL_PREY: FunctionDef u32> = FunctionDef{address: 0x0060cb3a, function_type: PhantomData}; - pub const F_DIE_F: FunctionDef = FunctionDef{address: 0x0060cbb3, function_type: PhantomData}; - pub const F_DIE: FunctionDef u32> = FunctionDef{address: 0x0060cbc8, function_type: PhantomData}; - pub const F_RETURN_TO_BUILDING_F: FunctionDef = FunctionDef{address: 0x0060cc66, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_caught_prey_f"))] + pub const F_CAUGHT_PREY_F: FunctionDef = FunctionDef{address: 0x005a593f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_target_building_f"))] + pub const F_TARGET_BUILDING_F: FunctionDef u32> = FunctionDef{address: 0x005a5b71, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_end_trick_f"))] + pub const F_END_TRICK_F: FunctionDef = FunctionDef{address: 0x005a6a22, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_enter_building_f"))] + pub const F_ENTER_BUILDING_F: FunctionDef = FunctionDef{address: 0x005ad42c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_play_set_tank_f"))] + pub const F_PLAY_SET_TANK_F: FunctionDef u32> = FunctionDef{address: 0x005b2be5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_spray_f"))] + pub const F_SPRAY_F: FunctionDef = FunctionDef{address: 0x0060caad, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_hatch_f"))] + pub const F_HATCH_F: FunctionDef = FunctionDef{address: 0x0060cacb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_hatch"))] + pub const F_HATCH: FunctionDef u32> = FunctionDef{address: 0x0060cae0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_kill_prey_f"))] + pub const F_KILL_PREY_F: FunctionDef = FunctionDef{address: 0x0060cb25, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_kill_prey"))] + pub const F_KILL_PREY: FunctionDef u32> = FunctionDef{address: 0x0060cb3a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_die_f"))] + pub const F_DIE_F: FunctionDef = FunctionDef{address: 0x0060cbb3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_die"))] + pub const F_DIE: FunctionDef u32> = FunctionDef{address: 0x0060cbc8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_return_to_building_f"))] + pub const F_RETURN_TO_BUILDING_F: FunctionDef = FunctionDef{address: 0x0060cc66, function_type: PhantomData}; } // ZTAdvTerrainMgr class functions pub mod ztadvterrainmgr { use super::*; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00419e14, function_type: PhantomData}; - pub const SETUP_RENDER: FunctionDef u32> = FunctionDef{address: 0x00463e60, function_type: PhantomData}; - pub const SET_GROUND_IMAGE: FunctionDef i8> = FunctionDef{address: 0x004ac218, function_type: PhantomData}; - pub const RENDER_SHAPE: FunctionDef u32> = FunctionDef{address: 0x004adff8, function_type: PhantomData}; - pub const RENDER_PASS: FunctionDef u32> = FunctionDef{address: 0x004ae4b3, function_type: PhantomData}; - pub const SET_AUX_IMAGE: FunctionDef = FunctionDef{address: 0x004aecb2, function_type: PhantomData}; - pub const SET_IMAGE: FunctionDef u32> = FunctionDef{address: 0x004aede5, function_type: PhantomData}; - pub const STOP: FunctionDef = FunctionDef{address: 0x005039cd, function_type: PhantomData}; - pub const STOP2D: FunctionDef = FunctionDef{address: 0x00503b7a, function_type: PhantomData}; - pub const ZTADV_TERRAIN_MGR_0: FunctionDef u32> = FunctionDef{address: 0x0050435b, function_type: PhantomData}; - pub const ZTADV_TERRAIN_MGR_1: FunctionDef u32> = FunctionDef{address: 0x0050458d, function_type: PhantomData}; - pub const START: FunctionDef u32> = FunctionDef{address: 0x00522470, function_type: PhantomData}; - pub const LOAD_TEXTURES_0: FunctionDef u32> = FunctionDef{address: 0x005224b9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00419e14, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/setup_render"))] + pub const SETUP_RENDER: FunctionDef u32> = FunctionDef{address: 0x00463e60, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/set_ground_image"))] + pub const SET_GROUND_IMAGE: FunctionDef i8> = FunctionDef{address: 0x004ac218, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/render_shape"))] + pub const RENDER_SHAPE: FunctionDef u32> = FunctionDef{address: 0x004adff8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/render_pass"))] + pub const RENDER_PASS: FunctionDef u32> = FunctionDef{address: 0x004ae4b3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/set_aux_image"))] + pub const SET_AUX_IMAGE: FunctionDef = FunctionDef{address: 0x004aecb2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/set_image"))] + pub const SET_IMAGE: FunctionDef u32> = FunctionDef{address: 0x004aede5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/stop"))] + pub const STOP: FunctionDef = FunctionDef{address: 0x005039cd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/stop2d"))] + pub const STOP2D: FunctionDef = FunctionDef{address: 0x00503b7a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/ztadv_terrain_mgr_0"))] + pub const ZTADV_TERRAIN_MGR_0: FunctionDef *const u32> = FunctionDef{address: 0x0050435b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/ztadv_terrain_mgr_1"))] + pub const ZTADV_TERRAIN_MGR_1: FunctionDef *const u32> = FunctionDef{address: 0x0050458d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/start"))] + pub const START: FunctionDef u32> = FunctionDef{address: 0x00522470, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/load_textures_0"))] + pub const LOAD_TEXTURES_0: FunctionDef u32> = FunctionDef{address: 0x005224b9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/load_textures_1"))] pub const LOAD_TEXTURES_1: FunctionDef = FunctionDef{address: 0x005228b3, function_type: PhantomData}; - pub const START2D: FunctionDef u32> = FunctionDef{address: 0x00522bd4, function_type: PhantomData}; - pub const START_D3D: FunctionDef u32> = FunctionDef{address: 0x00523ba3, function_type: PhantomData}; - pub const CREATE: FunctionDef = FunctionDef{address: 0x00525470, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef = FunctionDef{address: 0x005254af, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/start2d"))] + pub const START2D: FunctionDef u32> = FunctionDef{address: 0x00522bd4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/start_d3d"))] + pub const START_D3D: FunctionDef u32> = FunctionDef{address: 0x00523ba3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/create"))] + pub const CREATE: FunctionDef u32> = FunctionDef{address: 0x00525470, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x005254af, function_type: PhantomData}; } // ZTAmbient class functions pub mod ztambient { use super::*; - pub const ZTAMBIENT_0: FunctionDef u32> = FunctionDef{address: 0x00420519, function_type: PhantomData}; - pub const ZTAMBIENT_1: FunctionDef u32> = FunctionDef{address: 0x00420547, function_type: PhantomData}; - pub const CALC_SHADOW_WORLD_POSITION: FunctionDef = FunctionDef{address: 0x00433cad, function_type: PhantomData}; - pub const UPDATE_POSITION: FunctionDef = FunctionDef{address: 0x00434e9c, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00450261, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/ztambient_0"))] + pub const ZTAMBIENT_0: FunctionDef *const u32> = FunctionDef{address: 0x00420519, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/ztambient_1"))] + pub const ZTAMBIENT_1: FunctionDef *const u32> = FunctionDef{address: 0x00420547, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/calc_shadow_world_position"))] + pub const CALC_SHADOW_WORLD_POSITION: FunctionDef = FunctionDef{address: 0x00433cad, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/update_position"))] + pub const UPDATE_POSITION: FunctionDef = FunctionDef{address: 0x00434e9c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00450261, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047a7fd, function_type: PhantomData}; - pub const INIT: FunctionDef = FunctionDef{address: 0x004fc145, function_type: PhantomData}; - pub const INIT_STATUS_VARS: FunctionDef = FunctionDef{address: 0x004fc160, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004fc3aa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/init"))] + pub const INIT: FunctionDef = FunctionDef{address: 0x004fc145, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/init_status_vars"))] + pub const INIT_STATUS_VARS: FunctionDef = FunctionDef{address: 0x004fc160, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004fc3aa, function_type: PhantomData}; } // ZTAmbientType class functions pub mod ztambienttype { use super::*; - pub const LOAD_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x004c2ec9, function_type: PhantomData}; - pub const CREATE_ENTITY: FunctionDef = FunctionDef{address: 0x004fc358, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztambienttype/load_characteristics"))] + pub const LOAD_CHARACTERISTICS: FunctionDef u8> = FunctionDef{address: 0x004c2ec9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztambienttype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x004fc358, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztambienttype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x0051ca20, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051cd83, function_type: PhantomData}; - pub const ZTAMBIENT_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x0057cc85, function_type: PhantomData}; - pub const ZTAMBIENT_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x0057cccb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztambienttype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051cd83, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztambienttype/ztambient_type_0"))] + pub const ZTAMBIENT_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x0057cc85, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztambienttype/ztambient_type_1"))] + pub const ZTAMBIENT_TYPE_1: FunctionDef *const i32> = FunctionDef{address: 0x0057cccb, function_type: PhantomData}; } // ZTAnimal class functions pub mod ztanimal { use super::*; - pub const CALC_HABITAT: FunctionDef = FunctionDef{address: 0x00410675, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/calc_habitat"))] + pub const CALC_HABITAT: FunctionDef = FunctionDef{address: 0x00410675, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_swims"))] + pub const GET_SWIMS: FunctionDef u32> = FunctionDef{address: 0x004107d4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_footprint"))] pub const GET_FOOTPRINT: FunctionDef *const u32> = FunctionDef{address: 0x00410803, function_type: PhantomData}; - pub const GET_HABITAT_RATING: FunctionDef i32> = FunctionDef{address: 0x00411afd, function_type: PhantomData}; - pub const SET_HOME_HABITAT: FunctionDef = FunctionDef{address: 0x00411b92, function_type: PhantomData}; - pub const GET_IDLE_ANIM: FunctionDef i32> = FunctionDef{address: 0x00413582, function_type: PhantomData}; - pub const PREYS_ON_MAN: FunctionDef u32> = FunctionDef{address: 0x004138f0, function_type: PhantomData}; - pub const IS_IN_PREY_LIST: FunctionDef u32> = FunctionDef{address: 0x0041391d, function_type: PhantomData}; - pub const SET_TERRAIN_MODE: FunctionDef = FunctionDef{address: 0x004139c9, function_type: PhantomData}; - pub const GET_TERRAIN_COST: FunctionDef u32> = FunctionDef{address: 0x00414b13, function_type: PhantomData}; - pub const IS_WALKABLE: FunctionDef = FunctionDef{address: 0x00414c7f, function_type: PhantomData}; - pub const RECALC_HOME_HABITAT: FunctionDef = FunctionDef{address: 0x00416185, function_type: PhantomData}; - pub const IS_UNHAPPY_WITH_HABITAT: FunctionDef u32> = FunctionDef{address: 0x00418b8c, function_type: PhantomData}; - pub const FACE_TOWARD_FOOD: FunctionDef = FunctionDef{address: 0x0042661b, function_type: PhantomData}; - pub const IS_PREATTACK: FunctionDef u32> = FunctionDef{address: 0x0042fad3, function_type: PhantomData}; - pub const F_CHECK_REPRODUCTION: FunctionDef u32> = FunctionDef{address: 0x0043103b, function_type: PhantomData}; - pub const IS_WALKABLE_BY: FunctionDef u32> = FunctionDef{address: 0x00431696, function_type: PhantomData}; - pub const DRAW: FunctionDef = FunctionDef{address: 0x00433933, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00436f11, function_type: PhantomData}; - pub const UPDATE_POSITION: FunctionDef = FunctionDef{address: 0x00436f32, function_type: PhantomData}; - pub const UPDATE_GOALS: FunctionDef = FunctionDef{address: 0x00436f5c, function_type: PhantomData}; - pub const DO_AMBIENT_ANIMS: FunctionDef = FunctionDef{address: 0x00437102, function_type: PhantomData}; - pub const DO_CONDITIONALS: FunctionDef = FunctionDef{address: 0x00437620, function_type: PhantomData}; - pub const DO_BOXED_CHECK: FunctionDef u32> = FunctionDef{address: 0x004377fc, function_type: PhantomData}; - pub const DO_EGG_CHECK: FunctionDef = FunctionDef{address: 0x00437860, function_type: PhantomData}; - pub const UPDATE_STATUS_VARIABLES: FunctionDef = FunctionDef{address: 0x004378df, function_type: PhantomData}; - pub const DO_SLEEP_CHECK: FunctionDef = FunctionDef{address: 0x004384ba, function_type: PhantomData}; - pub const DO_ESCAPED_CHECK: FunctionDef = FunctionDef{address: 0x00438514, function_type: PhantomData}; - pub const DO_REPRODUCE_CHECK: FunctionDef = FunctionDef{address: 0x004385e5, function_type: PhantomData}; - pub const DO_BABY_TO_ADULT_CHECK: FunctionDef = FunctionDef{address: 0x00438663, function_type: PhantomData}; - pub const DO_SOCIAL_CHECK: FunctionDef = FunctionDef{address: 0x004386a9, function_type: PhantomData}; - pub const DO_HEALTH_CHECK: FunctionDef = FunctionDef{address: 0x004389aa, function_type: PhantomData}; - pub const DO_BREATH_CHECK: FunctionDef = FunctionDef{address: 0x004389f7, function_type: PhantomData}; - pub const DO_MURKY_WATER_CHECK: FunctionDef = FunctionDef{address: 0x00438a37, function_type: PhantomData}; - pub const DO_HUNGER_CHECK: FunctionDef = FunctionDef{address: 0x00438a79, function_type: PhantomData}; - pub const DO_BORED_CHECK: FunctionDef = FunctionDef{address: 0x00438ad7, function_type: PhantomData}; - pub const DO_HABITAT_CHECK: FunctionDef = FunctionDef{address: 0x00438c47, function_type: PhantomData}; - pub const DO_KEEPER_CHECK: FunctionDef = FunctionDef{address: 0x00438d31, function_type: PhantomData}; - pub const DO_OTHER_CHECK: FunctionDef = FunctionDef{address: 0x00438e70, function_type: PhantomData}; - pub const DO_ZAP_CHECK: FunctionDef u32> = FunctionDef{address: 0x00438ebc, function_type: PhantomData}; - pub const DO_BUILDING_USE_CHECK: FunctionDef u32> = FunctionDef{address: 0x00438f20, function_type: PhantomData}; - pub const DO_WATER_CHECK: FunctionDef u32> = FunctionDef{address: 0x00438f6c, function_type: PhantomData}; - pub const SET_ESCAPED: FunctionDef = FunctionDef{address: 0x004409f8, function_type: PhantomData}; - pub const ADD_TO_MAP: FunctionDef = FunctionDef{address: 0x00449c94, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00453cc6, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00455533, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_habitat_rating"))] + pub const GET_HABITAT_RATING: FunctionDef i64> = FunctionDef{address: 0x00411afd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/set_home_habitat"))] + pub const SET_HOME_HABITAT: FunctionDef = FunctionDef{address: 0x00411b92, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_idle_anim"))] + pub const GET_IDLE_ANIM: FunctionDef i32> = FunctionDef{address: 0x00413582, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/preys_on_man"))] + pub const PREYS_ON_MAN: FunctionDef u32> = FunctionDef{address: 0x004138f0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/is_in_prey_list"))] + pub const IS_IN_PREY_LIST: FunctionDef u32> = FunctionDef{address: 0x0041391d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/set_terrain_mode"))] + pub const SET_TERRAIN_MODE: FunctionDef = FunctionDef{address: 0x004139c9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_terrain_cost"))] + pub const GET_TERRAIN_COST: FunctionDef u32> = FunctionDef{address: 0x00414b13, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/is_walkable"))] + pub const IS_WALKABLE: FunctionDef u32> = FunctionDef{address: 0x00414c7f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/recalc_home_habitat"))] + pub const RECALC_HOME_HABITAT: FunctionDef = FunctionDef{address: 0x00416185, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/is_unhappy_with_habitat"))] + pub const IS_UNHAPPY_WITH_HABITAT: FunctionDef u32> = FunctionDef{address: 0x00418b8c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/face_toward_food"))] + pub const FACE_TOWARD_FOOD: FunctionDef = FunctionDef{address: 0x0042661b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/is_preattack"))] + pub const IS_PREATTACK: FunctionDef u32> = FunctionDef{address: 0x0042fad3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/f_check_reproduction"))] + pub const F_CHECK_REPRODUCTION: FunctionDef u32> = FunctionDef{address: 0x0043103b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/is_walkable_by"))] + pub const IS_WALKABLE_BY: FunctionDef u32> = FunctionDef{address: 0x00431696, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_only_swims"))] + pub const GET_ONLY_SWIMS: FunctionDef = FunctionDef{address: 0x00431b47, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/draw"))] + pub const DRAW: FunctionDef = FunctionDef{address: 0x00433933, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00436f11, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/update_position"))] + pub const UPDATE_POSITION: FunctionDef = FunctionDef{address: 0x00436f32, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/update_goals"))] + pub const UPDATE_GOALS: FunctionDef = FunctionDef{address: 0x00436f5c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_ambient_anims"))] + pub const DO_AMBIENT_ANIMS: FunctionDef = FunctionDef{address: 0x00437102, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_conditionals"))] + pub const DO_CONDITIONALS: FunctionDef = FunctionDef{address: 0x00437620, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_boxed_check"))] + pub const DO_BOXED_CHECK: FunctionDef *const u32> = FunctionDef{address: 0x004377fc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_egg_check"))] + pub const DO_EGG_CHECK: FunctionDef = FunctionDef{address: 0x00437860, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/update_status_variables"))] + pub const UPDATE_STATUS_VARIABLES: FunctionDef = FunctionDef{address: 0x004378df, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_sleep_check"))] + pub const DO_SLEEP_CHECK: FunctionDef = FunctionDef{address: 0x004384ba, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_escaped_check"))] + pub const DO_ESCAPED_CHECK: FunctionDef = FunctionDef{address: 0x00438514, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_reproduce_check"))] + pub const DO_REPRODUCE_CHECK: FunctionDef = FunctionDef{address: 0x004385e5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_baby_to_adult_check"))] + pub const DO_BABY_TO_ADULT_CHECK: FunctionDef = FunctionDef{address: 0x00438663, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_social_check"))] + pub const DO_SOCIAL_CHECK: FunctionDef = FunctionDef{address: 0x004386a9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_health_check"))] + pub const DO_HEALTH_CHECK: FunctionDef = FunctionDef{address: 0x004389aa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_breath_check"))] + pub const DO_BREATH_CHECK: FunctionDef = FunctionDef{address: 0x004389f7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_murky_water_check"))] + pub const DO_MURKY_WATER_CHECK: FunctionDef = FunctionDef{address: 0x00438a37, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_hunger_check"))] + pub const DO_HUNGER_CHECK: FunctionDef = FunctionDef{address: 0x00438a79, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_bored_check"))] + pub const DO_BORED_CHECK: FunctionDef = FunctionDef{address: 0x00438ad7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_habitat_check"))] + pub const DO_HABITAT_CHECK: FunctionDef = FunctionDef{address: 0x00438c47, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_keeper_check"))] + pub const DO_KEEPER_CHECK: FunctionDef = FunctionDef{address: 0x00438d31, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_other_check"))] + pub const DO_OTHER_CHECK: FunctionDef = FunctionDef{address: 0x00438e70, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_zap_check"))] + pub const DO_ZAP_CHECK: FunctionDef u32> = FunctionDef{address: 0x00438ebc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_building_use_check"))] + pub const DO_BUILDING_USE_CHECK: FunctionDef u32> = FunctionDef{address: 0x00438f20, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_water_check"))] + pub const DO_WATER_CHECK: FunctionDef *const c_void> = FunctionDef{address: 0x00438f6c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/set_visible"))] + pub const SET_VISIBLE: FunctionDef = FunctionDef{address: 0x0043f0d5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/set_escaped"))] + pub const SET_ESCAPED: FunctionDef = FunctionDef{address: 0x004409f8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/add_to_map"))] + pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x00449c94, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00453cc6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00455533, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/save"))] pub const SAVE: FunctionDef = FunctionDef{address: 0x00478cff, function_type: PhantomData}; - pub const GET_UNDESIRABLE_SCENERY_IN_HABITAT: FunctionDef u32> = FunctionDef{address: 0x00483979, function_type: PhantomData}; - pub const CHASE_DONE: FunctionDef = FunctionDef{address: 0x004a4d5f, function_type: PhantomData}; - pub const STOP_CHASE: FunctionDef = FunctionDef{address: 0x004a5e00, function_type: PhantomData}; - pub const PUT_DOWN_DIRT: FunctionDef bool> = FunctionDef{address: 0x004a8f89, function_type: PhantomData}; - pub const SET_NAME: FunctionDef = FunctionDef{address: 0x004e1d6b, function_type: PhantomData}; - pub const GET_ICON_ANIM: FunctionDef = FunctionDef{address: 0x004ee5be, function_type: PhantomData}; - pub const ZTANIMAL_0: FunctionDef u32> = FunctionDef{address: 0x004f9d83, function_type: PhantomData}; - pub const ZTANIMAL_1: FunctionDef u32> = FunctionDef{address: 0x004f9dac, function_type: PhantomData}; - pub const ZTANIMAL_2: FunctionDef u32> = FunctionDef{address: 0x004f9e18, function_type: PhantomData}; - pub const IS_SELECTABLE: FunctionDef = FunctionDef{address: 0x004fb70d, function_type: PhantomData}; - pub const STOP_EATING: FunctionDef = FunctionDef{address: 0x004fd86e, function_type: PhantomData}; - pub const F_EAT: FunctionDef u32> = FunctionDef{address: 0x004fd951, function_type: PhantomData}; - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004fe296, function_type: PhantomData}; - pub const BOX: FunctionDef u32> = FunctionDef{address: 0x00505941, function_type: PhantomData}; - pub const CONSUME: FunctionDef = FunctionDef{address: 0x0050e648, function_type: PhantomData}; - pub const WITHIN_PREATTACK_RANGE: FunctionDef u32> = FunctionDef{address: 0x0050eae2, function_type: PhantomData}; - pub const SHOW_ESCAPED_ANIMAL_ALERT: FunctionDef = FunctionDef{address: 0x0058cb88, function_type: PhantomData}; - pub const DROP_TEST_FENCE_CHANCE: FunctionDef = FunctionDef{address: 0x0059c4ba, function_type: PhantomData}; - pub const SET_EGG: FunctionDef = FunctionDef{address: 0x005a5283, function_type: PhantomData}; - pub const SET_DYING: FunctionDef = FunctionDef{address: 0x005a5606, function_type: PhantomData}; - pub const DRAW_AIINFO: FunctionDef = FunctionDef{address: 0x00613641, function_type: PhantomData}; - pub const BREAK_ESCAPE_FENCE: FunctionDef = FunctionDef{address: 0x006137fe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_undesirable_scenery_in_habitat"))] + pub const GET_UNDESIRABLE_SCENERY_IN_HABITAT: FunctionDef *const i32> = FunctionDef{address: 0x00483979, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/chase_done"))] + pub const CHASE_DONE: FunctionDef = FunctionDef{address: 0x004a4d5f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/stop_chase"))] + pub const STOP_CHASE: FunctionDef = FunctionDef{address: 0x004a5e00, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/put_down_dirt"))] + pub const PUT_DOWN_DIRT: FunctionDef bool> = FunctionDef{address: 0x004a8f89, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/set_name"))] + pub const SET_NAME: FunctionDef = FunctionDef{address: 0x004e1d6b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_icon_zoom"))] + pub const GET_ICON_ZOOM: FunctionDef i32> = FunctionDef{address: 0x004edb32, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_icon_anim"))] + pub const GET_ICON_ANIM: FunctionDef u32> = FunctionDef{address: 0x004ee5be, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/ztanimal_0"))] + pub const ZTANIMAL_0: FunctionDef *const u32> = FunctionDef{address: 0x004f9d83, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/ztanimal_1"))] + pub const ZTANIMAL_1: FunctionDef *const u32> = FunctionDef{address: 0x004f9dac, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/ztanimal_2"))] + pub const ZTANIMAL_2: FunctionDef *const u32> = FunctionDef{address: 0x004f9e18, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/is_selectable"))] + pub const IS_SELECTABLE: FunctionDef bool> = FunctionDef{address: 0x004fb70d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/stop_eating"))] + pub const STOP_EATING: FunctionDef = FunctionDef{address: 0x004fd86e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/f_eat"))] + pub const F_EAT: FunctionDef *const u32> = FunctionDef{address: 0x004fd951, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004fe296, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/box"))] + pub const BOX: FunctionDef u32> = FunctionDef{address: 0x00505941, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/consume"))] + pub const CONSUME: FunctionDef = FunctionDef{address: 0x0050e648, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/within_preattack_range"))] + pub const WITHIN_PREATTACK_RANGE: FunctionDef u32> = FunctionDef{address: 0x0050eae2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/show_escaped_animal_alert"))] + pub const SHOW_ESCAPED_ANIMAL_ALERT: FunctionDef = FunctionDef{address: 0x0058cb88, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/drop_test_fence_chance"))] + pub const DROP_TEST_FENCE_CHANCE: FunctionDef = FunctionDef{address: 0x0059c4ba, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/set_egg"))] + pub const SET_EGG: FunctionDef = FunctionDef{address: 0x005a5283, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/set_dying"))] + pub const SET_DYING: FunctionDef = FunctionDef{address: 0x005a5606, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/draw_aiinfo"))] + pub const DRAW_AIINFO: FunctionDef = FunctionDef{address: 0x00613641, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/break_escape_fence"))] + pub const BREAK_ESCAPE_FENCE: FunctionDef = FunctionDef{address: 0x006137fe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/change_to_dirt"))] pub const CHANGE_TO_DIRT: FunctionDef = FunctionDef{address: 0x00613c0c, function_type: PhantomData}; - pub const HATCH_EGG: FunctionDef = FunctionDef{address: 0x00613ca6, function_type: PhantomData}; - pub const FINISH_HATCH: FunctionDef = FunctionDef{address: 0x00613d24, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/hatch_egg"))] + pub const HATCH_EGG: FunctionDef = FunctionDef{address: 0x00613ca6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/finish_hatch"))] + pub const FINISH_HATCH: FunctionDef = FunctionDef{address: 0x00613d24, function_type: PhantomData}; } // ZTAnimalType class functions pub mod ztanimaltype { use super::*; - pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x00453d41, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS_0: FunctionDef = FunctionDef{address: 0x004b659e, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b6c51, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x00453d41, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/load_data"))] + pub const LOAD_DATA: FunctionDef = FunctionDef{address: 0x004b6381, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/set_idle_animation"))] + pub const SET_IDLE_ANIMATION: FunctionDef u32> = FunctionDef{address: 0x004b6456, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/load_characteristics_0"))] + pub const LOAD_CHARACTERISTICS_0: FunctionDef u8> = FunctionDef{address: 0x004b659e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/load_characteristics_1"))] + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b6c51, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x004be6ff, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004bece3, function_type: PhantomData}; - pub const ZTANIMAL_TYPE: FunctionDef u32> = FunctionDef{address: 0x00500be5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004bece3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/ztanimal_type"))] + pub const ZTANIMAL_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x00500be5, function_type: PhantomData}; } // ZTApp class functions pub mod ztapp { use super::*; - pub const GET_APP: FunctionDef u32> = FunctionDef{address: 0x004010c7, function_type: PhantomData}; - pub const REDRAW_SCREEN: FunctionDef = FunctionDef{address: 0x00419312, function_type: PhantomData}; - pub const UPDATE_UI: FunctionDef = FunctionDef{address: 0x00419d8c, function_type: PhantomData}; - pub const DO_EACH_LOOP: FunctionDef = FunctionDef{address: 0x0041a6cc, function_type: PhantomData}; - pub const UPDATE_SIM: FunctionDef = FunctionDef{address: 0x0041a6d1, function_type: PhantomData}; - pub const GET_SCREEN_CENTER: FunctionDef = FunctionDef{address: 0x0043f30d, function_type: PhantomData}; - pub const HANDLE_MESSAGES: FunctionDef i32> = FunctionDef{address: 0x00441880, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_app"))] + pub const GET_APP: FunctionDef *const u32> = FunctionDef{address: 0x004010c7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/redraw_screen"))] + pub const REDRAW_SCREEN: FunctionDef = FunctionDef{address: 0x00419312, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/update_ui"))] + pub const UPDATE_UI: FunctionDef = FunctionDef{address: 0x00419d8c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/do_each_loop"))] + pub const DO_EACH_LOOP: FunctionDef = FunctionDef{address: 0x0041a6cc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/update_sim"))] + pub const UPDATE_SIM: FunctionDef = FunctionDef{address: 0x0041a6d1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_screen_center"))] + pub const GET_SCREEN_CENTER: FunctionDef = FunctionDef{address: 0x0043f30d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/handle_messages"))] + pub const HANDLE_MESSAGES: FunctionDef u32> = FunctionDef{address: 0x00441880, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/handle_char2"))] pub const HANDLE_CHAR2: FunctionDef u32> = FunctionDef{address: 0x0046bdd6, function_type: PhantomData}; - pub const INIT_INSTANCE: FunctionDef = FunctionDef{address: 0x004bc17f, function_type: PhantomData}; - pub const RESTART_GRAPHICS_MGR: FunctionDef u32> = FunctionDef{address: 0x004caa0f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/init_instance"))] + pub const INIT_INSTANCE: FunctionDef u32> = FunctionDef{address: 0x004bc17f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/restart_graphics_mgr"))] + pub const RESTART_GRAPHICS_MGR: FunctionDef u32> = FunctionDef{address: 0x004caa0f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/reload_ui"))] pub const RELOAD_UI: FunctionDef = FunctionDef{address: 0x004d5a49, function_type: PhantomData}; - pub const TOGGLE_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d5c7f, function_type: PhantomData}; - pub const FORCE_REDRAW_0: FunctionDef = FunctionDef{address: 0x004d5dfe, function_type: PhantomData}; - pub const RESIZE_APP: FunctionDef = FunctionDef{address: 0x004d6dce, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/toggle_fullscreen"))] + pub const TOGGLE_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d5c7f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/force_redraw_0"))] + pub const FORCE_REDRAW_0: FunctionDef = FunctionDef{address: 0x004d5dfe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/resize_app"))] + pub const RESIZE_APP: FunctionDef = FunctionDef{address: 0x004d6dce, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/force_redraw_1"))] pub const FORCE_REDRAW_1: FunctionDef = FunctionDef{address: 0x004d6f85, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/handle_key_down"))] pub const HANDLE_KEY_DOWN: FunctionDef u32> = FunctionDef{address: 0x004f0b72, function_type: PhantomData}; - pub const EXIT_OVERRIDE: FunctionDef = FunctionDef{address: 0x00501303, function_type: PhantomData}; - pub const GET_AI: FunctionDef = FunctionDef{address: 0x00514ae1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/exit_override"))] + pub const EXIT_OVERRIDE: FunctionDef = FunctionDef{address: 0x00501303, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_ai"))] + pub const GET_AI: FunctionDef *const u32> = FunctionDef{address: 0x00514ae1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/toggle_entity_visibility"))] pub const TOGGLE_ENTITY_VISIBILITY: FunctionDef = FunctionDef{address: 0x0052df81, function_type: PhantomData}; - pub const GET_NEXT_SCREENSHOT_NAME: FunctionDef = FunctionDef{address: 0x005330cd, function_type: PhantomData}; - pub const LOAD_TYPEDATA: FunctionDef = FunctionDef{address: 0x0053768a, function_type: PhantomData}; - pub const TOGGLE_CURSORS: FunctionDef = FunctionDef{address: 0x0060442d, function_type: PhantomData}; - pub const GET_UPDATE_TIME: FunctionDef = FunctionDef{address: 0x00604480, function_type: PhantomData}; - pub const GET_WORLD: FunctionDef = FunctionDef{address: 0x006206bc, function_type: PhantomData}; - pub const GET_GAME: FunctionDef = FunctionDef{address: 0x006206c2, function_type: PhantomData}; - pub const GET_SCENARIO: FunctionDef = FunctionDef{address: 0x006206c8, function_type: PhantomData}; - pub const GET_SCRIPT: FunctionDef = FunctionDef{address: 0x006206ce, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_next_screenshot_name"))] + pub const GET_NEXT_SCREENSHOT_NAME: FunctionDef = FunctionDef{address: 0x005330cd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/load_typedata"))] + pub const LOAD_TYPEDATA: FunctionDef = FunctionDef{address: 0x0053768a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/toggle_cursors"))] + pub const TOGGLE_CURSORS: FunctionDef = FunctionDef{address: 0x0060442d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_update_time"))] + pub const GET_UPDATE_TIME: FunctionDef u32> = FunctionDef{address: 0x00604480, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_world"))] + pub const GET_WORLD: FunctionDef *const u32> = FunctionDef{address: 0x006206bc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_game"))] + pub const GET_GAME: FunctionDef *const u32> = FunctionDef{address: 0x006206c2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_scenario"))] + pub const GET_SCENARIO: FunctionDef *const u32> = FunctionDef{address: 0x006206c8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_script"))] + pub const GET_SCRIPT: FunctionDef *const u32> = FunctionDef{address: 0x006206ce, function_type: PhantomData}; +} + +// ZTAssignHabitatMode class functions +pub mod ztassignhabitatmode { + use super::*; + + #[cfg_attr(feature = "detour-validation", validate_detour("ztassignhabitatmode/check_mouse_over_entity"))] + pub const CHECK_MOUSE_OVER_ENTITY: FunctionDef = FunctionDef{address: 0x00471d52, function_type: PhantomData}; } // ZTAwardMgr class functions pub mod ztawardmgr { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztawardmgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047a064, function_type: PhantomData}; - pub const START: FunctionDef u32> = FunctionDef{address: 0x005141e1, function_type: PhantomData}; - pub const GET_AWARD: FunctionDef i32> = FunctionDef{address: 0x005a12ec, function_type: PhantomData}; - pub const ADD_AWARD: FunctionDef = FunctionDef{address: 0x005a13ed, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztawardmgr/start"))] + pub const START: FunctionDef u32> = FunctionDef{address: 0x005141e1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztawardmgr/get_award"))] + pub const GET_AWARD: FunctionDef i32> = FunctionDef{address: 0x005a12ec, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztawardmgr/add_award"))] + pub const ADD_AWARD: FunctionDef = FunctionDef{address: 0x005a13ed, function_type: PhantomData}; } // ZTBuilding class functions pub mod ztbuilding { use super::*; - pub const USER_DATA_CHANGED: FunctionDef = FunctionDef{address: 0x00412513, function_type: PhantomData}; - pub const FORCE_DEAD_ANIM: FunctionDef = FunctionDef{address: 0x004174dd, function_type: PhantomData}; - pub const MIGHT_START_AMBIENT_SOUND: FunctionDef = FunctionDef{address: 0x0041e3f8, function_type: PhantomData}; - pub const HAS_OPEN_SLOT: FunctionDef u32> = FunctionDef{address: 0x00429330, function_type: PhantomData}; - pub const GX_POS_FROM_XYPOS_0: FunctionDef = FunctionDef{address: 0x0042a10c, function_type: PhantomData}; - pub const GET_VALID_EXIT: FunctionDef u32> = FunctionDef{address: 0x0042aad5, function_type: PhantomData}; - pub const CAN_ADD_USER: FunctionDef u32> = FunctionDef{address: 0x0042ac87, function_type: PhantomData}; - pub const GX_POS_FROM_XYPOS_1: FunctionDef u32> = FunctionDef{address: 0x0042afd4, function_type: PhantomData}; - pub const GET_SLOT_ENTRANCES: FunctionDef u32> = FunctionDef{address: 0x0042b101, function_type: PhantomData}; - pub const GET_VALID_ENTRANCE_FOR_EXIT: FunctionDef u32> = FunctionDef{address: 0x0042b350, function_type: PhantomData}; - pub const FIND_NEAREST_OPEN_SLOT: FunctionDef u32> = FunctionDef{address: 0x0042c02b, function_type: PhantomData}; - pub const MIGHT_START_USE_SOUND: FunctionDef = FunctionDef{address: 0x0042cc1a, function_type: PhantomData}; - pub const ADD_USER: FunctionDef u32> = FunctionDef{address: 0x0042ce0a, function_type: PhantomData}; - pub const MIGHT_START_USE_ANIMATION: FunctionDef = FunctionDef{address: 0x0042d01c, function_type: PhantomData}; - pub const REMOVE_ITEMS: FunctionDef u8> = FunctionDef{address: 0x0042d181, function_type: PhantomData}; - pub const BUY_ITEM: FunctionDef u32> = FunctionDef{address: 0x0042d1e2, function_type: PhantomData}; - pub const REMOVE_USER: FunctionDef u32> = FunctionDef{address: 0x0042d858, function_type: PhantomData}; - pub const YANK_USER: FunctionDef u32> = FunctionDef{address: 0x0042da64, function_type: PhantomData}; - pub const DRAW_0: FunctionDef = FunctionDef{address: 0x00433aaf, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00434c4b, function_type: PhantomData}; - pub const UPDATE_RANDOM_USE_TIMER: FunctionDef = FunctionDef{address: 0x00434d2a, function_type: PhantomData}; - pub const RESET_INFO: FunctionDef = FunctionDef{address: 0x00450dbf, function_type: PhantomData}; - pub const RESET_CONSTRUCTION_DATE: FunctionDef = FunctionDef{address: 0x00450edd, function_type: PhantomData}; - pub const INIT_STATUS_VARS: FunctionDef = FunctionDef{address: 0x00450f17, function_type: PhantomData}; - pub const LOAD: FunctionDef = FunctionDef{address: 0x0045184a, function_type: PhantomData}; - pub const ADD_MEMBER: FunctionDef = FunctionDef{address: 0x0048cd9b, function_type: PhantomData}; - pub const PLAY_USE_ANIMATION: FunctionDef = FunctionDef{address: 0x004a067b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/user_data_changed"))] + pub const USER_DATA_CHANGED: FunctionDef = FunctionDef{address: 0x00412513, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/force_dead_anim"))] + pub const FORCE_DEAD_ANIM: FunctionDef = FunctionDef{address: 0x004174dd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/might_start_ambient_sound"))] + pub const MIGHT_START_AMBIENT_SOUND: FunctionDef = FunctionDef{address: 0x0041e3f8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/has_open_slot"))] + pub const HAS_OPEN_SLOT: FunctionDef u32> = FunctionDef{address: 0x00429330, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/gx_pos_from_xypos_0"))] + pub const GX_POS_FROM_XYPOS_0: FunctionDef = FunctionDef{address: 0x0042a10c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_valid_exit"))] + pub const GET_VALID_EXIT: FunctionDef u32> = FunctionDef{address: 0x0042aad5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/can_add_user"))] + pub const CAN_ADD_USER: FunctionDef u32> = FunctionDef{address: 0x0042ac87, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/gx_pos_from_xypos_1"))] + pub const GX_POS_FROM_XYPOS_1: FunctionDef *const u32> = FunctionDef{address: 0x0042afd4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_slot_entrances"))] + pub const GET_SLOT_ENTRANCES: FunctionDef *const u32> = FunctionDef{address: 0x0042b101, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_valid_entrance_for_exit"))] + pub const GET_VALID_ENTRANCE_FOR_EXIT: FunctionDef u32> = FunctionDef{address: 0x0042b350, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/find_nearest_open_slot"))] + pub const FIND_NEAREST_OPEN_SLOT: FunctionDef u32> = FunctionDef{address: 0x0042c02b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/might_start_use_sound"))] + pub const MIGHT_START_USE_SOUND: FunctionDef = FunctionDef{address: 0x0042cc1a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/add_user"))] + pub const ADD_USER: FunctionDef u32> = FunctionDef{address: 0x0042ce0a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/might_start_use_animation"))] + pub const MIGHT_START_USE_ANIMATION: FunctionDef = FunctionDef{address: 0x0042d01c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/remove_items"))] + pub const REMOVE_ITEMS: FunctionDef u8> = FunctionDef{address: 0x0042d181, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/buy_item"))] + pub const BUY_ITEM: FunctionDef u32> = FunctionDef{address: 0x0042d1e2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/remove_user"))] + pub const REMOVE_USER: FunctionDef u32> = FunctionDef{address: 0x0042d858, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/yank_user"))] + pub const YANK_USER: FunctionDef u32> = FunctionDef{address: 0x0042da64, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/draw_0"))] + pub const DRAW_0: FunctionDef = FunctionDef{address: 0x00433aaf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_aiinfo_on"))] + pub const GET_AIINFO_ON: FunctionDef u32> = FunctionDef{address: 0x00433b0e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00434c4b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/update_random_use_timer"))] + pub const UPDATE_RANDOM_USE_TIMER: FunctionDef = FunctionDef{address: 0x00434d2a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/reset_info"))] + pub const RESET_INFO: FunctionDef = FunctionDef{address: 0x00450dbf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/reset_construction_date"))] + pub const RESET_CONSTRUCTION_DATE: FunctionDef = FunctionDef{address: 0x00450edd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/init_status_vars"))] + pub const INIT_STATUS_VARS: FunctionDef = FunctionDef{address: 0x00450f17, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00451152, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/add_to_map"))] + pub const ADD_TO_MAP: FunctionDef u8> = FunctionDef{address: 0x0045158c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/load"))] + pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x0045184a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/add_member"))] + pub const ADD_MEMBER: FunctionDef = FunctionDef{address: 0x0048cd9b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/play_use_animation"))] + pub const PLAY_USE_ANIMATION: FunctionDef = FunctionDef{address: 0x004a067b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/receive_income"))] pub const RECEIVE_INCOME: FunctionDef = FunctionDef{address: 0x004a2e96, function_type: PhantomData}; - pub const GET_SLOT_EXIT: FunctionDef = FunctionDef{address: 0x004a705e, function_type: PhantomData}; - pub const EXIT_VIA_EXIT: FunctionDef u8> = FunctionDef{address: 0x004a75bb, function_type: PhantomData}; - pub const INIT_RANDOM_USE_TIMER: FunctionDef = FunctionDef{address: 0x004ab763, function_type: PhantomData}; - pub const MIGHT_STOP_AMBIENT_SOUND: FunctionDef = FunctionDef{address: 0x004b0bca, function_type: PhantomData}; - pub const DROP: FunctionDef = FunctionDef{address: 0x004e5282, function_type: PhantomData}; - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x0050023a, function_type: PhantomData}; - pub const CALCULATE_WATER_CAPACITY: FunctionDef i32> = FunctionDef{address: 0x0059398a, function_type: PhantomData}; - pub const INIT_AFTER_LOAD: FunctionDef = FunctionDef{address: 0x00593fd3, function_type: PhantomData}; - pub const REMOVE_USER_IF_PRESENT: FunctionDef u32> = FunctionDef{address: 0x0059be7b, function_type: PhantomData}; - pub const GET_FUN_GIFT_IF_AVAILABLE: FunctionDef u32> = FunctionDef{address: 0x0059cd02, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_slot_exit"))] + pub const GET_SLOT_EXIT: FunctionDef = FunctionDef{address: 0x004a705e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/exit_via_exit"))] + pub const EXIT_VIA_EXIT: FunctionDef u8> = FunctionDef{address: 0x004a75bb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/draw_underwater_section"))] + pub const DRAW_UNDERWATER_SECTION: FunctionDef = FunctionDef{address: 0x004a7972, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/init_random_use_timer"))] + pub const INIT_RANDOM_USE_TIMER: FunctionDef = FunctionDef{address: 0x004ab763, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/might_stop_ambient_sound"))] + pub const MIGHT_STOP_AMBIENT_SOUND: FunctionDef = FunctionDef{address: 0x004b0bca, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/drop"))] + pub const DROP: FunctionDef = FunctionDef{address: 0x004e5282, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x0050023a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/calculate_water_capacity"))] + pub const CALCULATE_WATER_CAPACITY: FunctionDef i32> = FunctionDef{address: 0x0059398a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/init_after_load"))] + pub const INIT_AFTER_LOAD: FunctionDef = FunctionDef{address: 0x00593fd3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/remove_user_if_present"))] + pub const REMOVE_USER_IF_PRESENT: FunctionDef u32> = FunctionDef{address: 0x0059be7b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_fun_gift_if_available"))] + pub const GET_FUN_GIFT_IF_AVAILABLE: FunctionDef u32> = FunctionDef{address: 0x0059cd02, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/draw_1"))] pub const DRAW_1: FunctionDef = FunctionDef{address: 0x0059fb8f, function_type: PhantomData}; - pub const REMOVE_MEMBER: FunctionDef = FunctionDef{address: 0x005a08ac, function_type: PhantomData}; - pub const GET_SLOT_DRAW_LOC: FunctionDef = FunctionDef{address: 0x005a954d, function_type: PhantomData}; - pub const GET_SLOT_FACING: FunctionDef u32> = FunctionDef{address: 0x005ad288, function_type: PhantomData}; - pub const GET_SLOT_LOC: FunctionDef = FunctionDef{address: 0x005ad347, function_type: PhantomData}; - pub const GET_SLOT_HAS_DRAW_SLOTS: FunctionDef u32> = FunctionDef{address: 0x005ad441, function_type: PhantomData}; - pub const REMOVE_ALL_USERS: FunctionDef = FunctionDef{address: 0x005ae745, function_type: PhantomData}; - pub const YANK_USER_IF_PRESENT: FunctionDef u32> = FunctionDef{address: 0x00611a98, function_type: PhantomData}; - pub const TURN_TO_RUBBLE: FunctionDef = FunctionDef{address: 0x00611bd6, function_type: PhantomData}; - pub const EMPTY_GRANDSTANDS: FunctionDef = FunctionDef{address: 0x006127b8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/remove_member"))] + pub const REMOVE_MEMBER: FunctionDef = FunctionDef{address: 0x005a08ac, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_slot_draw_loc"))] + pub const GET_SLOT_DRAW_LOC: FunctionDef = FunctionDef{address: 0x005a954d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_slot_facing"))] + pub const GET_SLOT_FACING: FunctionDef u32> = FunctionDef{address: 0x005ad288, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_slot_loc"))] + pub const GET_SLOT_LOC: FunctionDef = FunctionDef{address: 0x005ad347, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_slot_has_draw_slots"))] + pub const GET_SLOT_HAS_DRAW_SLOTS: FunctionDef u32> = FunctionDef{address: 0x005ad441, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/remove_all_users"))] + pub const REMOVE_ALL_USERS: FunctionDef = FunctionDef{address: 0x005ae745, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/yank_user_if_present"))] + pub const YANK_USER_IF_PRESENT: FunctionDef u32> = FunctionDef{address: 0x00611a98, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/turn_to_rubble"))] + pub const TURN_TO_RUBBLE: FunctionDef = FunctionDef{address: 0x00611bd6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/empty_grandstands"))] + pub const EMPTY_GRANDSTANDS: FunctionDef = FunctionDef{address: 0x006127b8, function_type: PhantomData}; } // ZTBuilding::Slot class functions pub mod ztbuilding_slot { use super::*; - pub const REMOVE_DRAW_USER: FunctionDef = FunctionDef{address: 0x0042dcd7, function_type: PhantomData}; - pub const GET_TOP_USER: FunctionDef u32> = FunctionDef{address: 0x004a7412, function_type: PhantomData}; - pub const ADD_DRAW_USER: FunctionDef = FunctionDef{address: 0x005a93fe, function_type: PhantomData}; - pub const SET_TOP_USER: FunctionDef u32> = FunctionDef{address: 0x005ac37c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding_slot/remove_draw_user"))] + pub const REMOVE_DRAW_USER: FunctionDef = FunctionDef{address: 0x0042dcd7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding_slot/clear_draw_users"))] + pub const CLEAR_DRAW_USERS: FunctionDef = FunctionDef{address: 0x00450f08, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding_slot/get_top_user"))] + pub const GET_TOP_USER: FunctionDef u32> = FunctionDef{address: 0x004a7412, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding_slot/add_draw_user"))] + pub const ADD_DRAW_USER: FunctionDef = FunctionDef{address: 0x005a93fe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding_slot/set_top_user"))] + pub const SET_TOP_USER: FunctionDef u32> = FunctionDef{address: 0x005ac37c, function_type: PhantomData}; } // ZTBuildingType class functions pub mod ztbuildingtype { use super::*; - pub const GET_SLOT_ENTRANCES: FunctionDef u32> = FunctionDef{address: 0x0042b29f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/get_slot_entrances"))] + pub const GET_SLOT_ENTRANCES: FunctionDef *const u32> = FunctionDef{address: 0x0042b29f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x0045134e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x0045e8f2, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0045ecdf, function_type: PhantomData}; - pub const GET_SLOT_IS_EXIT_ON_WATER: FunctionDef u32> = FunctionDef{address: 0x004a4a0f, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x004c042c, function_type: PhantomData}; - pub const ADD_UPGRADE: FunctionDef = FunctionDef{address: 0x0058ff14, function_type: PhantomData}; - pub const REMOVE_UPGRADE: FunctionDef = FunctionDef{address: 0x0059012d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0045ecdf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/get_slot_is_exit_on_water"))] + pub const GET_SLOT_IS_EXIT_ON_WATER: FunctionDef u32> = FunctionDef{address: 0x004a4a0f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/load_characteristics"))] + pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004c042c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/load_color_rep_info"))] + pub const LOAD_COLOR_REP_INFO: FunctionDef u32> = FunctionDef{address: 0x004c195d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/add_upgrade"))] + pub const ADD_UPGRADE: FunctionDef = FunctionDef{address: 0x0058ff14, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/remove_upgrade"))] + pub const REMOVE_UPGRADE: FunctionDef = FunctionDef{address: 0x0059012d, function_type: PhantomData}; } // ZTCheat class functions pub mod ztcheat { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztcheat/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x00435282, function_type: PhantomData}; - pub const RENAME_ENTITY: FunctionDef = FunctionDef{address: 0x0044940b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztcheat/rename_entity"))] + pub const RENAME_ENTITY: FunctionDef = FunctionDef{address: 0x0044940b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztcheat/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047a10c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztcheat/clear"))] pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6a3e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztcheat/guest_enters"))] pub const GUEST_ENTERS: FunctionDef = FunctionDef{address: 0x004f7ebe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztcheat/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x00514554, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztcheat/you_get"))] pub const YOU_GET: FunctionDef = FunctionDef{address: 0x00591325, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztcheat/start_of_game"))] pub const START_OF_GAME: FunctionDef = FunctionDef{address: 0x00591426, function_type: PhantomData}; - pub const RENAME_EXHIBIT: FunctionDef = FunctionDef{address: 0x005aee66, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztcheat/rename_exhibit"))] + pub const RENAME_EXHIBIT: FunctionDef = FunctionDef{address: 0x005aee66, function_type: PhantomData}; } // ZTFence class functions pub mod ztfence { use super::*; - pub const SET_ANIMATION: FunctionDef = FunctionDef{address: 0x00416ee8, function_type: PhantomData}; - pub const GET_ESTHETIC_BONUS: FunctionDef = FunctionDef{address: 0x0041fb50, function_type: PhantomData}; - pub const UPDATE_ANIMATION: FunctionDef = FunctionDef{address: 0x00434ad7, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00434b1d, function_type: PhantomData}; - pub const ZTFENCE_0: FunctionDef u32> = FunctionDef{address: 0x00443f37, function_type: PhantomData}; - pub const ZTFENCE_1: FunctionDef u32> = FunctionDef{address: 0x00443f57, function_type: PhantomData}; - pub const DIRTY_HABITAT_ESCAPABILITY: FunctionDef = FunctionDef{address: 0x00449ab4, function_type: PhantomData}; - pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x00449fb2, function_type: PhantomData}; - pub const ADD_TO_MAP: FunctionDef = FunctionDef{address: 0x0044cb57, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044ff2d, function_type: PhantomData}; - pub const MAKE_GATE: FunctionDef = FunctionDef{address: 0x0046600c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/set_animation"))] + pub const SET_ANIMATION: FunctionDef = FunctionDef{address: 0x00416ee8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/get_esthetic_bonus"))] + pub const GET_ESTHETIC_BONUS: FunctionDef *const i32> = FunctionDef{address: 0x0041fb50, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/update_animation"))] + pub const UPDATE_ANIMATION: FunctionDef = FunctionDef{address: 0x00434ad7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00434b1d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/ztfence_0"))] + pub const ZTFENCE_0: FunctionDef *const u32> = FunctionDef{address: 0x00443f37, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/ztfence_1"))] + pub const ZTFENCE_1: FunctionDef *const u32> = FunctionDef{address: 0x00443f57, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/dirty_habitat_escapability"))] + pub const DIRTY_HABITAT_ESCAPABILITY: FunctionDef = FunctionDef{address: 0x00449ab4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/validate_position"))] + pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x00449fb2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/add_to_map"))] + pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x0044cb57, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044ff2d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/make_gate"))] + pub const MAKE_GATE: FunctionDef = FunctionDef{address: 0x0046600c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00477e25, function_type: PhantomData}; - pub const CAN_DETERIORATE: FunctionDef u32> = FunctionDef{address: 0x004857b9, function_type: PhantomData}; - pub const SET_BROKEN: FunctionDef = FunctionDef{address: 0x004858a4, function_type: PhantomData}; - pub const MORPH: FunctionDef = FunctionDef{address: 0x0048676c, function_type: PhantomData}; - pub const GET_MWTILE: FunctionDef u32> = FunctionDef{address: 0x0049e3e2, function_type: PhantomData}; - pub const MAKE_FENCE: FunctionDef = FunctionDef{address: 0x004f93da, function_type: PhantomData}; - pub const GET_SELL_PRICE: FunctionDef f32> = FunctionDef{address: 0x004f945b, function_type: PhantomData}; - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004ffd6e, function_type: PhantomData}; - pub const INIT_AFTER_LOAD: FunctionDef = FunctionDef{address: 0x00594060, function_type: PhantomData}; - pub const GET_HEIGHT: FunctionDef = FunctionDef{address: 0x005997fa, function_type: PhantomData}; - pub const SET_HEALTHY: FunctionDef = FunctionDef{address: 0x005b391c, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x005b3a04, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/can_deteriorate"))] + pub const CAN_DETERIORATE: FunctionDef u32> = FunctionDef{address: 0x004857b9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/set_broken"))] + pub const SET_BROKEN: FunctionDef = FunctionDef{address: 0x004858a4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/morph"))] + pub const MORPH: FunctionDef = FunctionDef{address: 0x0048676c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/get_mwtile"))] + pub const GET_MWTILE: FunctionDef *const c_void> = FunctionDef{address: 0x0049e3e2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/make_fence"))] + pub const MAKE_FENCE: FunctionDef = FunctionDef{address: 0x004f93da, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/get_sell_price"))] + pub const GET_SELL_PRICE: FunctionDef f32> = FunctionDef{address: 0x004f945b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004ffd6e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/init_after_load"))] + pub const INIT_AFTER_LOAD: FunctionDef = FunctionDef{address: 0x00594060, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/get_height"))] + pub const GET_HEIGHT: FunctionDef u32> = FunctionDef{address: 0x005997fa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/set_healthy"))] + pub const SET_HEALTHY: FunctionDef = FunctionDef{address: 0x005b391c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x005b3a04, function_type: PhantomData}; } // ZTFenceType class functions pub mod ztfencetype { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfencetype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x004606f3, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004bb6f6, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004bb8ed, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004bf505, function_type: PhantomData}; - pub const ZTFENCE_TYPE: FunctionDef u32> = FunctionDef{address: 0x0050118e, function_type: PhantomData}; - pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x005b3a55, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfencetype/load_characteristics_0"))] + pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004bb6f6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfencetype/load_characteristics_1"))] + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004bb8ed, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfencetype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004bf505, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfencetype/ztfence_type"))] + pub const ZTFENCE_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x0050118e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfencetype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const i32> = FunctionDef{address: 0x005b3a55, function_type: PhantomData}; } // ZTFood class functions pub mod ztfood { use super::*; - pub const ZTFOOD_0: FunctionDef u32> = FunctionDef{address: 0x0041e080, function_type: PhantomData}; - pub const ZTFOOD_1: FunctionDef u32> = FunctionDef{address: 0x004f9f46, function_type: PhantomData}; - pub const ZTFOOD_2: FunctionDef u32> = FunctionDef{address: 0x004f9f64, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004fd1be, function_type: PhantomData}; - pub const CHANGED_FOOD_VALUE: FunctionDef = FunctionDef{address: 0x004fd3c1, function_type: PhantomData}; - pub const GET_FULLNESS: FunctionDef u32> = FunctionDef{address: 0x004fd494, function_type: PhantomData}; - pub const SET_ANIMATION: FunctionDef = FunctionDef{address: 0x004fd512, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfood/ztfood_0"))] + pub const ZTFOOD_0: FunctionDef *const u32> = FunctionDef{address: 0x0041e080, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfood/ztfood_1"))] + pub const ZTFOOD_1: FunctionDef *const u32> = FunctionDef{address: 0x004f9f46, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfood/ztfood_2"))] + pub const ZTFOOD_2: FunctionDef *const u32> = FunctionDef{address: 0x004f9f64, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfood/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004fd1be, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfood/changed_food_value"))] + pub const CHANGED_FOOD_VALUE: FunctionDef = FunctionDef{address: 0x004fd3c1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfood/get_fullness"))] + pub const GET_FULLNESS: FunctionDef u32> = FunctionDef{address: 0x004fd494, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfood/set_animation"))] + pub const SET_ANIMATION: FunctionDef = FunctionDef{address: 0x004fd512, function_type: PhantomData}; } // ZTFoodType class functions pub mod ztfoodtype { use super::*; - pub const GET_CLASS: FunctionDef = FunctionDef{address: 0x00401fa4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfoodtype/get_class"))] + pub const GET_CLASS: FunctionDef *const u32> = FunctionDef{address: 0x00401fa4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfoodtype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x004653d6, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00465634, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x004c2473, function_type: PhantomData}; - pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004fd1de, function_type: PhantomData}; - pub const ZTFOOD_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x00504c06, function_type: PhantomData}; - pub const ZTFOOD_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x00504c24, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfoodtype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00465634, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfoodtype/load_characteristics"))] + pub const LOAD_CHARACTERISTICS: FunctionDef u8> = FunctionDef{address: 0x004c2473, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfoodtype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const i32> = FunctionDef{address: 0x004fd1de, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfoodtype/ztfood_type_0"))] + pub const ZTFOOD_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x00504c06, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztfoodtype/ztfood_type_1"))] + pub const ZTFOOD_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x00504c24, function_type: PhantomData}; } // ZTGameMgr class functions pub mod ztgamemgr { use super::*; - pub const GET_DATE: FunctionDef u32> = FunctionDef{address: 0x0040e7e0, function_type: PhantomData}; - pub const ADD_CASH: FunctionDef = FunctionDef{address: 0x0040f018, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/get_date"))] + pub const GET_DATE: FunctionDef *const i64> = FunctionDef{address: 0x0040e7e0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/add_cash"))] + pub const ADD_CASH: FunctionDef = FunctionDef{address: 0x0040f018, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/is_real_world_date"))] pub const IS_REAL_WORLD_DATE: FunctionDef u32> = FunctionDef{address: 0x00412c22, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a154, function_type: PhantomData}; - pub const SUBTRACT_CASH: FunctionDef = FunctionDef{address: 0x0041ef68, function_type: PhantomData}; - pub const HOURS_AGO: FunctionDef u64> = FunctionDef{address: 0x0041f075, function_type: PhantomData}; - pub const TIME_AGO: FunctionDef u32> = FunctionDef{address: 0x0042620a, function_type: PhantomData}; - pub const UPDATE_SIM: FunctionDef = FunctionDef{address: 0x00435055, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a154, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/subtract_cash"))] + pub const SUBTRACT_CASH: FunctionDef = FunctionDef{address: 0x0041ef68, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/hours_ago"))] + pub const HOURS_AGO: FunctionDef u64> = FunctionDef{address: 0x0041f075, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/time_ago"))] + pub const TIME_AGO: FunctionDef *const f32> = FunctionDef{address: 0x0042620a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/update_sim"))] + pub const UPDATE_SIM: FunctionDef = FunctionDef{address: 0x00435055, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047acc5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/removed_zoo_doo"))] pub const REMOVED_ZOO_DOO: FunctionDef = FunctionDef{address: 0x004a2ee1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/start_menu_music"))] pub const START_MENU_MUSIC: FunctionDef = FunctionDef{address: 0x004bded9, function_type: PhantomData}; - pub const START_MENU_MUSIC_FADE_0: FunctionDef = FunctionDef{address: 0x004c9d67, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/start_menu_music_fade_0"))] + pub const START_MENU_MUSIC_FADE_0: FunctionDef = FunctionDef{address: 0x004c9d67, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/start_menu_music_fade_1"))] pub const START_MENU_MUSIC_FADE_1: FunctionDef = FunctionDef{address: 0x004ca478, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/start_menu_music_fade_2"))] pub const START_MENU_MUSIC_FADE_2: FunctionDef = FunctionDef{address: 0x004cc59d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/goto_start"))] pub const GOTO_START: FunctionDef u32> = FunctionDef{address: 0x004cc5b0, function_type: PhantomData}; - pub const IS_GAME_DATE: FunctionDef u32> = FunctionDef{address: 0x004f5f7a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/is_game_date"))] + pub const IS_GAME_DATE: FunctionDef u32> = FunctionDef{address: 0x004f5f7a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/stop"))] pub const STOP: FunctionDef = FunctionDef{address: 0x004fa123, function_type: PhantomData}; - pub const ZTGAME_MGR_0: FunctionDef u32> = FunctionDef{address: 0x00504dd8, function_type: PhantomData}; - pub const ZTGAME_MGR_1: FunctionDef u32> = FunctionDef{address: 0x00504e4c, function_type: PhantomData}; - pub const SET_NEW_GAME_DEFAULTS: FunctionDef = FunctionDef{address: 0x0058f39c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/ztgame_mgr_0"))] + pub const ZTGAME_MGR_0: FunctionDef *const u32> = FunctionDef{address: 0x00504dd8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/ztgame_mgr_1"))] + pub const ZTGAME_MGR_1: FunctionDef *const u32> = FunctionDef{address: 0x00504e4c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/set_new_game_defaults"))] + pub const SET_NEW_GAME_DEFAULTS: FunctionDef = FunctionDef{address: 0x0058f39c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/start"))] pub const START: FunctionDef = FunctionDef{address: 0x00592283, function_type: PhantomData}; - pub const LOAD: FunctionDef = FunctionDef{address: 0x005948c6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/load"))] + pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x005948c6, function_type: PhantomData}; } // ZTGameMgr::MenuMusicHandler class functions pub mod ztgamemgr_menumusichandler { use super::*; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a13a, function_type: PhantomData}; - pub const MENU_MUSIC_HANDLER: FunctionDef = FunctionDef{address: 0x00504e27, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr_menumusichandler/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a13a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr_menumusichandler/menu_music_handler"))] + pub const MENU_MUSIC_HANDLER: FunctionDef = FunctionDef{address: 0x00504e27, function_type: PhantomData}; } // ZTGoalAvoid class functions pub mod ztgoalavoid { use super::*; - pub const ZTGOAL_AVOID_0: FunctionDef u32> = FunctionDef{address: 0x0041226c, function_type: PhantomData}; - pub const EXIT_TANK: FunctionDef = FunctionDef{address: 0x00431834, function_type: PhantomData}; - pub const CHECK_DONE: FunctionDef = FunctionDef{address: 0x004a5471, function_type: PhantomData}; - pub const DECIDE: FunctionDef = FunctionDef{address: 0x004a557f, function_type: PhantomData}; - pub const ZTGOAL_AVOID_1: FunctionDef u32> = FunctionDef{address: 0x00604185, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalavoid/ztgoal_avoid_0"))] + pub const ZTGOAL_AVOID_0: FunctionDef *const u32> = FunctionDef{address: 0x0041226c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalavoid/exit_tank"))] + pub const EXIT_TANK: FunctionDef = FunctionDef{address: 0x00431834, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalavoid/check_done"))] + pub const CHECK_DONE: FunctionDef = FunctionDef{address: 0x004a5471, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalavoid/decide"))] + pub const DECIDE: FunctionDef = FunctionDef{address: 0x004a557f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalavoid/ztgoal_avoid_1"))] + pub const ZTGOAL_AVOID_1: FunctionDef *const u32> = FunctionDef{address: 0x00604185, function_type: PhantomData}; } // ZTGoalBagDoo class functions pub mod ztgoalbagdoo { use super::*; - pub const COMPLETE: FunctionDef = FunctionDef{address: 0x004a2c98, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalbagdoo/complete"))] + pub const COMPLETE: FunctionDef = FunctionDef{address: 0x004a2c98, function_type: PhantomData}; } // ZTGoalBuildingExit class functions pub mod ztgoalbuildingexit { use super::*; - pub const COMPLETE: FunctionDef = FunctionDef{address: 0x0042dddf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalbuildingexit/complete"))] + pub const COMPLETE: FunctionDef = FunctionDef{address: 0x0042dddf, function_type: PhantomData}; } // ZTGoalChase class functions pub mod ztgoalchase { use super::*; - pub const GET_TYPE: FunctionDef = FunctionDef{address: 0x004a4c06, function_type: PhantomData}; - pub const CHECK_DONE: FunctionDef = FunctionDef{address: 0x004a4c0c, function_type: PhantomData}; - pub const DECIDE: FunctionDef = FunctionDef{address: 0x004a4d6c, function_type: PhantomData}; - pub const ZTGOAL_CHASE: FunctionDef = FunctionDef{address: 0x004a4d98, function_type: PhantomData}; - pub const COMPLETE: FunctionDef = FunctionDef{address: 0x004a4dd2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalchase/get_type"))] + pub const GET_TYPE: FunctionDef u32> = FunctionDef{address: 0x004a4c06, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalchase/check_done"))] + pub const CHECK_DONE: FunctionDef = FunctionDef{address: 0x004a4c0c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalchase/decide"))] + pub const DECIDE: FunctionDef = FunctionDef{address: 0x004a4d6c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalchase/ztgoal_chase"))] + pub const ZTGOAL_CHASE: FunctionDef = FunctionDef{address: 0x004a4d98, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalchase/complete"))] + pub const COMPLETE: FunctionDef = FunctionDef{address: 0x004a4dd2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalchase/f_caught"))] pub const F_CAUGHT: FunctionDef = FunctionDef{address: 0x004a6043, function_type: PhantomData}; } @@ -1883,498 +3209,887 @@ pub mod ztgoalchase { pub mod ztgoalchaseanimal { use super::*; - pub const COMPLETE: FunctionDef = FunctionDef{address: 0x0050db25, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalchaseanimal/complete"))] + pub const COMPLETE: FunctionDef = FunctionDef{address: 0x0050db25, function_type: PhantomData}; } // ZTGoalEmptyTrash class functions pub mod ztgoalemptytrash { use super::*; - pub const INIT: FunctionDef = FunctionDef{address: 0x0048b3f2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalemptytrash/init"))] + pub const INIT: FunctionDef u32> = FunctionDef{address: 0x0048b3f2, function_type: PhantomData}; } // ZTGoalFactory class functions pub mod ztgoalfactory { use super::*; - pub const CREATE_SUB: FunctionDef u32> = FunctionDef{address: 0x00413aa7, function_type: PhantomData}; - pub const CREATE: FunctionDef u32> = FunctionDef{address: 0x00413bec, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef = FunctionDef{address: 0x00603e6b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalfactory/create_sub"))] + pub const CREATE_SUB: FunctionDef *const u32> = FunctionDef{address: 0x00413aa7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalfactory/create"))] + pub const CREATE: FunctionDef *const u32> = FunctionDef{address: 0x00413bec, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalfactory/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const c_void> = FunctionDef{address: 0x00603e6b, function_type: PhantomData}; } // ZTGoalFixFilter class functions pub mod ztgoalfixfilter { use super::*; - pub const FIX_FILTER: FunctionDef u32> = FunctionDef{address: 0x00595cde, function_type: PhantomData}; - pub const COMPLETE: FunctionDef = FunctionDef{address: 0x00595d17, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalfixfilter/fix_filter"))] + pub const FIX_FILTER: FunctionDef u32> = FunctionDef{address: 0x00595cde, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalfixfilter/complete"))] + pub const COMPLETE: FunctionDef = FunctionDef{address: 0x00595d17, function_type: PhantomData}; } // ZTGoalGawk class functions pub mod ztgoalgawk { use super::*; - pub const COMPLETE: FunctionDef = FunctionDef{address: 0x0042e9f9, function_type: PhantomData}; - pub const LEFT_VA: FunctionDef = FunctionDef{address: 0x0042ea14, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalgawk/complete"))] + pub const COMPLETE: FunctionDef = FunctionDef{address: 0x0042e9f9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalgawk/left_va"))] + pub const LEFT_VA: FunctionDef = FunctionDef{address: 0x0042ea14, function_type: PhantomData}; +} + +// ZTGoalHabitatDuties class functions +pub mod ztgoalhabitatduties { + use super::*; + + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalhabitatduties/complete"))] + pub const COMPLETE: FunctionDef = FunctionDef{address: 0x0049ebe7, function_type: PhantomData}; } // ZTGoalHeliReturn class functions pub mod ztgoalhelireturn { use super::*; - pub const CHECK_DONE: FunctionDef = FunctionDef{address: 0x005a4556, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalhelireturn/check_done"))] + pub const CHECK_DONE: FunctionDef = FunctionDef{address: 0x005a4556, function_type: PhantomData}; } // ZTGoalLeave class functions pub mod ztgoalleave { use super::*; - pub const DECIDE: FunctionDef = FunctionDef{address: 0x004233ea, function_type: PhantomData}; - pub const FIND_EXIT: FunctionDef u32> = FunctionDef{address: 0x004a6889, function_type: PhantomData}; - pub const COMPLETE: FunctionDef = FunctionDef{address: 0x004fa85d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalleave/decide"))] + pub const DECIDE: FunctionDef = FunctionDef{address: 0x004233ea, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalleave/find_exit"))] + pub const FIND_EXIT: FunctionDef u32> = FunctionDef{address: 0x004a6889, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalleave/complete"))] + pub const COMPLETE: FunctionDef = FunctionDef{address: 0x004fa85d, function_type: PhantomData}; } // ZTGoalPreattack class functions pub mod ztgoalpreattack { use super::*; - pub const INIT: FunctionDef = FunctionDef{address: 0x0061b2d6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalpreattack/init"))] + pub const INIT: FunctionDef u32> = FunctionDef{address: 0x0061b2d6, function_type: PhantomData}; } // ZTGoalSite class functions pub mod ztgoalsite { use super::*; - pub const DECIDE: FunctionDef = FunctionDef{address: 0x004281be, function_type: PhantomData}; - pub const SET_SITE_GOAL: FunctionDef u32> = FunctionDef{address: 0x004282e1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalsite/decide"))] + pub const DECIDE: FunctionDef = FunctionDef{address: 0x004281be, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalsite/set_site_goal"))] + pub const SET_SITE_GOAL: FunctionDef u32> = FunctionDef{address: 0x004282e1, function_type: PhantomData}; } // ZTGoalWaterDrown class functions pub mod ztgoalwaterdrown { use super::*; - pub const INIT: FunctionDef = FunctionDef{address: 0x0061a705, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalwaterdrown/init"))] + pub const INIT: FunctionDef u8> = FunctionDef{address: 0x0061a705, function_type: PhantomData}; } // ZTGoalZooDoo class functions pub mod ztgoalzoodoo { use super::*; - pub const GET_TYPE: FunctionDef = FunctionDef{address: 0x004a2746, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalzoodoo/get_type"))] + pub const GET_TYPE: FunctionDef u32> = FunctionDef{address: 0x004a2746, function_type: PhantomData}; } // ZTGuest class functions pub mod ztguest { use super::*; - pub const SEEN_HABITAT: FunctionDef u32> = FunctionDef{address: 0x0042281c, function_type: PhantomData}; - pub const F_GUEST_THOUGHT: FunctionDef = FunctionDef{address: 0x004231c1, function_type: PhantomData}; - pub const GET_NONSEEN_HABITATS: FunctionDef u32> = FunctionDef{address: 0x00427b08, function_type: PhantomData}; - pub const GET_NUM_NONSEEN_SITES: FunctionDef i32> = FunctionDef{address: 0x00427c88, function_type: PhantomData}; - pub const GET_NONSEEN_ATTRACTIONS: FunctionDef u32> = FunctionDef{address: 0x00427d5c, function_type: PhantomData}; - pub const GET_NUM_NONSEEN_GAWK_SCENERY: FunctionDef u32> = FunctionDef{address: 0x00428039, function_type: PhantomData}; - pub const SEEN_ATTRACTION: FunctionDef u32> = FunctionDef{address: 0x004285e2, function_type: PhantomData}; - pub const PICK_GAWK_SCENERY: FunctionDef u32> = FunctionDef{address: 0x0042945f, function_type: PhantomData}; - pub const GET_NONSEEN_GAWK_SCENERY: FunctionDef u32> = FunctionDef{address: 0x0042956e, function_type: PhantomData}; - pub const CONSUME_ITEM: FunctionDef u32> = FunctionDef{address: 0x0042d380, function_type: PhantomData}; - pub const REMOVE_ITEM: FunctionDef bool> = FunctionDef{address: 0x0042d533, function_type: PhantomData}; - pub const ADD_ITEM: FunctionDef u32> = FunctionDef{address: 0x0042d54e, function_type: PhantomData}; - pub const GET_NEED_ITEM: FunctionDef u32> = FunctionDef{address: 0x0042d74e, function_type: PhantomData}; - pub const CHECK_PREDATOR: FunctionDef u32> = FunctionDef{address: 0x004302ea, function_type: PhantomData}; - pub const DRAW: FunctionDef = FunctionDef{address: 0x00434029, function_type: PhantomData}; - pub const GET_COLOR_REP_INFO: FunctionDef i32> = FunctionDef{address: 0x0043408c, function_type: PhantomData}; - pub const LISTEN: FunctionDef = FunctionDef{address: 0x0043a698, function_type: PhantomData}; - pub const UPDATE_GOALS: FunctionDef = FunctionDef{address: 0x0043a6e4, function_type: PhantomData}; - pub const CHECK_LEAVE_ZOO: FunctionDef u32> = FunctionDef{address: 0x004a6acc, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004f5fd5, function_type: PhantomData}; - pub const INIT_STATUS_VARS: FunctionDef = FunctionDef{address: 0x004f6372, function_type: PhantomData}; - pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x004f70e4, function_type: PhantomData}; - pub const ZTGUEST: FunctionDef u32> = FunctionDef{address: 0x004fa44c, function_type: PhantomData}; - pub const DO_ANGRY_PRICE_CHANGE: FunctionDef = FunctionDef{address: 0x00533480, function_type: PhantomData}; - pub const ADD_TRASH: FunctionDef = FunctionDef{address: 0x0059d2c9, function_type: PhantomData}; - pub const SEEN_SHOW: FunctionDef u32> = FunctionDef{address: 0x005a2bcd, function_type: PhantomData}; - pub const DO_HAPPY_PRICE_CHANGE: FunctionDef = FunctionDef{address: 0x00619245, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/add_to_map"))] + pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x00412ba7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/seen_habitat"))] + pub const SEEN_HABITAT: FunctionDef u32> = FunctionDef{address: 0x0042281c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/f_guest_thought"))] + pub const F_GUEST_THOUGHT: FunctionDef = FunctionDef{address: 0x004231c1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x0042789a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_nonseen_habitats"))] + pub const GET_NONSEEN_HABITATS: FunctionDef *const u32> = FunctionDef{address: 0x00427b08, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_num_nonseen_sites"))] + pub const GET_NUM_NONSEEN_SITES: FunctionDef i32> = FunctionDef{address: 0x00427c88, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_nonseen_attractions"))] + pub const GET_NONSEEN_ATTRACTIONS: FunctionDef *const i32> = FunctionDef{address: 0x00427d5c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_num_nonseen_gawk_scenery"))] + pub const GET_NUM_NONSEEN_GAWK_SCENERY: FunctionDef *const i32> = FunctionDef{address: 0x00428039, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/seen_attraction"))] + pub const SEEN_ATTRACTION: FunctionDef u32> = FunctionDef{address: 0x004285e2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/pick_gawk_scenery"))] + pub const PICK_GAWK_SCENERY: FunctionDef *const i32> = FunctionDef{address: 0x0042945f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_nonseen_gawk_scenery"))] + pub const GET_NONSEEN_GAWK_SCENERY: FunctionDef *const i32> = FunctionDef{address: 0x0042956e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/set_visible"))] + pub const SET_VISIBLE: FunctionDef = FunctionDef{address: 0x0042aa0a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/consume_item"))] + pub const CONSUME_ITEM: FunctionDef u32> = FunctionDef{address: 0x0042d380, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/remove_item"))] + pub const REMOVE_ITEM: FunctionDef bool> = FunctionDef{address: 0x0042d533, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/add_item"))] + pub const ADD_ITEM: FunctionDef u32> = FunctionDef{address: 0x0042d54e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_need_item"))] + pub const GET_NEED_ITEM: FunctionDef *const i32> = FunctionDef{address: 0x0042d74e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/check_predator"))] + pub const CHECK_PREDATOR: FunctionDef u32> = FunctionDef{address: 0x004302ea, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/draw"))] + pub const DRAW: FunctionDef = FunctionDef{address: 0x00434029, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_color_rep_info"))] + pub const GET_COLOR_REP_INFO: FunctionDef i32> = FunctionDef{address: 0x0043408c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/listen"))] + pub const LISTEN: FunctionDef = FunctionDef{address: 0x0043a698, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/update_goals"))] + pub const UPDATE_GOALS: FunctionDef = FunctionDef{address: 0x0043a6e4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_terrain_cost"))] + pub const GET_TERRAIN_COST: FunctionDef i32> = FunctionDef{address: 0x0043a8fb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/check_leave_zoo"))] + pub const CHECK_LEAVE_ZOO: FunctionDef u32> = FunctionDef{address: 0x004a6acc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004f5fd5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/init_status_vars"))] + pub const INIT_STATUS_VARS: FunctionDef = FunctionDef{address: 0x004f6372, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/create_name"))] + pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x004f70e4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/ztguest"))] + pub const ZTGUEST: FunctionDef *const u32> = FunctionDef{address: 0x004fa44c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/do_angry_price_change"))] + pub const DO_ANGRY_PRICE_CHANGE: FunctionDef = FunctionDef{address: 0x00533480, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/add_trash"))] + pub const ADD_TRASH: FunctionDef = FunctionDef{address: 0x0059d2c9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/seen_show"))] + pub const SEEN_SHOW: FunctionDef u32> = FunctionDef{address: 0x005a2bcd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/reset_ai"))] + pub const RESET_AI: FunctionDef = FunctionDef{address: 0x005ae78a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/do_happy_price_change"))] + pub const DO_HAPPY_PRICE_CHANGE: FunctionDef = FunctionDef{address: 0x00619245, function_type: PhantomData}; } // ZTGuestType class functions pub mod ztguesttype { use super::*; - pub const LOAD_CHARACTERISTICS_0: FunctionDef = FunctionDef{address: 0x004c47dd, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c4cb9, function_type: PhantomData}; - pub const ZTGUEST_TYPE: FunctionDef u32> = FunctionDef{address: 0x004cbb9c, function_type: PhantomData}; - pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004f6060, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguesttype/load_characteristics_0"))] + pub const LOAD_CHARACTERISTICS_0: FunctionDef u8> = FunctionDef{address: 0x004c47dd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguesttype/load_characteristics_1"))] + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c4cb9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguesttype/ztguest_type"))] + pub const ZTGUEST_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x004cbb9c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguesttype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x004f6060, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguesttype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x005213de, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x005216f1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguesttype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x005216f1, function_type: PhantomData}; } // ZTGuide class functions pub mod ztguide { use super::*; - pub const GET_RANDOM_ASSIGNED_HABITAT: FunctionDef u32> = FunctionDef{address: 0x0058af73, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguide/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x0058952b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguide/remove_guest"))] + pub const REMOVE_GUEST: FunctionDef = FunctionDef{address: 0x0058aab4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguide/get_random_assigned_habitat"))] + pub const GET_RANDOM_ASSIGNED_HABITAT: FunctionDef u32> = FunctionDef{address: 0x0058af73, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguide/release_guests"))] + pub const RELEASE_GUESTS: FunctionDef = FunctionDef{address: 0x0058b362, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguide/get_terrain_cost"))] + pub const GET_TERRAIN_COST: FunctionDef i32> = FunctionDef{address: 0x0058cfd6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguide/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0059b50b, function_type: PhantomData}; } // ZTGuideType class functions pub mod ztguidetype { use super::*; - pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004c3ee2, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c406f, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051c2d6, function_type: PhantomData}; - pub const ZTGUIDE_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x0057cb67, function_type: PhantomData}; - pub const ZTGUIDE_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x0057cb85, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguidetype/load_characteristics_0"))] + pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004c3ee2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguidetype/load_characteristics_1"))] + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c406f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguidetype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051c2d6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguidetype/ztguide_type_0"))] + pub const ZTGUIDE_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x0057cb67, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguidetype/ztguide_type_1"))] + pub const ZTGUIDE_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x0057cb85, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztguidetype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x0059b550, function_type: PhantomData}; } // ZTHabitat class functions pub mod zthabitat { use super::*; - pub const RECALCULATE_VIEWING_AREAS: FunctionDef = FunctionDef{address: 0x0040f55a, function_type: PhantomData}; - pub const SET_DIRTY_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x0040f5a9, function_type: PhantomData}; - pub const IS_SHOW_TANK: FunctionDef u32> = FunctionDef{address: 0x0040fba2, function_type: PhantomData}; - pub const GET_SHOW_INFO_ID: FunctionDef u32> = FunctionDef{address: 0x0040fbc7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/recalculate_viewing_areas"))] + pub const RECALCULATE_VIEWING_AREAS: FunctionDef = FunctionDef{address: 0x0040f55a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/set_dirty_characteristics"))] + pub const SET_DIRTY_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x0040f5a9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/is_show_tank"))] + pub const IS_SHOW_TANK: FunctionDef u32> = FunctionDef{address: 0x0040fba2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_show_info_id"))] + pub const GET_SHOW_INFO_ID: FunctionDef u32> = FunctionDef{address: 0x0040fbc7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_gate_tile_in"))] pub const GET_GATE_TILE_IN: FunctionDef *const u32> = FunctionDef{address: 0x00410349, function_type: PhantomData}; - pub const GET_ALL_ANIMALS: FunctionDef u32> = FunctionDef{address: 0x00410def, function_type: PhantomData}; - pub const GET_GATE_TILE_OUT: FunctionDef i32> = FunctionDef{address: 0x00411285, function_type: PhantomData}; - pub const GET_NUM_ANIMALS: FunctionDef i32> = FunctionDef{address: 0x00412167, function_type: PhantomData}; - pub const GET_HABITAT_RATING: FunctionDef f32> = FunctionDef{address: 0x00415dd7, function_type: PhantomData}; - pub const CLEAR_AMPHIBIOUS_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00417460, function_type: PhantomData}; - pub const SET_IS_NOT_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x0041748d, function_type: PhantomData}; - pub const ACCEPT_DONATION: FunctionDef = FunctionDef{address: 0x0042ec49, function_type: PhantomData}; - pub const UPDATE_PORTALS: FunctionDef = FunctionDef{address: 0x0043578f, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x004357c6, function_type: PhantomData}; - pub const GET_SIZE: FunctionDef i32> = FunctionDef{address: 0x0044097c, function_type: PhantomData}; - pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x00444827, function_type: PhantomData}; - pub const REVISE_SPECIES_LIST: FunctionDef = FunctionDef{address: 0x00447dc1, function_type: PhantomData}; - pub const ADD_SPECIES: FunctionDef = FunctionDef{address: 0x00448f6b, function_type: PhantomData}; - pub const RESIZE: FunctionDef = FunctionDef{address: 0x0044b900, function_type: PhantomData}; - pub const CREATE_EDGE_PAIRS: FunctionDef = FunctionDef{address: 0x0044b95c, function_type: PhantomData}; - pub const CREATE_VIEWING_AREAS: FunctionDef = FunctionDef{address: 0x0044ba57, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0044dc0d, function_type: PhantomData}; - pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x0044df34, function_type: PhantomData}; - pub const PATH_PLACED: FunctionDef = FunctionDef{address: 0x0044ea19, function_type: PhantomData}; - pub const ADD_VIEWING_AREA: FunctionDef = FunctionDef{address: 0x0044efa4, function_type: PhantomData}; - pub const ADD_SHOW_UNIT: FunctionDef u32> = FunctionDef{address: 0x00458610, function_type: PhantomData}; - pub const REMOVE_SHOW_UNIT: FunctionDef = FunctionDef{address: 0x004586b9, function_type: PhantomData}; - pub const CLEAR_SHOW_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00458a88, function_type: PhantomData}; - pub const MOVE_GATE_TO: FunctionDef u32> = FunctionDef{address: 0x00466236, function_type: PhantomData}; - pub const HAS_KEEPER_ASSIGNED: FunctionDef = FunctionDef{address: 0x00468454, function_type: PhantomData}; - pub const GET_POPULARITY: FunctionDef i32> = FunctionDef{address: 0x00468732, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_all_animals"))] + pub const GET_ALL_ANIMALS: FunctionDef *const i32> = FunctionDef{address: 0x00410def, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_gate_tile_out"))] + pub const GET_GATE_TILE_OUT: FunctionDef i32> = FunctionDef{address: 0x00411285, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_num_animals"))] + pub const GET_NUM_ANIMALS: FunctionDef i32> = FunctionDef{address: 0x00412167, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_habitat_rating"))] + pub const GET_HABITAT_RATING: FunctionDef f32> = FunctionDef{address: 0x00415dd7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/clear_amphibious_neighbors"))] + pub const CLEAR_AMPHIBIOUS_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00417460, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/set_is_not_show_exhibit"))] + pub const SET_IS_NOT_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x0041748d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/block_service"))] + pub const BLOCK_SERVICE: FunctionDef u32> = FunctionDef{address: 0x00423e01, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/accept_donation"))] + pub const ACCEPT_DONATION: FunctionDef = FunctionDef{address: 0x0042ec49, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/update_portals"))] + pub const UPDATE_PORTALS: FunctionDef = FunctionDef{address: 0x0043578f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x004357c6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_size"))] + pub const GET_SIZE: FunctionDef i32> = FunctionDef{address: 0x0044097c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/recalculate_characteristics"))] + pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x00444827, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/revise_species_list"))] + pub const REVISE_SPECIES_LIST: FunctionDef = FunctionDef{address: 0x00447dc1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/add_species"))] + pub const ADD_SPECIES: FunctionDef = FunctionDef{address: 0x00448f6b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/resize"))] + pub const RESIZE: FunctionDef = FunctionDef{address: 0x0044b900, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/create_edge_pairs"))] + pub const CREATE_EDGE_PAIRS: FunctionDef = FunctionDef{address: 0x0044b95c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/create_viewing_areas"))] + pub const CREATE_VIEWING_AREAS: FunctionDef = FunctionDef{address: 0x0044ba57, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0044dc0d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/create_name"))] + pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x0044df34, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/path_placed"))] + pub const PATH_PLACED: FunctionDef = FunctionDef{address: 0x0044ea19, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/add_viewing_area"))] + pub const ADD_VIEWING_AREA: FunctionDef = FunctionDef{address: 0x0044efa4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/add_show_unit"))] + pub const ADD_SHOW_UNIT: FunctionDef u32> = FunctionDef{address: 0x00458610, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/remove_show_unit"))] + pub const REMOVE_SHOW_UNIT: FunctionDef u8> = FunctionDef{address: 0x004586b9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/clear_show_neighbors"))] + pub const CLEAR_SHOW_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00458a88, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/move_gate_to"))] + pub const MOVE_GATE_TO: FunctionDef u32> = FunctionDef{address: 0x00466236, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/has_keeper_assigned"))] + pub const HAS_KEEPER_ASSIGNED: FunctionDef u8> = FunctionDef{address: 0x00468454, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_popularity"))] + pub const GET_POPULARITY: FunctionDef i32> = FunctionDef{address: 0x00468732, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00479b73, function_type: PhantomData}; - pub const GET_UNDESIRABLE_SCENERY: FunctionDef = FunctionDef{address: 0x00483a67, function_type: PhantomData}; - pub const GET_GATE: FunctionDef i32> = FunctionDef{address: 0x00492ca3, function_type: PhantomData}; - pub const GET_SPECIES_RATING: FunctionDef f32> = FunctionDef{address: 0x004d92db, function_type: PhantomData}; - pub const GET_SURROUNDING_SPECIES: FunctionDef u32> = FunctionDef{address: 0x004fb11c, function_type: PhantomData}; - pub const REMOVE_SPECIES: FunctionDef = FunctionDef{address: 0x004fbe4f, function_type: PhantomData}; - pub const ADD_AMPHIBIOUS_NEIGHBOR: FunctionDef = FunctionDef{address: 0x005078d3, function_type: PhantomData}; - pub const REMOVE_AMPHIBIOUS_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x00507a90, function_type: PhantomData}; - pub const REMOVE_FROM_ALL_VAS: FunctionDef = FunctionDef{address: 0x0050bb53, function_type: PhantomData}; - pub const REMOVE_VIEWING_AREA: FunctionDef = FunctionDef{address: 0x0050bc94, function_type: PhantomData}; - pub const GET_SHOW_PORTAL: FunctionDef i32> = FunctionDef{address: 0x0059e0a9, function_type: PhantomData}; - pub const REMOVE_SHOW_PORTAL: FunctionDef = FunctionDef{address: 0x005aa4d9, function_type: PhantomData}; - pub const REMOVE_SHOW_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005aa75e, function_type: PhantomData}; - pub const ADD_SHOW_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005ab1e7, function_type: PhantomData}; - pub const ADD_SHOW_PORTAL: FunctionDef u32> = FunctionDef{address: 0x005ab354, function_type: PhantomData}; - pub const SET_IS_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x005ab661, function_type: PhantomData}; - pub const SET_NAME: FunctionDef = FunctionDef{address: 0x005aedbd, function_type: PhantomData}; - pub const RECREATE_OAS: FunctionDef = FunctionDef{address: 0x005b2ffb, function_type: PhantomData}; - pub const TRIGGER_DEATH_ARRIVED: FunctionDef = FunctionDef{address: 0x00605b8e, function_type: PhantomData}; - pub const HILITE_SHOW_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00605c02, function_type: PhantomData}; - pub const HILITE_AMPHIBIOUS_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00605c80, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_undesirable_scenery"))] + pub const GET_UNDESIRABLE_SCENERY: FunctionDef = FunctionDef{address: 0x00483a67, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_gate"))] + pub const GET_GATE: FunctionDef i32> = FunctionDef{address: 0x00492ca3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/set_time_last_serviced"))] + pub const SET_TIME_LAST_SERVICED: FunctionDef = FunctionDef{address: 0x0049e950, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_species_rating"))] + pub const GET_SPECIES_RATING: FunctionDef f32> = FunctionDef{address: 0x004d92db, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_surrounding_species"))] + pub const GET_SURROUNDING_SPECIES: FunctionDef *const i32> = FunctionDef{address: 0x004fb11c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/remove_species"))] + pub const REMOVE_SPECIES: FunctionDef = FunctionDef{address: 0x004fbe4f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/add_amphibious_neighbor"))] + pub const ADD_AMPHIBIOUS_NEIGHBOR: FunctionDef u8> = FunctionDef{address: 0x005078d3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/remove_amphibious_neighbor"))] + pub const REMOVE_AMPHIBIOUS_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x00507a90, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/remove_from_all_vas"))] + pub const REMOVE_FROM_ALL_VAS: FunctionDef = FunctionDef{address: 0x0050bb53, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/remove_viewing_area"))] + pub const REMOVE_VIEWING_AREA: FunctionDef = FunctionDef{address: 0x0050bc94, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_show_portal"))] + pub const GET_SHOW_PORTAL: FunctionDef i32> = FunctionDef{address: 0x0059e0a9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/remove_show_portal"))] + pub const REMOVE_SHOW_PORTAL: FunctionDef = FunctionDef{address: 0x005aa4d9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/remove_show_neighbor"))] + pub const REMOVE_SHOW_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005aa75e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/add_show_neighbor"))] + pub const ADD_SHOW_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005ab1e7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/add_show_portal"))] + pub const ADD_SHOW_PORTAL: FunctionDef u32> = FunctionDef{address: 0x005ab354, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/set_is_show_exhibit"))] + pub const SET_IS_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x005ab661, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/set_name"))] + pub const SET_NAME: FunctionDef = FunctionDef{address: 0x005aedbd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/recreate_oas"))] + pub const RECREATE_OAS: FunctionDef = FunctionDef{address: 0x005b2ffb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/trigger_death_arrived"))] + pub const TRIGGER_DEATH_ARRIVED: FunctionDef = FunctionDef{address: 0x00605b8e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/hilite_show_neighbors"))] + pub const HILITE_SHOW_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00605c02, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/hilite_amphibious_neighbors"))] + pub const HILITE_AMPHIBIOUS_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00605c80, function_type: PhantomData}; } // ZTHabitatMgr class functions pub mod zthabitatmgr { use super::*; - pub const GET_HABITAT: FunctionDef u32> = FunctionDef{address: 0x00410bf9, function_type: PhantomData}; - pub const GET_ZOO_ENTRANCE_TILE: FunctionDef i32> = FunctionDef{address: 0x00410d04, function_type: PhantomData}; - pub const SCENERY_ENTITY_CHANGE: FunctionDef = FunctionDef{address: 0x00417295, function_type: PhantomData}; - pub const REPLACE_GATE: FunctionDef = FunctionDef{address: 0x0041ec94, function_type: PhantomData}; - pub const GET_NONEMPTY_NON_WORLD_HABITATS: FunctionDef = FunctionDef{address: 0x00440d9a, function_type: PhantomData}; - pub const RECALCULATE_DETERIORATION: FunctionDef = FunctionDef{address: 0x00449920, function_type: PhantomData}; - pub const ADD_HABITAT: FunctionDef = FunctionDef{address: 0x0044c7b2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/get_habitat"))] + pub const GET_HABITAT: FunctionDef u32> = FunctionDef{address: 0x00410bf9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/get_zoo_entrance_tile"))] + pub const GET_ZOO_ENTRANCE_TILE: FunctionDef i32> = FunctionDef{address: 0x00410d04, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/scenery_entity_change"))] + pub const SCENERY_ENTITY_CHANGE: FunctionDef = FunctionDef{address: 0x00417295, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/replace_gate"))] + pub const REPLACE_GATE: FunctionDef = FunctionDef{address: 0x0041ec94, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/get_nonempty_non_world_habitats"))] + pub const GET_NONEMPTY_NON_WORLD_HABITATS: FunctionDef = FunctionDef{address: 0x00440d9a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/recalculate_deterioration"))] + pub const RECALCULATE_DETERIORATION: FunctionDef = FunctionDef{address: 0x00449920, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/add_habitat"))] + pub const ADD_HABITAT: FunctionDef = FunctionDef{address: 0x0044c7b2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/do_tank_check"))] pub const DO_TANK_CHECK: FunctionDef u32> = FunctionDef{address: 0x0044c8ab, function_type: PhantomData}; - pub const MORPH_EXHIBIT: FunctionDef = FunctionDef{address: 0x0044ca8c, function_type: PhantomData}; - pub const FENCE_PLACED: FunctionDef = FunctionDef{address: 0x0044ce67, function_type: PhantomData}; - pub const CAN_FIND_PATH: FunctionDef u32> = FunctionDef{address: 0x0044d598, function_type: PhantomData}; - pub const CLEAR_PATHFINDING: FunctionDef = FunctionDef{address: 0x0044dab9, function_type: PhantomData}; - pub const DO_SHOW_CHECK: FunctionDef u32> = FunctionDef{address: 0x0044e1e8, function_type: PhantomData}; - pub const CREATE_HABITAT: FunctionDef = FunctionDef{address: 0x0044e389, function_type: PhantomData}; - pub const NAME_HABITAT: FunctionDef = FunctionDef{address: 0x0044e43e, function_type: PhantomData}; - pub const PLACE_GATE: FunctionDef u32> = FunctionDef{address: 0x0044e4eb, function_type: PhantomData}; - pub const GET_NEXT_NUM: FunctionDef u32> = FunctionDef{address: 0x0044e9f9, function_type: PhantomData}; - pub const DECREMENT_HABITAT_NUM: FunctionDef = FunctionDef{address: 0x0045bbf6, function_type: PhantomData}; - pub const SNAP_TANK_WALLS_INWARD: FunctionDef u32> = FunctionDef{address: 0x0045c80a, function_type: PhantomData}; - pub const CHECK_EXHIBIT_MORPH: FunctionDef = FunctionDef{address: 0x0045ce9a, function_type: PhantomData}; - pub const UPDATE_AMPHIBIOUS_NEIGHBORS_0: FunctionDef = FunctionDef{address: 0x0045cf03, function_type: PhantomData}; - pub const UPDATE_SHOW_NEIGHBORS_0: FunctionDef = FunctionDef{address: 0x0045cf65, function_type: PhantomData}; - pub const INSTANTIATE: FunctionDef u32> = FunctionDef{address: 0x004635aa, function_type: PhantomData}; - pub const REPLACE_FENCE_WITH_GATE: FunctionDef u32> = FunctionDef{address: 0x004666c5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/morph_exhibit"))] + pub const MORPH_EXHIBIT: FunctionDef = FunctionDef{address: 0x0044ca8c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/fence_placed"))] + pub const FENCE_PLACED: FunctionDef = FunctionDef{address: 0x0044ce67, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/can_find_path"))] + pub const CAN_FIND_PATH: FunctionDef u32> = FunctionDef{address: 0x0044d598, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/clear_pathfinding"))] + pub const CLEAR_PATHFINDING: FunctionDef = FunctionDef{address: 0x0044dab9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/do_show_check"))] + pub const DO_SHOW_CHECK: FunctionDef u32> = FunctionDef{address: 0x0044e1e8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/create_habitat"))] + pub const CREATE_HABITAT: FunctionDef = FunctionDef{address: 0x0044e389, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/name_habitat"))] + pub const NAME_HABITAT: FunctionDef = FunctionDef{address: 0x0044e43e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/place_gate"))] + pub const PLACE_GATE: FunctionDef u32> = FunctionDef{address: 0x0044e4eb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/get_next_num"))] + pub const GET_NEXT_NUM: FunctionDef u32> = FunctionDef{address: 0x0044e9f9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/path_placed"))] + pub const PATH_PLACED: FunctionDef = FunctionDef{address: 0x00451d6d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/decrement_habitat_num"))] + pub const DECREMENT_HABITAT_NUM: FunctionDef = FunctionDef{address: 0x0045bbf6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/snap_tank_walls_inward"))] + pub const SNAP_TANK_WALLS_INWARD: FunctionDef u32> = FunctionDef{address: 0x0045c80a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/check_exhibit_morph"))] + pub const CHECK_EXHIBIT_MORPH: FunctionDef = FunctionDef{address: 0x0045ce9a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/update_amphibious_neighbors_0"))] + pub const UPDATE_AMPHIBIOUS_NEIGHBORS_0: FunctionDef = FunctionDef{address: 0x0045cf03, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/update_show_neighbors_0"))] + pub const UPDATE_SHOW_NEIGHBORS_0: FunctionDef = FunctionDef{address: 0x0045cf65, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/instantiate"))] + pub const INSTANTIATE: FunctionDef *const i16> = FunctionDef{address: 0x004635aa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/replace_fence_with_gate"))] + pub const REPLACE_FENCE_WITH_GATE: FunctionDef u32> = FunctionDef{address: 0x004666c5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00479a54, function_type: PhantomData}; - pub const ENTER_NEW_MONTH: FunctionDef = FunctionDef{address: 0x0048430c, function_type: PhantomData}; - pub const MERGE_TANKS: FunctionDef = FunctionDef{address: 0x0048712c, function_type: PhantomData}; - pub const GET_MERGE_TANK_WALLS: FunctionDef = FunctionDef{address: 0x00487498, function_type: PhantomData}; - pub const SPLIT_TANK: FunctionDef u32> = FunctionDef{address: 0x004877bf, function_type: PhantomData}; - pub const GET_NEXT_FENCE_PAIR: FunctionDef u32> = FunctionDef{address: 0x00487f34, function_type: PhantomData}; - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6b2c, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004c7e6c, function_type: PhantomData}; - pub const BEFORE_ENTITY_CHANGE: FunctionDef = FunctionDef{address: 0x004d8a4d, function_type: PhantomData}; - pub const ENTITY_ABOUT_TO_BE_PLACED: FunctionDef = FunctionDef{address: 0x004d8cd2, function_type: PhantomData}; - pub const TERRAIN_ABOUT_TO_BE_CHANGED: FunctionDef = FunctionDef{address: 0x004db967, function_type: PhantomData}; - pub const TERRAIN_CHANGED: FunctionDef = FunctionDef{address: 0x004dbc79, function_type: PhantomData}; - pub const ZTHABITAT_MGR: FunctionDef u32> = FunctionDef{address: 0x0050363d, function_type: PhantomData}; - pub const ENTITY_ABOUT_TO_BE_REMOVED: FunctionDef = FunctionDef{address: 0x0050a5db, function_type: PhantomData}; - pub const REPLACE_GATE_WITH_FENCE: FunctionDef bool> = FunctionDef{address: 0x0050b0c8, function_type: PhantomData}; - pub const PATH_REMOVED: FunctionDef = FunctionDef{address: 0x0050bae5, function_type: PhantomData}; - pub const FENCE_REMOVED: FunctionDef = FunctionDef{address: 0x0050c3d8, function_type: PhantomData}; - pub const REMOVE_HABITAT_0: FunctionDef = FunctionDef{address: 0x0050c515, function_type: PhantomData}; - pub const CLEAR_STAFF_HABITAT: FunctionDef = FunctionDef{address: 0x0050c6b8, function_type: PhantomData}; - pub const EMPTY_GRANDSTANDS: FunctionDef = FunctionDef{address: 0x0050c813, function_type: PhantomData}; - pub const CREATE_WORLD_HABITAT: FunctionDef = FunctionDef{address: 0x0058e607, function_type: PhantomData}; - pub const MARK_ZOO_EXTERIOR: FunctionDef = FunctionDef{address: 0x00594729, function_type: PhantomData}; - pub const FILL_ZOO_EXTERIOR: FunctionDef = FunctionDef{address: 0x00594848, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/enter_new_month"))] + pub const ENTER_NEW_MONTH: FunctionDef = FunctionDef{address: 0x0048430c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/merge_tanks"))] + pub const MERGE_TANKS: FunctionDef = FunctionDef{address: 0x0048712c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/get_merge_tank_walls"))] + pub const GET_MERGE_TANK_WALLS: FunctionDef = FunctionDef{address: 0x00487498, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/split_tank"))] + pub const SPLIT_TANK: FunctionDef u32> = FunctionDef{address: 0x004877bf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/get_next_fence_pair"))] + pub const GET_NEXT_FENCE_PAIR: FunctionDef u32> = FunctionDef{address: 0x00487f34, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/get_needy_nested_tank"))] + pub const GET_NEEDY_NESTED_TANK: FunctionDef *const i32> = FunctionDef{address: 0x0049e8fa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/clear"))] + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6b2c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004c7e6c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/create_world_habitat_0"))] + pub const CREATE_WORLD_HABITAT_0: FunctionDef = FunctionDef{address: 0x004c842e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/before_entity_change"))] + pub const BEFORE_ENTITY_CHANGE: FunctionDef = FunctionDef{address: 0x004d8a4d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/entity_about_to_be_placed"))] + pub const ENTITY_ABOUT_TO_BE_PLACED: FunctionDef = FunctionDef{address: 0x004d8cd2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/terrain_about_to_be_changed"))] + pub const TERRAIN_ABOUT_TO_BE_CHANGED: FunctionDef = FunctionDef{address: 0x004db967, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/terrain_changed"))] + pub const TERRAIN_CHANGED: FunctionDef = FunctionDef{address: 0x004dbc79, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/zthabitat_mgr"))] + pub const ZTHABITAT_MGR: FunctionDef *const u32> = FunctionDef{address: 0x0050363d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/entity_about_to_be_removed"))] + pub const ENTITY_ABOUT_TO_BE_REMOVED: FunctionDef = FunctionDef{address: 0x0050a5db, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/replace_gate_with_fence"))] + pub const REPLACE_GATE_WITH_FENCE: FunctionDef bool> = FunctionDef{address: 0x0050b0c8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/path_removed"))] + pub const PATH_REMOVED: FunctionDef = FunctionDef{address: 0x0050bae5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/fence_removed"))] + pub const FENCE_REMOVED: FunctionDef = FunctionDef{address: 0x0050c3d8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/remove_habitat_0"))] + pub const REMOVE_HABITAT_0: FunctionDef = FunctionDef{address: 0x0050c515, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/clear_staff_habitat"))] + pub const CLEAR_STAFF_HABITAT: FunctionDef = FunctionDef{address: 0x0050c6b8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/empty_grandstands"))] + pub const EMPTY_GRANDSTANDS: FunctionDef = FunctionDef{address: 0x0050c813, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/create_world_habitat_1"))] + pub const CREATE_WORLD_HABITAT_1: FunctionDef = FunctionDef{address: 0x0058e607, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/name_loaded_habitats"))] + pub const NAME_LOADED_HABITATS: FunctionDef = FunctionDef{address: 0x005939fb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/mark_zoo_exterior"))] + pub const MARK_ZOO_EXTERIOR: FunctionDef = FunctionDef{address: 0x00594729, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/fill_zoo_exterior"))] + pub const FILL_ZOO_EXTERIOR: FunctionDef = FunctionDef{address: 0x00594848, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/highlight_habitat"))] + pub const HIGHLIGHT_HABITAT: FunctionDef = FunctionDef{address: 0x0059a6b7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/unhighlight_habitat"))] + pub const UNHIGHLIGHT_HABITAT: FunctionDef = FunctionDef{address: 0x0059a735, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/can_see_habitat_from_building"))] pub const CAN_SEE_HABITAT_FROM_BUILDING: FunctionDef u32> = FunctionDef{address: 0x0059e349, function_type: PhantomData}; - pub const HABITAT_SEEN_FROM_BUILDING: FunctionDef u32> = FunctionDef{address: 0x005a2b61, function_type: PhantomData}; - pub const CHECK_SHOW_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005aaed2, function_type: PhantomData}; - pub const REMOVE_ALL_HABITATS: FunctionDef = FunctionDef{address: 0x005b11d2, function_type: PhantomData}; - pub const UPDATE_SHOW_NEIGHBORS_1: FunctionDef = FunctionDef{address: 0x005b2d3a, function_type: PhantomData}; - pub const UPDATE_AMPHIBIOUS_NEIGHBORS_1: FunctionDef = FunctionDef{address: 0x005b2e8a, function_type: PhantomData}; - pub const CHECK_AMPHIBIOUS_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005b2fa1, function_type: PhantomData}; - pub const HABITAT_TILE_CHANGED: FunctionDef = FunctionDef{address: 0x005b3a77, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/habitat_seen_from_building"))] + pub const HABITAT_SEEN_FROM_BUILDING: FunctionDef *const i32> = FunctionDef{address: 0x005a2b61, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/check_show_neighbor"))] + pub const CHECK_SHOW_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005aaed2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/remove_all_habitats"))] + pub const REMOVE_ALL_HABITATS: FunctionDef = FunctionDef{address: 0x005b11d2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/update_show_neighbors_1"))] + pub const UPDATE_SHOW_NEIGHBORS_1: FunctionDef = FunctionDef{address: 0x005b2d3a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/update_amphibious_neighbors_1"))] + pub const UPDATE_AMPHIBIOUS_NEIGHBORS_1: FunctionDef = FunctionDef{address: 0x005b2e8a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/check_amphibious_neighbor"))] + pub const CHECK_AMPHIBIOUS_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005b2fa1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/habitat_tile_changed"))] + pub const HABITAT_TILE_CHANGED: FunctionDef = FunctionDef{address: 0x005b3a77, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/remove_habitat_1"))] pub const REMOVE_HABITAT_1: FunctionDef = FunctionDef{address: 0x005b66ea, function_type: PhantomData}; - pub const SPLIT_TANK_INTO_LAND: FunctionDef u32> = FunctionDef{address: 0x006044a5, function_type: PhantomData}; - pub const TERRAIN_TILE_CHANGED: FunctionDef = FunctionDef{address: 0x0060497a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/split_tank_into_land"))] + pub const SPLIT_TANK_INTO_LAND: FunctionDef u32> = FunctionDef{address: 0x006044a5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/terrain_tile_changed"))] + pub const TERRAIN_TILE_CHANGED: FunctionDef = FunctionDef{address: 0x0060497a, function_type: PhantomData}; } // ZTHelicopter class functions pub mod zthelicopter { use super::*; - pub const INIT_AFTER_LOAD: FunctionDef = FunctionDef{address: 0x00482cf1, function_type: PhantomData}; - pub const GET_NEXT_POS: FunctionDef = FunctionDef{address: 0x0048c0c6, function_type: PhantomData}; - pub const START_LOOP_SOUND: FunctionDef = FunctionDef{address: 0x0048d645, function_type: PhantomData}; - pub const VALIDATE_TANK_POSITION: FunctionDef = FunctionDef{address: 0x005067be, function_type: PhantomData}; - pub const SET_DEST_TILE: FunctionDef = FunctionDef{address: 0x0061a117, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/init_after_load"))] + pub const INIT_AFTER_LOAD: FunctionDef = FunctionDef{address: 0x00482cf1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/set_world_dest"))] + pub const SET_WORLD_DEST: FunctionDef = FunctionDef{address: 0x0048bf41, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/get_next_pos"))] + pub const GET_NEXT_POS: FunctionDef = FunctionDef{address: 0x0048c0c6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/start_loop_sound"))] + pub const START_LOOP_SOUND: FunctionDef = FunctionDef{address: 0x0048d645, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004e56e9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/validate_position"))] + pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x005066ff, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/validate_position_inner"))] + pub const VALIDATE_POSITION_INNER: FunctionDef = FunctionDef{address: 0x0050675f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/validate_tank_position"))] + pub const VALIDATE_TANK_POSITION: FunctionDef = FunctionDef{address: 0x005067be, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/set_dest_tile"))] + pub const SET_DEST_TILE: FunctionDef = FunctionDef{address: 0x0061a117, function_type: PhantomData}; } // ZTHelicopterType class functions pub mod zthelicoptertype { use super::*; - pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004c42ff, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051c7b5, function_type: PhantomData}; - pub const ZTHELICOPTER_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x0057cb90, function_type: PhantomData}; - pub const ZTHELICOPTER_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x0057cbae, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthelicoptertype/load_characteristics"))] + pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004c42ff, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthelicoptertype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x004e5725, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthelicoptertype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051c7b5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthelicoptertype/zthelicopter_type_0"))] + pub const ZTHELICOPTER_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x0057cb90, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zthelicoptertype/zthelicopter_type_1"))] + pub const ZTHELICOPTER_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x0057cbae, function_type: PhantomData}; } // ZTItem class functions pub mod ztitem { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztitem/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x00464b90, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x00464f00, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004651cf, function_type: PhantomData}; - pub const GET_ITEM: FunctionDef u32> = FunctionDef{address: 0x004a84f3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztitem/load_characteristics"))] + pub const LOAD_CHARACTERISTICS: FunctionDef *const i16> = FunctionDef{address: 0x00464f00, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztitem/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const c_void> = FunctionDef{address: 0x004651cf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztitem/get_item"))] + pub const GET_ITEM: FunctionDef u32> = FunctionDef{address: 0x004a84f3, function_type: PhantomData}; } // ZTKeeper class functions pub mod ztkeeper { use super::*; - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x00458759, function_type: PhantomData}; - pub const NOTIFY_HABITAT_NOT_COMING: FunctionDef = FunctionDef{address: 0x004a879f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztkeeper/get_terrain_cost"))] + pub const GET_TERRAIN_COST: FunctionDef i32> = FunctionDef{address: 0x00423b28, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztkeeper/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00457b2e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztkeeper/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x00458759, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztkeeper/notify_habitat_not_coming"))] + pub const NOTIFY_HABITAT_NOT_COMING: FunctionDef = FunctionDef{address: 0x004a879f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztkeeper/reset_ai"))] + pub const RESET_AI: FunctionDef = FunctionDef{address: 0x005ae772, function_type: PhantomData}; } // ZTKeeperType class functions pub mod ztkeepertype { use super::*; - pub const LOAD_CHARACTERISTICS_0: FunctionDef = FunctionDef{address: 0x004c32bd, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c34ae, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051bde7, function_type: PhantomData}; - pub const ZTKEEPER_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x0057ca95, function_type: PhantomData}; - pub const ZTKEEPER_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x0057cae0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztkeepertype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x00457b4e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztkeepertype/load_characteristics_0"))] + pub const LOAD_CHARACTERISTICS_0: FunctionDef u8> = FunctionDef{address: 0x004c32bd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztkeepertype/load_characteristics_1"))] + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c34ae, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztkeepertype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051bde7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztkeepertype/ztkeeper_type_0"))] + pub const ZTKEEPER_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x0057ca95, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztkeepertype/ztkeeper_type_1"))] + pub const ZTKEEPER_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x0057cae0, function_type: PhantomData}; } // ZTMVTempEntityList class functions pub mod ztmvtempentitylist { use super::*; - pub const CLEAR: FunctionDef = FunctionDef{address: 0x00443e12, function_type: PhantomData}; - pub const ADD_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004df44e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmvtempentitylist/clear"))] + pub const CLEAR: FunctionDef = FunctionDef{address: 0x00443e12, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmvtempentitylist/add_entity"))] + pub const ADD_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x004df44e, function_type: PhantomData}; } // ZTMaint class functions pub mod ztmaint { use super::*; - pub const GET_TERRAIN_COST: FunctionDef = FunctionDef{address: 0x00439c73, function_type: PhantomData}; - pub const FINISH_TASK: FunctionDef = FunctionDef{address: 0x004a97e5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmaint/get_terrain_cost"))] + pub const GET_TERRAIN_COST: FunctionDef = FunctionDef{address: 0x00439c73, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmaint/finish_task"))] + pub const FINISH_TASK: FunctionDef = FunctionDef{address: 0x004a97e5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmaint/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const i32> = FunctionDef{address: 0x004c5ecf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmaint/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x00502078, function_type: PhantomData}; } // ZTMaintTaskPool class functions pub mod ztmainttaskpool { use super::*; - pub const CLEAR: FunctionDef = FunctionDef{address: 0x005b11a2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmainttaskpool/clear"))] + pub const CLEAR: FunctionDef = FunctionDef{address: 0x005b11a2, function_type: PhantomData}; } // ZTMaintType class functions pub mod ztmainttype { use super::*; - pub const LOAD_CHARACTERISTICS_0: FunctionDef = FunctionDef{address: 0x004c3bb3, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c3d44, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051bf9e, function_type: PhantomData}; - pub const ZTMAINT_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x0057cafe, function_type: PhantomData}; - pub const ZTMAINT_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x0057cb49, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmainttype/load_characteristics_0"))] + pub const LOAD_CHARACTERISTICS_0: FunctionDef u8> = FunctionDef{address: 0x004c3bb3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmainttype/load_characteristics_1"))] + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c3d44, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmainttype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x004c5ead, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmainttype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const i32> = FunctionDef{address: 0x0051bf9e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmainttype/ztmaint_type_0"))] + pub const ZTMAINT_TYPE_0: FunctionDef *const i32> = FunctionDef{address: 0x0057cafe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmainttype/ztmaint_type_1"))] + pub const ZTMAINT_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x0057cb49, function_type: PhantomData}; } // ZTMapView class functions pub mod ztmapview { use super::*; - pub const CLEAR_CONFLICTING_ENTITIES: FunctionDef = FunctionDef{address: 0x0040248a, function_type: PhantomData}; - pub const SET_HIGHLIGHTED_ENTITY: FunctionDef = FunctionDef{address: 0x0040fcdb, function_type: PhantomData}; - pub const SCROLL_MAP: FunctionDef = FunctionDef{address: 0x00418da5, function_type: PhantomData}; - pub const DRAW: FunctionDef = FunctionDef{address: 0x00419729, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00419eb2, function_type: PhantomData}; - pub const PREPARE_TO_DELETE_ENTITY: FunctionDef = FunctionDef{address: 0x0041e145, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/clear_conflicting_entities"))] + pub const CLEAR_CONFLICTING_ENTITIES: FunctionDef = FunctionDef{address: 0x0040248a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_highlighted_entity"))] + pub const SET_HIGHLIGHTED_ENTITY: FunctionDef = FunctionDef{address: 0x0040fcdb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/scroll_map"))] + pub const SCROLL_MAP: FunctionDef = FunctionDef{address: 0x00418da5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/draw"))] + pub const DRAW: FunctionDef = FunctionDef{address: 0x00419729, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00419eb2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/prepare_to_delete_entity"))] + pub const PREPARE_TO_DELETE_ENTITY: FunctionDef = FunctionDef{address: 0x0041e145, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/use_cursor"))] pub const USE_CURSOR_0: FunctionDef = FunctionDef{address: 0x0043231a, function_type: PhantomData}; - pub const RENDER_0: FunctionDef = FunctionDef{address: 0x00432bd7, function_type: PhantomData}; - pub const SHOW_CURRENT_COST: FunctionDef = FunctionDef{address: 0x00433918, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/render_0"))] + pub const RENDER_0: FunctionDef = FunctionDef{address: 0x00432bd7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/show_current_cost"))] + pub const SHOW_CURRENT_COST: FunctionDef = FunctionDef{address: 0x00433918, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/check_mouse_over_entity"))] pub const CHECK_MOUSE_OVER_ENTITY: FunctionDef = FunctionDef{address: 0x00433b34, function_type: PhantomData}; - pub const USE_CURSOR_1: FunctionDef = FunctionDef{address: 0x00443d97, function_type: PhantomData}; - pub const HIGHLIGHT_MAP: FunctionDef = FunctionDef{address: 0x00443daf, function_type: PhantomData}; - pub const CANCEL_ENTITY_MOVE: FunctionDef = FunctionDef{address: 0x00443df7, function_type: PhantomData}; - pub const SET_MAP_SELECTION_SIZE: FunctionDef u32> = FunctionDef{address: 0x00449739, function_type: PhantomData}; - pub const HAS_UNDO_ACTION: FunctionDef u32> = FunctionDef{address: 0x00458b5f, function_type: PhantomData}; - pub const GET_HABITAT: FunctionDef i32> = FunctionDef{address: 0x00468a7d, function_type: PhantomData}; - pub const PICK_UP_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x0046ab75, function_type: PhantomData}; - pub const HANDLE_CHAR: FunctionDef u32> = FunctionDef{address: 0x0046bd7d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_current_cost"))] + pub const SET_CURRENT_COST: FunctionDef = FunctionDef{address: 0x00443d97, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/highlight_map"))] + pub const HIGHLIGHT_MAP: FunctionDef = FunctionDef{address: 0x00443daf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/cancel_entity_move"))] + pub const CANCEL_ENTITY_MOVE: FunctionDef = FunctionDef{address: 0x00443df7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_map_selection_size"))] + pub const SET_MAP_SELECTION_SIZE: FunctionDef *const u8> = FunctionDef{address: 0x00449739, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/has_undo_action"))] + pub const HAS_UNDO_ACTION: FunctionDef u32> = FunctionDef{address: 0x00458b5f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/get_habitat"))] + pub const GET_HABITAT: FunctionDef i32> = FunctionDef{address: 0x00468a7d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/pick_up_selected_entity"))] + pub const PICK_UP_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x0046ab75, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/handle_char"))] + pub const HANDLE_CHAR: FunctionDef u32> = FunctionDef{address: 0x0046bd7d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/save_state"))] pub const SAVE_STATE: FunctionDef u32> = FunctionDef{address: 0x0047abeb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/place_entity_on_map_0"))] pub const PLACE_ENTITY_ON_MAP_0: FunctionDef u32> = FunctionDef{address: 0x004868cf, function_type: PhantomData}; - pub const FOLLOW_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x0048c5e9, function_type: PhantomData}; - pub const REMOVE_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x0048d065, function_type: PhantomData}; - pub const DO_SNAKE: FunctionDef = FunctionDef{address: 0x0048e56c, function_type: PhantomData}; - pub const SET_MAP_VIEW: FunctionDef = FunctionDef{address: 0x004b0384, function_type: PhantomData}; - pub const SET_MAP_SELECTION: FunctionDef = FunctionDef{address: 0x004b05ab, function_type: PhantomData}; - pub const ROTATE_MAP: FunctionDef = FunctionDef{address: 0x004b06be, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/follow_selected_entity"))] + pub const FOLLOW_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x0048c5e9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/remove_selected_entity"))] + pub const REMOVE_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x0048d065, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/do_snake"))] + pub const DO_SNAKE: FunctionDef = FunctionDef{address: 0x0048e56c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/do_ysnake"))] + pub const DO_YSNAKE: FunctionDef = FunctionDef{address: 0x0048eb89, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/do_xsnake"))] + pub const DO_XSNAKE: FunctionDef = FunctionDef{address: 0x0048ec4b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_map_view"))] + pub const SET_MAP_VIEW: FunctionDef = FunctionDef{address: 0x004b0384, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_map_selection"))] + pub const SET_MAP_SELECTION: FunctionDef = FunctionDef{address: 0x004b05ab, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/rotate_map"))] + pub const ROTATE_MAP: FunctionDef = FunctionDef{address: 0x004b06be, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/zoom_map"))] pub const ZOOM_MAP: FunctionDef = FunctionDef{address: 0x004b072d, function_type: PhantomData}; - pub const SET_SELECTED_ENTITY_0: FunctionDef = FunctionDef{address: 0x004b2322, function_type: PhantomData}; - pub const CHECK_ZOOM_OPTIONS: FunctionDef = FunctionDef{address: 0x004b2868, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_selected_entity_0"))] + pub const SET_SELECTED_ENTITY_0: FunctionDef = FunctionDef{address: 0x004b2322, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/check_zoom_options"))] + pub const CHECK_ZOOM_OPTIONS: FunctionDef = FunctionDef{address: 0x004b2868, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/destroy_cursors"))] pub const DESTROY_CURSORS: FunctionDef = FunctionDef{address: 0x004b2c84, function_type: PhantomData}; - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6c4c, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d3f9e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/clear"))] + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6c4c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d3f9e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/init_cursors"))] pub const INIT_CURSORS: FunctionDef = FunctionDef{address: 0x004d40c4, function_type: PhantomData}; - pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x004d83d7, function_type: PhantomData}; - pub const HANDLE_LEFT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004d8533, function_type: PhantomData}; - pub const PLACE_ENTITY_ON_MAP_1: FunctionDef u32> = FunctionDef{address: 0x004d9088, function_type: PhantomData}; - pub const COMMIT_TERRAFORM: FunctionDef = FunctionDef{address: 0x004da19c, function_type: PhantomData}; - pub const UNDO_LAST_ACTION_0: FunctionDef = FunctionDef{address: 0x004de527, function_type: PhantomData}; - pub const SET_ENTITY_POSITION: FunctionDef = FunctionDef{address: 0x004ded90, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/handle_left_button_down"))] + pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x004d83d7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/handle_left_button_up"))] + pub const HANDLE_LEFT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004d8533, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/place_entity_on_map_1"))] + pub const PLACE_ENTITY_ON_MAP_1: FunctionDef *const i32> = FunctionDef{address: 0x004d9088, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/commit_terraform"))] + pub const COMMIT_TERRAFORM: FunctionDef = FunctionDef{address: 0x004da19c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/undo_last_action_0"))] + pub const UNDO_LAST_ACTION_0: FunctionDef = FunctionDef{address: 0x004de527, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_entity_position"))] + pub const SET_ENTITY_POSITION: FunctionDef = FunctionDef{address: 0x004ded90, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/check_tank_placement"))] pub const CHECK_TANK_PLACEMENT: FunctionDef bool> = FunctionDef{address: 0x004df688, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/render_1"))] pub const RENDER_1: FunctionDef = FunctionDef{address: 0x004df7e8, function_type: PhantomData}; - pub const SET_PLACE_GATE_MODE: FunctionDef = FunctionDef{address: 0x004e1064, function_type: PhantomData}; - pub const FILL_CANVASES: FunctionDef = FunctionDef{address: 0x004ec8bf, function_type: PhantomData}; - pub const HANDLE_KEY_UP: FunctionDef = FunctionDef{address: 0x004f0b1e, function_type: PhantomData}; - pub const HANDLE_KEY_DOWN: FunctionDef = FunctionDef{address: 0x004f0ee4, function_type: PhantomData}; - pub const CLEAR_UNDO_ACTIONS: FunctionDef = FunctionDef{address: 0x004f16f0, function_type: PhantomData}; - pub const SET_TEMP_ENTITY: FunctionDef = FunctionDef{address: 0x004f189a, function_type: PhantomData}; - pub const REMOVE_ENTITY_FROM_MAP_0: FunctionDef = FunctionDef{address: 0x004f94be, function_type: PhantomData}; - pub const HANDLE_RIGHT_BUTTON_DOWN: FunctionDef = FunctionDef{address: 0x004f95e4, function_type: PhantomData}; - pub const CANCEL_CURRENT_OPERATION: FunctionDef = FunctionDef{address: 0x004f9621, function_type: PhantomData}; - pub const HANDLE_RIGHT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004f96fd, function_type: PhantomData}; - pub const CHECK_UNDO_BUFFER: FunctionDef = FunctionDef{address: 0x004fa68c, function_type: PhantomData}; - pub const RENDER_CURRENT_COST: FunctionDef = FunctionDef{address: 0x004fb175, function_type: PhantomData}; - pub const CANCEL_DRAG: FunctionDef = FunctionDef{address: 0x004ffa6b, function_type: PhantomData}; - pub const ZTMAP_VIEW_0: FunctionDef u32> = FunctionDef{address: 0x00502431, function_type: PhantomData}; - pub const ZTMAP_VIEW_1: FunctionDef u32> = FunctionDef{address: 0x005026cf, function_type: PhantomData}; - pub const SET_BULLDOZER: FunctionDef = FunctionDef{address: 0x005096e8, function_type: PhantomData}; - pub const REMOVE_ENTITY_FROM_MAP_1: FunctionDef = FunctionDef{address: 0x0050a0b0, function_type: PhantomData}; - pub const REMOVE_ENTITY: FunctionDef = FunctionDef{address: 0x0050a432, function_type: PhantomData}; - pub const ADD_HABITAT_NAME_UNDO_ACTIONS: FunctionDef = FunctionDef{address: 0x0050ae37, function_type: PhantomData}; - pub const SET_MAP: FunctionDef = FunctionDef{address: 0x00519ba0, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051f80c, function_type: PhantomData}; - pub const CREATE: FunctionDef = FunctionDef{address: 0x005205bc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_place_gate_mode"))] + pub const SET_PLACE_GATE_MODE: FunctionDef = FunctionDef{address: 0x004e1064, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/fill_canvases"))] + pub const FILL_CANVASES: FunctionDef = FunctionDef{address: 0x004ec8bf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/handle_key_up"))] + pub const HANDLE_KEY_UP: FunctionDef u32> = FunctionDef{address: 0x004f0b1e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/handle_key_down"))] + pub const HANDLE_KEY_DOWN: FunctionDef u32> = FunctionDef{address: 0x004f0ee4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/clear_undo_actions"))] + pub const CLEAR_UNDO_ACTIONS: FunctionDef = FunctionDef{address: 0x004f16f0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_temp_entity"))] + pub const SET_TEMP_ENTITY: FunctionDef = FunctionDef{address: 0x004f189a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/remove_entity_from_map_0"))] + pub const REMOVE_ENTITY_FROM_MAP_0: FunctionDef = FunctionDef{address: 0x004f94be, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/handle_right_button_down"))] + pub const HANDLE_RIGHT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x004f95e4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/cancel_current_operation"))] + pub const CANCEL_CURRENT_OPERATION: FunctionDef = FunctionDef{address: 0x004f9621, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/handle_right_button_up"))] + pub const HANDLE_RIGHT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004f96fd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/check_undo_buffer"))] + pub const CHECK_UNDO_BUFFER: FunctionDef = FunctionDef{address: 0x004fa68c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/render_current_cost"))] + pub const RENDER_CURRENT_COST: FunctionDef = FunctionDef{address: 0x004fb175, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/cancel_drag"))] + pub const CANCEL_DRAG: FunctionDef = FunctionDef{address: 0x004ffa6b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/ztmap_view_0"))] + pub const ZTMAP_VIEW_0: FunctionDef *const u32> = FunctionDef{address: 0x00502431, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/ztmap_view_1"))] + pub const ZTMAP_VIEW_1: FunctionDef *const u32> = FunctionDef{address: 0x005026cf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_bulldozer"))] + pub const SET_BULLDOZER: FunctionDef = FunctionDef{address: 0x005096e8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/remove_entity_from_map_1"))] + pub const REMOVE_ENTITY_FROM_MAP_1: FunctionDef = FunctionDef{address: 0x0050a0b0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/remove_entity"))] + pub const REMOVE_ENTITY: FunctionDef = FunctionDef{address: 0x0050a432, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/add_habitat_name_undo_actions"))] + pub const ADD_HABITAT_NAME_UNDO_ACTIONS: FunctionDef = FunctionDef{address: 0x0050ae37, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_map"))] + pub const SET_MAP: FunctionDef = FunctionDef{address: 0x00519ba0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051f80c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/create"))] + pub const CREATE: FunctionDef *const u32> = FunctionDef{address: 0x005205bc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/take_snapshot"))] pub const TAKE_SNAPSHOT: FunctionDef = FunctionDef{address: 0x00532c75, function_type: PhantomData}; - pub const LOAD_STATE: FunctionDef = FunctionDef{address: 0x00592907, function_type: PhantomData}; - pub const SET_VIEW_CENTER: FunctionDef = FunctionDef{address: 0x0059b90c, function_type: PhantomData}; - pub const ADD_UNDO_ACTION: FunctionDef = FunctionDef{address: 0x005b32de, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/load_state"))] + pub const LOAD_STATE: FunctionDef bool> = FunctionDef{address: 0x00592907, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_view_center"))] + pub const SET_VIEW_CENTER: FunctionDef = FunctionDef{address: 0x0059b90c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/add_undo_action"))] + pub const ADD_UNDO_ACTION: FunctionDef = FunctionDef{address: 0x005b32de, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_selected_entity_1"))] pub const SET_SELECTED_ENTITY_1: FunctionDef = FunctionDef{address: 0x005b669e, function_type: PhantomData}; - pub const UNDO_LAST_ACTION_1: FunctionDef = FunctionDef{address: 0x005b6710, function_type: PhantomData}; - pub const CANCEL_TERRAFORM: FunctionDef = FunctionDef{address: 0x006097ef, function_type: PhantomData}; - pub const DRAW_BACK_CUBE: FunctionDef = FunctionDef{address: 0x00609ae0, function_type: PhantomData}; - pub const DRAW_FRONT_CUBE: FunctionDef = FunctionDef{address: 0x00609ee1, function_type: PhantomData}; - pub const DRAW_LEFT_CUBE: FunctionDef = FunctionDef{address: 0x0060a2e2, function_type: PhantomData}; - pub const DRAW_RIGHT_CUBE: FunctionDef = FunctionDef{address: 0x0060a5da, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/undo_last_action_1"))] + pub const UNDO_LAST_ACTION_1: FunctionDef = FunctionDef{address: 0x005b6710, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/cancel_terraform"))] + pub const CANCEL_TERRAFORM: FunctionDef = FunctionDef{address: 0x006097ef, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/draw_back_cube"))] + pub const DRAW_BACK_CUBE: FunctionDef = FunctionDef{address: 0x00609ae0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/draw_front_cube"))] + pub const DRAW_FRONT_CUBE: FunctionDef = FunctionDef{address: 0x00609ee1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/draw_left_cube"))] + pub const DRAW_LEFT_CUBE: FunctionDef = FunctionDef{address: 0x0060a2e2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/draw_right_cube"))] + pub const DRAW_RIGHT_CUBE: FunctionDef = FunctionDef{address: 0x0060a5da, function_type: PhantomData}; } // ZTMegatileMgr class functions pub mod ztmegatilemgr { use super::*; - pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x0041ffdc, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0043525b, function_type: PhantomData}; - pub const INIT: FunctionDef = FunctionDef{address: 0x0058e82d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmegatilemgr/recalculate_characteristics"))] + pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x0041ffdc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmegatilemgr/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0043525b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztmegatilemgr/init"))] + pub const INIT: FunctionDef = FunctionDef{address: 0x0058e82d, function_type: PhantomData}; } // ZTMiniMap class functions pub mod ztminimap { use super::*; - pub const ROTATE_XY: FunctionDef = FunctionDef{address: 0x0044458a, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x004445ca, function_type: PhantomData}; - pub const GET_TILE_COLOR: FunctionDef u32> = FunctionDef{address: 0x0048ff22, function_type: PhantomData}; - pub const SET_CENTER: FunctionDef = FunctionDef{address: 0x004aff88, function_type: PhantomData}; - pub const ZTMINI_MAP: FunctionDef u32> = FunctionDef{address: 0x00503494, function_type: PhantomData}; - pub const SET_DIMENSIONS: FunctionDef = FunctionDef{address: 0x0058e416, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00619477, function_type: PhantomData}; - pub const COPY: FunctionDef u32> = FunctionDef{address: 0x006198d7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/rotate_xy"))] + pub const ROTATE_XY: FunctionDef = FunctionDef{address: 0x0044458a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x004445ca, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/get_tile_color"))] + pub const GET_TILE_COLOR: FunctionDef u32> = FunctionDef{address: 0x0048ff22, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/set_center"))] + pub const SET_CENTER: FunctionDef = FunctionDef{address: 0x004aff88, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/ztmini_map"))] + pub const ZTMINI_MAP: FunctionDef *const u32> = FunctionDef{address: 0x00503494, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/set_dimensions"))] + pub const SET_DIMENSIONS: FunctionDef = FunctionDef{address: 0x0058e416, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00619477, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/copy"))] + pub const COPY: FunctionDef *const u32> = FunctionDef{address: 0x006198d7, function_type: PhantomData}; } // ZTObservableArea class functions pub mod ztobservablearea { use super::*; - pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x00447a00, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0044ef63, function_type: PhantomData}; - pub const ADD_TILE: FunctionDef = FunctionDef{address: 0x004f3b00, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztobservablearea/recalculate_characteristics"))] + pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x00447a00, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztobservablearea/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0044ef63, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztobservablearea/add_tile"))] + pub const ADD_TILE: FunctionDef = FunctionDef{address: 0x004f3b00, function_type: PhantomData}; } // ZTPath class functions pub mod ztpath { use super::*; - pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x0044a261, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztpath/shape_to_set"))] + pub const SHAPE_TO_SET: FunctionDef u32> = FunctionDef{address: 0x0044a1a5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztpath/set_shape"))] + pub const SET_SHAPE: FunctionDef = FunctionDef{address: 0x0044a20a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztpath/validate_position"))] + pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x0044a261, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztpath/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00451b68, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztpath/add_to_map"))] + pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x00451c0b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztpath/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x00500184, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztpath/verify_shape"))] + pub const VERIFY_SHAPE: FunctionDef bool> = FunctionDef{address: 0x00619f4a, function_type: PhantomData}; } // ZTPathType class functions pub mod ztpathtype { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztpathtype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x00451b8a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztpathtype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x00465a0a, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00465c62, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x004c24cf, function_type: PhantomData}; - pub const ZTPATH_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x00504c2f, function_type: PhantomData}; - pub const ZTPATH_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x00504ce0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztpathtype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00465c62, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztpathtype/load_characteristics"))] + pub const LOAD_CHARACTERISTICS: FunctionDef u8> = FunctionDef{address: 0x004c24cf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztpathtype/ztpath_type_0"))] + pub const ZTPATH_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x00504c2f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztpathtype/ztpath_type_1"))] + pub const ZTPATH_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x00504ce0, function_type: PhantomData}; } // ZTResearchBranch class functions pub mod ztresearchbranch { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchbranch/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041f1ba, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchbranch/increase_funding"))] pub const INCREASE_FUNDING: FunctionDef = FunctionDef{address: 0x0046c2e0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchbranch/get_funding_text"))] pub const GET_FUNDING_TEXT: FunctionDef *const u32> = FunctionDef{address: 0x00470d0f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchbranch/days_remaining_on_program"))] pub const DAYS_REMAINING_ON_PROGRAM: FunctionDef = FunctionDef{address: 0x004eb1bf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchbranch/pct_remaining_on_program"))] pub const PCT_REMAINING_ON_PROGRAM: FunctionDef i64> = FunctionDef{address: 0x004eb1f2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchbranch/ztresearch_branch"))] pub const ZTRESEARCH_BRANCH: FunctionDef = FunctionDef{address: 0x005018a2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchbranch/load_branch"))] pub const LOAD_BRANCH: FunctionDef u32> = FunctionDef{address: 0x00590832, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchbranch/pick_random_program"))] pub const PICK_RANDOM_PROGRAM: FunctionDef = FunctionDef{address: 0x005b09f6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchbranch/clear_branch"))] pub const CLEAR_BRANCH: FunctionDef = FunctionDef{address: 0x005b0da6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchbranch/decrease_funding"))] pub const DECREASE_FUNDING: FunctionDef = FunctionDef{address: 0x0061a547, function_type: PhantomData}; } @@ -2382,9 +4097,13 @@ pub mod ztresearchbranch { pub mod ztresearchcategory { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchcategory/ztresearch_category"))] pub const ZTRESEARCH_CATEGORY: FunctionDef = FunctionDef{address: 0x0050198d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchcategory/load_category"))] pub const LOAD_CATEGORY: FunctionDef u32> = FunctionDef{address: 0x00590b76, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchcategory/constructor"))] pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00590d52, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchcategory/clear_category"))] pub const CLEAR_CATEGORY: FunctionDef = FunctionDef{address: 0x005b0d44, function_type: PhantomData}; } @@ -2392,21 +4111,33 @@ pub mod ztresearchcategory { pub mod ztresearchmgr { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchmgr/update"))] pub const UPDATE: FunctionDef i32> = FunctionDef{address: 0x00435a6f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchmgr/save"))] pub const SAVE: FunctionDef bool> = FunctionDef{address: 0x0047a923, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchmgr/force_research"))] pub const FORCE_RESEARCH: FunctionDef = FunctionDef{address: 0x0047e657, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchmgr/ztresearch_mgr_0"))] pub const ZTRESEARCH_MGR_0: FunctionDef *const u32> = FunctionDef{address: 0x00504d37, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchmgr/ztresearch_mgr_1"))] pub const ZTRESEARCH_MGR_1: FunctionDef *const u32> = FunctionDef{address: 0x00504d55, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchmgr/load"))] // Confirmed against ZTResearchMgr_load.asm: the function ends `RET 0x8`, popping 2 stack dwords // beyond `this`/ECX. Param 1 is the file/stream pointer (passed straight through to `deallocate` // as its 4th arg). Param 2 is a version value: `CMP [param2], 0x28; JC ` gates whether the // saved-records stream is read at all (records are only read when `param2 >= 0x28`). pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x00593c3c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchmgr/get_program"))] pub const GET_PROGRAM: FunctionDef *const i16> = FunctionDef{address: 0x005944b6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchmgr/get_category"))] pub const GET_CATEGORY: FunctionDef *const i16> = FunctionDef{address: 0x00594595, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchmgr/get_branch"))] pub const GET_BRANCH: FunctionDef *const i16> = FunctionDef{address: 0x0059466e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchmgr/set_effect_discount"))] pub const SET_EFFECT_DISCOUNT: FunctionDef *const i16> = FunctionDef{address: 0x0059b71d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchmgr/clear_branches"))] pub const CLEAR_BRANCHES: FunctionDef = FunctionDef{address: 0x005b0cb4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchmgr/load_branches"))] pub const LOAD_BRANCHES: FunctionDef u32> = FunctionDef{address: 0x0059064e, function_type: PhantomData}; } @@ -2414,10 +4145,15 @@ pub mod ztresearchmgr { pub mod ztresearchprogram { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchprogram/ztresearch_program"))] pub const ZTRESEARCH_PROGRAM: FunctionDef = FunctionDef{address: 0x00501a3e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchprogram/on_completion"))] pub const ON_COMPLETION: FunctionDef u32> = FunctionDef{address: 0x0058fb83, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchprogram/reset"))] pub const RESET: FunctionDef u32> = FunctionDef{address: 0x005900d8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchprogram/load_program"))] pub const LOAD_PROGRAM: FunctionDef u32> = FunctionDef{address: 0x00590e00, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchprogram/constructor"))] pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0059109b, function_type: PhantomData}; } @@ -2425,155 +4161,263 @@ pub mod ztresearchprogram { pub mod ztrubble { use super::*; - pub const PLAY_EXPLOSION_SOUND: FunctionDef = FunctionDef{address: 0x0047c863, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztrubble/play_explosion_sound"))] + pub const PLAY_EXPLOSION_SOUND: FunctionDef = FunctionDef{address: 0x0047c863, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztrubble/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0048e343, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztrubble/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x0048e50d, function_type: PhantomData}; } // ZTRubbleType class functions pub mod ztrubbletype { use super::*; - pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004c42a2, function_type: PhantomData}; - pub const LOAD_TYPE_MEMBERS: FunctionDef = FunctionDef{address: 0x0051ce38, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051d2cb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztrubbletype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x0048e370, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztrubbletype/load_characteristics"))] + pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004c42a2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztrubbletype/load_type_members"))] + pub const LOAD_TYPE_MEMBERS: FunctionDef u8> = FunctionDef{address: 0x0051ce38, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztrubbletype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051d2cb, function_type: PhantomData}; } // ZTScenarioMgr class functions pub mod ztscenariomgr { use super::*; - pub const END_SCENARIO: FunctionDef = FunctionDef{address: 0x0048a408, function_type: PhantomData}; - pub const BEGIN_SCENARIO: FunctionDef = FunctionDef{address: 0x004c998b, function_type: PhantomData}; - pub const COMMON_SETUP: FunctionDef = FunctionDef{address: 0x0058ed1f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariomgr/end_scenario"))] + pub const END_SCENARIO: FunctionDef u32> = FunctionDef{address: 0x0048a408, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariomgr/begin_scenario"))] + pub const BEGIN_SCENARIO: FunctionDef u32> = FunctionDef{address: 0x004c998b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariomgr/common_setup"))] + pub const COMMON_SETUP: FunctionDef = FunctionDef{address: 0x0058ed1f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariomgr/set_cash"))] pub const SET_CASH: FunctionDef = FunctionDef{address: 0x005b0f17, function_type: PhantomData}; - pub const ADD_CASH: FunctionDef = FunctionDef{address: 0x0060ccc2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariomgr/add_cash"))] + pub const ADD_CASH: FunctionDef = FunctionDef{address: 0x0060ccc2, function_type: PhantomData}; } // ZTScenarioSimpleGoal class functions pub mod ztscenariosimplegoal { use super::*; - pub const EVAL: FunctionDef i32> = FunctionDef{address: 0x0041d665, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/eval"))] + pub const EVAL: FunctionDef i32> = FunctionDef{address: 0x0041d665, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/eval00"))] pub const EVAL00: FunctionDef u32> = FunctionDef{address: 0x0041da81, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger10"))] pub const TRIGGER10: FunctionDef = FunctionDef{address: 0x0047e76a, function_type: PhantomData}; - pub const TRIGGER: FunctionDef = FunctionDef{address: 0x004fc783, function_type: PhantomData}; - pub const DO_DIALOG: FunctionDef = FunctionDef{address: 0x004fc812, function_type: PhantomData}; - pub const TRIGGER02: FunctionDef = FunctionDef{address: 0x005a0a10, function_type: PhantomData}; - pub const TRIGGER04: FunctionDef = FunctionDef{address: 0x005a0fc2, function_type: PhantomData}; - pub const TRIGGER07: FunctionDef = FunctionDef{address: 0x005a1139, function_type: PhantomData}; - pub const TRIGGER03: FunctionDef = FunctionDef{address: 0x005a13c5, function_type: PhantomData}; - pub const TRIGGER06: FunctionDef = FunctionDef{address: 0x005a154a, function_type: PhantomData}; - pub const TRIGGER05: FunctionDef = FunctionDef{address: 0x005a17a8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger"))] + pub const TRIGGER: FunctionDef = FunctionDef{address: 0x004fc783, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/do_dialog"))] + pub const DO_DIALOG: FunctionDef = FunctionDef{address: 0x004fc812, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger02"))] + pub const TRIGGER02: FunctionDef = FunctionDef{address: 0x005a0a10, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger04"))] + pub const TRIGGER04: FunctionDef = FunctionDef{address: 0x005a0fc2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger07"))] + pub const TRIGGER07: FunctionDef = FunctionDef{address: 0x005a1139, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger03"))] + pub const TRIGGER03: FunctionDef = FunctionDef{address: 0x005a13c5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger06"))] + pub const TRIGGER06: FunctionDef = FunctionDef{address: 0x005a154a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger05"))] + pub const TRIGGER05: FunctionDef = FunctionDef{address: 0x005a17a8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/eval11"))] pub const EVAL11: FunctionDef u32> = FunctionDef{address: 0x0061bb06, function_type: PhantomData}; - pub const TRIGGER01: FunctionDef = FunctionDef{address: 0x0061c139, function_type: PhantomData}; - pub const TRIGGER08: FunctionDef = FunctionDef{address: 0x0061c27d, function_type: PhantomData}; - pub const TRIGGER09: FunctionDef = FunctionDef{address: 0x0061c408, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger01"))] + pub const TRIGGER01: FunctionDef = FunctionDef{address: 0x0061c139, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger08"))] + pub const TRIGGER08: FunctionDef = FunctionDef{address: 0x0061c27d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger09"))] + pub const TRIGGER09: FunctionDef = FunctionDef{address: 0x0061c408, function_type: PhantomData}; } // ZTScenarioTimer class functions pub mod ztscenariotimer { use super::*; - pub const GET_STATE: FunctionDef u32> = FunctionDef{address: 0x0040f121, function_type: PhantomData}; - pub const SIZE: FunctionDef = FunctionDef{address: 0x004113d7, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0042425d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/get_state"))] + pub const GET_STATE: FunctionDef u32> = FunctionDef{address: 0x0040f121, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/size"))] + pub const SIZE: FunctionDef u32> = FunctionDef{address: 0x004113d7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0042425d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/save"))] pub const SAVE: FunctionDef = FunctionDef{address: 0x0047a04c, function_type: PhantomData}; - pub const DISPLAY_GOAL: FunctionDef = FunctionDef{address: 0x004f042c, function_type: PhantomData}; - pub const GET_TEXT: FunctionDef u32> = FunctionDef{address: 0x004f0484, function_type: PhantomData}; - pub const GET_ICON_NAME: FunctionDef = FunctionDef{address: 0x004f0488, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0058e218, function_type: PhantomData}; - pub const LOAD: FunctionDef = FunctionDef{address: 0x005950ab, function_type: PhantomData}; - pub const ZTSCENARIO_TIMER: FunctionDef u32> = FunctionDef{address: 0x005b130f, function_type: PhantomData}; - pub const LOAD_STATE: FunctionDef = FunctionDef{address: 0x0061c430, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/display_goal"))] + pub const DISPLAY_GOAL: FunctionDef = FunctionDef{address: 0x004f042c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/get_text"))] + pub const GET_TEXT: FunctionDef u32> = FunctionDef{address: 0x004f0484, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/get_icon_name"))] + pub const GET_ICON_NAME: FunctionDef u32> = FunctionDef{address: 0x004f0488, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0058e218, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/load"))] + pub const LOAD: FunctionDef = FunctionDef{address: 0x005950ab, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/ztscenario_timer"))] + pub const ZTSCENARIO_TIMER: FunctionDef *const u32> = FunctionDef{address: 0x005b130f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/load_state"))] + pub const LOAD_STATE: FunctionDef = FunctionDef{address: 0x0061c430, function_type: PhantomData}; } // ZTScenery class functions pub mod ztscenery { use super::*; - pub const FORCE_IDLE_ANIM: FunctionDef = FunctionDef{address: 0x00410540, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenery/force_idle_anim"))] + pub const FORCE_IDLE_ANIM: FunctionDef = FunctionDef{address: 0x00410540, function_type: PhantomData}; } // ZTSceneryType class functions pub mod ztscenerytype { use super::*; - pub const GET_PURCHASE_COST: FunctionDef = FunctionDef{address: 0x0040fbb6, function_type: PhantomData}; - pub const CHECK_DEAD_STATE: FunctionDef u32> = FunctionDef{address: 0x0041038b, function_type: PhantomData}; - pub const GET_TANK: FunctionDef u32> = FunctionDef{address: 0x00410460, function_type: PhantomData}; - pub const IS_SNAP_TO_GROUND: FunctionDef = FunctionDef{address: 0x004104ca, function_type: PhantomData}; - pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x004104cd, function_type: PhantomData}; - pub const ZTSCENERY_0: FunctionDef u32> = FunctionDef{address: 0x0041294b, function_type: PhantomData}; - pub const INIT_STATUS_VARS: FunctionDef u32> = FunctionDef{address: 0x00412972, function_type: PhantomData}; - pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x00412977, function_type: PhantomData}; - pub const INIT: FunctionDef = FunctionDef{address: 0x00412999, function_type: PhantomData}; - pub const ZTSCENERY_1: FunctionDef u32> = FunctionDef{address: 0x0041e075, function_type: PhantomData}; - pub const GET_SELL_PRICE: FunctionDef = FunctionDef{address: 0x0041ec7f, function_type: PhantomData}; - pub const GET_ESTHETIC_BONUS: FunctionDef = FunctionDef{address: 0x0041f05c, function_type: PhantomData}; - pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x00427340, function_type: PhantomData}; - pub const DRAW: FunctionDef = FunctionDef{address: 0x0043306b, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00434a75, function_type: PhantomData}; - pub const SET_NAME: FunctionDef = FunctionDef{address: 0x00449515, function_type: PhantomData}; - pub const FORCE_DEAD_ANIM: FunctionDef = FunctionDef{address: 0x0044a6ae, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044f625, function_type: PhantomData}; - pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00477b03, function_type: PhantomData}; - pub const TURN_TO_RUBBLE: FunctionDef = FunctionDef{address: 0x0047c2ac, function_type: PhantomData}; - pub const MORPH: FunctionDef = FunctionDef{address: 0x0048663a, function_type: PhantomData}; - pub const GET_HEIGHT: FunctionDef = FunctionDef{address: 0x004937a4, function_type: PhantomData}; - pub const IS_ZOO_GATE: FunctionDef u32> = FunctionDef{address: 0x004a4389, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004ba5b0, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004bf2d4, function_type: PhantomData}; - pub const GET_HELP_ID: FunctionDef = FunctionDef{address: 0x004e9e89, function_type: PhantomData}; - pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x004f40af, function_type: PhantomData}; - pub const SET_FOOD_UNITS: FunctionDef = FunctionDef{address: 0x004f429d, function_type: PhantomData}; - pub const GET_ONLY_SWIMS: FunctionDef = FunctionDef{address: 0x004f84b0, function_type: PhantomData}; - pub const GET_SWIMS: FunctionDef = FunctionDef{address: 0x004f84c2, function_type: PhantomData}; - pub const IS_SELECTABLE: FunctionDef = FunctionDef{address: 0x004fb59e, function_type: PhantomData}; - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004fe778, function_type: PhantomData}; - pub const ZTSCENERY_TYPE: FunctionDef u32> = FunctionDef{address: 0x00501080, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_purchase_cost"))] + pub const GET_PURCHASE_COST: FunctionDef f32> = FunctionDef{address: 0x0040fbb6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/check_dead_state"))] + pub const CHECK_DEAD_STATE: FunctionDef u32> = FunctionDef{address: 0x0041038b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_tank"))] + pub const GET_TANK: FunctionDef *const i32> = FunctionDef{address: 0x00410460, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/is_snap_to_ground"))] + pub const IS_SNAP_TO_GROUND: FunctionDef u8> = FunctionDef{address: 0x004104ca, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/validate_position"))] + pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x004104cd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/ztscenery_0"))] + pub const ZTSCENERY_0: FunctionDef *const u32> = FunctionDef{address: 0x0041294b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/init_status_vars"))] + pub const INIT_STATUS_VARS: FunctionDef u32> = FunctionDef{address: 0x00412972, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x00412977, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/init"))] + pub const INIT: FunctionDef = FunctionDef{address: 0x00412999, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/ztscenery_1"))] + pub const ZTSCENERY_1: FunctionDef *const u32> = FunctionDef{address: 0x0041e075, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_sell_price"))] + pub const GET_SELL_PRICE: FunctionDef f32> = FunctionDef{address: 0x0041ec7f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_esthetic_bonus"))] + pub const GET_ESTHETIC_BONUS: FunctionDef = FunctionDef{address: 0x0041f05c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/create_name"))] + pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x00427340, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/draw"))] + pub const DRAW: FunctionDef = FunctionDef{address: 0x0043306b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00434a75, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/set_name"))] + pub const SET_NAME: FunctionDef = FunctionDef{address: 0x00449515, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/force_dead_anim"))] + pub const FORCE_DEAD_ANIM: FunctionDef = FunctionDef{address: 0x0044a6ae, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044f625, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/save"))] + pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00477b03, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/turn_to_rubble"))] + pub const TURN_TO_RUBBLE: FunctionDef = FunctionDef{address: 0x0047c2ac, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/morph"))] + pub const MORPH: FunctionDef = FunctionDef{address: 0x0048663a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_height"))] + pub const GET_HEIGHT: FunctionDef u32> = FunctionDef{address: 0x004937a4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/is_zoo_gate"))] + pub const IS_ZOO_GATE: FunctionDef u32> = FunctionDef{address: 0x004a4389, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/load_characteristics"))] + pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004ba5b0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004bf2d4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_help_id"))] + pub const GET_HELP_ID: FunctionDef u32> = FunctionDef{address: 0x004e9e89, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/add_to_map"))] + pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x004f40af, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/set_food_units"))] + pub const SET_FOOD_UNITS: FunctionDef = FunctionDef{address: 0x004f429d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_only_swims"))] + pub const GET_ONLY_SWIMS: FunctionDef = FunctionDef{address: 0x004f84b0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_swims"))] + pub const GET_SWIMS: FunctionDef = FunctionDef{address: 0x004f84c2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/is_selectable"))] + pub const IS_SELECTABLE: FunctionDef u32> = FunctionDef{address: 0x004fb59e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004fe778, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/ztscenery_type"))] + pub const ZTSCENERY_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x00501080, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x0051b091, function_type: PhantomData}; - pub const INIT_AFTER_LOAD: FunctionDef u32> = FunctionDef{address: 0x00593f72, function_type: PhantomData}; - pub const GET_HABITAT: FunctionDef = FunctionDef{address: 0x006067d1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/init_after_load"))] + pub const INIT_AFTER_LOAD: FunctionDef u32> = FunctionDef{address: 0x00593f72, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_habitat"))] + pub const GET_HABITAT: FunctionDef u32> = FunctionDef{address: 0x006067d1, function_type: PhantomData}; } // ZTShow class functions pub mod ztshow { use super::*; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0046df38, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004cca2c, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0059e773, function_type: PhantomData}; - pub const CLEAR_SHOW_SCRIPT_STATES: FunctionDef = FunctionDef{address: 0x0059f79e, function_type: PhantomData}; - pub const STOP_0: FunctionDef = FunctionDef{address: 0x005a3db4, function_type: PhantomData}; - pub const STOP_1: FunctionDef = FunctionDef{address: 0x005a4057, function_type: PhantomData}; - pub const GATHER_UNITS: FunctionDef u32> = FunctionDef{address: 0x005a4519, function_type: PhantomData}; - pub const SEND_EVENT_GENERIC: FunctionDef = FunctionDef{address: 0x005a6f37, function_type: PhantomData}; - pub const START: FunctionDef = FunctionDef{address: 0x005a85e9, function_type: PhantomData}; - pub const CLEAR_UNIT_GOALS: FunctionDef = FunctionDef{address: 0x005a8a93, function_type: PhantomData}; - pub const REINIT: FunctionDef = FunctionDef{address: 0x005a8b25, function_type: PhantomData}; - pub const ZTSHOW: FunctionDef u32> = FunctionDef{address: 0x00604d36, function_type: PhantomData}; - pub const INIT: FunctionDef = FunctionDef{address: 0x00612c6e, function_type: PhantomData}; - pub const CLEAR: FunctionDef = FunctionDef{address: 0x00612c8c, function_type: PhantomData}; - pub const ABORT_SHOW: FunctionDef u32> = FunctionDef{address: 0x00612d20, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0046df38, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004cca2c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/update"))] + pub const UPDATE: FunctionDef *const u32> = FunctionDef{address: 0x0059e773, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/clear_show_script_states"))] + pub const CLEAR_SHOW_SCRIPT_STATES: FunctionDef = FunctionDef{address: 0x0059f79e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/stop_0"))] + pub const STOP_0: FunctionDef = FunctionDef{address: 0x005a3db4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/stop_1"))] + pub const STOP_1: FunctionDef = FunctionDef{address: 0x005a4057, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/gather_units"))] + pub const GATHER_UNITS: FunctionDef u32> = FunctionDef{address: 0x005a4519, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/send_event_generic"))] + pub const SEND_EVENT_GENERIC: FunctionDef = FunctionDef{address: 0x005a6f37, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/start"))] + pub const START: FunctionDef u32> = FunctionDef{address: 0x005a85e9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/clear_unit_goals"))] + pub const CLEAR_UNIT_GOALS: FunctionDef = FunctionDef{address: 0x005a8a93, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/reinit"))] + pub const REINIT: FunctionDef = FunctionDef{address: 0x005a8b25, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/ztshow"))] + pub const ZTSHOW: FunctionDef *const u32> = FunctionDef{address: 0x00604d36, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/init"))] + pub const INIT: FunctionDef u32> = FunctionDef{address: 0x00612c6e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/clear"))] + pub const CLEAR: FunctionDef = FunctionDef{address: 0x00612c8c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/abort_show"))] + pub const ABORT_SHOW: FunctionDef u32> = FunctionDef{address: 0x00612d20, function_type: PhantomData}; } // ZTShowInfo class functions pub mod ztshowinfo { use super::*; - pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x0046d779, function_type: PhantomData}; - pub const UPDATE_FROM_LOAD: FunctionDef = FunctionDef{address: 0x00484ec8, function_type: PhantomData}; - pub const ENTER_NEW_MONTH: FunctionDef = FunctionDef{address: 0x0048b57e, function_type: PhantomData}; - pub const SET_SHOW_FREQUENCY: FunctionDef = FunctionDef{address: 0x004cc86a, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004cc890, function_type: PhantomData}; - pub const RECALCULATE_SCHEDULE: FunctionDef = FunctionDef{address: 0x004f2947, function_type: PhantomData}; - pub const GET_SCHEDULED_SHOW_SCRIPT: FunctionDef u32> = FunctionDef{address: 0x0059dff6, function_type: PhantomData}; - pub const IS_STARTED: FunctionDef u32> = FunctionDef{address: 0x0059fa05, function_type: PhantomData}; - pub const GET_SHOW_UNIT_LIST: FunctionDef i32> = FunctionDef{address: 0x005a20ae, function_type: PhantomData}; - pub const INCREMENT_RECEIPTS: FunctionDef = FunctionDef{address: 0x005a95be, function_type: PhantomData}; - pub const INCREMENT_ATTENDANCE: FunctionDef = FunctionDef{address: 0x005a9826, function_type: PhantomData}; - pub const ADD_UNIT_TO_LIST: FunctionDef u32> = FunctionDef{address: 0x005a9a48, function_type: PhantomData}; - pub const ADD_UNIT: FunctionDef u32> = FunctionDef{address: 0x005a9c81, function_type: PhantomData}; - pub const REMOVE_UNIT: FunctionDef = FunctionDef{address: 0x005a9c96, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/load"))] + pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x0046d779, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/update_from_load"))] + pub const UPDATE_FROM_LOAD: FunctionDef = FunctionDef{address: 0x00484ec8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/enter_new_month"))] + pub const ENTER_NEW_MONTH: FunctionDef = FunctionDef{address: 0x0048b57e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/set_show_frequency"))] + pub const SET_SHOW_FREQUENCY: FunctionDef = FunctionDef{address: 0x004cc86a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004cc890, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/recalculate_schedule"))] + pub const RECALCULATE_SCHEDULE: FunctionDef = FunctionDef{address: 0x004f2947, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/get_scheduled_show_script"))] + pub const GET_SCHEDULED_SHOW_SCRIPT: FunctionDef u32> = FunctionDef{address: 0x0059dff6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/is_started"))] + pub const IS_STARTED: FunctionDef u32> = FunctionDef{address: 0x0059fa05, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/get_show_unit_list"))] + pub const GET_SHOW_UNIT_LIST: FunctionDef i32> = FunctionDef{address: 0x005a20ae, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/increment_receipts"))] + pub const INCREMENT_RECEIPTS: FunctionDef = FunctionDef{address: 0x005a95be, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/increment_attendance"))] + pub const INCREMENT_ATTENDANCE: FunctionDef = FunctionDef{address: 0x005a9826, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/add_unit_to_list"))] + pub const ADD_UNIT_TO_LIST: FunctionDef u32> = FunctionDef{address: 0x005a9a48, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/add_unit"))] + pub const ADD_UNIT: FunctionDef u32> = FunctionDef{address: 0x005a9c81, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/remove_unit"))] + pub const REMOVE_UNIT: FunctionDef = FunctionDef{address: 0x005a9c96, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00610076, function_type: PhantomData}; } @@ -2581,19 +4425,27 @@ pub mod ztshowinfo { pub mod ztshowmgr { use super::*; - pub const GET_SHOW_INFO: FunctionDef u32> = FunctionDef{address: 0x0041ebfd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowmgr/get_show_info"))] + pub const GET_SHOW_INFO: FunctionDef u32> = FunctionDef{address: 0x0041ebfd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowmgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00479fa4, function_type: PhantomData}; - pub const ENTER_NEW_MONTH: FunctionDef = FunctionDef{address: 0x004842a2, function_type: PhantomData}; - pub const INIT_SHOW_PARAMS: FunctionDef u32> = FunctionDef{address: 0x0051f59b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowmgr/enter_new_month"))] + pub const ENTER_NEW_MONTH: FunctionDef = FunctionDef{address: 0x004842a2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowmgr/init_show_params"))] + pub const INIT_SHOW_PARAMS: FunctionDef u32> = FunctionDef{address: 0x0051f59b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowmgr/destroy"))] pub const DESTROY: FunctionDef = FunctionDef{address: 0x0057db2e, function_type: PhantomData}; - pub const UNREGISTER_SHOW: FunctionDef u32> = FunctionDef{address: 0x005aaa95, function_type: PhantomData}; - pub const REGISTER_SHOW: FunctionDef u32> = FunctionDef{address: 0x005abb26, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowmgr/unregister_show"))] + pub const UNREGISTER_SHOW: FunctionDef u32> = FunctionDef{address: 0x005aaa95, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowmgr/register_show"))] + pub const REGISTER_SHOW: FunctionDef u32> = FunctionDef{address: 0x005abb26, function_type: PhantomData}; } // ZTShowScript class functions pub mod ztshowscript { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowscript/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0061c825, function_type: PhantomData}; } @@ -2601,8 +4453,11 @@ pub mod ztshowscript { pub mod ztshowscriptitem { use super::*; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004b9024, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004b9690, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowscriptitem/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004b9024, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowscriptitem/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004b9690, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowscriptitem/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0061c471, function_type: PhantomData}; } @@ -2610,6 +4465,7 @@ pub mod ztshowscriptitem { pub mod ztshowscriptmgr { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowscriptmgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00479f44, function_type: PhantomData}; } @@ -2617,150 +4473,261 @@ pub mod ztshowscriptmgr { pub mod ztshowstate { use super::*; - pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x0046de22, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004cc9c6, function_type: PhantomData}; - pub const ZTSHOW_STATE: FunctionDef u32> = FunctionDef{address: 0x004f28c3, function_type: PhantomData}; - pub const CLEAR: FunctionDef u32> = FunctionDef{address: 0x0059f72f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowstate/load"))] + pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x0046de22, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowstate/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004cc9c6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowstate/ztshow_state"))] + pub const ZTSHOW_STATE: FunctionDef *const u32> = FunctionDef{address: 0x004f28c3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztshowstate/clear"))] + pub const CLEAR: FunctionDef u32> = FunctionDef{address: 0x0059f72f, function_type: PhantomData}; } // ZTSoundscape class functions pub mod ztsoundscape { use super::*; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x004352dd, function_type: PhantomData}; - pub const ZTSOUNDSCAPE: FunctionDef u32> = FunctionDef{address: 0x005003e2, function_type: PhantomData}; - pub const INIT: FunctionDef = FunctionDef{address: 0x005922fd, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00592596, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztsoundscape/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x004352dd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztsoundscape/ztsoundscape"))] + pub const ZTSOUNDSCAPE: FunctionDef *const u32> = FunctionDef{address: 0x005003e2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztsoundscape/init"))] + pub const INIT: FunctionDef = FunctionDef{address: 0x005922fd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztsoundscape/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00592596, function_type: PhantomData}; } // ZTStaff class functions pub mod ztstaff { use super::*; - pub const GET_TERRAIN_COST: FunctionDef i32> = FunctionDef{address: 0x00439c80, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00457a0c, function_type: PhantomData}; - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004586f6, function_type: PhantomData}; - pub const ZTSTAFF: FunctionDef u32> = FunctionDef{address: 0x004f9d09, function_type: PhantomData}; - pub const REASSIGN_HABITATS: FunctionDef u32> = FunctionDef{address: 0x00595237, function_type: PhantomData}; - pub const INIT_AFTER_LOAD: FunctionDef u32> = FunctionDef{address: 0x005952dc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztstaff/get_terrain_cost"))] + pub const GET_TERRAIN_COST: FunctionDef i32> = FunctionDef{address: 0x00439c80, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztstaff/add_to_map"))] + pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x00449ed0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztstaff/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00457a0c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztstaff/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004586f6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztstaff/ztstaff"))] + pub const ZTSTAFF: FunctionDef *const u32> = FunctionDef{address: 0x004f9d09, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztstaff/reassign_habitats"))] + pub const REASSIGN_HABITATS: FunctionDef u32> = FunctionDef{address: 0x00595237, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztstaff/init_after_load"))] + pub const INIT_AFTER_LOAD: FunctionDef u32> = FunctionDef{address: 0x005952dc, function_type: PhantomData}; } // ZTStaffType class functions pub mod ztstafftype { use super::*; - pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004c3081, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c3783, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztstafftype/load_characteristics_0"))] + pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004c3081, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztstafftype/load_characteristics_1"))] + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c3783, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztstafftype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x0051b581, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051bd29, function_type: PhantomData}; - pub const ZTSTAFF_TYPE: FunctionDef u32> = FunctionDef{address: 0x0057ca11, function_type: PhantomData}; - pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x006112d9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztstafftype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051bd29, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztstafftype/ztstaff_type"))] + pub const ZTSTAFF_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x0057ca11, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztstafftype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x006112d9, function_type: PhantomData}; } // ZTTankExhibit class functions pub mod zttankexhibit { use super::*; - pub const GET_WATER_LEVEL: FunctionDef u32> = FunctionDef{address: 0x004110fd, function_type: PhantomData}; - pub const GET_TANK_HEIGHT: FunctionDef u32> = FunctionDef{address: 0x00411111, function_type: PhantomData}; - pub const IS_PURE_WATER: FunctionDef bool> = FunctionDef{address: 0x004111a9, function_type: PhantomData}; - pub const IS_EXTREMELY_MURKY_WATER: FunctionDef bool> = FunctionDef{address: 0x00411254, function_type: PhantomData}; - pub const SET_BASE_TERRAIN_TYPE: FunctionDef = FunctionDef{address: 0x00458bea, function_type: PhantomData}; - pub const REMOVE_ILLEGAL_ENTITIES: FunctionDef u32> = FunctionDef{address: 0x00458c2b, function_type: PhantomData}; - pub const SET_BASE_LEVEL: FunctionDef = FunctionDef{address: 0x00458c6a, function_type: PhantomData}; - pub const GET_ALL_ENTITIES: FunctionDef = FunctionDef{address: 0x004599a0, function_type: PhantomData}; - pub const UPDATE_TANK_WALL_INFO: FunctionDef = FunctionDef{address: 0x00459ab2, function_type: PhantomData}; - pub const UPDATE_ADJUSTMENT_COSTS: FunctionDef = FunctionDef{address: 0x00459b19, function_type: PhantomData}; - pub const FILL: FunctionDef = FunctionDef{address: 0x00459d94, function_type: PhantomData}; - pub const CHECK_ENTITIES_FOR_FILL: FunctionDef u32> = FunctionDef{address: 0x00459e09, function_type: PhantomData}; - pub const CAN_BE_IN_TANK: FunctionDef = FunctionDef{address: 0x00459f52, function_type: PhantomData}; - pub const SET_IS_NOT_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x0045b7ec, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0045b92f, function_type: PhantomData}; - pub const LEVEL_ALL_TILES: FunctionDef = FunctionDef{address: 0x0045bbbb, function_type: PhantomData}; - pub const UPDATE_TANK_INFO: FunctionDef = FunctionDef{address: 0x0045bc0f, function_type: PhantomData}; - pub const IS_ILLEGAL_ENTITY: FunctionDef u32> = FunctionDef{address: 0x0045da65, function_type: PhantomData}; - pub const GET_ILLEGAL_ENTITIES: FunctionDef = FunctionDef{address: 0x0045da8b, function_type: PhantomData}; - pub const RECLAIM_TILES: FunctionDef = FunctionDef{address: 0x00487a63, function_type: PhantomData}; - pub const SET_WATER_PURITY: FunctionDef = FunctionDef{address: 0x0049340d, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0049625f, function_type: PhantomData}; - pub const GET_LADDER_BASE_INSIDE_POS: FunctionDef = FunctionDef{address: 0x0049b1cc, function_type: PhantomData}; - pub const REMOVE_OWNED_TRANSIENTS: FunctionDef = FunctionDef{address: 0x00505099, function_type: PhantomData}; - pub const REMOVE_ALL_SPARKLES: FunctionDef = FunctionDef{address: 0x005050e2, function_type: PhantomData}; - pub const ZTTANK_EXHIBIT: FunctionDef u32> = FunctionDef{address: 0x00505148, function_type: PhantomData}; - pub const SET_WATER_CLEAN: FunctionDef = FunctionDef{address: 0x005052b1, function_type: PhantomData}; - pub const REMOVE_ALL_SPARKLES_BY_ID: FunctionDef = FunctionDef{address: 0x005052bd, function_type: PhantomData}; - pub const SET_IS_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x005ab683, function_type: PhantomData}; - pub const SET_WATER_LEVEL: FunctionDef = FunctionDef{address: 0x005ae565, function_type: PhantomData}; - pub const REMOVE_WATER_RIPPLES: FunctionDef = FunctionDef{address: 0x005ae615, function_type: PhantomData}; - pub const GET_MIN_DEPTH: FunctionDef i32> = FunctionDef{address: 0x005af226, function_type: PhantomData}; - pub const SET_TANK_HEIGHT: FunctionDef = FunctionDef{address: 0x005af39e, function_type: PhantomData}; - pub const DO_DEPTH_SUITABILITY: FunctionDef = FunctionDef{address: 0x005af4b9, function_type: PhantomData}; - pub const ADD_WATER_RIPPLES: FunctionDef = FunctionDef{address: 0x005af78f, function_type: PhantomData}; - pub const ADD_WATER_RIPPLE: FunctionDef = FunctionDef{address: 0x005af81a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/get_water_level"))] + pub const GET_WATER_LEVEL: FunctionDef u32> = FunctionDef{address: 0x004110fd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/get_tank_height"))] + pub const GET_TANK_HEIGHT: FunctionDef u32> = FunctionDef{address: 0x00411111, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/is_pure_water"))] + pub const IS_PURE_WATER: FunctionDef bool> = FunctionDef{address: 0x004111a9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/is_extremely_murky_water"))] + pub const IS_EXTREMELY_MURKY_WATER: FunctionDef bool> = FunctionDef{address: 0x00411254, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_base_terrain_type"))] + pub const SET_BASE_TERRAIN_TYPE: FunctionDef = FunctionDef{address: 0x00458bea, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/remove_illegal_entities"))] + pub const REMOVE_ILLEGAL_ENTITIES: FunctionDef u32> = FunctionDef{address: 0x00458c2b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_base_level"))] + pub const SET_BASE_LEVEL: FunctionDef = FunctionDef{address: 0x00458c6a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/get_all_entities"))] + pub const GET_ALL_ENTITIES: FunctionDef = FunctionDef{address: 0x004599a0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/update_tank_wall_info"))] + pub const UPDATE_TANK_WALL_INFO: FunctionDef = FunctionDef{address: 0x00459ab2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/update_adjustment_costs"))] + pub const UPDATE_ADJUSTMENT_COSTS: FunctionDef = FunctionDef{address: 0x00459b19, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/fill"))] + pub const FILL: FunctionDef = FunctionDef{address: 0x00459d94, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/check_entities_for_fill"))] + pub const CHECK_ENTITIES_FOR_FILL: FunctionDef u32> = FunctionDef{address: 0x00459e09, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/can_be_in_tank"))] + pub const CAN_BE_IN_TANK: FunctionDef u8> = FunctionDef{address: 0x00459f52, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_is_not_show_exhibit"))] + pub const SET_IS_NOT_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x0045b7ec, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0045b92f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/level_all_tiles"))] + pub const LEVEL_ALL_TILES: FunctionDef = FunctionDef{address: 0x0045bbbb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/update_tank_info"))] + pub const UPDATE_TANK_INFO: FunctionDef = FunctionDef{address: 0x0045bc0f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/is_illegal_entity"))] + pub const IS_ILLEGAL_ENTITY: FunctionDef u32> = FunctionDef{address: 0x0045da65, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/get_illegal_entities"))] + pub const GET_ILLEGAL_ENTITIES: FunctionDef = FunctionDef{address: 0x0045da8b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/reclaim_tiles"))] + pub const RECLAIM_TILES: FunctionDef = FunctionDef{address: 0x00487a63, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_water_purity"))] + pub const SET_WATER_PURITY: FunctionDef = FunctionDef{address: 0x0049340d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0049625f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/get_ladder_base_inside_pos"))] + pub const GET_LADDER_BASE_INSIDE_POS: FunctionDef = FunctionDef{address: 0x0049b1cc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/clean_water_amount"))] + pub const CLEAN_WATER_AMOUNT: FunctionDef = FunctionDef{address: 0x0049bd60, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/remove_owned_transients"))] + pub const REMOVE_OWNED_TRANSIENTS: FunctionDef = FunctionDef{address: 0x00505099, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/remove_all_sparkles"))] + pub const REMOVE_ALL_SPARKLES: FunctionDef = FunctionDef{address: 0x005050e2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/zttank_exhibit"))] + pub const ZTTANK_EXHIBIT: FunctionDef *const u32> = FunctionDef{address: 0x00505148, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_water_clean"))] + pub const SET_WATER_CLEAN: FunctionDef = FunctionDef{address: 0x005052b1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/remove_all_sparkles_by_id"))] + pub const REMOVE_ALL_SPARKLES_BY_ID: FunctionDef = FunctionDef{address: 0x005052bd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_is_show_exhibit"))] + pub const SET_IS_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x005ab683, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_water_level"))] + pub const SET_WATER_LEVEL: FunctionDef = FunctionDef{address: 0x005ae565, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/remove_water_ripples"))] + pub const REMOVE_WATER_RIPPLES: FunctionDef = FunctionDef{address: 0x005ae615, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/get_min_depth"))] + pub const GET_MIN_DEPTH: FunctionDef i32> = FunctionDef{address: 0x005af226, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_tank_height"))] + pub const SET_TANK_HEIGHT: FunctionDef = FunctionDef{address: 0x005af39e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/do_depth_suitability"))] + pub const DO_DEPTH_SUITABILITY: FunctionDef = FunctionDef{address: 0x005af4b9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/add_water_ripples"))] + pub const ADD_WATER_RIPPLES: FunctionDef = FunctionDef{address: 0x005af78f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/add_water_ripple"))] + pub const ADD_WATER_RIPPLE: FunctionDef = FunctionDef{address: 0x005af81a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00606398, function_type: PhantomData}; - pub const SET_SALINITY: FunctionDef u32> = FunctionDef{address: 0x0060644b, function_type: PhantomData}; - pub const DRAIN: FunctionDef = FunctionDef{address: 0x006064ed, function_type: PhantomData}; - pub const CHECK_ENTITIES_FOR_DRAIN: FunctionDef i32> = FunctionDef{address: 0x0060656e, function_type: PhantomData}; - pub const RESTORE_OWNED_TRANSIENTS: FunctionDef = FunctionDef{address: 0x006066eb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_salinity"))] + pub const SET_SALINITY: FunctionDef u32> = FunctionDef{address: 0x0060644b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/drain"))] + pub const DRAIN: FunctionDef = FunctionDef{address: 0x006064ed, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/check_entities_for_drain"))] + pub const CHECK_ENTITIES_FOR_DRAIN: FunctionDef i32> = FunctionDef{address: 0x0060656e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/restore_owned_transients"))] + pub const RESTORE_OWNED_TRANSIENTS: FunctionDef = FunctionDef{address: 0x006066eb, function_type: PhantomData}; } // ZTTankFilter class functions pub mod zttankfilter { use super::*; - pub const SET_CURRENT_ANIMATION: FunctionDef = FunctionDef{address: 0x0045d234, function_type: PhantomData}; - pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x0045d384, function_type: PhantomData}; - pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x0045d468, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00497e0f, function_type: PhantomData}; - pub const START_APPROPRIATE_SOUND: FunctionDef = FunctionDef{address: 0x00497f5c, function_type: PhantomData}; - pub const UPDATE_SOUND_VOLUMES: FunctionDef = FunctionDef{address: 0x00497fb2, function_type: PhantomData}; - pub const START_DECAYED_SOUND: FunctionDef = FunctionDef{address: 0x004980be, function_type: PhantomData}; - pub const STOP_ALL_SOUNDS: FunctionDef = FunctionDef{address: 0x00498270, function_type: PhantomData}; - pub const START_HEALTHY_SOUND: FunctionDef = FunctionDef{address: 0x004a7a38, function_type: PhantomData}; - pub const REMOVE_BUBBLES: FunctionDef = FunctionDef{address: 0x004fb151, function_type: PhantomData}; - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x0050558c, function_type: PhantomData}; - pub const SET_HEALTHY: FunctionDef = FunctionDef{address: 0x00595c8e, function_type: PhantomData}; - pub const SERVICE: FunctionDef = FunctionDef{address: 0x00595cad, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/set_current_animation"))] + pub const SET_CURRENT_ANIMATION: FunctionDef = FunctionDef{address: 0x0045d234, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/add_to_map"))] + pub const ADD_TO_MAP: FunctionDef *const c_void> = FunctionDef{address: 0x0045d384, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/load"))] + pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x0045d468, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0045d55f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00497e0f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/start_appropriate_sound"))] + pub const START_APPROPRIATE_SOUND: FunctionDef = FunctionDef{address: 0x00497f5c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/update_sound_volumes"))] + pub const UPDATE_SOUND_VOLUMES: FunctionDef = FunctionDef{address: 0x00497fb2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/start_decayed_sound"))] + pub const START_DECAYED_SOUND: FunctionDef = FunctionDef{address: 0x004980be, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/stop_all_sounds"))] + pub const STOP_ALL_SOUNDS: FunctionDef = FunctionDef{address: 0x00498270, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/start_healthy_sound"))] + pub const START_HEALTHY_SOUND: FunctionDef = FunctionDef{address: 0x004a7a38, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/remove_bubbles"))] + pub const REMOVE_BUBBLES: FunctionDef = FunctionDef{address: 0x004fb151, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x0050558c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/set_healthy"))] + pub const SET_HEALTHY: FunctionDef = FunctionDef{address: 0x00595c8e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/service"))] + pub const SERVICE: FunctionDef = FunctionDef{address: 0x00595cad, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00615b31, function_type: PhantomData}; - pub const SET_BROKEN: FunctionDef = FunctionDef{address: 0x00615c0f, function_type: PhantomData}; - pub const DECAY: FunctionDef = FunctionDef{address: 0x00615c29, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/set_broken"))] + pub const SET_BROKEN: FunctionDef = FunctionDef{address: 0x00615c0f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/decay"))] + pub const DECAY: FunctionDef = FunctionDef{address: 0x00615c29, function_type: PhantomData}; } // ZTTankFilterType class functions pub mod zttankfiltertype { use super::*; - pub const LOAD_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x004c44aa, function_type: PhantomData}; - pub const LOAD_TYPE_MEMBERS: FunctionDef = FunctionDef{address: 0x0051d8b0, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051de26, function_type: PhantomData}; - pub const ZTTANK_FILTER_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x0057d29e, function_type: PhantomData}; - pub const ZTTANK_FILTER_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x0057d2bc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfiltertype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x0045d893, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfiltertype/load_characteristics"))] + pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004c44aa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfiltertype/load_type_members"))] + pub const LOAD_TYPE_MEMBERS: FunctionDef u8> = FunctionDef{address: 0x0051d8b0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfiltertype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051de26, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfiltertype/zttank_filter_type_0"))] + pub const ZTTANK_FILTER_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x0057d29e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankfiltertype/zttank_filter_type_1"))] + pub const ZTTANK_FILTER_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x0057d2bc, function_type: PhantomData}; } // ZTTankWall class functions pub mod zttankwall { use super::*; - pub const SET_IMAGES: FunctionDef = FunctionDef{address: 0x0044a8b1, function_type: PhantomData}; - pub const UPDATE_MIXER_FACING: FunctionDef = FunctionDef{address: 0x0044aadb, function_type: PhantomData}; - pub const SET_WALL_HEIGHT: FunctionDef = FunctionDef{address: 0x0044ac6e, function_type: PhantomData}; - pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x0044ac9c, function_type: PhantomData}; - pub const SET_IS_COMBINED_CONNECTOR: FunctionDef = FunctionDef{address: 0x00458b9f, function_type: PhantomData}; - pub const SET_GATE_MIXERS: FunctionDef = FunctionDef{address: 0x00458bc4, function_type: PhantomData}; - pub const SET_MIDDLE_FENCE: FunctionDef = FunctionDef{address: 0x00459fdf, function_type: PhantomData}; - pub const SET_RIGHT_EDGE_FENCE: FunctionDef = FunctionDef{address: 0x0045a409, function_type: PhantomData}; - pub const SET_LEFT_EDGE_FENCE: FunctionDef = FunctionDef{address: 0x0045a833, function_type: PhantomData}; - pub const SET_BOTH_EDGES_FENCE: FunctionDef = FunctionDef{address: 0x0045afed, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0045cd8d, function_type: PhantomData}; - pub const MORPH: FunctionDef = FunctionDef{address: 0x004868a9, function_type: PhantomData}; - pub const DRAW: FunctionDef = FunctionDef{address: 0x00492bd9, function_type: PhantomData}; - pub const DRAW_PLATFORM: FunctionDef = FunctionDef{address: 0x00495007, function_type: PhantomData}; - pub const SET_IS_OPEN_PORTAL: FunctionDef = FunctionDef{address: 0x0059ea94, function_type: PhantomData}; - pub const SET_PORTAL_ANIMATION: FunctionDef = FunctionDef{address: 0x0059f39e, function_type: PhantomData}; - pub const START_PORTAL_CLOSE_SOUND: FunctionDef = FunctionDef{address: 0x005a333b, function_type: PhantomData}; - pub const START_PORTAL_OPEN_SOUND: FunctionDef = FunctionDef{address: 0x005a35e1, function_type: PhantomData}; - pub const ZTTANK_WALL_0: FunctionDef u32> = FunctionDef{address: 0x005ae7a0, function_type: PhantomData}; - pub const ZTTANK_WALL_1: FunctionDef u32> = FunctionDef{address: 0x005ae9e4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_images"))] + pub const SET_IMAGES: FunctionDef = FunctionDef{address: 0x0044a8b1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/update_mixer_facing"))] + pub const UPDATE_MIXER_FACING: FunctionDef = FunctionDef{address: 0x0044aadb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_wall_height"))] + pub const SET_WALL_HEIGHT: FunctionDef = FunctionDef{address: 0x0044ac6e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/validate_position"))] + pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x0044ac9c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_is_combined_connector"))] + pub const SET_IS_COMBINED_CONNECTOR: FunctionDef = FunctionDef{address: 0x00458b9f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_gate_mixers"))] + pub const SET_GATE_MIXERS: FunctionDef = FunctionDef{address: 0x00458bc4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_middle_fence"))] + pub const SET_MIDDLE_FENCE: FunctionDef = FunctionDef{address: 0x00459fdf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_right_edge_fence"))] + pub const SET_RIGHT_EDGE_FENCE: FunctionDef = FunctionDef{address: 0x0045a409, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_left_edge_fence"))] + pub const SET_LEFT_EDGE_FENCE: FunctionDef = FunctionDef{address: 0x0045a833, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_both_edges_fence"))] + pub const SET_BOTH_EDGES_FENCE: FunctionDef = FunctionDef{address: 0x0045afed, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0045cd8d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/morph"))] + pub const MORPH: FunctionDef = FunctionDef{address: 0x004868a9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/draw"))] + pub const DRAW: FunctionDef = FunctionDef{address: 0x00492bd9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/draw_platform"))] + pub const DRAW_PLATFORM: FunctionDef = FunctionDef{address: 0x00495007, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_is_open_portal"))] + pub const SET_IS_OPEN_PORTAL: FunctionDef = FunctionDef{address: 0x0059ea94, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_portal_animation"))] + pub const SET_PORTAL_ANIMATION: FunctionDef = FunctionDef{address: 0x0059f39e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/start_portal_close_sound"))] + pub const START_PORTAL_CLOSE_SOUND: FunctionDef = FunctionDef{address: 0x005a333b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/start_portal_open_sound"))] + pub const START_PORTAL_OPEN_SOUND: FunctionDef = FunctionDef{address: 0x005a35e1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/zttank_wall_0"))] + pub const ZTTANK_WALL_0: FunctionDef *const u32> = FunctionDef{address: 0x005ae7a0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/zttank_wall_1"))] + pub const ZTTANK_WALL_1: FunctionDef *const u32> = FunctionDef{address: 0x005ae9e4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00605b38, function_type: PhantomData}; } @@ -2768,7 +4735,9 @@ pub mod zttankwall { pub mod zttankwalltype { use super::*; - pub const LOAD_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x004c2c4d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwalltype/load_characteristics"))] + pub const LOAD_CHARACTERISTICS: FunctionDef u8> = FunctionDef{address: 0x004c2c4d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zttankwalltype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x0051d2fe, function_type: PhantomData}; } @@ -2776,41 +4745,73 @@ pub mod zttankwalltype { pub mod ztterraformmode { use super::*; - pub const COMMIT_TERRAFORM: FunctionDef = FunctionDef{address: 0x004da252, function_type: PhantomData}; - pub const DO_TERRAIN_PAINT: FunctionDef = FunctionDef{address: 0x004dce9a, function_type: PhantomData}; - pub const CANCEL_TERRAFORM: FunctionDef = FunctionDef{address: 0x00619368, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztterraformmode/handle_mouse_move"))] + pub const HANDLE_MOUSE_MOVE: FunctionDef u32> = FunctionDef{address: 0x004dc202, function_type: PhantomData}; +} + +// ZTTerraformMode_old class functions +pub mod ztterraformmode_old { + use super::*; + + #[cfg_attr(feature = "detour-validation", validate_detour("ztterraformmode_old/commit_terraform"))] + pub const COMMIT_TERRAFORM: FunctionDef = FunctionDef{address: 0x004da252, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztterraformmode_old/hilite_habitats"))] + pub const HILITE_HABITATS: FunctionDef = FunctionDef{address: 0x004dc362, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztterraformmode_old/do_terrain_paint"))] + pub const DO_TERRAIN_PAINT: FunctionDef = FunctionDef{address: 0x004dce9a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztterraformmode_old/cancel_terraform"))] + pub const CANCEL_TERRAFORM: FunctionDef = FunctionDef{address: 0x00619368, function_type: PhantomData}; } // ZTThought class functions pub mod ztthought { use super::*; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00423043, function_type: PhantomData}; - pub const GET_STRING: FunctionDef u32> = FunctionDef{address: 0x004edbfc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztthought/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00423043, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztthought/get_string"))] + pub const GET_STRING: FunctionDef *const u32> = FunctionDef{address: 0x004edbfc, function_type: PhantomData}; } // ZTThoughtMgr class functions pub mod ztthoughtmgr { use super::*; - pub const GET_THOUGHTS_BY_HABITAT: FunctionDef u32> = FunctionDef{address: 0x0046863a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztthoughtmgr/get_thoughts_by_habitat"))] + pub const GET_THOUGHTS_BY_HABITAT: FunctionDef *const i32> = FunctionDef{address: 0x0046863a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztthoughtmgr/save"))] pub const SAVE: FunctionDef bool> = FunctionDef{address: 0x0047a1a2, function_type: PhantomData}; - pub const REMOVE_THOUGHTS_BY_HABITAT: FunctionDef = FunctionDef{address: 0x004ffe56, function_type: PhantomData}; - pub const ZTTHOUGHT_MGR: FunctionDef u32> = FunctionDef{address: 0x0057d815, function_type: PhantomData}; - pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x0059435b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztthoughtmgr/remove_thoughts_by_thinker"))] + pub const REMOVE_THOUGHTS_BY_THINKER: FunctionDef = FunctionDef{address: 0x004fa377, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztthoughtmgr/remove_thoughts_by_habitat"))] + pub const REMOVE_THOUGHTS_BY_HABITAT: FunctionDef = FunctionDef{address: 0x004ffe56, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztthoughtmgr/ztthought_mgr"))] + pub const ZTTHOUGHT_MGR: FunctionDef *const u32> = FunctionDef{address: 0x0057d815, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztthoughtmgr/load"))] + pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x0059435b, function_type: PhantomData}; } // ZTUI class functions pub mod ztui { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a281, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui/click_continue"))] pub const CLICK_CONTINUE: FunctionDef = FunctionDef{address: 0x00485c7e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui/reinit_on_load"))] pub const REINIT_ON_LOAD: FunctionDef = FunctionDef{address: 0x004c735c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui/show_game_opts"))] pub const SHOW_GAME_OPTS: FunctionDef = FunctionDef{address: 0x004d81b8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui/exit_app"))] + pub const EXIT_APP: FunctionDef = FunctionDef{address: 0x00501224, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui/destroy"))] pub const DESTROY: FunctionDef = FunctionDef{address: 0x00504346, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x0051275a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00514daa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui/hide_game_opts"))] pub const HIDE_GAME_OPTS: FunctionDef = FunctionDef{address: 0x005b14c5, function_type: PhantomData}; } @@ -2818,10 +4819,17 @@ pub mod ztui { pub mod ztui_animalinfo { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_animalinfo/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a76f, function_type: PhantomData}; - pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x00427996, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_animalinfo/force_update"))] + pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x00427996, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_animalinfo/set_animal_visible"))] + pub const SET_ANIMAL_VISIBLE: FunctionDef = FunctionDef{address: 0x0043f0c5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_animalinfo/show"))] pub const SHOW: FunctionDef = FunctionDef{address: 0x004ee820, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_animalinfo/set_can_sell"))] pub const SET_CAN_SELL: FunctionDef = FunctionDef{address: 0x00592fe3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_animalinfo/unfollow"))] pub const UNFOLLOW: FunctionDef = FunctionDef{address: 0x00618c47, function_type: PhantomData}; } @@ -2829,10 +4837,15 @@ pub mod ztui_animalinfo { pub mod ztui_buya { use super::*; - pub const UPDATE_DISPLAY_LIST: FunctionDef = FunctionDef{address: 0x004eb68b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buya/update_display_list"))] + pub const UPDATE_DISPLAY_LIST: FunctionDef = FunctionDef{address: 0x004eb68b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buya/clear_selections"))] pub const CLEAR_SELECTIONS: FunctionDef = FunctionDef{address: 0x004f0a84, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buya/get_info_plaque"))] pub const GET_INFO_PLAQUE: FunctionDef = FunctionDef{address: 0x004f187a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buya/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00515b78, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buya/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x0051a2c9, function_type: PhantomData}; } @@ -2840,6 +4853,7 @@ pub mod ztui_buya { pub mod ztui_buyh { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buyh/clear_selections"))] pub const CLEAR_SELECTIONS: FunctionDef = FunctionDef{address: 0x004f0a49, function_type: PhantomData}; } @@ -2847,9 +4861,13 @@ pub mod ztui_buyh { pub mod ztui_buyobj { use super::*; - pub const UPDATE_DISPLAY_LIST: FunctionDef = FunctionDef{address: 0x004eb401, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buyobj/update_display_list"))] + pub const UPDATE_DISPLAY_LIST: FunctionDef = FunctionDef{address: 0x004eb401, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buyobj/clear_selections"))] pub const CLEAR_SELECTIONS: FunctionDef = FunctionDef{address: 0x004f0abf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buyobj/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00515dc5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buyobj/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x0051a2e4, function_type: PhantomData}; } @@ -2857,7 +4875,9 @@ pub mod ztui_buyobj { pub mod ztui_cbuildinginfo { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_cbuildinginfo/show"))] pub const SHOW: FunctionDef = FunctionDef{address: 0x00488e4c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_cbuildinginfo/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x0051503f, function_type: PhantomData}; } @@ -2865,7 +4885,9 @@ pub mod ztui_cbuildinginfo { pub mod ztui_credits { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_credits/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a430, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_credits/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00516e9f, function_type: PhantomData}; } @@ -2873,7 +4895,9 @@ pub mod ztui_credits { pub mod ztui_developer { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_developer/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00517739, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_developer/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x0058ed04, function_type: PhantomData}; } @@ -2881,13 +4905,21 @@ pub mod ztui_developer { pub mod ztui_expansionselect { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_expansionselect/get_any_expansions_disabled"))] pub const GET_ANY_EXPANSIONS_DISABLED: FunctionDef u32> = FunctionDef{address: 0x0041eee3, function_type: PhantomData}; - pub const IS_EXPANSION_DISABLED: FunctionDef = FunctionDef{address: 0x0041ef86, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_expansionselect/is_expansion_disabled"))] + pub const IS_EXPANSION_DISABLED: FunctionDef u8> = FunctionDef{address: 0x0041ef86, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_expansionselect/get_expansion_list"))] pub const GET_EXPANSION_LIST: FunctionDef u32> = FunctionDef{address: 0x004b1d62, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_expansionselect/hide"))] pub const HIDE: FunctionDef = FunctionDef{address: 0x004e0f09, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_expansionselect/set_expansion_id"))] pub const SET_EXPANSION_ID: FunctionDef = FunctionDef{address: 0x004f06a5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_expansionselect/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x00516b0a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_expansionselect/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00517014, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_expansionselect/setup"))] pub const SETUP: FunctionDef = FunctionDef{address: 0x005291fb, function_type: PhantomData}; } @@ -2895,15 +4927,25 @@ pub mod ztui_expansionselect { pub mod ztui_gameopts { use super::*; - pub const LOAD_FILE: FunctionDef u32> = FunctionDef{address: 0x00453000, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_gameopts/load_file"))] + pub const LOAD_FILE: FunctionDef u32> = FunctionDef{address: 0x00453000, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_gameopts/save_game"))] pub const SAVE_GAME: FunctionDef u32> = FunctionDef{address: 0x004769ac, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_gameopts/start_new_game"))] pub const START_NEW_GAME: FunctionDef = FunctionDef{address: 0x004ca30e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_gameopts/trigger_load"))] pub const TRIGGER_LOAD: FunctionDef = FunctionDef{address: 0x004cb9fa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_gameopts/load_game"))] pub const LOAD_GAME: FunctionDef u32> = FunctionDef{address: 0x004cc0d7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_gameopts/check_video_options"))] pub const CHECK_VIDEO_OPTIONS: FunctionDef = FunctionDef{address: 0x004d7e4d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_gameopts/stop_game"))] pub const STOP_GAME: FunctionDef = FunctionDef{address: 0x00501dfb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_gameopts/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x005164c3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_gameopts/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x00518375, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_gameopts/return_to_main"))] pub const RETURN_TO_MAIN: FunctionDef = FunctionDef{address: 0x0059c339, function_type: PhantomData}; } @@ -2911,7 +4953,9 @@ pub mod ztui_gameopts { pub mod ztui_gamescrn { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_gamescrn/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x0051595d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_gamescrn/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x00519b19, function_type: PhantomData}; } @@ -2919,19 +4963,33 @@ pub mod ztui_gamescrn { pub mod ztui_general { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/get_mapview"))] pub const GET_MAPVIEW: FunctionDef u32> = FunctionDef{address: 0x004017e5, function_type: PhantomData}; - pub const UPDATE_DISPLAY_LISTS: FunctionDef = FunctionDef{address: 0x0040d37f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/update_display_lists"))] + pub const UPDATE_DISPLAY_LISTS: FunctionDef = FunctionDef{address: 0x0040d37f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/get_selected_entity"))] pub const GET_SELECTED_ENTITY: FunctionDef u32> = FunctionDef{address: 0x00410f84, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/hide_misc_panels"))] pub const HIDE_MISC_PANELS: FunctionDef = FunctionDef{address: 0x00443af8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/deselect_bulldozer"))] pub const DESELECT_BULLDOZER: FunctionDef = FunctionDef{address: 0x00443b60, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/hide_plaques"))] pub const HIDE_PLAQUES: FunctionDef = FunctionDef{address: 0x0044410c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/remove_selected_entity"))] pub const REMOVE_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x0048d052, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/hide_info_panels"))] pub const HIDE_INFO_PANELS: FunctionDef = FunctionDef{address: 0x004b2355, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/entity_type_is_displayed"))] pub const ENTITY_TYPE_IS_DISPLAYED: FunctionDef bool> = FunctionDef{address: 0x004e8cc8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/get_info_image_name"))] pub const GET_INFO_IMAGE_NAME: FunctionDef u32> = FunctionDef{address: 0x004f85d2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x00519d24, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/hide_object_panels"))] pub const HIDE_OBJECT_PANELS: FunctionDef = FunctionDef{address: 0x005b135b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/hide_multi_panels"))] pub const HIDE_MULTI_PANELS: FunctionDef = FunctionDef{address: 0x005b1426, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/hide_all_layouts"))] pub const HIDE_ALL_LAYOUTS: FunctionDef = FunctionDef{address: 0x005b14a4, function_type: PhantomData}; } @@ -2939,8 +4997,13 @@ pub mod ztui_general { pub mod ztui_guestinfo { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_guestinfo/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a78a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_guestinfo/set_guest_visible"))] + pub const SET_GUEST_VISIBLE: FunctionDef = FunctionDef{address: 0x0042a9fa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_guestinfo/show"))] pub const SHOW: FunctionDef = FunctionDef{address: 0x0046aa50, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_guestinfo/unfollow"))] pub const UNFOLLOW: FunctionDef = FunctionDef{address: 0x00618b0c, function_type: PhantomData}; } @@ -2948,22 +5011,33 @@ pub mod ztui_guestinfo { pub mod ztui_habitatinfo { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a384, function_type: PhantomData}; - pub const ADD_HABITAT: FunctionDef = FunctionDef{address: 0x0044e48a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/add_habitat"))] + pub const ADD_HABITAT: FunctionDef = FunctionDef{address: 0x0044e48a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/select_tank_button"))] pub const SELECT_TANK_BUTTON: FunctionDef = FunctionDef{address: 0x00468b9d, function_type: PhantomData}; - pub const REMOVE_HABITAT: FunctionDef = FunctionDef{address: 0x0050c715, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/remove_habitat"))] + pub const REMOVE_HABITAT: FunctionDef = FunctionDef{address: 0x0050c715, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x0051512d, function_type: PhantomData}; - pub const SET_HABITAT: FunctionDef = FunctionDef{address: 0x0058b5ce, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/set_habitat"))] + pub const SET_HABITAT: FunctionDef = FunctionDef{address: 0x0058b5ce, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/set_tank_button_enabled"))] pub const SET_TANK_BUTTON_ENABLED: FunctionDef = FunctionDef{address: 0x0058b5f2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/refill_habitat_list"))] pub const REFILL_HABITAT_LIST: FunctionDef = FunctionDef{address: 0x005aeb82, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/remove_all_habitats"))] pub const REMOVE_ALL_HABITATS: FunctionDef = FunctionDef{address: 0x005b1244, function_type: PhantomData}; - pub const GET_ICON_NAME: FunctionDef u32> = FunctionDef{address: 0x005b3149, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/get_icon_name"))] + pub const GET_ICON_NAME: FunctionDef *const u8> = FunctionDef{address: 0x005b3149, function_type: PhantomData}; } // ZTUI::heliinfo class functions pub mod ztui_heliinfo { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_heliinfo/show"))] pub const SHOW: FunctionDef = FunctionDef{address: 0x0048cd7a, function_type: PhantomData}; } @@ -2971,7 +5045,9 @@ pub mod ztui_heliinfo { pub mod ztui_help { use super::*; - pub const SHOW: FunctionDef = FunctionDef{address: 0x00484a32, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_help/show"))] + pub const SHOW: FunctionDef = FunctionDef{address: 0x00484a32, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_help/hide"))] pub const HIDE: FunctionDef = FunctionDef{address: 0x004b2972, function_type: PhantomData}; } @@ -2979,9 +5055,13 @@ pub mod ztui_help { pub mod ztui_hirestaff { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_hirestaff/clear_selections"))] pub const CLEAR_SELECTIONS: FunctionDef = FunctionDef{address: 0x004c7486, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_hirestaff/randomize_sex"))] pub const RANDOMIZE_SEX: FunctionDef = FunctionDef{address: 0x004e770d, function_type: PhantomData}; - pub const UPDATE_DISPLAY_LIST: FunctionDef = FunctionDef{address: 0x004eb4cd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_hirestaff/update_display_list"))] + pub const UPDATE_DISPLAY_LIST: FunctionDef = FunctionDef{address: 0x004eb4cd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_hirestaff/get_info_plaque"))] pub const GET_INFO_PLAQUE: FunctionDef = FunctionDef{address: 0x004f188a, function_type: PhantomData}; } @@ -2989,7 +5069,9 @@ pub mod ztui_hirestaff { pub mod ztui_infoplaque { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_infoplaque/hide"))] pub const HIDE: FunctionDef = FunctionDef{address: 0x004440d6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_infoplaque/set_animal"))] pub const SET_ANIMAL: FunctionDef = FunctionDef{address: 0x00483157, function_type: PhantomData}; } @@ -2997,9 +5079,13 @@ pub mod ztui_infoplaque { pub mod ztui_keeperinfo { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_keeperinfo/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a331, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_keeperinfo/hide"))] pub const HIDE: FunctionDef = FunctionDef{address: 0x004440f1, function_type: PhantomData}; - pub const SET_ANIMAL: FunctionDef = FunctionDef{address: 0x004831b2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_keeperinfo/set_animal"))] + pub const SET_ANIMAL: FunctionDef = FunctionDef{address: 0x004831b2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_keeperinfo/force_update"))] pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x00483714, function_type: PhantomData}; } @@ -3007,15 +5093,25 @@ pub mod ztui_keeperinfo { pub mod ztui_main { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_main/set_money_text"))] pub const SET_MONEY_TEXT: FunctionDef = FunctionDef{address: 0x0040ee3d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_main/set_animal_rating"))] pub const SET_ANIMAL_RATING: FunctionDef = FunctionDef{address: 0x0041d08b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_main/set_guest_rating"))] pub const SET_GUEST_RATING: FunctionDef = FunctionDef{address: 0x0041d15d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_main/set_zoo_rating"))] pub const SET_ZOO_RATING: FunctionDef = FunctionDef{address: 0x0041d22f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_main/set_date_text"))] pub const SET_DATE_TEXT: FunctionDef = FunctionDef{address: 0x0041d565, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_main/clear_selections"))] pub const CLEAR_SELECTIONS: FunctionDef = FunctionDef{address: 0x004c77bb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_main/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00515979, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_main/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x00519c1b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_main/pause_game"))] pub const PAUSE_GAME: FunctionDef = FunctionDef{address: 0x0059c6b8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_main/unpause_game"))] pub const UNPAUSE_GAME: FunctionDef = FunctionDef{address: 0x0059c7a9, function_type: PhantomData}; } @@ -3023,6 +5119,7 @@ pub mod ztui_main { pub mod ztui_mapselect { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_mapselect/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00516db1, function_type: PhantomData}; } @@ -3030,16 +5127,43 @@ pub mod ztui_mapselect { pub mod ztui_multianimal { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multianimal/force_update"))] pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x00418c35, function_type: PhantomData}; - pub const ADD_ENTITY: FunctionDef = FunctionDef{address: 0x00453b38, function_type: PhantomData}; - pub const REMOVE_ENTITY: FunctionDef = FunctionDef{address: 0x004fe532, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multianimal/add_entity"))] + pub const ADD_ENTITY: FunctionDef = FunctionDef{address: 0x00453b38, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multianimal/remove_entity"))] + pub const REMOVE_ENTITY: FunctionDef = FunctionDef{address: 0x004fe532, function_type: PhantomData}; +} + +// ZTUI::multiguest class functions +pub mod ztui_multiguest { + use super::*; + + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multiguest/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a316, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multiguest/add_entity"))] + pub const ADD_ENTITY: FunctionDef = FunctionDef{address: 0x004f5eb2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multiguest/remove_entity"))] + pub const REMOVE_ENTITY: FunctionDef = FunctionDef{address: 0x004fa3a1, function_type: PhantomData}; +} + +// ZTUI::multistaff class functions +pub mod ztui_multistaff { + use super::*; + + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multistaff/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a39f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multistaff/add_entity"))] + pub const ADD_ENTITY: FunctionDef = FunctionDef{address: 0x00457f81, function_type: PhantomData}; } // ZTUI::ncbuildinginfo class functions pub mod ztui_ncbuildinginfo { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_ncbuildinginfo/force_update"))] pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x0058ff06, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_ncbuildinginfo/show"))] pub const SHOW: FunctionDef = FunctionDef{address: 0x006183ff, function_type: PhantomData}; } @@ -3047,6 +5171,7 @@ pub mod ztui_ncbuildinginfo { pub mod ztui_objective { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_objective/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00516ed0, function_type: PhantomData}; } @@ -3054,7 +5179,9 @@ pub mod ztui_objective { pub mod ztui_rescon { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_rescon/update_display_list"))] pub const UPDATE_DISPLAY_LIST: FunctionDef = FunctionDef{address: 0x004eb3f7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_rescon/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00514f6c, function_type: PhantomData}; } @@ -3062,6 +5189,7 @@ pub mod ztui_rescon { pub mod ztui_scenario { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_scenario/start_scenario"))] pub const START_SCENARIO: FunctionDef u32> = FunctionDef{address: 0x004c9bc9, function_type: PhantomData}; } @@ -3069,16 +5197,27 @@ pub mod ztui_scenario { pub mod ztui_showpanel { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_showpanel/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a750, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_showpanel/show_0"))] pub const SHOW_0: FunctionDef = FunctionDef{address: 0x004681b5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_showpanel/fill_exhibit_info_0"))] pub const FILL_EXHIBIT_INFO_0: FunctionDef = FunctionDef{address: 0x00468968, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_showpanel/set_exhibit"))] pub const SET_EXHIBIT: FunctionDef = FunctionDef{address: 0x00468a5b, function_type: PhantomData}; - pub const FILL_EXHIBIT_INFO_1: FunctionDef = FunctionDef{address: 0x00474400, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_showpanel/fill_exhibit_info_1"))] + pub const FILL_EXHIBIT_INFO_1: FunctionDef = FunctionDef{address: 0x00474400, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_showpanel/select_show_tab"))] pub const SELECT_SHOW_TAB: FunctionDef = FunctionDef{address: 0x00474646, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_showpanel/show_1"))] pub const SHOW_1: FunctionDef = FunctionDef{address: 0x00474684, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_showpanel/set_species"))] pub const SET_SPECIES: FunctionDef = FunctionDef{address: 0x00474ced, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_showpanel/fill_trick_lists"))] pub const FILL_TRICK_LISTS: FunctionDef = FunctionDef{address: 0x004751dc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_showpanel/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x005167ca, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_showpanel/force_update"))] pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x005a996f, function_type: PhantomData}; } @@ -3086,9 +5225,13 @@ pub mod ztui_showpanel { pub mod ztui_staffinfo { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_staffinfo/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a733, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_staffinfo/show"))] pub const SHOW: FunctionDef = FunctionDef{address: 0x00471813, function_type: PhantomData}; - pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x005b0f93, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_staffinfo/force_update"))] + pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x005b0f93, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_staffinfo/unfollow"))] pub const UNFOLLOW: FunctionDef = FunctionDef{address: 0x00618847, function_type: PhantomData}; } @@ -3096,7 +5239,9 @@ pub mod ztui_staffinfo { pub mod ztui_startup { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_startup/trigger_load"))] pub const TRIGGER_LOAD: FunctionDef = FunctionDef{address: 0x004cc606, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_startup/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00514e7e, function_type: PhantomData}; } @@ -3104,8 +5249,11 @@ pub mod ztui_startup { pub mod ztui_tankmodify { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_tankmodify/set_tank"))] pub const SET_TANK: FunctionDef = FunctionDef{address: 0x0046895a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_tankmodify/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x00516c04, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_tankmodify/fetch_values_from_tank"))] pub const FETCH_VALUES_FROM_TANK: FunctionDef = FunctionDef{address: 0x005ae509, function_type: PhantomData}; } @@ -3113,8 +5261,11 @@ pub mod ztui_tankmodify { pub mod ztui_terraform { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_terraform/set_money_text"))] pub const SET_MONEY_TEXT: FunctionDef = FunctionDef{address: 0x004d9cae, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_terraform/set_unit_cost"))] pub const SET_UNIT_COST: FunctionDef = FunctionDef{address: 0x004d9dbd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_terraform/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00516318, function_type: PhantomData}; } @@ -3122,6 +5273,7 @@ pub mod ztui_terraform { pub mod ztui_zooitems { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_zooitems/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a45b, function_type: PhantomData}; } @@ -3129,9 +5281,13 @@ pub mod ztui_zooitems { pub mod ztui_zoostatus { use super::*; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_zoostatus/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x00401644, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_zoostatus/force_update"))] pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x0041739a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_zoostatus/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00517320, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztui_zoostatus/add_completed_research"))] pub const ADD_COMPLETED_RESEARCH: FunctionDef = FunctionDef{address: 0x0058fc10, function_type: PhantomData}; } @@ -3139,550 +5295,1090 @@ pub mod ztui_zoostatus { pub mod ztundobuffer { use super::*; - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004f15c8, function_type: PhantomData}; - pub const ADD_ACTION: FunctionDef = FunctionDef{address: 0x004f8a1f, function_type: PhantomData}; - pub const REMOVE_ACTION: FunctionDef u32> = FunctionDef{address: 0x004fa670, function_type: PhantomData}; - pub const ZTUNDO_BUFFER: FunctionDef u32> = FunctionDef{address: 0x00502713, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztundobuffer/clear"))] + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004f15c8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztundobuffer/add_action"))] + pub const ADD_ACTION: FunctionDef = FunctionDef{address: 0x004f8a1f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztundobuffer/remove_action"))] + pub const REMOVE_ACTION: FunctionDef u32> = FunctionDef{address: 0x004fa670, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztundobuffer/ztundo_buffer"))] + pub const ZTUNDO_BUFFER: FunctionDef *const u32> = FunctionDef{address: 0x00502713, function_type: PhantomData}; } // ZTUnit class functions pub mod ztunit { use super::*; - pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x004102b3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/validate_position"))] + pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x004102b3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_footprint"))] pub const GET_FOOTPRINT: FunctionDef *const u32> = FunctionDef{address: 0x0041070b, function_type: PhantomData}; - pub const IS_ON_WATER: FunctionDef u32> = FunctionDef{address: 0x00410fe0, function_type: PhantomData}; - pub const GET_PREDATOR_UNIT: FunctionDef i32> = FunctionDef{address: 0x00412259, function_type: PhantomData}; - pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x00412c70, function_type: PhantomData}; - pub const GET_IDLE_ANIM: FunctionDef i32> = FunctionDef{address: 0x0041338a, function_type: PhantomData}; - pub const FACE_TOWARD_TARGET: FunctionDef = FunctionDef{address: 0x00426f21, function_type: PhantomData}; - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004277c9, function_type: PhantomData}; - pub const FIND_NEAREST_SATISFIER: FunctionDef u32> = FunctionDef{address: 0x004290f3, function_type: PhantomData}; - pub const FACE_TOWARD_TARGET_UNIT: FunctionDef = FunctionDef{address: 0x0042fa2c, function_type: PhantomData}; - pub const ABORT_SHOW: FunctionDef = FunctionDef{address: 0x0042fa42, function_type: PhantomData}; - pub const UPDATE_BUILDING_TILES: FunctionDef u32> = FunctionDef{address: 0x0043b2f6, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00454488, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_swims"))] + pub const GET_SWIMS: FunctionDef = FunctionDef{address: 0x00410764, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/is_on_water"))] + pub const IS_ON_WATER: FunctionDef u32> = FunctionDef{address: 0x00410fe0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_predator_unit"))] + pub const GET_PREDATOR_UNIT: FunctionDef i32> = FunctionDef{address: 0x00412259, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/add_to_map"))] + pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x00412c70, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_idle_anim"))] + pub const GET_IDLE_ANIM: FunctionDef i32> = FunctionDef{address: 0x0041338a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/face_toward_target"))] + pub const FACE_TOWARD_TARGET: FunctionDef = FunctionDef{address: 0x00426f21, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/remove_from_map"))] + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004277c9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/find_nearest_satisfier"))] + pub const FIND_NEAREST_SATISFIER: FunctionDef u32> = FunctionDef{address: 0x004290f3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/face_toward_target_unit"))] + pub const FACE_TOWARD_TARGET_UNIT: FunctionDef = FunctionDef{address: 0x0042fa2c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/abort_show"))] + pub const ABORT_SHOW: FunctionDef = FunctionDef{address: 0x0042fa42, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/update_building_tiles"))] + pub const UPDATE_BUILDING_TILES: FunctionDef u32> = FunctionDef{address: 0x0043b2f6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00454488, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00478501, function_type: PhantomData}; - pub const F_ZOO_MESSAGE_TILE_0: FunctionDef = FunctionDef{address: 0x004807c2, function_type: PhantomData}; - pub const F_ZOO_MESSAGE_TILE_1: FunctionDef = FunctionDef{address: 0x0048083d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/f_zoo_message_tile_0"))] + pub const F_ZOO_MESSAGE_TILE_0: FunctionDef = FunctionDef{address: 0x004807c2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/f_zoo_message_tile_1"))] + pub const F_ZOO_MESSAGE_TILE_1: FunctionDef = FunctionDef{address: 0x0048083d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/f_exit_building"))] pub const F_EXIT_BUILDING: FunctionDef = FunctionDef{address: 0x0048c522, function_type: PhantomData}; - pub const CHECK_ELEVATION: FunctionDef bool> = FunctionDef{address: 0x004935aa, function_type: PhantomData}; - pub const FORMAT_NAME_MESSAGE: FunctionDef u32> = FunctionDef{address: 0x0049cfeb, function_type: PhantomData}; - pub const F_ZOO_MESSAGE_NAME: FunctionDef = FunctionDef{address: 0x0049d18e, function_type: PhantomData}; - pub const DO_RANDOM_WALK: FunctionDef = FunctionDef{address: 0x0049dafe, function_type: PhantomData}; - pub const GET_TARGET_UNIT: FunctionDef i32> = FunctionDef{address: 0x004a4b53, function_type: PhantomData}; - pub const IN_FRIENDLY_CHASE: FunctionDef u32> = FunctionDef{address: 0x004a4bb7, function_type: PhantomData}; - pub const CHASE_DONE: FunctionDef bool> = FunctionDef{address: 0x004a4ca0, function_type: PhantomData}; - pub const AVOID_DONE: FunctionDef u32> = FunctionDef{address: 0x004a5508, function_type: PhantomData}; - pub const GET_PATH_TO_TARGET: FunctionDef u32> = FunctionDef{address: 0x004a5b4d, function_type: PhantomData}; - pub const GET_PATH_AWAY_FROM_TARGET: FunctionDef = FunctionDef{address: 0x004a639e, function_type: PhantomData}; - pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x004e1b58, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004f578d, function_type: PhantomData}; - pub const ZTUNIT: FunctionDef u32> = FunctionDef{address: 0x004f9cf0, function_type: PhantomData}; - pub const SET_IS_REMOVED: FunctionDef = FunctionDef{address: 0x004fa78e, function_type: PhantomData}; - pub const INIT_AFTER_LOAD: FunctionDef u32> = FunctionDef{address: 0x005951b3, function_type: PhantomData}; - pub const REMOVE_FROM_BUILDING_IF_PRESENT: FunctionDef = FunctionDef{address: 0x005ae65f, function_type: PhantomData}; - pub const RESET_AI: FunctionDef u32> = FunctionDef{address: 0x005ae68b, function_type: PhantomData}; - pub const GET_TERRAIN_COST: FunctionDef = FunctionDef{address: 0x00612f15, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/check_elevation"))] + pub const CHECK_ELEVATION: FunctionDef bool> = FunctionDef{address: 0x004935aa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/format_name_message"))] + pub const FORMAT_NAME_MESSAGE: FunctionDef *const u32> = FunctionDef{address: 0x0049cfeb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/f_zoo_message_name"))] + pub const F_ZOO_MESSAGE_NAME: FunctionDef = FunctionDef{address: 0x0049d18e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/do_random_walk"))] + pub const DO_RANDOM_WALK: FunctionDef i8> = FunctionDef{address: 0x0049dafe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_target_unit"))] + pub const GET_TARGET_UNIT: FunctionDef i32> = FunctionDef{address: 0x004a4b53, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/in_friendly_chase"))] + pub const IN_FRIENDLY_CHASE: FunctionDef u32> = FunctionDef{address: 0x004a4bb7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/chase_done"))] + pub const CHASE_DONE: FunctionDef bool> = FunctionDef{address: 0x004a4ca0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/avoid_done"))] + pub const AVOID_DONE: FunctionDef u32> = FunctionDef{address: 0x004a5508, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_path_to_target"))] + pub const GET_PATH_TO_TARGET: FunctionDef u32> = FunctionDef{address: 0x004a5b4d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_path_away_from_target"))] + pub const GET_PATH_AWAY_FROM_TARGET: FunctionDef = FunctionDef{address: 0x004a639e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/create_name"))] + pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x004e1b58, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_icon_anim"))] + pub const GET_ICON_ANIM: FunctionDef = FunctionDef{address: 0x004ee499, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004f578d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/ztunit"))] + pub const ZTUNIT: FunctionDef *const u32> = FunctionDef{address: 0x004f9cf0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/set_is_removed"))] + pub const SET_IS_REMOVED: FunctionDef = FunctionDef{address: 0x004fa78e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/init_after_load"))] + pub const INIT_AFTER_LOAD: FunctionDef u32> = FunctionDef{address: 0x005951b3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/remove_from_building_if_present"))] + pub const REMOVE_FROM_BUILDING_IF_PRESENT: FunctionDef = FunctionDef{address: 0x005ae65f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/reset_ai"))] + pub const RESET_AI: FunctionDef u32> = FunctionDef{address: 0x005ae68b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_terrain_cost"))] + pub const GET_TERRAIN_COST: FunctionDef = FunctionDef{address: 0x00612f15, function_type: PhantomData}; } // ZTUnitType class functions pub mod ztunittype { use super::*; - pub const SET_AVAILABLE: FunctionDef = FunctionDef{address: 0x0040d3ac, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/set_available"))] + pub const SET_AVAILABLE: FunctionDef = FunctionDef{address: 0x0040d3ac, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/get_dirt_type"))] pub const GET_DIRT_TYPE: FunctionDef i32> = FunctionDef{address: 0x00410438, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/get_dino_dirt_type"))] pub const GET_DINO_DIRT_TYPE: FunctionDef i32> = FunctionDef{address: 0x0041044c, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004b5681, function_type: PhantomData}; - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b5c71, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004be558, function_type: PhantomData}; - pub const ZTUNIT_TYPE: FunctionDef u32> = FunctionDef{address: 0x00500a69, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/set_idle_animation"))] + pub const SET_IDLE_ANIMATION: FunctionDef u32> = FunctionDef{address: 0x004b54ea, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/load_characteristics_0"))] + pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004b5681, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/load_characteristics_1"))] + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b5c71, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/load_data"))] + pub const LOAD_DATA: FunctionDef = FunctionDef{address: 0x004bb628, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004be558, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/ztunit_type"))] + pub const ZTUNIT_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x00500a69, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/get_trash_type"))] pub const GET_TRASH_TYPE: FunctionDef i32> = FunctionDef{address: 0x0052cfbe, function_type: PhantomData}; - pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x006151b3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/set_trick_available"))] + pub const SET_TRICK_AVAILABLE: FunctionDef = FunctionDef{address: 0x0059b599, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/create_entity"))] + pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x006151b3, function_type: PhantomData}; } // ZTViewingArea class functions pub mod ztviewingarea { use super::*; - pub const UPDATE_AMBIENTS: FunctionDef = FunctionDef{address: 0x004358f2, function_type: PhantomData}; - pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x00447957, function_type: PhantomData}; - pub const RECALCULATE_OA: FunctionDef = FunctionDef{address: 0x004479fd, function_type: PhantomData}; - pub const ADD_TILE: FunctionDef = FunctionDef{address: 0x0044ebe6, function_type: PhantomData}; - pub const GET_EWEXTENT: FunctionDef = FunctionDef{address: 0x0044ee46, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0044ee8e, function_type: PhantomData}; - pub const GET_NSEXTENT: FunctionDef = FunctionDef{address: 0x0044f0f2, function_type: PhantomData}; - pub const CLEAR_TILE_OF_VA: FunctionDef = FunctionDef{address: 0x004590c7, function_type: PhantomData}; - pub const ZTVIEWING_AREA: FunctionDef = FunctionDef{address: 0x00459196, function_type: PhantomData}; - pub const CREATE_OA: FunctionDef = FunctionDef{address: 0x004f380b, function_type: PhantomData}; - pub const REMOVE_TILE: FunctionDef = FunctionDef{address: 0x0050bc1a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/update_ambients"))] + pub const UPDATE_AMBIENTS: FunctionDef = FunctionDef{address: 0x004358f2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/recalculate_characteristics"))] + pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x00447957, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/recalculate_oa"))] + pub const RECALCULATE_OA: FunctionDef = FunctionDef{address: 0x004479fd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/add_tile"))] + pub const ADD_TILE: FunctionDef = FunctionDef{address: 0x0044ebe6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/get_ewextent"))] + pub const GET_EWEXTENT: FunctionDef = FunctionDef{address: 0x0044ee46, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0044ee8e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/get_nsextent"))] + pub const GET_NSEXTENT: FunctionDef = FunctionDef{address: 0x0044f0f2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/clear_tile_of_va"))] + pub const CLEAR_TILE_OF_VA: FunctionDef = FunctionDef{address: 0x004590c7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/ztviewing_area"))] + pub const ZTVIEWING_AREA: FunctionDef = FunctionDef{address: 0x00459196, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/create_oa"))] + pub const CREATE_OA: FunctionDef = FunctionDef{address: 0x004f380b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/remove_tile"))] + pub const REMOVE_TILE: FunctionDef = FunctionDef{address: 0x0050bc1a, function_type: PhantomData}; } // ZTWorldMgr class functions pub mod ztworldmgr { use super::*; - pub const SATISFIES: FunctionDef u32> = FunctionDef{address: 0x0041239d, function_type: PhantomData}; - pub const GET_BUILDING_LIST: FunctionDef = FunctionDef{address: 0x00413db8, function_type: PhantomData}; - pub const GET_ATTRACTIONS: FunctionDef = FunctionDef{address: 0x00427f43, function_type: PhantomData}; - pub const GET_GAWK_SCENERY: FunctionDef = FunctionDef{address: 0x00427fd9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/satisfies"))] + pub const SATISFIES: FunctionDef u32> = FunctionDef{address: 0x0041239d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/get_building_list"))] + pub const GET_BUILDING_LIST: FunctionDef = FunctionDef{address: 0x00413db8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/get_attractions"))] + pub const GET_ATTRACTIONS: FunctionDef = FunctionDef{address: 0x00427f43, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/get_gawk_scenery"))] + pub const GET_GAWK_SCENERY: FunctionDef = FunctionDef{address: 0x00427fd9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/get_num_sites"))] pub const GET_NUM_SITES: FunctionDef i32> = FunctionDef{address: 0x004281fd, function_type: PhantomData}; - pub const GET_NEED_FROM_INDEX: FunctionDef u32> = FunctionDef{address: 0x0042aeaf, function_type: PhantomData}; - pub const GET_NEED_INDEX: FunctionDef i8> = FunctionDef{address: 0x0043aa46, function_type: PhantomData}; - pub const FIND_NEAREST_UNSEEN_STARTING_SHOW: FunctionDef u32> = FunctionDef{address: 0x00440f0c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/get_need_from_index"))] + pub const GET_NEED_FROM_INDEX: FunctionDef *const u32> = FunctionDef{address: 0x0042aeaf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/get_need_index"))] + pub const GET_NEED_INDEX: FunctionDef i8> = FunctionDef{address: 0x0043aa46, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/find_nearest_unseen_starting_show"))] + pub const FIND_NEAREST_UNSEEN_STARTING_SHOW: FunctionDef u32> = FunctionDef{address: 0x00440f0c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/add_to_gawk_scenery_list"))] pub const ADD_TO_GAWK_SCENERY_LIST: FunctionDef bool> = FunctionDef{address: 0x00451785, function_type: PhantomData}; - pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x00452e13, function_type: PhantomData}; - pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004611d4, function_type: PhantomData}; - pub const CREATE: FunctionDef = FunctionDef{address: 0x0046498e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/load"))] + pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x00452e13, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/constructor"))] + pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004611d4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/create"))] + pub const CREATE: FunctionDef *const u32> = FunctionDef{address: 0x0046498e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/save"))] pub const SAVE: FunctionDef u8> = FunctionDef{address: 0x0047704c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/remove_all_tank_owned_transients"))] pub const REMOVE_ALL_TANK_OWNED_TRANSIENTS: FunctionDef = FunctionDef{address: 0x00479eba, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/remove_transients"))] pub const REMOVE_TRANSIENTS: FunctionDef = FunctionDef{address: 0x00479efa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/remove_all_water_effects"))] pub const REMOVE_ALL_WATER_EFFECTS: FunctionDef = FunctionDef{address: 0x00479f0b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/restore_all_tank_owned_transients"))] pub const RESTORE_ALL_TANK_OWNED_TRANSIENTS: FunctionDef = FunctionDef{address: 0x0047a162, function_type: PhantomData}; - pub const LOAD_TYPES: FunctionDef u32> = FunctionDef{address: 0x004bf19a, function_type: PhantomData}; - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6a77, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/load_types"))] + pub const LOAD_TYPES: FunctionDef u32> = FunctionDef{address: 0x004bf19a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/clear"))] + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6a77, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/init_building_map"))] pub const INIT_BUILDING_MAP: FunctionDef u32> = FunctionDef{address: 0x004c75ae, function_type: PhantomData}; - pub const GUESTICIDE: FunctionDef = FunctionDef{address: 0x004c9d8c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/guesticide"))] + pub const GUESTICIDE: FunctionDef = FunctionDef{address: 0x004c9d8c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/reset_guests_without_removing"))] pub const RESET_GUESTS_WITHOUT_REMOVING: FunctionDef = FunctionDef{address: 0x004c9eae, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/reset_scenery"))] pub const RESET_SCENERY: FunctionDef = FunctionDef{address: 0x004c9f8a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/reset_animal_counts"))] pub const RESET_ANIMAL_COUNTS: FunctionDef = FunctionDef{address: 0x004c9fd4, function_type: PhantomData}; - pub const ADD_TO_OBJECT_LIST: FunctionDef = FunctionDef{address: 0x004fdf04, function_type: PhantomData}; - pub const REMOVE_FROM_ALL_BUILDING_LISTS: FunctionDef u32> = FunctionDef{address: 0x005002ac, function_type: PhantomData}; - pub const REMOVE_FROM_BUILDING_LIST: FunctionDef u32> = FunctionDef{address: 0x00500339, function_type: PhantomData}; - pub const ZTWORLD_MGR: FunctionDef u32> = FunctionDef{address: 0x0057cce9, function_type: PhantomData}; - pub const ADD_AMBIENT_EFFECT: FunctionDef = FunctionDef{address: 0x0059148e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/add_to_object_list"))] + pub const ADD_TO_OBJECT_LIST: FunctionDef = FunctionDef{address: 0x004fdf04, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/remove_from_all_building_lists"))] + pub const REMOVE_FROM_ALL_BUILDING_LISTS: FunctionDef u32> = FunctionDef{address: 0x005002ac, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/remove_from_building_list"))] + pub const REMOVE_FROM_BUILDING_LIST: FunctionDef u32> = FunctionDef{address: 0x00500339, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/ztworld_mgr"))] + pub const ZTWORLD_MGR: FunctionDef *const u32> = FunctionDef{address: 0x0057cce9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/add_ambient_effect"))] + pub const ADD_AMBIENT_EFFECT: FunctionDef = FunctionDef{address: 0x0059148e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/rubble_all_cars"))] pub const RUBBLE_ALL_CARS: FunctionDef = FunctionDef{address: 0x0060d8e3, function_type: PhantomData}; - pub const BOX_UP_AND_FIND_APLACE_FOR_ANIMAL: FunctionDef u32> = FunctionDef{address: 0x0060da6b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/box_up_and_find_aplace_for_animal"))] + pub const BOX_UP_AND_FIND_APLACE_FOR_ANIMAL: FunctionDef u32> = FunctionDef{address: 0x0060da6b, function_type: PhantomData}; } // ZooStatus class functions pub mod zoostatus { use super::*; - pub const CALCULATE_SUMS: FunctionDef = FunctionDef{address: 0x0041f881, function_type: PhantomData}; - pub const RATING_CHECKS: FunctionDef = FunctionDef{address: 0x0041fcc1, function_type: PhantomData}; - pub const MESSAGE_CHECKS: FunctionDef = FunctionDef{address: 0x00420347, function_type: PhantomData}; - pub const NEWGUEST_CHECKS: FunctionDef = FunctionDef{address: 0x00424375, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/calculate_sums"))] + pub const CALCULATE_SUMS: FunctionDef = FunctionDef{address: 0x0041f881, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/rating_checks"))] + pub const RATING_CHECKS: FunctionDef = FunctionDef{address: 0x0041fcc1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/message_checks"))] + pub const MESSAGE_CHECKS: FunctionDef = FunctionDef{address: 0x00420347, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/newguest_checks"))] + pub const NEWGUEST_CHECKS: FunctionDef = FunctionDef{address: 0x00424375, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/f_chance"))] pub const F_CHANCE: FunctionDef u32> = FunctionDef{address: 0x004244ab, function_type: PhantomData}; - pub const ADMISSION_MESSAGE: FunctionDef = FunctionDef{address: 0x00429d68, function_type: PhantomData}; - pub const BUY_PEOPLE_FOOD: FunctionDef = FunctionDef{address: 0x0042df22, function_type: PhantomData}; - pub const INCREASE_DONATIONS: FunctionDef = FunctionDef{address: 0x0042ebbe, function_type: PhantomData}; - pub const UPDATE: FunctionDef = FunctionDef{address: 0x004351a9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/admission_message"))] + pub const ADMISSION_MESSAGE: FunctionDef = FunctionDef{address: 0x00429d68, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/buy_people_food"))] + pub const BUY_PEOPLE_FOOD: FunctionDef = FunctionDef{address: 0x0042df22, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/increase_donations"))] + pub const INCREASE_DONATIONS: FunctionDef = FunctionDef{address: 0x0042ebbe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/update"))] + pub const UPDATE: FunctionDef = FunctionDef{address: 0x004351a9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047ad4e, function_type: PhantomData}; - pub const SPEND_MAINT_WAGES: FunctionDef = FunctionDef{address: 0x00483d34, function_type: PhantomData}; - pub const FINANCE_CHECKS: FunctionDef = FunctionDef{address: 0x00483f11, function_type: PhantomData}; - pub const INCREASE_ENDOWMENT: FunctionDef = FunctionDef{address: 0x0048442b, function_type: PhantomData}; - pub const SPEND_GUIDE_WAGES: FunctionDef = FunctionDef{address: 0x0048bd8b, function_type: PhantomData}; - pub const REFUND_ANIMAL_COST: FunctionDef = FunctionDef{address: 0x0048d2da, function_type: PhantomData}; - pub const SPEND_BUILDING_UPKEEP: FunctionDef = FunctionDef{address: 0x0049bd80, function_type: PhantomData}; - pub const F_ZOO_MESSAGE: FunctionDef = FunctionDef{address: 0x0049ce6b, function_type: PhantomData}; - pub const INIT: FunctionDef = FunctionDef{address: 0x004c2683, function_type: PhantomData}; - pub const RESET_FINANCE_INFO: FunctionDef = FunctionDef{address: 0x004c9f13, function_type: PhantomData}; - pub const SPEND_CONSTRUCTION: FunctionDef = FunctionDef{address: 0x004d9250, function_type: PhantomData}; - pub const SPEND_KEEPER_WAGES_0: FunctionDef = FunctionDef{address: 0x004e1fde, function_type: PhantomData}; - pub const F_CREATE_GUEST: FunctionDef = FunctionDef{address: 0x004f6e3c, function_type: PhantomData}; - pub const REFUND_CONSTRUCTION: FunctionDef = FunctionDef{address: 0x004f9329, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/spend_maint_wages"))] + pub const SPEND_MAINT_WAGES: FunctionDef = FunctionDef{address: 0x00483d34, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/finance_checks"))] + pub const FINANCE_CHECKS: FunctionDef = FunctionDef{address: 0x00483f11, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/increase_endowment"))] + pub const INCREASE_ENDOWMENT: FunctionDef = FunctionDef{address: 0x0048442b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/spend_guide_wages"))] + pub const SPEND_GUIDE_WAGES: FunctionDef = FunctionDef{address: 0x0048bd8b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/refund_animal_cost"))] + pub const REFUND_ANIMAL_COST: FunctionDef = FunctionDef{address: 0x0048d2da, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/spend_building_upkeep"))] + pub const SPEND_BUILDING_UPKEEP: FunctionDef = FunctionDef{address: 0x0049bd80, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/f_zoo_message"))] + pub const F_ZOO_MESSAGE: FunctionDef = FunctionDef{address: 0x0049ce6b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/init"))] + pub const INIT: FunctionDef = FunctionDef{address: 0x004c2683, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/reset_finance_info"))] + pub const RESET_FINANCE_INFO: FunctionDef = FunctionDef{address: 0x004c9f13, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/spend_construction"))] + pub const SPEND_CONSTRUCTION: FunctionDef = FunctionDef{address: 0x004d9250, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/spend_keeper_wages_0"))] + pub const SPEND_KEEPER_WAGES_0: FunctionDef = FunctionDef{address: 0x004e1fde, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/f_create_guest"))] + pub const F_CREATE_GUEST: FunctionDef = FunctionDef{address: 0x004f6e3c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/refund_construction"))] + pub const REFUND_CONSTRUCTION: FunctionDef = FunctionDef{address: 0x004f9329, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/animal_escaped"))] pub const ANIMAL_ESCAPED: FunctionDef = FunctionDef{address: 0x0050cde4, function_type: PhantomData}; - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0059497f, function_type: PhantomData}; - pub const INCREASE_SHOW_ADMISSION: FunctionDef = FunctionDef{address: 0x005a9718, function_type: PhantomData}; - pub const SPEND_KEEPER_WAGES_1: FunctionDef = FunctionDef{address: 0x005ad038, function_type: PhantomData}; - pub const CHANGE_ENDOWMENT_MEMBERS: FunctionDef = FunctionDef{address: 0x005ad160, function_type: PhantomData}; - pub const F_GRANT_DONATION: FunctionDef = FunctionDef{address: 0x00613e4a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/load"))] + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0059497f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/increase_show_admission"))] + pub const INCREASE_SHOW_ADMISSION: FunctionDef = FunctionDef{address: 0x005a9718, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/spend_keeper_wages_1"))] + pub const SPEND_KEEPER_WAGES_1: FunctionDef = FunctionDef{address: 0x005ad038, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/change_endowment_members"))] + pub const CHANGE_ENDOWMENT_MEMBERS: FunctionDef = FunctionDef{address: 0x005ad160, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/f_grant_donation"))] + pub const F_GRANT_DONATION: FunctionDef = FunctionDef{address: 0x00613e4a, function_type: PhantomData}; } // bfinternat class functions pub mod bfinternat { use super::*; - pub const GET_MONEY_TEXT_0: FunctionDef u32> = FunctionDef{address: 0x0040eca1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/get_money_text_0"))] + pub const GET_MONEY_TEXT_0: FunctionDef *const u32> = FunctionDef{address: 0x0040eca1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/set_money_text_0"))] pub const SET_MONEY_TEXT_0: FunctionDef = FunctionDef{address: 0x0040ed88, function_type: PhantomData}; - pub const GET_NUMBER_TEXT: FunctionDef u32> = FunctionDef{address: 0x00417879, function_type: PhantomData}; - pub const GET_DATE_TEXT: FunctionDef u32> = FunctionDef{address: 0x0041d39c, function_type: PhantomData}; - pub const SET_DATE_TEXT: FunctionDef = FunctionDef{address: 0x0041d4df, function_type: PhantomData}; - pub const GET_MONEY_TEXT_1: FunctionDef u32> = FunctionDef{address: 0x004ef4d4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/get_number_text"))] + pub const GET_NUMBER_TEXT: FunctionDef *const u32> = FunctionDef{address: 0x00417879, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/get_date_text"))] + pub const GET_DATE_TEXT: FunctionDef *const u32> = FunctionDef{address: 0x0041d39c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/set_date_text"))] + pub const SET_DATE_TEXT: FunctionDef = FunctionDef{address: 0x0041d4df, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/get_money_text_1"))] + pub const GET_MONEY_TEXT_1: FunctionDef *const u32> = FunctionDef{address: 0x004ef4d4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/set_money_text_1"))] pub const SET_MONEY_TEXT_1: FunctionDef = FunctionDef{address: 0x004ef5eb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/set_number_text"))] pub const SET_NUMBER_TEXT: FunctionDef = FunctionDef{address: 0x004efe4f, function_type: PhantomData}; - pub const GET_TEXT_RESOURCE: FunctionDef u32> = FunctionDef{address: 0x004f00f6, function_type: PhantomData}; - pub const SET_TEXT_RESOURCE: FunctionDef = FunctionDef{address: 0x004f0264, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/get_text_resource"))] + pub const GET_TEXT_RESOURCE: FunctionDef *const u32> = FunctionDef{address: 0x004f00f6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/set_text_resource"))] + pub const SET_TEXT_RESOURCE: FunctionDef = FunctionDef{address: 0x004f0264, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x005358b7, function_type: PhantomData}; - pub const GET_CURRENCY_SYMBOL: FunctionDef u32> = FunctionDef{address: 0x005fe02d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/get_currency_symbol"))] + pub const GET_CURRENCY_SYMBOL: FunctionDef *const u32> = FunctionDef{address: 0x005fe02d, function_type: PhantomData}; } // ph_BFPathMove class functions pub mod ph_bfpathmove { use super::*; - pub const DO_PROGRESS: FunctionDef i8> = FunctionDef{address: 0x00439cee, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("ph_bfpathmove/do_progress"))] + pub const DO_PROGRESS: FunctionDef i8> = FunctionDef{address: 0x00439cee, function_type: PhantomData}; } // sndutil class functions pub mod sndutil { use super::*; - pub const COMPUTE_VOLUME_AND_PAN: FunctionDef = FunctionDef{address: 0x0043f5ba, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("sndutil/compute_volume_and_pan"))] + pub const COMPUTE_VOLUME_AND_PAN: FunctionDef = FunctionDef{address: 0x0043f5ba, function_type: PhantomData}; } // std::__vector_deleter<> class functions pub mod std_vector_deleter { use super::*; - pub const VECTOR_DELETER: FunctionDef u32> = FunctionDef{address: 0x0060e4f5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("std_vector_deleter/vector_deleter"))] + pub const VECTOR_DELETER: FunctionDef *const u32> = FunctionDef{address: 0x0060e4f5, function_type: PhantomData}; } // std::basic_string<> class functions pub mod std_basic_string { use super::*; - pub const BASIC_STRING: FunctionDef = FunctionDef{address: 0x004012ba, function_type: PhantomData}; - pub const COMPARE: FunctionDef = FunctionDef{address: 0x00401a94, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("std_basic_string/basic_string_0"))] + pub const BASIC_STRING_0: FunctionDef = FunctionDef{address: 0x004012ba, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("std_basic_string/compare"))] + pub const COMPARE: FunctionDef = FunctionDef{address: 0x00401a94, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("std_basic_string/basic_string_1"))] + pub const BASIC_STRING_1: FunctionDef = FunctionDef{address: 0x00401da8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("std_basic_string/basic_string_2"))] + pub const BASIC_STRING_2: FunctionDef *const i32> = FunctionDef{address: 0x00404cf4, function_type: PhantomData}; } // Standalone functions pub mod standalone { use super::*; - pub const NULLSUB_0: FunctionDef = FunctionDef{address: 0x0040100b, function_type: PhantomData}; - pub const NULLSUB_1: FunctionDef = FunctionDef{address: 0x0040100c, function_type: PhantomData}; - pub const VF_RETURN_TRUE_0: FunctionDef = FunctionDef{address: 0x00401302, function_type: PhantomData}; - pub const VF_RETURN_FALSE: FunctionDef = FunctionDef{address: 0x004016d1, function_type: PhantomData}; - pub const FIND_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD722_TREE_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q33STD380MAP_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING13VALUE_COMPARE_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_FRCQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q33STD722_TREE_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q33STD380MAP_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING13VALUE_COMPARE_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING21_GENERIC_ITERATOR0: FunctionDef = FunctionDef{address: 0x00401b9f, function_type: PhantomData}; - pub const SEARCH_CONFIG_METHOD: FunctionDef = FunctionDef{address: 0x00401eb1, function_type: PhantomData}; - pub const OPERATOR_NEW: FunctionDef u32> = FunctionDef{address: 0x00402a5a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_0"))] + pub const NULLSUB_0: FunctionDef = FunctionDef{address: 0x0040100b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_1"))] + pub const NULLSUB_1: FunctionDef = FunctionDef{address: 0x0040100c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/vf_return_true_0"))] + pub const VF_RETURN_TRUE_0: FunctionDef u8> = FunctionDef{address: 0x00401302, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/vf_return_false"))] + pub const VF_RETURN_FALSE: FunctionDef u8> = FunctionDef{address: 0x004016d1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/find_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std722_tree_q23std135pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding_q33std380map_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding_q23std73less_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std155allocator_q23std135pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding13value_compare_q23std155allocator_q23std135pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding_frcq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q33std722_tree_q23std135pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding_q33std380map_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding_q23std73less_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std155allocator_q23std135pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding13value_compare_q23std155allocator_q23std135pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding21_generic_iterator0"))] + pub const FIND_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD722_TREE_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q33STD380MAP_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING13VALUE_COMPARE_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_FRCQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q33STD722_TREE_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q33STD380MAP_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING13VALUE_COMPARE_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING21_GENERIC_ITERATOR0: FunctionDef = FunctionDef{address: 0x00401b9f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/search_config_method"))] + pub const SEARCH_CONFIG_METHOD: FunctionDef = FunctionDef{address: 0x00401eb1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/operator_new"))] + pub const OPERATOR_NEW: FunctionDef *const c_void> = FunctionDef{address: 0x00402a5a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_2"))] pub const NULLSUB_2: FunctionDef = FunctionDef{address: 0x00402e53, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_3"))] pub const NULLSUB_3: FunctionDef = FunctionDef{address: 0x00402f82, function_type: PhantomData}; - pub const CRC32: FunctionDef u32> = FunctionDef{address: 0x004036cc, function_type: PhantomData}; - pub const BFRESOURCE_HASH_KEY: FunctionDef = FunctionDef{address: 0x00403802, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/crc32"))] + pub const CRC32: FunctionDef u32> = FunctionDef{address: 0x004036cc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/bfresource_hash_key"))] + pub const BFRESOURCE_HASH_KEY: FunctionDef = FunctionDef{address: 0x00403802, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/deallocate"))] pub const DEALLOCATE: FunctionDef u32> = FunctionDef{address: 0x00403e06, function_type: PhantomData}; - pub const VF_RETURN_TRUE_1: FunctionDef = FunctionDef{address: 0x00404a7e, function_type: PhantomData}; - pub const LOAD_STRING_FROM_RESOURCE: FunctionDef i32> = FunctionDef{address: 0x00404e72, function_type: PhantomData}; - pub const NULLSUB_4: FunctionDef = FunctionDef{address: 0x00404fcf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/vf_return_true_1"))] + pub const VF_RETURN_TRUE_1: FunctionDef u8> = FunctionDef{address: 0x00404a7e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/load_string_from_resource"))] + pub const LOAD_STRING_FROM_RESOURCE: FunctionDef i32> = FunctionDef{address: 0x00404e72, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_4"))] + pub const NULLSUB_4: FunctionDef = FunctionDef{address: 0x00404fcf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_5"))] pub const NULLSUB_5: FunctionDef = FunctionDef{address: 0x004072ef, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_6"))] pub const NULLSUB_6: FunctionDef = FunctionDef{address: 0x0040733c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_7"))] pub const NULLSUB_7: FunctionDef = FunctionDef{address: 0x00409b61, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_8"))] pub const NULLSUB_8: FunctionDef = FunctionDef{address: 0x0040bcc9, function_type: PhantomData}; - pub const VER_QUERY_VALUE_A: FunctionDef bool> = FunctionDef{address: 0x0040dcfb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/ver_query_value_a"))] + pub const VER_QUERY_VALUE_A: FunctionDef bool> = FunctionDef{address: 0x0040dcfb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_needs_order_recalculate"))] pub const SET_NEEDS_ORDER_RECALCULATE: FunctionDef = FunctionDef{address: 0x0040f15b, function_type: PhantomData}; - pub const SCALE_RECT: FunctionDef u32> = FunctionDef{address: 0x0040f33d, function_type: PhantomData}; - pub const EXPAND_RECT: FunctionDef = FunctionDef{address: 0x0040f38d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/scale_rect"))] + pub const SCALE_RECT: FunctionDef *const i32> = FunctionDef{address: 0x0040f33d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/expand_rect"))] + pub const EXPAND_RECT: FunctionDef = FunctionDef{address: 0x0040f38d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/is_snap_to_ground"))] + pub const IS_SNAP_TO_GROUND: FunctionDef u32> = FunctionDef{address: 0x00410309, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_rotate_ccw"))] pub const CLICK_ROTATE_CCW: FunctionDef = FunctionDef{address: 0x00416cb7, function_type: PhantomData}; - pub const LISTABLE_OBJECT: FunctionDef u32> = FunctionDef{address: 0x004172e3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/listable_object"))] + pub const LISTABLE_OBJECT: FunctionDef u32> = FunctionDef{address: 0x004172e3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_9"))] pub const NULLSUB_9: FunctionDef = FunctionDef{address: 0x00418d1e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/null_startup"))] pub const NULL_STARTUP: FunctionDef = FunctionDef{address: 0x004190ff, function_type: PhantomData}; - pub const UIRENDER_TEXT_0: FunctionDef = FunctionDef{address: 0x00419b0c, function_type: PhantomData}; - pub const UIRENDER_TEXT_1: FunctionDef = FunctionDef{address: 0x00419c3d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/uirender_text_0"))] + pub const UIRENDER_TEXT_0: FunctionDef = FunctionDef{address: 0x00419b0c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/uirender_text_1"))] + pub const UIRENDER_TEXT_1: FunctionDef = FunctionDef{address: 0x00419c3d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/startup_update"))] pub const STARTUP_UPDATE: FunctionDef = FunctionDef{address: 0x0041a3d5, function_type: PhantomData}; - pub const MAYBE_SNPRINTF: FunctionDef u32> = FunctionDef{address: 0x0041b460, function_type: PhantomData}; - pub const LOAD_INI_VALUE_STRING: FunctionDef u32> = FunctionDef{address: 0x0041b4bc, function_type: PhantomData}; - pub const MAYBE_SSCANF: FunctionDef = FunctionDef{address: 0x0041b958, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/maybe_snprintf"))] + pub const MAYBE_SNPRINTF: FunctionDef u32> = FunctionDef{address: 0x0041b460, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/load_ini_value_string"))] + pub const LOAD_INI_VALUE_STRING: FunctionDef *const u32> = FunctionDef{address: 0x0041b4bc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/maybe_sscanf"))] + pub const MAYBE_SSCANF: FunctionDef = FunctionDef{address: 0x0041b958, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_status"))] pub const SET_STATUS: FunctionDef = FunctionDef{address: 0x0041d058, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_10"))] pub const NULLSUB_10: FunctionDef = FunctionDef{address: 0x0041e63a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/tile_within_ava"))] pub const TILE_WITHIN_AVA: FunctionDef u32> = FunctionDef{address: 0x0044ed0c, function_type: PhantomData}; - pub const CHECK_CHARACTERISTICS: FunctionDef bool> = FunctionDef{address: 0x004537fe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/validate_neighbor_paths"))] + pub const VALIDATE_NEIGHBOR_PATHS: FunctionDef = FunctionDef{address: 0x00451aa6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/can_put_path"))] + pub const CAN_PUT_PATH: FunctionDef u32> = FunctionDef{address: 0x00451e44, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/showpanel_update_available_trick_list"))] + pub const SHOWPANEL_UPDATE_AVAILABLE_TRICK_LIST: FunctionDef = FunctionDef{address: 0x004522ae, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/check_characteristics_0"))] + pub const CHECK_CHARACTERISTICS_0: FunctionDef bool> = FunctionDef{address: 0x004537fe, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/refill_animal_display"))] pub const REFILL_ANIMAL_DISPLAY: FunctionDef = FunctionDef{address: 0x0045390c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/check_characteristics_1"))] + pub const CHECK_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x00457d70, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/make_shape_idx"))] pub const MAKE_SHAPE_IDX: FunctionDef u32> = FunctionDef{address: 0x0045e493, function_type: PhantomData}; - pub const CREATE_ZTMEGATILE_MGR: FunctionDef = FunctionDef{address: 0x00463e1e, function_type: PhantomData}; - pub const CREATE_ZTHABITAT_MGR: FunctionDef = FunctionDef{address: 0x00464925, function_type: PhantomData}; - pub const CREATE_ZTTHOUGHT_MGR: FunctionDef = FunctionDef{address: 0x00464b34, function_type: PhantomData}; - pub const UPDATE_INFO_0: FunctionDef = FunctionDef{address: 0x004673b5, function_type: PhantomData}; - pub const FILL_LIST_BOX_0: FunctionDef = FunctionDef{address: 0x00467a33, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztmegatile_mgr"))] + pub const CREATE_ZTMEGATILE_MGR: FunctionDef *const u32> = FunctionDef{address: 0x00463e1e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_zthabitat_mgr"))] + pub const CREATE_ZTHABITAT_MGR: FunctionDef *const u32> = FunctionDef{address: 0x00464925, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztthought_mgr"))] + pub const CREATE_ZTTHOUGHT_MGR: FunctionDef *const u32> = FunctionDef{address: 0x00464b34, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_info_0"))] + pub const UPDATE_INFO_0: FunctionDef = FunctionDef{address: 0x004673b5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/fill_list_box_0"))] + pub const FILL_LIST_BOX_0: FunctionDef = FunctionDef{address: 0x00467a33, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/refill_habitat_info"))] pub const REFILL_HABITAT_INFO: FunctionDef = FunctionDef{address: 0x00467c6f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/refill_thoughts_list"))] pub const REFILL_THOUGHTS_LIST: FunctionDef = FunctionDef{address: 0x00467e76, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/refill_animal_list"))] pub const REFILL_ANIMAL_LIST: FunctionDef = FunctionDef{address: 0x00467fc8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_selected_habitat"))] pub const SET_SELECTED_HABITAT: FunctionDef = FunctionDef{address: 0x00468178, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_info_tab"))] pub const CLICK_INFO_TAB: FunctionDef = FunctionDef{address: 0x004681d0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_habitat"))] pub const HIDE_HABITAT: FunctionDef = FunctionDef{address: 0x004682f1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_habitat"))] pub const SHOW_HABITAT: FunctionDef = FunctionDef{address: 0x0046836c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_admission"))] pub const UPDATE_ADMISSION: FunctionDef = FunctionDef{address: 0x00468865, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_tank_modify"))] pub const CLICK_TANK_MODIFY: FunctionDef = FunctionDef{address: 0x00468c00, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/tankmodify_adjust_tank_base"))] pub const TANKMODIFY_ADJUST_TANK_BASE: FunctionDef = FunctionDef{address: 0x0046937e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_thoughts_tab"))] pub const CLICK_THOUGHTS_TAB: FunctionDef = FunctionDef{address: 0x0046981e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_donations_tab"))] pub const CLICK_DONATIONS_TAB: FunctionDef = FunctionDef{address: 0x004699d2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_animals_tab"))] pub const CLICK_ANIMALS_TAB: FunctionDef = FunctionDef{address: 0x00469af2, function_type: PhantomData}; - pub const FILL_LIST_BOX_1: FunctionDef = FunctionDef{address: 0x0046a040, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/refill_staff_display"))] + pub const REFILL_STAFF_DISPLAY: FunctionDef = FunctionDef{address: 0x00469e10, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/fill_list_box_1"))] + pub const FILL_LIST_BOX_1: FunctionDef = FunctionDef{address: 0x0046a040, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_grab_animal"))] pub const CLICK_GRAB_ANIMAL: FunctionDef = FunctionDef{address: 0x0046af10, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_cursor_quality"))] + pub const SET_CURSOR_QUALITY: FunctionDef u32> = FunctionDef{address: 0x0046bb82, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_conservation"))] pub const CLICK_CONSERVATION: FunctionDef = FunctionDef{address: 0x00470a71, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_research"))] pub const CLICK_RESEARCH: FunctionDef = FunctionDef{address: 0x0047104b, function_type: PhantomData}; - pub const UPDATE_INFO_1: FunctionDef = FunctionDef{address: 0x0047108a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_info_1"))] + pub const UPDATE_INFO_1: FunctionDef = FunctionDef{address: 0x0047108a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_exhibit_info"))] pub const UPDATE_EXHIBIT_INFO: FunctionDef = FunctionDef{address: 0x00473b1f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_stats"))] pub const UPDATE_STATS: FunctionDef = FunctionDef{address: 0x00473b61, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/disable_everything"))] pub const DISABLE_EVERYTHING: FunctionDef = FunctionDef{address: 0x004745a7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/copy_list_to_script"))] pub const COPY_LIST_TO_SCRIPT: FunctionDef u32> = FunctionDef{address: 0x00475d92, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_save_0"))] pub const CLICK_SAVE_0: FunctionDef = FunctionDef{address: 0x00477004, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_save_1"))] pub const CLICK_SAVE_1: FunctionDef = FunctionDef{address: 0x00477041, function_type: PhantomData}; - pub const GET_SAVE_FILE_NAME_A: FunctionDef bool> = FunctionDef{address: 0x00477046, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_save_file_name_a"))] + pub const GET_SAVE_FILE_NAME_A: FunctionDef bool> = FunctionDef{address: 0x00477046, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/write_bytes_to_file"))] pub const WRITE_BYTES_TO_FILE: FunctionDef bool> = FunctionDef{address: 0x0047772e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/force_research"))] pub const FORCE_RESEARCH: FunctionDef = FunctionDef{address: 0x0047ebd4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_info_0"))] pub const HIDE_INFO_0: FunctionDef = FunctionDef{address: 0x0047ecc0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_developer"))] pub const HIDE_DEVELOPER: FunctionDef = FunctionDef{address: 0x0047ed35, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_info_labels_0"))] pub const HIDE_INFO_LABELS_0: FunctionDef = FunctionDef{address: 0x0047ed53, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/depopulate_obj_list_0"))] pub const DEPOPULATE_OBJ_LIST_0: FunctionDef = FunctionDef{address: 0x0047edc8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_developer_list"))] pub const HIDE_DEVELOPER_LIST: FunctionDef = FunctionDef{address: 0x0047ee2b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_developer"))] pub const SHOW_DEVELOPER: FunctionDef = FunctionDef{address: 0x0047ee5d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_developer_list"))] pub const CLICK_DEVELOPER_LIST: FunctionDef = FunctionDef{address: 0x0047ee74, function_type: PhantomData}; - pub const REPOPULATE_OBJ_LIST_0: FunctionDef = FunctionDef{address: 0x0047ee98, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/repopulate_obj_list_0"))] + pub const REPOPULATE_OBJ_LIST_0: FunctionDef = FunctionDef{address: 0x0047ee98, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_developer_list"))] pub const SHOW_DEVELOPER_LIST: FunctionDef = FunctionDef{address: 0x0047f0a2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/staffplaque_set_staff"))] pub const STAFFPLAQUE_SET_STAFF: FunctionDef = FunctionDef{address: 0x00481648, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/check_keeper_info_button"))] pub const CHECK_KEEPER_INFO_BUTTON: FunctionDef = FunctionDef{address: 0x004830c0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/unclick_keeper_info"))] pub const UNCLICK_KEEPER_INFO: FunctionDef = FunctionDef{address: 0x0048330d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_info_plaque"))] pub const CLICK_INFO_PLAQUE: FunctionDef = FunctionDef{address: 0x004833e3, function_type: PhantomData}; - pub const SET_MAIN_TEXT: FunctionDef = FunctionDef{address: 0x00483481, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_main_text"))] + pub const SET_MAIN_TEXT: FunctionDef = FunctionDef{address: 0x00483481, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_general_info"))] pub const SHOW_GENERAL_INFO: FunctionDef = FunctionDef{address: 0x004834b5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_info_2"))] pub const UPDATE_INFO_2: FunctionDef = FunctionDef{address: 0x004834cc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_keeper_info"))] pub const CLICK_KEEPER_INFO: FunctionDef = FunctionDef{address: 0x00483b21, function_type: PhantomData}; - pub const CLICK_TOPIC_LIST: FunctionDef = FunctionDef{address: 0x0048482b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_topic_list"))] + pub const CLICK_TOPIC_LIST: FunctionDef = FunctionDef{address: 0x0048482b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_about"))] pub const CLICK_ABOUT: FunctionDef = FunctionDef{address: 0x00484b9a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_cbuilding_info"))] pub const HIDE_CBUILDING_INFO: FunctionDef = FunctionDef{address: 0x004881a9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_info_3"))] pub const UPDATE_INFO_3: FunctionDef = FunctionDef{address: 0x00488446, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_cbuilding_info"))] pub const SHOW_CBUILDING_INFO: FunctionDef = FunctionDef{address: 0x00488b79, function_type: PhantomData}; - pub const S_SET_KEY: FunctionDef = FunctionDef{address: 0x0048a80a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/s_set_key"))] + pub const S_SET_KEY: FunctionDef = FunctionDef{address: 0x0048a80a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_animal_info_follow"))] pub const CLICK_ANIMAL_INFO_FOLLOW: FunctionDef = FunctionDef{address: 0x0048c7ef, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_sell_animal"))] pub const CLICK_SELL_ANIMAL: FunctionDef = FunctionDef{address: 0x0048d0b4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_rotate_right_0"))] pub const CLICK_ROTATE_RIGHT_0: FunctionDef = FunctionDef{address: 0x0048e40f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_info_4"))] pub const UPDATE_INFO_4: FunctionDef = FunctionDef{address: 0x004a02f7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_res_con"))] pub const HIDE_RES_CON: FunctionDef = FunctionDef{address: 0x004a02fc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_res_con"))] pub const SHOW_RES_CON: FunctionDef = FunctionDef{address: 0x004a031a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_messages"))] pub const CLICK_MESSAGES: FunctionDef = FunctionDef{address: 0x004a0399, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/persistent_text_callback"))] pub const PERSISTENT_TEXT_CALLBACK: FunctionDef = FunctionDef{address: 0x004a09f8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_11"))] pub const NULLSUB_11: FunctionDef = FunctionDef{address: 0x004aba22, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_12"))] pub const NULLSUB_12: FunctionDef = FunctionDef{address: 0x004abafb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_13"))] pub const NULLSUB_13: FunctionDef = FunctionDef{address: 0x004abc9b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_14"))] pub const NULLSUB_14: FunctionDef = FunctionDef{address: 0x004ac022, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_15"))] pub const NULLSUB_15: FunctionDef = FunctionDef{address: 0x004ac06c, function_type: PhantomData}; - pub const SET_NEIGHBOR: FunctionDef = FunctionDef{address: 0x004ac3f9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_neighbor"))] + pub const SET_NEIGHBOR: FunctionDef = FunctionDef{address: 0x004ac3f9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_16"))] pub const NULLSUB_16: FunctionDef = FunctionDef{address: 0x004ad05f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_rotate_cw"))] pub const CLICK_ROTATE_CW: FunctionDef = FunctionDef{address: 0x004b071a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_zoom_out"))] pub const CLICK_ZOOM_OUT: FunctionDef = FunctionDef{address: 0x004b0779, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_zoom_in"))] pub const CLICK_ZOOM_IN: FunctionDef = FunctionDef{address: 0x004b081b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/fps"))] pub const FPS: FunctionDef u32> = FunctionDef{address: 0x004b1949, function_type: PhantomData}; - pub const SAVE_INI_VALUE_STRING: FunctionDef = FunctionDef{address: 0x004b294a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/save_ini_value_string"))] + pub const SAVE_INI_VALUE_STRING: FunctionDef = FunctionDef{address: 0x004b294a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_17"))] pub const NULLSUB_17: FunctionDef = FunctionDef{address: 0x004b31cf, function_type: PhantomData}; - pub const TIME: FunctionDef = FunctionDef{address: 0x004bc0c7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/time"))] + pub const TIME: FunctionDef = FunctionDef{address: 0x004bc0c7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_18"))] pub const NULLSUB_18: FunctionDef = FunctionDef{address: 0x004c6761, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_19"))] pub const NULLSUB_19: FunctionDef = FunctionDef{address: 0x004c67d5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_go_0"))] pub const CLICK_GO_0: FunctionDef = FunctionDef{address: 0x004ca15d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_go_1"))] pub const CLICK_GO_1: FunctionDef = FunctionDef{address: 0x004ca34e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_map_list"))] pub const CLICK_MAP_LIST: FunctionDef = FunctionDef{address: 0x004ca58e, function_type: PhantomData}; - pub const S_GET_KEY: FunctionDef u32> = FunctionDef{address: 0x004cab6a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/s_get_key"))] + pub const S_GET_KEY: FunctionDef u32> = FunctionDef{address: 0x004cab6a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/fill_scenario_list"))] pub const FILL_SCENARIO_LIST: FunctionDef = FunctionDef{address: 0x004cacf3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_scenario"))] pub const SHOW_SCENARIO: FunctionDef = FunctionDef{address: 0x004caf09, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_cash"))] pub const SET_CASH: FunctionDef = FunctionDef{address: 0x004cb384, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_map_select"))] pub const SHOW_MAP_SELECT: FunctionDef = FunctionDef{address: 0x004cb4b1, function_type: PhantomData}; - pub const MAKE_INITIAL_DIR: FunctionDef u32> = FunctionDef{address: 0x004cb6b6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/make_initial_dir"))] + pub const MAKE_INITIAL_DIR: FunctionDef u32> = FunctionDef{address: 0x004cb6b6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_save_as_0"))] pub const CLICK_SAVE_AS_0: FunctionDef = FunctionDef{address: 0x004cb8ed, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_save_as_1"))] pub const CLICK_SAVE_AS_1: FunctionDef = FunctionDef{address: 0x004cb9b4, function_type: PhantomData}; - pub const IMM_GET_DEFAULT_IMEWND: FunctionDef u32> = FunctionDef{address: 0x004cc6cb, function_type: PhantomData}; - pub const MAKE_FILE_FILTER: FunctionDef = FunctionDef{address: 0x004cc6eb, function_type: PhantomData}; - pub const GET_OPEN_FILE_NAME_A: FunctionDef bool> = FunctionDef{address: 0x004cc7cb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/imm_get_default_imewnd"))] + pub const IMM_GET_DEFAULT_IMEWND: FunctionDef *const u32> = FunctionDef{address: 0x004cc6cb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/make_file_filter"))] + pub const MAKE_FILE_FILTER: FunctionDef = FunctionDef{address: 0x004cc6eb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_open_file_name_a"))] + pub const GET_OPEN_FILE_NAME_A: FunctionDef bool> = FunctionDef{address: 0x004cc7cb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_load_0"))] pub const CLICK_LOAD_0: FunctionDef = FunctionDef{address: 0x004cc7d1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/commit_if_possible"))] pub const COMMIT_IF_POSSIBLE: FunctionDef = FunctionDef{address: 0x004da2e0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_terraform_layout"))] pub const SHOW_TERRAFORM_LAYOUT: FunctionDef = FunctionDef{address: 0x004da60d, function_type: PhantomData}; - pub const CONVERT_TERRAIN_TYPE_VECTOR: FunctionDef u32> = FunctionDef{address: 0x004da780, function_type: PhantomData}; - pub const CLICK_BUY_HABITAT_LIST: FunctionDef = FunctionDef{address: 0x004da916, function_type: PhantomData}; - pub const SHOW_INFO_0: FunctionDef = FunctionDef{address: 0x004dab14, function_type: PhantomData}; - pub const REPOPULATE_OBJ_LIST_1: FunctionDef = FunctionDef{address: 0x004dae5c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/convert_terrain_type_vector"))] + pub const CONVERT_TERRAIN_TYPE_VECTOR: FunctionDef *const i32> = FunctionDef{address: 0x004da780, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_buy_habitat_list"))] + pub const CLICK_BUY_HABITAT_LIST: FunctionDef = FunctionDef{address: 0x004da916, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_info_0"))] + pub const SHOW_INFO_0: FunctionDef = FunctionDef{address: 0x004dab14, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/repopulate_obj_list_1"))] + pub const REPOPULATE_OBJ_LIST_1: FunctionDef = FunctionDef{address: 0x004dae5c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_paint"))] pub const CLICK_PAINT: FunctionDef = FunctionDef{address: 0x004dcb50, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_modify"))] pub const CLICK_MODIFY: FunctionDef = FunctionDef{address: 0x004dd68c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/terraform_suspend"))] pub const TERRAFORM_SUSPEND: FunctionDef = FunctionDef{address: 0x004de496, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_undo"))] pub const CLICK_UNDO: FunctionDef = FunctionDef{address: 0x004de9ce, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/general_set_temp_entity_rotation"))] pub const GENERAL_SET_TEMP_ENTITY_ROTATION: FunctionDef = FunctionDef{address: 0x004df56d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_expansion_list"))] pub const HIDE_EXPANSION_LIST: FunctionDef = FunctionDef{address: 0x004e0ee9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_info_1"))] pub const HIDE_INFO_1: FunctionDef = FunctionDef{address: 0x004e0f12, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/unclick_buy_habitat_list"))] pub const UNCLICK_BUY_HABITAT_LIST: FunctionDef = FunctionDef{address: 0x004e0fe6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/depopulate_obj_list_1"))] pub const DEPOPULATE_OBJ_LIST_1: FunctionDef = FunctionDef{address: 0x004e1006, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_buy_habitat_list"))] pub const HIDE_BUY_HABITAT_LIST: FunctionDef = FunctionDef{address: 0x004e1079, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/deselected_tab_0"))] pub const DESELECTED_TAB_0: FunctionDef = FunctionDef{address: 0x004e1088, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/record_scroll_pos_0"))] pub const RECORD_SCROLL_POS_0: FunctionDef = FunctionDef{address: 0x004e27a9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_info_plaque"))] pub const SHOW_INFO_PLAQUE: FunctionDef = FunctionDef{address: 0x004e2865, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_info_labels_1"))] pub const HIDE_INFO_LABELS_1: FunctionDef = FunctionDef{address: 0x004e28c8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_info_2"))] pub const HIDE_INFO_2: FunctionDef = FunctionDef{address: 0x004e2967, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_buy_animal_list"))] pub const HIDE_BUY_ANIMAL_LIST: FunctionDef = FunctionDef{address: 0x004e2ba6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/unclick_buy_animal_list"))] pub const UNCLICK_BUY_ANIMAL_LIST: FunctionDef = FunctionDef{address: 0x004e2bb5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_buy_animal_list"))] pub const SHOW_BUY_ANIMAL_LIST: FunctionDef = FunctionDef{address: 0x004e2bda, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/depopulate_obj_list_2"))] pub const DEPOPULATE_OBJ_LIST_2: FunctionDef = FunctionDef{address: 0x004e2bec, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_buy_animal"))] pub const HIDE_BUY_ANIMAL: FunctionDef = FunctionDef{address: 0x004e2cdd, function_type: PhantomData}; - pub const CLICK_BUY_ANIMAL_LIST: FunctionDef = FunctionDef{address: 0x004e2cf8, function_type: PhantomData}; - pub const SHOW_INFO_1: FunctionDef = FunctionDef{address: 0x004e2f17, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_buy_animal_list"))] + pub const CLICK_BUY_ANIMAL_LIST: FunctionDef = FunctionDef{address: 0x004e2cf8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_info_1"))] + pub const SHOW_INFO_1: FunctionDef = FunctionDef{address: 0x004e2f17, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_info_labels_0"))] pub const SHOW_INFO_LABELS_0: FunctionDef = FunctionDef{address: 0x004e32c6, function_type: PhantomData}; - pub const REPOPULATE_OBJ_LIST_2: FunctionDef = FunctionDef{address: 0x004e334b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/repopulate_obj_list_2"))] + pub const REPOPULATE_OBJ_LIST_2: FunctionDef = FunctionDef{address: 0x004e334b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_subtitle"))] pub const SET_SUBTITLE: FunctionDef = FunctionDef{address: 0x004e3842, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/deselected_tab_1"))] pub const DESELECTED_TAB_1: FunctionDef = FunctionDef{address: 0x004e3867, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_buy_animal"))] pub const SHOW_BUY_ANIMAL: FunctionDef = FunctionDef{address: 0x004e3917, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_animal_tab"))] pub const CLICK_ANIMAL_TAB: FunctionDef = FunctionDef{address: 0x004e3bc1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_rotate_buttons_0"))] pub const HIDE_ROTATE_BUTTONS_0: FunctionDef = FunctionDef{address: 0x004e3c83, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_sex_buttons"))] pub const SHOW_SEX_BUTTONS: FunctionDef = FunctionDef{address: 0x004e3d22, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_sex_button"))] pub const CLICK_SEX_BUTTON: FunctionDef = FunctionDef{address: 0x004e3ec3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_info_3"))] pub const HIDE_INFO_3: FunctionDef = FunctionDef{address: 0x004e3f64, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_info_labels_2"))] pub const HIDE_INFO_LABELS_2: FunctionDef = FunctionDef{address: 0x004e3fd9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_buy_obj_list"))] pub const HIDE_BUY_OBJ_LIST: FunctionDef = FunctionDef{address: 0x004e4012, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/depopulate_obj_list_3"))] pub const DEPOPULATE_OBJ_LIST_3: FunctionDef = FunctionDef{address: 0x004e4021, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/unclick_buy_object_list"))] pub const UNCLICK_BUY_OBJECT_LIST: FunctionDef = FunctionDef{address: 0x004e4084, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_buy_object"))] pub const HIDE_BUY_OBJECT: FunctionDef = FunctionDef{address: 0x004e40d9, function_type: PhantomData}; - pub const CLICK_BUY_OBJECT_LIST: FunctionDef = FunctionDef{address: 0x004e40f4, function_type: PhantomData}; - pub const REPOPULATE_OBJ_LIST_3: FunctionDef = FunctionDef{address: 0x004e4343, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_buy_object_list"))] + pub const CLICK_BUY_OBJECT_LIST: FunctionDef = FunctionDef{address: 0x004e40f4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/repopulate_obj_list_3"))] + pub const REPOPULATE_OBJ_LIST_3: FunctionDef = FunctionDef{address: 0x004e4343, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_grouping_title"))] pub const SET_GROUPING_TITLE: FunctionDef = FunctionDef{address: 0x004e4890, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/deselected_tab_2"))] pub const DESELECTED_TAB_2: FunctionDef = FunctionDef{address: 0x004e48b5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_buy_obj_list"))] pub const SHOW_BUY_OBJ_LIST: FunctionDef = FunctionDef{address: 0x004e48be, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_building_tab"))] pub const CLICK_BUILDING_TAB: FunctionDef = FunctionDef{address: 0x004e4951, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_buy_object"))] pub const SHOW_BUY_OBJECT: FunctionDef = FunctionDef{address: 0x004e49f5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/select_expansion"))] pub const SELECT_EXPANSION: FunctionDef = FunctionDef{address: 0x004e4c4d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_expansion_list"))] pub const SHOW_EXPANSION_LIST: FunctionDef = FunctionDef{address: 0x004e4c97, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_scenery_tab"))] pub const CLICK_SCENERY_TAB: FunctionDef = FunctionDef{address: 0x004e5090, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_rotate_right_1"))] pub const CLICK_ROTATE_RIGHT_1: FunctionDef = FunctionDef{address: 0x004e5134, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/record_scroll_pos_1"))] pub const RECORD_SCROLL_POS_1: FunctionDef = FunctionDef{address: 0x004e5835, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_rotate_buttons"))] pub const SHOW_ROTATE_BUTTONS: FunctionDef = FunctionDef{address: 0x004e58f9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_shelters_tab"))] pub const CLICK_SHELTERS_TAB: FunctionDef = FunctionDef{address: 0x004e60e8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_toys_tab"))] pub const CLICK_TOYS_TAB: FunctionDef = FunctionDef{address: 0x004e6366, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_show_toys_tab"))] pub const CLICK_SHOW_TOYS_TAB: FunctionDef = FunctionDef{address: 0x004e6414, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_rotate_buttons_1"))] pub const HIDE_ROTATE_BUTTONS_1: FunctionDef = FunctionDef{address: 0x004e65ab, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/depopulate_obj_list_4"))] pub const DEPOPULATE_OBJ_LIST_4: FunctionDef = FunctionDef{address: 0x004e673b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_hire_staff_list"))] pub const HIDE_HIRE_STAFF_LIST: FunctionDef = FunctionDef{address: 0x004e6794, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_hire_staff_list"))] pub const CLICK_HIRE_STAFF_LIST: FunctionDef = FunctionDef{address: 0x004e69b8, function_type: PhantomData}; - pub const SHOW_INFO_2: FunctionDef = FunctionDef{address: 0x004e6ad3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_info_2"))] + pub const SHOW_INFO_2: FunctionDef = FunctionDef{address: 0x004e6ad3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_info_labels_1"))] pub const SHOW_INFO_LABELS_1: FunctionDef = FunctionDef{address: 0x004e6b43, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/repopulate_obj_list_4"))] pub const REPOPULATE_OBJ_LIST_4: FunctionDef = FunctionDef{address: 0x004e6bbd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_text"))] + pub const SET_TEXT: FunctionDef = FunctionDef{address: 0x004eae2f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_info_5"))] pub const UPDATE_INFO_5: FunctionDef = FunctionDef{address: 0x004eae69, function_type: PhantomData}; - pub const GET_BRANCH: FunctionDef u32> = FunctionDef{address: 0x004eb21b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_time"))] + pub const SET_TIME: FunctionDef = FunctionDef{address: 0x004eb0a8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_image"))] + pub const SET_IMAGE: FunctionDef = FunctionDef{address: 0x004eb173, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_tooltip"))] + pub const SET_TOOLTIP: FunctionDef = FunctionDef{address: 0x004eb19a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_branch"))] + pub const GET_BRANCH: FunctionDef *const i16> = FunctionDef{address: 0x004eb21b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/fill_list"))] pub const FILL_LIST: FunctionDef = FunctionDef{address: 0x004eb270, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/refilll_animal_display"))] pub const REFILLL_ANIMAL_DISPLAY: FunctionDef = FunctionDef{address: 0x004ed7f1, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_animal_info_close"))] pub const CLICK_ANIMAL_INFO_CLOSE: FunctionDef = FunctionDef{address: 0x004ed80a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_animal_info"))] pub const SHOW_ANIMAL_INFO: FunctionDef = FunctionDef{address: 0x004ee665, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_tab"))] pub const CLICK_TAB: FunctionDef = FunctionDef{address: 0x004ee81b, function_type: PhantomData}; - pub const GENERAL_SET_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x004ef75b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/general_set_selected_entity"))] + pub const GENERAL_SET_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x004ef75b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_scenario_objectives"))] pub const SHOW_SCENARIO_OBJECTIVES: FunctionDef = FunctionDef{address: 0x004efdf6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_scenario_info"))] pub const UPDATE_SCENARIO_INFO: FunctionDef = FunctionDef{address: 0x004f004a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/check_trigger_ele"))] pub const CHECK_TRIGGER_ELE: FunctionDef u32> = FunctionDef{address: 0x004f052c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_multi_building_list"))] pub const UPDATE_MULTI_BUILDING_LIST: FunctionDef = FunctionDef{address: 0x004f0979, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_terraforming"))] + pub const SET_TERRAFORMING: FunctionDef = FunctionDef{address: 0x004f1e6e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_progress"))] pub const UPDATE_PROGRESS: FunctionDef = FunctionDef{address: 0x004f202e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/check_characteristics_2"))] + pub const CHECK_CHARACTERISTICS_2: FunctionDef bool> = FunctionDef{address: 0x004f5d7f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_20"))] pub const NULLSUB_20: FunctionDef = FunctionDef{address: 0x00501634, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_new_0"))] pub const CLICK_NEW_0: FunctionDef u32> = FunctionDef{address: 0x00501699, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_new_1"))] pub const CLICK_NEW_1: FunctionDef = FunctionDef{address: 0x00501713, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_load_1"))] pub const CLICK_LOAD_1: FunctionDef = FunctionDef{address: 0x00501d71, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_load_2"))] pub const CLICK_LOAD_2: FunctionDef = FunctionDef{address: 0x00501df6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_21"))] pub const NULLSUB_21: FunctionDef = FunctionDef{address: 0x00503e72, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_22"))] pub const NULLSUB_22: FunctionDef = FunctionDef{address: 0x00503ebc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_23"))] pub const NULLSUB_23: FunctionDef = FunctionDef{address: 0x00504060, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_24"))] pub const NULLSUB_24: FunctionDef = FunctionDef{address: 0x005040aa, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_25"))] pub const NULLSUB_25: FunctionDef = FunctionDef{address: 0x005041d6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_26"))] pub const NULLSUB_26: FunctionDef = FunctionDef{address: 0x00504220, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_bulldozer"))] pub const CLICK_BULLDOZER: FunctionDef = FunctionDef{address: 0x00509722, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/unclick_bulldozer"))] pub const UNCLICK_BULLDOZER: FunctionDef = FunctionDef{address: 0x005097b8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/check_last_file"))] pub const CHECK_LAST_FILE: FunctionDef = FunctionDef{address: 0x0050ef37, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_startup"))] pub const SHOW_STARTUP: FunctionDef = FunctionDef{address: 0x0050f1c8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_selected_map"))] pub const SET_SELECTED_MAP: FunctionDef = FunctionDef{address: 0x0050f396, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_download_state"))] pub const SET_DOWNLOAD_STATE: FunctionDef = FunctionDef{address: 0x00512c87, function_type: PhantomData}; - pub const CLEAR_Q23STD539_TREE_Q23STD90PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T_Q33STD289MAP_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD109ALLOCATOR_Q23STD90PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T13VALUE_COMPARE_Q23STD109ALLOCATOR_Q23STD90PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T_FV: FunctionDef = FunctionDef{address: 0x005145cc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/clear_q23std539_tree_q23std90pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_13superkeeper_t_q33std289map_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_13superkeeper_t_q23std73less_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std109allocator_q23std90pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_13superkeeper_t13value_compare_q23std109allocator_q23std90pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_13superkeeper_t_fv"))] + pub const CLEAR_Q23STD539_TREE_Q23STD90PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T_Q33STD289MAP_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD109ALLOCATOR_Q23STD90PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T13VALUE_COMPARE_Q23STD109ALLOCATOR_Q23STD90PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T_FV: FunctionDef = FunctionDef{address: 0x005145cc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/animalinfo_add_callbacks"))] pub const ANIMALINFO_ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00515f1f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/buyh_add_callbacks"))] pub const BUYH_ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x0051611c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/zooitems_add_callbacks"))] + pub const ZOOITEMS_ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00516c45, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/check_terrain_options"))] pub const CHECK_TERRAIN_OPTIONS: FunctionDef = FunctionDef{address: 0x00517854, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/save_terrain_options"))] pub const SAVE_TERRAIN_OPTIONS: FunctionDef = FunctionDef{address: 0x005178d7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/adjust_terrain"))] pub const ADJUST_TERRAIN: FunctionDef = FunctionDef{address: 0x00517b9a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/enumerate_display_modes"))] pub const ENUMERATE_DISPLAY_MODES: FunctionDef = FunctionDef{address: 0x00518cbb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/init_terrain_options"))] pub const INIT_TERRAIN_OPTIONS: FunctionDef = FunctionDef{address: 0x00518d7f, function_type: PhantomData}; - pub const CREATE_ZTSCRIPT_MGR: FunctionDef = FunctionDef{address: 0x0051e0d6, function_type: PhantomData}; - pub const CREATE_ZTRESEARCH_MGR: FunctionDef = FunctionDef{address: 0x0051e293, function_type: PhantomData}; - pub const CREATE_ZTSHOW_MGR: FunctionDef = FunctionDef{address: 0x0051f79e, function_type: PhantomData}; - pub const CREATE_ZTMESSAGE_QUEUE: FunctionDef = FunctionDef{address: 0x00520b61, function_type: PhantomData}; - pub const CREATE_ZTMINI_MAP: FunctionDef = FunctionDef{address: 0x00520d1c, function_type: PhantomData}; - pub const LOAD_INI_VALUE_FLOAT: FunctionDef f32> = FunctionDef{address: 0x0052211d, function_type: PhantomData}; - pub const CREATE_ALPHA_SURFACE: FunctionDef bool> = FunctionDef{address: 0x00522a31, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztscript_mgr"))] + pub const CREATE_ZTSCRIPT_MGR: FunctionDef *const u32> = FunctionDef{address: 0x0051e0d6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztresearch_mgr"))] + pub const CREATE_ZTRESEARCH_MGR: FunctionDef *const u32> = FunctionDef{address: 0x0051e293, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztshow_mgr"))] + pub const CREATE_ZTSHOW_MGR: FunctionDef *const u32> = FunctionDef{address: 0x0051f79e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztmessage_queue"))] + pub const CREATE_ZTMESSAGE_QUEUE: FunctionDef *const u32> = FunctionDef{address: 0x00520b61, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztmini_map"))] + pub const CREATE_ZTMINI_MAP: FunctionDef *const u32> = FunctionDef{address: 0x00520d1c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/load_ini_value_float"))] + pub const LOAD_INI_VALUE_FLOAT: FunctionDef f32> = FunctionDef{address: 0x0052211d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_alpha_surface"))] + pub const CREATE_ALPHA_SURFACE: FunctionDef bool> = FunctionDef{address: 0x00522a31, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/load_image"))] pub const LOAD_IMAGE: FunctionDef = FunctionDef{address: 0x00523326, function_type: PhantomData}; - pub const CREATE_ZTMARKETING_MGR: FunctionDef = FunctionDef{address: 0x005257e7, function_type: PhantomData}; - pub const CREATE_ZTSCENARIO_MGR: FunctionDef = FunctionDef{address: 0x00525e27, function_type: PhantomData}; - pub const CREATE_ZTGAME_MGR: FunctionDef = FunctionDef{address: 0x00527dc7, function_type: PhantomData}; - pub const CREATE_DXSND_MGR: FunctionDef = FunctionDef{address: 0x005280c3, function_type: PhantomData}; - pub const DIR_SEARCH: FunctionDef u32> = FunctionDef{address: 0x00529b75, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztmarketing_mgr"))] + pub const CREATE_ZTMARKETING_MGR: FunctionDef *const u32> = FunctionDef{address: 0x005257e7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztscenario_mgr"))] + pub const CREATE_ZTSCENARIO_MGR: FunctionDef *const u32> = FunctionDef{address: 0x00525e27, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztgame_mgr"))] + pub const CREATE_ZTGAME_MGR: FunctionDef *const u32> = FunctionDef{address: 0x00527dc7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_dxsnd_mgr"))] + pub const CREATE_DXSND_MGR: FunctionDef *const u32> = FunctionDef{address: 0x005280c3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/dir_search"))] + pub const DIR_SEARCH: FunctionDef *const u32> = FunctionDef{address: 0x00529b75, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/setup_progress_bar"))] pub const SETUP_PROGRESS_BAR: FunctionDef = FunctionDef{address: 0x0052ae16, function_type: PhantomData}; - pub const GET_LOG_LEVEL_STRING: FunctionDef u32> = FunctionDef{address: 0x0052ba65, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_log_level_string"))] + pub const GET_LOG_LEVEL_STRING: FunctionDef *const i8> = FunctionDef{address: 0x0052ba65, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_marketing_info"))] pub const UPDATE_MARKETING_INFO: FunctionDef = FunctionDef{address: 0x0052f686, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_finance_info"))] pub const UPDATE_FINANCE_INFO: FunctionDef = FunctionDef{address: 0x0052fa39, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_graphs"))] pub const UPDATE_GRAPHS: FunctionDef = FunctionDef{address: 0x0052ff4d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_zoo_status_info"))] pub const UPDATE_ZOO_STATUS_INFO: FunctionDef = FunctionDef{address: 0x0053002b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_zoo_status"))] pub const SHOW_ZOO_STATUS: FunctionDef = FunctionDef{address: 0x005314f3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_awards"))] pub const SHOW_AWARDS: FunctionDef = FunctionDef{address: 0x0053167f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_snapshot"))] pub const CLICK_SNAPSHOT: FunctionDef = FunctionDef{address: 0x00532df9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/ijl_init_0"))] pub const IJL_INIT_0: FunctionDef = FunctionDef{address: 0x00532f9b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/ijl_write"))] pub const IJL_WRITE: FunctionDef = FunctionDef{address: 0x00533041, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/ijl_free_0"))] pub const IJL_FREE_0: FunctionDef = FunctionDef{address: 0x00533047, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/ijl_init_1"))] pub const IJL_INIT_1: FunctionDef = FunctionDef{address: 0x0053304d, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/ijl_free_1"))] pub const IJL_FREE_1: FunctionDef = FunctionDef{address: 0x005330ae, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/ijl_init_2"))] pub const IJL_INIT_2: FunctionDef = FunctionDef{address: 0x005330b4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_27"))] pub const NULLSUB_27: FunctionDef = FunctionDef{address: 0x005330ba, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/ijl_init_3"))] pub const IJL_INIT_3: FunctionDef = FunctionDef{address: 0x00533180, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/init_video_quality"))] pub const INIT_VIDEO_QUALITY: FunctionDef = FunctionDef{address: 0x00533a78, function_type: PhantomData}; - pub const LOAD_STRING_TO_GLOBAL_BUFFER: FunctionDef u32> = FunctionDef{address: 0x005349b0, function_type: PhantomData}; - pub const GET_FILE_VERSION_INFO_SIZE_A: FunctionDef i32> = FunctionDef{address: 0x005357d6, function_type: PhantomData}; - pub const GET_FILE_VERSION_INFO_A: FunctionDef bool> = FunctionDef{address: 0x005357dc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/load_string_to_global_buffer"))] + pub const LOAD_STRING_TO_GLOBAL_BUFFER: FunctionDef *const u8> = FunctionDef{address: 0x005349b0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_file_version_info_size_a"))] + pub const GET_FILE_VERSION_INFO_SIZE_A: FunctionDef u32> = FunctionDef{address: 0x005357d6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_file_version_info_a"))] + pub const GET_FILE_VERSION_INFO_A: FunctionDef bool> = FunctionDef{address: 0x005357dc, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/init_terrain_quality"))] pub const INIT_TERRAIN_QUALITY: FunctionDef = FunctionDef{address: 0x00536599, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/init_sound_quality"))] pub const INIT_SOUND_QUALITY: FunctionDef = FunctionDef{address: 0x0053672f, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_dxversion"))] pub const GET_DXVERSION: FunctionDef u32> = FunctionDef{address: 0x00536bce, function_type: PhantomData}; - pub const LOCALTIME: FunctionDef u32> = FunctionDef{address: 0x0053833a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/localtime"))] + pub const LOCALTIME: FunctionDef *const i32> = FunctionDef{address: 0x0053833a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/sinit_zt_cpp_0"))] pub const SINIT_ZT_CPP_0: FunctionDef = FunctionDef{address: 0x005784d3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/sinit_zt_cpp_1"))] pub const SINIT_ZT_CPP_1: FunctionDef = FunctionDef{address: 0x00579322, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/load_ini_debug_settings"))] pub const LOAD_INI_DEBUG_SETTINGS: FunctionDef u32> = FunctionDef{address: 0x00579f4c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/initialize_application_heap"))] pub const INITIALIZE_APPLICATION_HEAP: FunctionDef u32> = FunctionDef{address: 0x0057becf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/sinit_zoo_tycoon_app_cp"))] pub const SINIT_ZOO_TYCOON_APP_CP: FunctionDef = FunctionDef{address: 0x0057c528, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/exit"))] pub const EXIT: FunctionDef = FunctionDef{address: 0x0057e4b7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/init_global_bfregistry"))] pub const INIT_GLOBAL_BFREGISTRY: FunctionDef = FunctionDef{address: 0x005886cd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_rotate_left_0"))] pub const CLICK_ROTATE_LEFT_0: FunctionDef = FunctionDef{address: 0x00589cf4, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_toggle_entity_tooltips"))] pub const SET_TOGGLE_ENTITY_TOOLTIPS: FunctionDef = FunctionDef{address: 0x0058b67d, function_type: PhantomData}; - pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x0058c78e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/force_update"))] + pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x0058c78e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_avail"))] pub const SET_AVAIL: FunctionDef = FunctionDef{address: 0x0058fd9f, function_type: PhantomData}; - pub const SET_BUILDING_UPGRADE: FunctionDef u32> = FunctionDef{address: 0x0058feb7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_building_upgrade"))] + pub const SET_BUILDING_UPGRADE: FunctionDef u32> = FunctionDef{address: 0x0058feb7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_startup"))] pub const HIDE_STARTUP: FunctionDef = FunctionDef{address: 0x0059274c, function_type: PhantomData}; - pub const IS_ZOO_WALL: FunctionDef bool> = FunctionDef{address: 0x005947b2, function_type: PhantomData}; - pub const IS_ZOO_GATE: FunctionDef bool> = FunctionDef{address: 0x0059486c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/is_zoo_wall"))] + pub const IS_ZOO_WALL: FunctionDef bool> = FunctionDef{address: 0x005947b2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/is_zoo_gate"))] + pub const IS_ZOO_GATE: FunctionDef bool> = FunctionDef{address: 0x0059486c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_habitat_list"))] pub const CLICK_HABITAT_LIST: FunctionDef = FunctionDef{address: 0x00599ae7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_family_characteristic"))] + pub const SET_FAMILY_CHARACTERISTIC: FunctionDef u32> = FunctionDef{address: 0x0059abd5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_food_characteristic"))] + pub const SET_FOOD_CHARACTERISTIC: FunctionDef u32> = FunctionDef{address: 0x0059addb, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_entity_characteristic"))] + pub const SET_ENTITY_CHARACTERISTIC: FunctionDef u8> = FunctionDef{address: 0x0059af88, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_trick_available"))] + pub const SET_TRICK_AVAILABLE: FunctionDef u32> = FunctionDef{address: 0x0059b60a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_effect_discount"))] pub const SET_EFFECT_DISCOUNT: FunctionDef u32> = FunctionDef{address: 0x0059b6b5, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_pause"))] pub const CLICK_PAUSE: FunctionDef = FunctionDef{address: 0x0059c7a4, function_type: PhantomData}; - pub const ANIMALINFO_SET_ANIMAL_DYING: FunctionDef = FunctionDef{address: 0x005a55f6, function_type: PhantomData}; - pub const FLYINGOBJECT: FunctionDef u32> = FunctionDef{address: 0x005a58ff, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/animalinfo_set_animal_dying"))] + pub const ANIMALINFO_SET_ANIMAL_DYING: FunctionDef = FunctionDef{address: 0x005a55f6, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/flyingobject"))] + pub const FLYINGOBJECT: FunctionDef *const i32> = FunctionDef{address: 0x005a58ff, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_28"))] pub const NULLSUB_28: FunctionDef = FunctionDef{address: 0x005aacaf, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_fullscreen"))] pub const SET_FULLSCREEN: FunctionDef = FunctionDef{address: 0x005ac651, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_depth"))] + pub const GET_DEPTH: FunctionDef i32> = FunctionDef{address: 0x005af19b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_window"))] pub const SET_WINDOW: FunctionDef = FunctionDef{address: 0x005aff13, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_map_select"))] pub const HIDE_MAP_SELECT: FunctionDef = FunctionDef{address: 0x005b0f12, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_info_6"))] pub const UPDATE_INFO_6: FunctionDef = FunctionDef{address: 0x005b108b, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/check_name"))] pub const CHECK_NAME: FunctionDef = FunctionDef{address: 0x005b10f4, function_type: PhantomData}; - pub const FAST_ERROR_EXIT: FunctionDef = FunctionDef{address: 0x005fcf1c, function_type: PhantomData}; - pub const RTL_UNWIND: FunctionDef = FunctionDef{address: 0x005fd361, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/fast_error_exit"))] + pub const FAST_ERROR_EXIT: FunctionDef = FunctionDef{address: 0x005fcf1c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/rtl_unwind"))] + pub const RTL_UNWIND: FunctionDef = FunctionDef{address: 0x005fd361, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/george_w"))] pub const GEORGE_W: FunctionDef = FunctionDef{address: 0x00607174, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/colloseum"))] pub const COLLOSEUM: FunctionDef = FunctionDef{address: 0x006074ed, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hitchcock"))] pub const HITCHCOCK: FunctionDef = FunctionDef{address: 0x00607552, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/poo_rock"))] pub const POO_ROCK: FunctionDef = FunctionDef{address: 0x00607871, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/permanentflyingobject"))] pub const PERMANENTFLYINGOBJECT: FunctionDef = FunctionDef{address: 0x00607a78, function_type: PhantomData}; - pub const INSERT_ONE_Q23STD244_TREE_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD78ALLOCATOR_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_FRCQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC: FunctionDef = FunctionDef{address: 0x00607ab7, function_type: PhantomData}; - pub const ASSIGN_IF_POSITIVE: FunctionDef = FunctionDef{address: 0x0060875c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/insert_one_q23std244_tree_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std73less_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std78allocator_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_frcq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc"))] + pub const INSERT_ONE_Q23STD244_TREE_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD78ALLOCATOR_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_FRCQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC: FunctionDef = FunctionDef{address: 0x00607ab7, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/assign_if_positive"))] + pub const ASSIGN_IF_POSITIVE: FunctionDef = FunctionDef{address: 0x0060875c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_cancel"))] + pub const CLICK_CANCEL: FunctionDef = FunctionDef{address: 0x0060b7d3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_download"))] pub const CLICK_DOWNLOAD: FunctionDef = FunctionDef{address: 0x0060b7f0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_zoo_items"))] + pub const SHOW_ZOO_ITEMS: FunctionDef = FunctionDef{address: 0x0060baf0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_zoo_items"))] + pub const HIDE_ZOO_ITEMS: FunctionDef = FunctionDef{address: 0x0060baf8, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/download_completed"))] pub const DOWNLOAD_COMPLETED: FunctionDef = FunctionDef{address: 0x0060bb54, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_animal_list"))] pub const CLICK_ANIMAL_LIST: FunctionDef = FunctionDef{address: 0x00610755, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/change_habitat_name"))] pub const CHANGE_HABITAT_NAME: FunctionDef = FunctionDef{address: 0x006107ef, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/tankmodify_fill_tank"))] pub const TANKMODIFY_FILL_TANK: FunctionDef = FunctionDef{address: 0x006115f2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/enable_everything"))] pub const ENABLE_EVERYTHING: FunctionDef = FunctionDef{address: 0x00615794, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_show_species"))] pub const SET_SHOW_SPECIES: FunctionDef = FunctionDef{address: 0x006158a0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/unclick_animal_info_follow"))] pub const UNCLICK_ANIMAL_INFO_FOLLOW: FunctionDef = FunctionDef{address: 0x00616231, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/complete_current_goal"))] pub const COMPLETE_CURRENT_GOAL: FunctionDef = FunctionDef{address: 0x00616242, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_credits"))] pub const SHOW_CREDITS: FunctionDef = FunctionDef{address: 0x00616290, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_page"))] pub const SHOW_PAGE: FunctionDef = FunctionDef{address: 0x006162c0, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_credits"))] pub const HIDE_CREDITS: FunctionDef = FunctionDef{address: 0x00616348, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_cash_up"))] pub const CLICK_CASH_UP: FunctionDef = FunctionDef{address: 0x00616350, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_cash_down"))] pub const CLICK_CASH_DOWN: FunctionDef = FunctionDef{address: 0x006163b2, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/edit_starting_cash"))] pub const EDIT_STARTING_CASH: FunctionDef = FunctionDef{address: 0x00616414, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/unclick_developer_list"))] pub const UNCLICK_DEVELOPER_LIST: FunctionDef = FunctionDef{address: 0x006169ba, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_rotate_left_1"))] pub const CLICK_ROTATE_LEFT_1: FunctionDef = FunctionDef{address: 0x006169df, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_rotate_right_2"))] pub const CLICK_ROTATE_RIGHT_2: FunctionDef = FunctionDef{address: 0x00616a9a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/adjust_cash"))] pub const ADJUST_CASH: FunctionDef = FunctionDef{address: 0x00616b58, function_type: PhantomData}; - pub const GET_ANIMAL_UNHAPPY_WITH_SCENERY_STRING: FunctionDef u32> = FunctionDef{address: 0x00616c3e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_animal_unhappy_with_scenery_string"))] + pub const GET_ANIMAL_UNHAPPY_WITH_SCENERY_STRING: FunctionDef *const u32> = FunctionDef{address: 0x00616c3e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_category_list"))] pub const CLICK_CATEGORY_LIST: FunctionDef = FunctionDef{address: 0x006173f3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_ncbuilding_info"))] pub const SHOW_NCBUILDING_INFO: FunctionDef = FunctionDef{address: 0x0061794a, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_terraform_cancel"))] pub const CLICK_TERRAFORM_CANCEL: FunctionDef = FunctionDef{address: 0x00618a22, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/change_animal_name"))] pub const CHANGE_ANIMAL_NAME: FunctionDef = FunctionDef{address: 0x00618b27, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_animal_more_info_button"))] pub const CLICK_ANIMAL_MORE_INFO_BUTTON: FunctionDef = FunctionDef{address: 0x00618c02, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_rotate_left_2"))] pub const CLICK_ROTATE_LEFT_2: FunctionDef = FunctionDef{address: 0x00618c9c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/unclick_info_plaque"))] pub const UNCLICK_INFO_PLAQUE: FunctionDef = FunctionDef{address: 0x00618d57, function_type: PhantomData}; - pub const THREAD_DOWNLOAD: FunctionDef bool> = FunctionDef{address: 0x0062671e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_genus_characteristic"))] + pub const SET_GENUS_CHARACTERISTIC: FunctionDef u32> = FunctionDef{address: 0x00618d7c, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/thread_download"))] + pub const THREAD_DOWNLOAD: FunctionDef bool> = FunctionDef{address: 0x0062671e, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/configure_keyboard_settings"))] pub const CONFIGURE_KEYBOARD_SETTINGS: FunctionDef = FunctionDef{address: 0x00629a38, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/exit_application_gracefully"))] pub const EXIT_APPLICATION_GRACEFULLY: FunctionDef = FunctionDef{address: 0x00629b1c, function_type: PhantomData}; - pub const IMM_RELEASE_CONTEXT: FunctionDef bool> = FunctionDef{address: 0x0062c7cd, function_type: PhantomData}; - pub const IMM_NOTIFY_IME: FunctionDef bool> = FunctionDef{address: 0x0062c7d3, function_type: PhantomData}; - pub const IMM_GET_OPEN_STATUS: FunctionDef bool> = FunctionDef{address: 0x0062c7d9, function_type: PhantomData}; - pub const IMM_GET_CONTEXT: FunctionDef u32> = FunctionDef{address: 0x0062c7df, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/imm_release_context"))] + pub const IMM_RELEASE_CONTEXT: FunctionDef bool> = FunctionDef{address: 0x0062c7cd, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/imm_notify_ime"))] + pub const IMM_NOTIFY_IME: FunctionDef bool> = FunctionDef{address: 0x0062c7d3, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/imm_get_open_status"))] + pub const IMM_GET_OPEN_STATUS: FunctionDef bool> = FunctionDef{address: 0x0062c7d9, function_type: PhantomData}; + #[cfg_attr(feature = "detour-validation", validate_detour("standalone/imm_get_context"))] + pub const IMM_GET_CONTEXT: FunctionDef *const u32> = FunctionDef{address: 0x0062c7df, function_type: PhantomData}; } \ No newline at end of file diff --git a/openzt-dll/Cargo.toml b/openzt-dll/Cargo.toml index 0f7b719..93e6968 100644 --- a/openzt-dll/Cargo.toml +++ b/openzt-dll/Cargo.toml @@ -22,4 +22,5 @@ crate-type = ["cdylib"] command-console = ["openzt/command-console"] integration-tests = ["openzt/integration-tests"] release = ["openzt/release"] +detour-validation = ["openzt/detour-validation"] vanilla-research-config = ["openzt/vanilla-research-config"] diff --git a/openzt.bat b/openzt.bat index 9227a3f..5d6217d 100644 --- a/openzt.bat +++ b/openzt.bat @@ -4,10 +4,35 @@ setlocal enabledelayedexpansion REM OpenZT Unified Build Script REM Combines build, run, and docs functionality +REM ============================================================ +REM Global --no-pause flag: can appear anywhere in the argument +REM list. Strips itself out before dispatch and skips every +REM `pause` this script would otherwise do on failure, so agents +REM and CI can run it non-interactively without hanging waiting +REM for a keypress. +REM ============================================================ +SET NO_PAUSE= +SET FILTERED_ARGS= +:filter_args_loop +IF "%~1"=="" GOTO filter_args_done +IF "%~1"=="--no-pause" ( + SET NO_PAUSE=1 + SHIFT + GOTO filter_args_loop +) +SET FILTERED_ARGS=!FILTERED_ARGS! "%~1" +SHIFT +GOTO filter_args_loop + +:filter_args_done +CALL :main %FILTERED_ARGS% +EXIT /B !ERRORLEVEL! + REM ============================================================ REM Main Dispatcher REM ============================================================ +:main IF "%~1"=="" GOTO show_help IF "%~1"=="help" GOTO show_help IF "%~1"=="--help" GOTO show_help @@ -20,6 +45,7 @@ IF "%~1"=="check" GOTO check IF "%~1"=="clippy" GOTO clippy IF "%~1"=="test" GOTO test IF "%~1"=="integration-tests" GOTO integration_tests +IF "%~1"=="validate-detours" GOTO validate_detours echo Error: Unknown subcommand "%~1" echo. @@ -52,6 +78,34 @@ SET INTEGRATION_TESTS_MODE=1 SHIFT GOTO build +REM ============================================================ +REM Validate Detours Command +REM ============================================================ + +:validate_detours +SHIFT +SET VALIDATE_DETOUR_NAMES= +:validate_collect_args +IF "%~1"=="" GOTO validate_build +IF DEFINED VALIDATE_DETOUR_NAMES ( + SET VALIDATE_DETOUR_NAMES=!VALIDATE_DETOUR_NAMES!,%~1 +) ELSE ( + SET VALIDATE_DETOUR_NAMES=%~1 +) +SHIFT +GOTO validate_collect_args + +:validate_build +IF "!VALIDATE_DETOUR_NAMES!"=="" SET VALIDATE_DETOUR_NAMES=all +SET OPENZT_VALIDATE_DETOURS=!VALIDATE_DETOUR_NAMES! +SET VALIDATE_DETOURS_MODE=1 +SET RUN_AFTER_BUILD=1 +SET RELEASE_FLAG=1 +SET WAIT_FLAG=1 +SET CARGO_ARGS=--features "detour-validation,command-console" +echo Validate-detours: [!VALIDATE_DETOUR_NAMES!] +GOTO build + :parse_flags SET RELEASE_FLAG= SET TEST_FLAG= @@ -126,6 +180,9 @@ echo Building !DLL_NAME! (!BUILD_TYPE!)... IF DEFINED FEATURE_FLAGS ( echo Features: !FEATURE_FLAGS! ) +IF DEFINED CARGO_ARGS ( + echo Cargo args: !CARGO_ARGS! +) REM Execute cargo build for DLL cargo build --manifest-path !MANIFEST_PATH! --lib --target=i686-pc-windows-msvc !BUILD_FLAGS! !FEATURE_FLAGS! !CARGO_ARGS! @@ -133,7 +190,7 @@ cargo build --manifest-path !MANIFEST_PATH! --lib --target=i686-pc-windows-msvc IF !errorlevel! NEQ 0 ( echo. echo Build failed - pause + IF NOT DEFINED NO_PAUSE pause exit /b !errorlevel! ) @@ -176,7 +233,7 @@ SET SOURCE_DLL=target\i686-pc-windows-msvc\!BUILD_TYPE!\!DLL_NAME! REM Check source exists IF NOT EXIST "!SOURCE_DLL!" ( echo Error: Built DLL not found at !SOURCE_DLL! - pause + IF NOT DEFINED NO_PAUSE pause exit /b 1 ) @@ -206,7 +263,7 @@ copy "!SOURCE_DLL!" "C:\Program Files (x86)\Microsoft Games\Zoo Tycoon\!DEST_NAM IF !errorlevel! NEQ 0 ( echo. echo Copy failed - pause + IF NOT DEFINED NO_PAUSE pause exit /b !errorlevel! ) @@ -232,6 +289,22 @@ IF DEFINED WAIT_FLAG ( echo ============================================================ echo. ) + + REM Display detour validation results if in validate-detours mode + IF DEFINED VALIDATE_DETOURS_MODE ( + echo. + echo ============================================================ + echo Detour Validation Results [!OPENZT_VALIDATE_DETOURS!] + echo ============================================================ + powershell -Command "[Console]::OutputEncoding = [System.Text.Encoding]::UTF8; Select-String -Path 'C:\Program Files (x86)\Microsoft Games\Zoo Tycoon\openzt.log' -Pattern 'DETOUR_CALLED|[Vv]alidation detour' | Select-Object -ExpandProperty Line | Out-Host" + echo. + powershell -Command "if (Select-String -Path 'C:\Program Files (x86)\Microsoft Games\Zoo Tycoon\openzt.log' -Pattern 'OPENZT_CLEAN_SHUTDOWN' -Quiet) { Write-Host 'Exit status: clean' } else { Write-Host 'Exit status: CRASHED (no clean shutdown marker in log)' }" + echo. + echo Full logs: + echo "C:\Program Files (x86)\Microsoft Games\Zoo Tycoon\openzt.log" + echo ============================================================ + echo. + ) ) ELSE ( echo Launching Zoo Tycoon... start "Zoo Tycoon" "C:\Program Files (x86)\Microsoft Games\Zoo Tycoon\zoo.exe" @@ -250,7 +323,7 @@ cargo rustdoc --manifest-path openzt/Cargo.toml --lib --target i686-pc-windows-m IF !errorlevel! NEQ 0 ( echo. echo Documentation generation failed - pause + IF NOT DEFINED NO_PAUSE pause exit /b !errorlevel! ) @@ -281,7 +354,7 @@ IF "!CONSOLE_ARGS!"=="" ( IF !errorlevel! NEQ 0 ( echo. echo Console failed - pause + IF NOT DEFINED NO_PAUSE pause exit /b !errorlevel! ) @@ -293,12 +366,36 @@ REM ============================================================ :check echo Running cargo check on openzt... -cargo check --manifest-path openzt/Cargo.toml --target i686-pc-windows-msvc +echo openzt.bat arguments: %* +SHIFT +SET CHECK_CARGO_ARGS= +SET CHECK_PARSING_CARGO_ARGS= + +:check_parse_loop +IF "%~1"=="" GOTO check_run +IF "%~1"=="--" ( + SET CHECK_PARSING_CARGO_ARGS=1 + SHIFT + GOTO check_parse_loop +) +IF DEFINED CHECK_PARSING_CARGO_ARGS ( + SET CHECK_CARGO_ARGS=!CHECK_CARGO_ARGS! %~1 + SHIFT + GOTO check_parse_loop +) +echo Error: Unknown check flag "%~1" +exit /b 1 + +:check_run +IF DEFINED CHECK_CARGO_ARGS ( + echo Cargo args: !CHECK_CARGO_ARGS! +) +cargo check --manifest-path openzt/Cargo.toml --target i686-pc-windows-msvc !CHECK_CARGO_ARGS! IF !errorlevel! NEQ 0 ( echo. echo Cargo check failed - pause + IF NOT DEFINED NO_PAUSE pause exit /b !errorlevel! ) @@ -312,12 +409,13 @@ REM ============================================================ :clippy echo Running cargo clippy on openzt... +echo openzt.bat arguments: %* cargo clippy --manifest-path openzt/Cargo.toml --target i686-pc-windows-msvc IF !errorlevel! NEQ 0 ( echo. echo Clippy found issues - pause + IF NOT DEFINED NO_PAUSE pause exit /b !errorlevel! ) @@ -330,22 +428,37 @@ REM Test Function REM ============================================================ :test +echo Running cargo test on openzt... +echo openzt.bat arguments: %* SHIFT -SET TEST_ARGS= -:test_args_loop -IF "%~1"=="" GOTO run_test -SET TEST_ARGS=!TEST_ARGS! %1 -SHIFT -GOTO test_args_loop +SET TEST_CARGO_ARGS= +SET TEST_PARSING_CARGO_ARGS= -:run_test -echo Running cargo test on openzt... -cargo test --manifest-path openzt/Cargo.toml --target i686-pc-windows-msvc !TEST_ARGS! +:test_parse_loop +IF "%~1"=="" GOTO test_run +IF "%~1"=="--" ( + SET TEST_PARSING_CARGO_ARGS=1 + SHIFT + GOTO test_parse_loop +) +IF DEFINED TEST_PARSING_CARGO_ARGS ( + SET TEST_CARGO_ARGS=!TEST_CARGO_ARGS! %~1 + SHIFT + GOTO test_parse_loop +) +echo Error: Unknown test flag "%~1" +exit /b 1 + +:test_run +IF DEFINED TEST_CARGO_ARGS ( + echo Cargo args: !TEST_CARGO_ARGS! +) +cargo test --manifest-path openzt/Cargo.toml --target i686-pc-windows-msvc !TEST_CARGO_ARGS! IF !errorlevel! NEQ 0 ( echo. echo Tests failed - pause + IF NOT DEFINED NO_PAUSE pause exit /b !errorlevel! ) @@ -369,6 +482,7 @@ echo check Run cargo check on openzt crate echo clippy Run cargo clippy on openzt crate echo test Run cargo test on openzt crate echo integration-tests Run integration tests (builds release, launches game, displays results) +echo validate-detours Validate detour addresses (builds release, launches game, shows calls) echo docs Generate and open documentation echo console Open interactive Lua console or run oneshot command echo help Show this help message @@ -379,6 +493,9 @@ echo --test Build the test DLL (openzt-test-dll) echo --wait Wait for Zoo Tycoon to exit before returning echo -- ^ Forward additional arguments to cargo echo. +echo Global Flags (any subcommand, any position): +echo --no-pause Skip the `pause` on failure - for agents/CI running non-interactively +echo. echo Note: command-console feature is enabled by default for non-test builds. echo. echo Examples: @@ -390,8 +507,9 @@ echo openzt.bat run --test Build test DLL and launch game echo openzt.bat check Run cargo check on openzt echo openzt.bat clippy Run cargo clippy on openzt echo openzt.bat test Run cargo test on openzt -echo openzt.bat test -- --nocapture Run cargo test, forwarding extra args to cargo echo openzt.bat integration-tests Run integration tests (builds release, displays results) +echo openzt.bat validate-detours Validate all annotated detours +echo openzt.bat validate-detours bfanimcache/update Validate specific detour echo openzt.bat docs Generate and open docs echo openzt.bat console Open interactive Lua console echo openzt.bat console --oneshot "help()" Run single Lua command and exit diff --git a/openzt/Cargo.toml b/openzt/Cargo.toml index f8904d1..7c83058 100644 --- a/openzt/Cargo.toml +++ b/openzt/Cargo.toml @@ -35,6 +35,7 @@ itertools = "0.14.0" nt-time = "0.14.0" proptest = { version = "1.9.0", optional = true} mlua = { version = "0.11.5", features = ["luajit52", "vendored", "send"] } +inventory = { version = "0.3", optional = true } encoding_rs = "0.8" ratatui = { version = "0.29", optional = true } crossterm = { version = "0.28", optional = true } @@ -60,3 +61,4 @@ integration-tests = [] command-console = [] tui = ["dep:ratatui", "dep:crossterm"] proptest = ["dep:proptest"] +detour-validation = ["openzt-detour/detour-validation", "dep:inventory"] diff --git a/openzt/src/lib.rs b/openzt/src/lib.rs index ef36e83..9c9a089 100644 --- a/openzt/src/lib.rs +++ b/openzt/src/lib.rs @@ -120,6 +120,12 @@ pub mod reimplementation_tests; #[cfg(feature = "integration-tests")] pub mod integration_tests; +/// Pass-through logging stubs for validating addresses in generated.rs. +/// Annotate consts with #[validate_detour("name")] and run: +/// ./openzt.bat validate-detours [names...] (or "all") +#[cfg(all(feature = "detour-validation", target_os = "windows"))] +mod detour_validation; + #[cfg(target_os = "windows")] use openzt_detour_macro::detour_mod; @@ -135,7 +141,7 @@ mod zoo_init { // Note(finn): We hook the LoadLangDLLs function to perform some later initialization steps. Starting // the console starts a new thead which is not recommended in the DllMain function. #[detour(LOAD_LANG_DLLS)] - unsafe extern "thiscall" fn load_lang_dlls(this: u32) -> u32 { + unsafe extern "thiscall" fn load_lang_dlls(this: * const u32) -> u32 { // Load config to determine logging settings let config = resource_manager::mod_config::get_openzt_config(); @@ -152,13 +158,23 @@ mod zoo_init { info!("OpenZT initialization starting"); + #[cfg(feature = "detour-validation")] + { + let names_env = std::env::var("OPENZT_VALIDATE_DETOURS").unwrap_or_default(); + let names: Vec<&str> = names_env + .split([',', ' ']) + .map(str::trim) + .filter(|s| !s.is_empty()) + .collect(); + detour_validation::init(&names); + } + // Initialize TUI if enabled #[cfg(feature = "tui")] - if config.tui.enabled { - if let Err(e) = tui_console::init(&config.tui) { + if config.tui.enabled + && let Err(e) = tui_console::init(&config.tui) { info!("Failed to initialize TUI: {}", e); } - } // Command console is broken on latest stable Rust so we disable it by default. if cfg!(feature = "command-console") { From 8d16be21b8ab080231bb580ea5193c83ce65798c Mon Sep 17 00:00:00 2001 From: Finn Hartshorn Date: Wed, 19 Aug 2026 08:46:28 +1000 Subject: [PATCH 3/7] Strip egui-owned content from AGENTS.md and root Cargo.toml Both files are new/changed only by feature/detour-testing-framework's own commits (untouched by egui-overlay-plumbing or save-logging), but their content documents/depends on the egui overlay work that isn't part of this branch's scope: AGENTS.md documented the egui-overlay feature and its build commands, and root Cargo.toml listed egui-tiny-skia as a workspace member even though that crate directory only exists on feature/egui-overlay-plumbing. --- AGENTS.md | 16 ---------------- Cargo.toml | 1 - 2 files changed, 17 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index 36e1775..eff5f67 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -54,12 +54,6 @@ OpenZT is a DLL injection framework for Zoo Tycoon (2001) written in Rust. It pr ./openzt.bat run # Debug with command-console ./openzt.bat run --release # Release with command-console -# Extra Cargo args/features go after `--` -./openzt.bat build -- --features egui-overlay -./openzt.bat check -- --features egui-overlay -./openzt.bat run -- --features egui-overlay -./openzt.bat build -- --features egui-overlay --features debug-blit - # Build and run with --wait flag (waits for game to exit before returning) ./openzt.bat run --wait # Debug, wait for exit ./openzt.bat run --release --wait # Release, wait for exit @@ -69,7 +63,6 @@ OpenZT is a DLL injection framework for Zoo Tycoon (2001) written in Rust. It pr # Code quality checks ./openzt.bat check # Run cargo check on openzt -./openzt.bat check -- --features egui-overlay # Required when touching egui overlay code ./openzt.bat clippy # Run cargo clippy on openzt ./openzt.bat test # Run cargo test on openzt @@ -297,15 +290,6 @@ resource_manager::add_handler("bfb", Box::new(BfbHandler)); - **Conditional compilation**: Most features behind flags for testing - **Hot-swappable**: DLL can be reloaded during development -### egui Overlay - -- Enabled with `egui-overlay` and gated by `experimental`; run with `./openzt.bat run -- --features egui-overlay` -- When changing `openzt/src/ui/**` or egui overlay behavior, ALWAYS verify with `./openzt.bat check -- --features egui-overlay` or `./openzt.bat build -- --features egui-overlay`; a plain `./openzt.bat check` does not compile this code. -- UI code lives in `openzt/src/ui/mod.rs`; add/update egui widgets inside the `backend.run_frame(...)` closure. -- Rendering uses `egui-tiny-skia` into a `tiny_skia::Pixmap`, then `openzt/src/ui/blit.rs` uploads it to a click-through layered overlay window with per-pixel alpha. -- Frame timing hooks are in `openzt/src/ui/render_hook.rs`; mouse events come from the subclassed game WndProc in `openzt/src/ui/wndproc.rs`; keyboard events are forwarded from `shortcuts.rs`. -- Use `--features egui-overlay --features debug-blit` only to test the overlay/window upload path with a solid red image. - ### Vanilla UI Layout Notes - Vanilla `.lyt` files are INI-like and may repeat keys (`state=`, `button=`, `image=`, `backcolor=`); use `openzt-configparser` vector access (`get_vec`) when order or all values matter. diff --git a/Cargo.toml b/Cargo.toml index d381fb1..eb44ec6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -15,7 +15,6 @@ members = [ "openzt-detour", "openzt-dll", "openzt-instance-manager", - "egui-tiny-skia", # vendor "vendor/retour-rs", From d3320b96470c5b897dabf1f00b730ac09c78cdfd Mon Sep 17 00:00:00 2001 From: Finn Hartshorn Date: Wed, 19 Aug 2026 08:46:57 +1000 Subject: [PATCH 4/7] Regenerate Cargo.lock for detour-validation/inventory dependency --- Cargo.lock | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/Cargo.lock b/Cargo.lock index ad8c30a..cea0f3f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1280,6 +1280,15 @@ dependencies = [ "syn 2.0.117", ] +[[package]] +name = "inventory" +version = "0.3.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a4f0c30c76f2f4ccee3fe55a2435f691ca00c0e4bd87abe4f4a851b1d4dac39b" +dependencies = [ + "rustversion", +] + [[package]] name = "ipnet" version = "2.11.0" @@ -1764,6 +1773,7 @@ dependencies = [ "field_accessor_as_string_trait", "getset", "indexmap 2.13.0", + "inventory", "itertools 0.14.0", "maplit", "mlua", @@ -1806,7 +1816,10 @@ dependencies = [ name = "openzt-detour" version = "0.1.0" dependencies = [ + "inventory", + "openzt-detour-macro", "retour", + "tracing", ] [[package]] From 76db7d942cb9595d6c1361323bdce1c63a2c6592 Mon Sep 17 00:00:00 2001 From: Finn Hartshorn Date: Wed, 19 Aug 2026 08:48:12 +1000 Subject: [PATCH 5/7] Fix absurd_extreme_comparisons clippy error in check_avoid_edges Wholesale-copying ztworldmgr.rs from the original detour-testing-framework tip reintroduces the pre-existing bug where avoid_edges - 1 stays unsigned, making radius < 0 always false and tripping clippy's deny-by-default absurd_extreme_comparisons lint. Cast to i32 before subtracting, same fix already applied on main. --- openzt/src/ztworldmgr.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/openzt/src/ztworldmgr.rs b/openzt/src/ztworldmgr.rs index a1427a7..51abb95 100644 --- a/openzt/src/ztworldmgr.rs +++ b/openzt/src/ztworldmgr.rs @@ -254,7 +254,7 @@ impl BFEntity { } pub fn check_avoid_edges(&self, tile: &BFTile) -> bool { - let radius = self.entity_type().avoid_edges - 1; + let radius = self.entity_type().avoid_edges as i32 - 1; if radius < 0 { return false; From dba1ee3413984050a0a2e3d4c3930913c1bc5a8a Mon Sep 17 00:00:00 2001 From: Finn Hartshorn Date: Wed, 19 Aug 2026 09:27:29 +1000 Subject: [PATCH 6/7] Fix regression: stop reverting already-merged buckets via the stale original tip The wholesale-copy step earlier this session sourced its "48 exclusive files" from the original 36-commit detour-testing-framework tip (e8ce74f), cross-checked only against feature/egui-overlay-plumbing and feature/save-logging. That missed that main had independently moved past the same stale tip via four already-merged extraction PRs (struct-foundation #94, tank/habitat #95, string-registry #96, ZTResearch #97) - none of which the cross-check accounted for. The result silently reverted their fixes wherever a file only they (not egui/save-logging) had touched: a real logic bug reintroduced in ZTAnimal::get_footprint's rotation branch, a ZTHabitat struct-layout regression (water_level/is_filled fields dropped), a deliberately broken proptest assertion in reimplementation_tests, and openzt-detour disabling the already-merged structs module. Fix: ztworldmgr.rs, bfentitytype.rs, ztmapview.rs, zthabitatmgr.rs, ztresearch.rs, bfconfigfile.rs, and reimplementation_tests/mod.rs are reverted to main's content wholesale (byte-identical, verified via empty diff) - detour-testing-framework has no legitimate independent claim on entity-type/world-mgr/research logic. openzt-detour/src/lib.rs re-enables `pub mod structs;`. generated.rs is rebuilt from main's content instead of the stale tip: every entry keeps main's current type and gets the validate_detour annotation where the tip has one, except the ~46 entries (bfregistry, bfmgr, uielement, bflog, ztapp, bfresource*, ztui_general, bfuimgr, ztscenerytype, ztmapview::PLACE_ENTITY_ON_MAP_1, ztui_gameopts, bfversioninfo, bfapp::LOAD_LANG_DLLS) that detour-testing's own genuinely-owned files (roofs.rs, bfregistry.rs, resource_manager/hooks.rs, experimental.rs, version.rs, capture_ztlog.rs, command_console.rs, lib.rs) actually call with a retyped pointer signature - confirmed by compiling and fixing exactly what broke, rather than assuming. Also added ztui::EXIT_APP, a new entry detour_validation.rs itself needs that never existed on main. Verified ./openzt.bat check/clippy clean under both default features and default+detour-validation (temporarily, reverted after). --- openzt-detour/src/generated.rs | 3759 ++++++++++------------ openzt-detour/src/lib.rs | 3 +- openzt/src/bfconfigfile.rs | 6 +- openzt/src/bfentitytype.rs | 101 +- openzt/src/reimplementation_tests/mod.rs | 241 +- openzt/src/zthabitatmgr.rs | 9 +- openzt/src/ztmapview.rs | 25 +- openzt/src/ztresearch.rs | 12 +- openzt/src/ztworldmgr.rs | 261 +- 9 files changed, 2307 insertions(+), 2110 deletions(-) diff --git a/openzt-detour/src/generated.rs b/openzt-detour/src/generated.rs index 21b6c8f..ec02c80 100644 --- a/openzt-detour/src/generated.rs +++ b/openzt-detour/src/generated.rs @@ -16,7 +16,7 @@ pub mod ai_cls_0x404fd6 { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ai_cls_0x404fd6/find"))] - pub const FIND: FunctionDef = FunctionDef{address: 0x004031b1, function_type: PhantomData}; + pub const FIND: FunctionDef = FunctionDef{address: 0x004031b1, function_type: PhantomData}; } // Ambients class functions @@ -24,11 +24,11 @@ pub mod ambients { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ambients/ambients"))] - pub const AMBIENTS: FunctionDef = FunctionDef{address: 0x0041e930, function_type: PhantomData}; + pub const AMBIENTS: FunctionDef = FunctionDef{address: 0x0041e930, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ambients/play"))] - pub const PLAY: FunctionDef = FunctionDef{address: 0x0043f445, function_type: PhantomData}; + pub const PLAY: FunctionDef = FunctionDef{address: 0x0043f445, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ambients/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004495a3, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004495a3, function_type: PhantomData}; } // AmbientsGroup class functions @@ -36,9 +36,9 @@ pub mod ambientsgroup { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ambientsgroup/play"))] - pub const PLAY: FunctionDef = FunctionDef{address: 0x0043f4d5, function_type: PhantomData}; + pub const PLAY: FunctionDef = FunctionDef{address: 0x0043f4d5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ambientsgroup/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0045067e, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0045067e, function_type: PhantomData}; } // BFAIMgr class functions @@ -46,35 +46,31 @@ pub mod bfaimgr { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_move_slow_f"))] - pub const F_MOVE_SLOW_F: FunctionDef u32> = FunctionDef{address: 0x00436606, function_type: PhantomData}; + pub const F_MOVE_SLOW_F: FunctionDef u32> = FunctionDef{address: 0x00436606, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/execute_call"))] - pub const EXECUTE_CALL: FunctionDef u32> = FunctionDef{address: 0x00437ccd, function_type: PhantomData}; + pub const EXECUTE_CALL: FunctionDef u32> = FunctionDef{address: 0x00437ccd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_random_walk"))] - pub const F_RANDOM_WALK: FunctionDef u32> = FunctionDef{address: 0x0043d948, function_type: PhantomData}; + pub const F_RANDOM_WALK: FunctionDef u32> = FunctionDef{address: 0x0043d948, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_play_set"))] - pub const F_PLAY_SET: FunctionDef u32> = FunctionDef{address: 0x0043ddc1, function_type: PhantomData}; + pub const F_PLAY_SET: FunctionDef u32> = FunctionDef{address: 0x0043ddc1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047b081, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_move_medium_f"))] - pub const F_MOVE_MEDIUM_F: FunctionDef u32> = FunctionDef{address: 0x004a31de, function_type: PhantomData}; + pub const F_MOVE_MEDIUM_F: FunctionDef u32> = FunctionDef{address: 0x004a31de, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_move_fast_f"))] - pub const F_MOVE_FAST_F: FunctionDef u32> = FunctionDef{address: 0x004a5310, function_type: PhantomData}; + pub const F_MOVE_FAST_F: FunctionDef u32> = FunctionDef{address: 0x004a5310, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/bfaimgr"))] - pub const BFAIMGR: FunctionDef *const u32> = FunctionDef{address: 0x0050374b, function_type: PhantomData}; + pub const BFAIMGR: FunctionDef u32> = FunctionDef{address: 0x0050374b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00525e90, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00525e90, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/init_aiparams"))] - pub const INIT_AIPARAMS: FunctionDef u32> = FunctionDef{address: 0x005267ec, function_type: PhantomData}; + pub const INIT_AIPARAMS: FunctionDef = FunctionDef{address: 0x005267ec, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/get_path"))] - pub const GET_PATH: FunctionDef = FunctionDef{address: 0x0052d8e8, function_type: PhantomData}; + pub const GET_PATH: FunctionDef = FunctionDef{address: 0x0052d8e8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_play_special"))] - pub const F_PLAY_SPECIAL: FunctionDef u32> = FunctionDef{address: 0x00588f7e, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_move_entity_special_f"))] - pub const F_MOVE_ENTITY_SPECIAL_F: FunctionDef u32> = FunctionDef{address: 0x00601aa5, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_move_entity_delta_f"))] - pub const F_MOVE_ENTITY_DELTA_F: FunctionDef u32> = FunctionDef{address: 0x00601b73, function_type: PhantomData}; + pub const F_PLAY_SPECIAL: FunctionDef u32> = FunctionDef{address: 0x00588f7e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfaimgr/f_play_set_terrain_f"))] - pub const F_PLAY_SET_TERRAIN_F: FunctionDef u32> = FunctionDef{address: 0x00601d2d, function_type: PhantomData}; + pub const F_PLAY_SET_TERRAIN_F: FunctionDef u32> = FunctionDef{address: 0x00601d2d, function_type: PhantomData}; } // BFAnimCache class functions @@ -82,13 +78,13 @@ pub mod bfanimcache { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfanimcache/find_anim"))] - pub const FIND_ANIM: FunctionDef *const i8> = FunctionDef{address: 0x00401fdd, function_type: PhantomData}; + pub const FIND_ANIM: FunctionDef u32> = FunctionDef{address: 0x00401fdd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfanimcache/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00419e91, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00419e91, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfanimcache/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x0052812e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfanimcache/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const i32> = FunctionDef{address: 0x005283f4, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x005283f4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfanimcache/instantiate"))] pub const INSTANTIATE: FunctionDef u32> = FunctionDef{address: 0x00528447, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfanimcache/unload_anims"))] @@ -102,47 +98,47 @@ pub mod bfapp { #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/load_string"))] pub const LOAD_STRING: FunctionDef u32> = FunctionDef{address: 0x00404e0a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/handle_messages"))] - pub const HANDLE_MESSAGES: FunctionDef u32> = FunctionDef{address: 0x00418f4f, function_type: PhantomData}; + pub const HANDLE_MESSAGES: FunctionDef i32> = FunctionDef{address: 0x00418f4f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/win_main"))] - pub const WIN_MAIN: FunctionDef i32> = FunctionDef{address: 0x0041a8bc, function_type: PhantomData}; + pub const WIN_MAIN: FunctionDef i32> = FunctionDef{address: 0x0041a8bc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/build_string"))] - pub const BUILD_STRING: FunctionDef *const u32> = FunctionDef{address: 0x0041ca7f, function_type: PhantomData}; + pub const BUILD_STRING: FunctionDef u32> = FunctionDef{address: 0x0041ca7f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/get_installed_expansion"))] - pub const GET_INSTALLED_EXPANSION: FunctionDef u32> = FunctionDef{address: 0x004ab32c, function_type: PhantomData}; + pub const GET_INSTALLED_EXPANSION: FunctionDef u32> = FunctionDef{address: 0x004ab32c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/load_user_resource"))] - pub const LOAD_USER_RESOURCE: FunctionDef u32> = FunctionDef{address: 0x004f029d, function_type: PhantomData}; + pub const LOAD_USER_RESOURCE: FunctionDef u32> = FunctionDef{address: 0x004f029d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/find_instance"))] - pub const FIND_INSTANCE: FunctionDef bool> = FunctionDef{address: 0x005337e6, function_type: PhantomData}; + pub const FIND_INSTANCE: FunctionDef = FunctionDef{address: 0x005337e6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/init_instance"))] - pub const INIT_INSTANCE: FunctionDef bool> = FunctionDef{address: 0x005340ba, function_type: PhantomData}; + pub const INIT_INSTANCE: FunctionDef bool> = FunctionDef{address: 0x005340ba, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/load_lang_dlls"))] pub const LOAD_LANG_DLLS: FunctionDef u32> = FunctionDef{address: 0x00537333, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/init_window_class"))] - pub const INIT_WINDOW_CLASS: FunctionDef bool> = FunctionDef{address: 0x005376bb, function_type: PhantomData}; + pub const INIT_WINDOW_CLASS: FunctionDef = FunctionDef{address: 0x005376bb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/register_class"))] - pub const REGISTER_CLASS: FunctionDef bool> = FunctionDef{address: 0x005378f6, function_type: PhantomData}; + pub const REGISTER_CLASS: FunctionDef bool> = FunctionDef{address: 0x005378f6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/store_typedata"))] - pub const STORE_TYPEDATA: FunctionDef = FunctionDef{address: 0x0053797b, function_type: PhantomData}; + pub const STORE_TYPEDATA: FunctionDef = FunctionDef{address: 0x0053797b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/create_window_class"))] - pub const CREATE_WINDOW_CLASS: FunctionDef = FunctionDef{address: 0x00537b37, function_type: PhantomData}; + pub const CREATE_WINDOW_CLASS: FunctionDef = FunctionDef{address: 0x00537b37, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/load_res_dlls"))] - pub const LOAD_RES_DLLS: FunctionDef u32> = FunctionDef{address: 0x00537ee3, function_type: PhantomData}; + pub const LOAD_RES_DLLS: FunctionDef u32> = FunctionDef{address: 0x00537ee3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x005784f8, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x005784f8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/exit_override"))] pub const EXIT_OVERRIDE: FunctionDef = FunctionDef{address: 0x0057de3e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/bfapp_0"))] - pub const BFAPP_0: FunctionDef *const u32> = FunctionDef{address: 0x00587641, function_type: PhantomData}; + pub const BFAPP_0: FunctionDef u32> = FunctionDef{address: 0x00587641, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/destroy_window_class"))] - pub const DESTROY_WINDOW_CLASS: FunctionDef = FunctionDef{address: 0x00587661, function_type: PhantomData}; + pub const DESTROY_WINDOW_CLASS: FunctionDef = FunctionDef{address: 0x00587661, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/get_screen_center"))] - pub const GET_SCREEN_CENTER: FunctionDef = FunctionDef{address: 0x005fd367, function_type: PhantomData}; + pub const GET_SCREEN_CENTER: FunctionDef = FunctionDef{address: 0x005fd367, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/bfapp_1"))] - pub const BFAPP_1: FunctionDef *const u32> = FunctionDef{address: 0x005fd382, function_type: PhantomData}; + pub const BFAPP_1: FunctionDef u32> = FunctionDef{address: 0x005fd382, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/load_typedata"))] - pub const LOAD_TYPEDATA: FunctionDef = FunctionDef{address: 0x005fd3a0, function_type: PhantomData}; + pub const LOAD_TYPEDATA: FunctionDef = FunctionDef{address: 0x005fd3a0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfapp/toggle_cursors"))] - pub const TOGGLE_CURSORS: FunctionDef = FunctionDef{address: 0x005fd3d1, function_type: PhantomData}; + pub const TOGGLE_CURSORS: FunctionDef = FunctionDef{address: 0x005fd3d1, function_type: PhantomData}; } // BFBSCall class functions @@ -150,7 +146,7 @@ pub mod bfbscall { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfbscall/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004109fe, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004109fe, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfbscall/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x004781e9, function_type: PhantomData}; } @@ -160,17 +156,17 @@ pub mod bfbehaviorset { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfbehaviorset/execute_0"))] - pub const EXECUTE_0: FunctionDef = FunctionDef{address: 0x00435e57, function_type: PhantomData}; + pub const EXECUTE_0: FunctionDef = FunctionDef{address: 0x00435e57, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfbehaviorset/execute_child"))] - pub const EXECUTE_CHILD: FunctionDef u32> = FunctionDef{address: 0x0043745f, function_type: PhantomData}; + pub const EXECUTE_CHILD: FunctionDef u32> = FunctionDef{address: 0x0043745f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfbehaviorset/init_child"))] - pub const INIT_CHILD: FunctionDef u32> = FunctionDef{address: 0x0043de4f, function_type: PhantomData}; + pub const INIT_CHILD: FunctionDef u32> = FunctionDef{address: 0x0043de4f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfbehaviorset/execute_1"))] pub const EXECUTE_1: FunctionDef = FunctionDef{address: 0x0043e7fc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfbehaviorset/load"))] - pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x0044fb77, function_type: PhantomData}; + pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x0044fb77, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfbehaviorset/set_entity"))] - pub const SET_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x004551cb, function_type: PhantomData}; + pub const SET_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004551cb, function_type: PhantomData}; } // BFCPUSPEED class functions @@ -186,7 +182,7 @@ pub mod bfcategory { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfcategory/get_value"))] - pub const GET_VALUE: FunctionDef *const i32> = FunctionDef{address: 0x00410ec0, function_type: PhantomData}; + pub const GET_VALUE: FunctionDef u32> = FunctionDef{address: 0x00410ec0, function_type: PhantomData}; } // BFCogGoal class functions @@ -194,17 +190,17 @@ pub mod bfcoggoal { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfcoggoal/set_tile"))] - pub const SET_TILE: FunctionDef = FunctionDef{address: 0x0041300b, function_type: PhantomData}; + pub const SET_TILE: FunctionDef = FunctionDef{address: 0x0041300b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfcoggoal/set_idsub"))] - pub const SET_IDSUB: FunctionDef = FunctionDef{address: 0x0041308d, function_type: PhantomData}; + pub const SET_IDSUB: FunctionDef = FunctionDef{address: 0x0041308d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfcoggoal/set_tile_sub"))] - pub const SET_TILE_SUB: FunctionDef = FunctionDef{address: 0x004131c8, function_type: PhantomData}; + pub const SET_TILE_SUB: FunctionDef = FunctionDef{address: 0x004131c8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfcoggoal/clear_target_sub"))] - pub const CLEAR_TARGET_SUB: FunctionDef = FunctionDef{address: 0x004131f9, function_type: PhantomData}; + pub const CLEAR_TARGET_SUB: FunctionDef = FunctionDef{address: 0x004131f9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfcoggoal/set_target_pos"))] - pub const SET_TARGET_POS: FunctionDef = FunctionDef{address: 0x00413c2b, function_type: PhantomData}; + pub const SET_TARGET_POS: FunctionDef = FunctionDef{address: 0x00413c2b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfcoggoal/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00454aaf, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00454aaf, function_type: PhantomData}; } // BFConfigFile class functions @@ -212,43 +208,43 @@ pub mod bfconfigfile { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_string_0"))] - pub const GET_STRING_0: FunctionDef *const i32> = FunctionDef{address: 0x00404c52, function_type: PhantomData}; + pub const GET_STRING_0: FunctionDef u32> = FunctionDef{address: 0x00404c52, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_string_list_ptr"))] - pub const GET_STRING_LIST_PTR: FunctionDef u8> = FunctionDef{address: 0x00405223, function_type: PhantomData}; + pub const GET_STRING_LIST_PTR: FunctionDef u8> = FunctionDef{address: 0x00405223, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_string_list"))] - pub const GET_STRING_LIST: FunctionDef *const u32> = FunctionDef{address: 0x00405463, function_type: PhantomData}; + pub const GET_STRING_LIST: FunctionDef u32> = FunctionDef{address: 0x00405463, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_string_1"))] - pub const GET_STRING_1: FunctionDef bool> = FunctionDef{address: 0x004098c1, function_type: PhantomData}; + pub const GET_STRING_1: FunctionDef bool> = FunctionDef{address: 0x004098c1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/attempt_0"))] - pub const ATTEMPT_0: FunctionDef = FunctionDef{address: 0x00409ac0, function_type: PhantomData}; + pub const ATTEMPT_0: FunctionDef = FunctionDef{address: 0x00409ac0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_int"))] - pub const GET_INT: FunctionDef u32> = FunctionDef{address: 0x00409c14, function_type: PhantomData}; + pub const GET_INT: FunctionDef u32> = FunctionDef{address: 0x00409c14, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_keys"))] - pub const GET_KEYS: FunctionDef *const u32> = FunctionDef{address: 0x00409cf3, function_type: PhantomData}; + pub const GET_KEYS: FunctionDef u32> = FunctionDef{address: 0x00409cf3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/release"))] - pub const RELEASE: FunctionDef = FunctionDef{address: 0x0040a5bc, function_type: PhantomData}; + pub const RELEASE: FunctionDef = FunctionDef{address: 0x0040a5bc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/parse"))] - pub const PARSE: FunctionDef bool> = FunctionDef{address: 0x0040ade7, function_type: PhantomData}; + pub const PARSE: FunctionDef bool> = FunctionDef{address: 0x0040ade7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/attempt_1"))] - pub const ATTEMPT_1: FunctionDef u32> = FunctionDef{address: 0x0040aeda, function_type: PhantomData}; + pub const ATTEMPT_1: FunctionDef u32> = FunctionDef{address: 0x0040aeda, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/add_key_val"))] - pub const ADD_KEY_VAL: FunctionDef = FunctionDef{address: 0x0040af4f, function_type: PhantomData}; + pub const ADD_KEY_VAL: FunctionDef = FunctionDef{address: 0x0040af4f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/add_block"))] - pub const ADD_BLOCK: FunctionDef *const u32> = FunctionDef{address: 0x0040b540, function_type: PhantomData}; + pub const ADD_BLOCK: FunctionDef u32> = FunctionDef{address: 0x0040b540, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_int_list"))] - pub const GET_INT_LIST: FunctionDef *const u32> = FunctionDef{address: 0x004aabb8, function_type: PhantomData}; + pub const GET_INT_LIST: FunctionDef u32> = FunctionDef{address: 0x004aabb8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/acquire"))] - pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x004aaf2d, function_type: PhantomData}; + pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x004aaf2d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_float"))] - pub const GET_FLOAT: FunctionDef u32> = FunctionDef{address: 0x004b37c3, function_type: PhantomData}; + pub const GET_FLOAT: FunctionDef u32> = FunctionDef{address: 0x004b37c3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/get_blocks"))] - pub const GET_BLOCKS: FunctionDef *const u32> = FunctionDef{address: 0x004b435e, function_type: PhantomData}; + pub const GET_BLOCKS: FunctionDef u32> = FunctionDef{address: 0x004b435e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/constructor_0"))] - pub const CONSTRUCTOR_0: FunctionDef *const u32> = FunctionDef{address: 0x004b4516, function_type: PhantomData}; + pub const CONSTRUCTOR_0: FunctionDef u32> = FunctionDef{address: 0x004b4516, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/constructor_1"))] - pub const CONSTRUCTOR_1: FunctionDef *const i32> = FunctionDef{address: 0x004d56f9, function_type: PhantomData}; + pub const CONSTRUCTOR_1: FunctionDef u32> = FunctionDef{address: 0x004d56f9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigfile/constructor_2"))] - pub const CONSTRUCTOR_2: FunctionDef *const u32> = FunctionDef{address: 0x005fed91, function_type: PhantomData}; + pub const CONSTRUCTOR_2: FunctionDef u32> = FunctionDef{address: 0x005fed91, function_type: PhantomData}; } // BFConfigStringTable class functions @@ -256,9 +252,9 @@ pub mod bfconfigstringtable { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigstringtable/del_string"))] - pub const DEL_STRING: FunctionDef = FunctionDef{address: 0x0040a6ad, function_type: PhantomData}; + pub const DEL_STRING: FunctionDef = FunctionDef{address: 0x0040a6ad, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfconfigstringtable/add_string"))] - pub const ADD_STRING: FunctionDef u32> = FunctionDef{address: 0x0040ae55, function_type: PhantomData}; + pub const ADD_STRING: FunctionDef u32> = FunctionDef{address: 0x0040ae55, function_type: PhantomData}; } // BFDiagnostic class functions @@ -268,7 +264,7 @@ pub mod bfdiagnostic { #[cfg_attr(feature = "detour-validation", validate_detour("bfdiagnostic/get_cpuspeed"))] pub const GET_CPUSPEED: FunctionDef u32> = FunctionDef{address: 0x00533a62, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfdiagnostic/get_memory"))] - pub const GET_MEMORY: FunctionDef u32> = FunctionDef{address: 0x005368c0, function_type: PhantomData}; + pub const GET_MEMORY: FunctionDef i32> = FunctionDef{address: 0x005368c0, function_type: PhantomData}; } // BFEntity class functions @@ -276,139 +272,139 @@ pub mod bfentity { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/init_ambient_anims"))] - pub const INIT_AMBIENT_ANIMS: FunctionDef = FunctionDef{address: 0x00401115, function_type: PhantomData}; + pub const INIT_AMBIENT_ANIMS: FunctionDef = FunctionDef{address: 0x00401115, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_tile"))] - pub const GET_TILE: FunctionDef i32> = FunctionDef{address: 0x0040f8ac, function_type: PhantomData}; + pub const GET_TILE: FunctionDef i32> = FunctionDef{address: 0x0040f8ac, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_footprint"))] pub const GET_FOOTPRINT: FunctionDef *const u32> = FunctionDef{address: 0x0040f916, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/is_walkable"))] - pub const IS_WALKABLE: FunctionDef u32> = FunctionDef{address: 0x0040fbbd, function_type: PhantomData}; + pub const IS_WALKABLE: FunctionDef = FunctionDef{address: 0x0040fbbd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/dir_to_set"))] - pub const DIR_TO_SET: FunctionDef u32> = FunctionDef{address: 0x0040ff43, function_type: PhantomData}; + pub const DIR_TO_SET: FunctionDef u32> = FunctionDef{address: 0x0040ff43, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/validate_position"))] - pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x0040ffc2, function_type: PhantomData}; + pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x0040ffc2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_world_pos"))] - pub const SET_WORLD_POS: FunctionDef = FunctionDef{address: 0x00410141, function_type: PhantomData}; + pub const SET_WORLD_POS: FunctionDef = FunctionDef{address: 0x00410141, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_draw_dithered"))] - pub const SET_DRAW_DITHERED: FunctionDef = FunctionDef{address: 0x0041028c, function_type: PhantomData}; + pub const SET_DRAW_DITHERED: FunctionDef = FunctionDef{address: 0x0041028c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/init_after_load"))] - pub const INIT_AFTER_LOAD: FunctionDef u8> = FunctionDef{address: 0x00410cb0, function_type: PhantomData}; + pub const INIT_AFTER_LOAD: FunctionDef = FunctionDef{address: 0x00410cb0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/find_anim"))] - pub const FIND_ANIM: FunctionDef = FunctionDef{address: 0x00410ffe, function_type: PhantomData}; + pub const FIND_ANIM: FunctionDef = FunctionDef{address: 0x00410ffe, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00412693, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00412693, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/init"))] - pub const INIT: FunctionDef i32> = FunctionDef{address: 0x0041281b, function_type: PhantomData}; + pub const INIT: FunctionDef i32> = FunctionDef{address: 0x0041281b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/init_status_vars"))] - pub const INIT_STATUS_VARS: FunctionDef u32> = FunctionDef{address: 0x004128e0, function_type: PhantomData}; + pub const INIT_STATUS_VARS: FunctionDef u32> = FunctionDef{address: 0x004128e0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_grid_pos"))] - pub const GET_GRID_POS: FunctionDef *const i32> = FunctionDef{address: 0x0041426f, function_type: PhantomData}; + pub const GET_GRID_POS: FunctionDef u32> = FunctionDef{address: 0x0041426f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/is_walkable_by"))] - pub const IS_WALKABLE_BY: FunctionDef = FunctionDef{address: 0x004147fd, function_type: PhantomData}; + pub const IS_WALKABLE_BY: FunctionDef = FunctionDef{address: 0x004147fd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/check_avoid_edges"))] - pub const CHECK_AVOID_EDGES: FunctionDef u32> = FunctionDef{address: 0x004149e6, function_type: PhantomData}; + pub const CHECK_AVOID_EDGES: FunctionDef u32> = FunctionDef{address: 0x004149e6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/bfentity_0"))] - pub const BFENTITY_0: FunctionDef *const u32> = FunctionDef{address: 0x0041df2e, function_type: PhantomData}; + pub const BFENTITY_0: FunctionDef u32> = FunctionDef{address: 0x0041df2e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_is_removed"))] - pub const SET_IS_REMOVED: FunctionDef = FunctionDef{address: 0x0041e0d9, function_type: PhantomData}; + pub const SET_IS_REMOVED: FunctionDef = FunctionDef{address: 0x0041e0d9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_visible"))] - pub const SET_VISIBLE: FunctionDef = FunctionDef{address: 0x0041e0f0, function_type: PhantomData}; + pub const SET_VISIBLE: FunctionDef = FunctionDef{address: 0x0041e0f0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/is_removed_undo"))] - pub const IS_REMOVED_UNDO: FunctionDef u8> = FunctionDef{address: 0x0041e1b5, function_type: PhantomData}; + pub const IS_REMOVED_UNDO: FunctionDef = FunctionDef{address: 0x0041e1b5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/create_name"))] - pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x0041e84f, function_type: PhantomData}; + pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x0041e84f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_blocking_rect"))] pub const GET_BLOCKING_RECT: FunctionDef *const u32> = FunctionDef{address: 0x0042721a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_placement_footprint"))] - pub const GET_PLACEMENT_FOOTPRINT: FunctionDef = FunctionDef{address: 0x004272d4, function_type: PhantomData}; + pub const GET_PLACEMENT_FOOTPRINT: FunctionDef = FunctionDef{address: 0x004272d4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/clear_bs"))] - pub const CLEAR_BS: FunctionDef u32> = FunctionDef{address: 0x004274de, function_type: PhantomData}; + pub const CLEAR_BS: FunctionDef u32> = FunctionDef{address: 0x004274de, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/clear_queue"))] - pub const CLEAR_QUEUE: FunctionDef = FunctionDef{address: 0x004275bb, function_type: PhantomData}; + pub const CLEAR_QUEUE: FunctionDef = FunctionDef{address: 0x004275bb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_inside_pos"))] - pub const GET_INSIDE_POS: FunctionDef *const u32> = FunctionDef{address: 0x0042b875, function_type: PhantomData}; + pub const GET_INSIDE_POS: FunctionDef u32> = FunctionDef{address: 0x0042b875, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/replace_colors"))] - pub const REPLACE_COLORS: FunctionDef = FunctionDef{address: 0x00432fc7, function_type: PhantomData}; + pub const REPLACE_COLORS: FunctionDef = FunctionDef{address: 0x00432fc7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/draw_0"))] - pub const DRAW_0: FunctionDef = FunctionDef{address: 0x00432ff4, function_type: PhantomData}; + pub const DRAW_0: FunctionDef = FunctionDef{address: 0x00432ff4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_shadow_tile"))] - pub const GET_SHADOW_TILE: FunctionDef i32> = FunctionDef{address: 0x00433d31, function_type: PhantomData}; + pub const GET_SHADOW_TILE: FunctionDef = FunctionDef{address: 0x00433d31, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_color_rep_info"))] - pub const GET_COLOR_REP_INFO: FunctionDef i32> = FunctionDef{address: 0x00433fbd, function_type: PhantomData}; + pub const GET_COLOR_REP_INFO: FunctionDef i32> = FunctionDef{address: 0x00433fbd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/update_animation"))] - pub const UPDATE_ANIMATION: FunctionDef = FunctionDef{address: 0x00434899, function_type: PhantomData}; + pub const UPDATE_ANIMATION: FunctionDef = FunctionDef{address: 0x00434899, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/is_removed"))] - pub const IS_REMOVED: FunctionDef u8> = FunctionDef{address: 0x004348b0, function_type: PhantomData}; + pub const IS_REMOVED: FunctionDef = FunctionDef{address: 0x004348b0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0043494e, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0043494e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_stop_at_end"))] - pub const SET_STOP_AT_END: FunctionDef = FunctionDef{address: 0x00434aca, function_type: PhantomData}; + pub const SET_STOP_AT_END: FunctionDef = FunctionDef{address: 0x00434aca, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_bs"))] - pub const SET_BS: FunctionDef u32> = FunctionDef{address: 0x0043c6c5, function_type: PhantomData}; + pub const SET_BS: FunctionDef u32> = FunctionDef{address: 0x0043c6c5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/draw_shadow"))] - pub const DRAW_SHADOW: FunctionDef = FunctionDef{address: 0x0043f81c, function_type: PhantomData}; + pub const DRAW_SHADOW: FunctionDef = FunctionDef{address: 0x0043f81c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_underwater_section_anim"))] - pub const GET_UNDERWATER_SECTION_ANIM: FunctionDef i32> = FunctionDef{address: 0x0043fd53, function_type: PhantomData}; + pub const GET_UNDERWATER_SECTION_ANIM: FunctionDef i32> = FunctionDef{address: 0x0043fd53, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_direction"))] - pub const SET_DIRECTION: FunctionDef = FunctionDef{address: 0x004403ea, function_type: PhantomData}; + pub const SET_DIRECTION: FunctionDef = FunctionDef{address: 0x004403ea, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_icon_zoom"))] - pub const GET_ICON_ZOOM: FunctionDef u32> = FunctionDef{address: 0x004440cc, function_type: PhantomData}; + pub const GET_ICON_ZOOM: FunctionDef = FunctionDef{address: 0x004440cc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/verify_shape"))] - pub const VERIFY_SHAPE: FunctionDef u8> = FunctionDef{address: 0x00446995, function_type: PhantomData}; + pub const VERIFY_SHAPE: FunctionDef = FunctionDef{address: 0x00446995, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_name"))] - pub const SET_NAME: FunctionDef = FunctionDef{address: 0x00449215, function_type: PhantomData}; + pub const SET_NAME: FunctionDef = FunctionDef{address: 0x00449215, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044f866, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044f866, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00477998, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/force_anim"))] - pub const FORCE_ANIM: FunctionDef u32> = FunctionDef{address: 0x00485580, function_type: PhantomData}; + pub const FORCE_ANIM: FunctionDef = FunctionDef{address: 0x00485580, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/morph"))] - pub const MORPH: FunctionDef = FunctionDef{address: 0x004865c4, function_type: PhantomData}; + pub const MORPH: FunctionDef = FunctionDef{address: 0x004865c4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/calc_shadow_world_position"))] - pub const CALC_SHADOW_WORLD_POSITION: FunctionDef = FunctionDef{address: 0x00492def, function_type: PhantomData}; + pub const CALC_SHADOW_WORLD_POSITION: FunctionDef = FunctionDef{address: 0x00492def, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/draw_underwater_section"))] - pub const DRAW_UNDERWATER_SECTION: FunctionDef = FunctionDef{address: 0x00496b99, function_type: PhantomData}; + pub const DRAW_UNDERWATER_SECTION: FunctionDef = FunctionDef{address: 0x00496b99, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_height"))] - pub const GET_HEIGHT: FunctionDef u32> = FunctionDef{address: 0x00498d30, function_type: PhantomData}; + pub const GET_HEIGHT: FunctionDef = FunctionDef{address: 0x00498d30, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_bsnew"))] - pub const SET_BSNEW: FunctionDef u32> = FunctionDef{address: 0x004a7e94, function_type: PhantomData}; + pub const SET_BSNEW: FunctionDef u32> = FunctionDef{address: 0x004a7e94, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/is_on_tile"))] pub const IS_ON_TILE: FunctionDef bool> = FunctionDef{address: 0x004e16f1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/draw_selection_graphic"))] - pub const DRAW_SELECTION_GRAPHIC: FunctionDef = FunctionDef{address: 0x004ed85d, function_type: PhantomData}; + pub const DRAW_SELECTION_GRAPHIC: FunctionDef = FunctionDef{address: 0x004ed85d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/set_selected"))] - pub const SET_SELECTED: FunctionDef = FunctionDef{address: 0x004ee29a, function_type: PhantomData}; + pub const SET_SELECTED: FunctionDef = FunctionDef{address: 0x004ee29a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/send_event_0"))] - pub const SEND_EVENT_0: FunctionDef = FunctionDef{address: 0x004f2bd5, function_type: PhantomData}; + pub const SEND_EVENT_0: FunctionDef = FunctionDef{address: 0x004f2bd5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/add_to_map"))] - pub const ADD_TO_MAP: FunctionDef = FunctionDef{address: 0x004f421f, function_type: PhantomData}; + pub const ADD_TO_MAP: FunctionDef = FunctionDef{address: 0x004f421f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_blocking_rect_virt_ztpath"))] pub const GET_BLOCKING_RECT_VIRT_ZTPATH: FunctionDef *const u32> = FunctionDef{address: 0x004fbbee, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/destroy_selection_graphics"))] pub const DESTROY_SELECTION_GRAPHICS: FunctionDef = FunctionDef{address: 0x005028c5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/snap_to_grid"))] - pub const SNAP_TO_GRID: FunctionDef = FunctionDef{address: 0x00505763, function_type: PhantomData}; + pub const SNAP_TO_GRID: FunctionDef = FunctionDef{address: 0x00505763, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/send_event_1"))] - pub const SEND_EVENT_1: FunctionDef = FunctionDef{address: 0x0059df63, function_type: PhantomData}; + pub const SEND_EVENT_1: FunctionDef = FunctionDef{address: 0x0059df63, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_depth"))] - pub const GET_DEPTH: FunctionDef u32> = FunctionDef{address: 0x005af392, function_type: PhantomData}; + pub const GET_DEPTH: FunctionDef = FunctionDef{address: 0x005af392, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_idle_anim"))] - pub const GET_IDLE_ANIM: FunctionDef u32> = FunctionDef{address: 0x005ff91c, function_type: PhantomData}; + pub const GET_IDLE_ANIM: FunctionDef = FunctionDef{address: 0x005ff91c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_icon_anim"))] - pub const GET_ICON_ANIM: FunctionDef = FunctionDef{address: 0x005ff92b, function_type: PhantomData}; + pub const GET_ICON_ANIM: FunctionDef = FunctionDef{address: 0x005ff92b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/is_snap_to_ground"))] - pub const IS_SNAP_TO_GROUND: FunctionDef u8> = FunctionDef{address: 0x005ff936, function_type: PhantomData}; + pub const IS_SNAP_TO_GROUND: FunctionDef = FunctionDef{address: 0x005ff936, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/bfentity_1"))] - pub const BFENTITY_1: FunctionDef *const u32> = FunctionDef{address: 0x005ff93d, function_type: PhantomData}; + pub const BFENTITY_1: FunctionDef u32> = FunctionDef{address: 0x005ff93d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/draw_1"))] - pub const DRAW_1: FunctionDef = FunctionDef{address: 0x005ff95b, function_type: PhantomData}; + pub const DRAW_1: FunctionDef = FunctionDef{address: 0x005ff95b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/draw_aiinfo"))] - pub const DRAW_AIINFO: FunctionDef = FunctionDef{address: 0x005ff9e8, function_type: PhantomData}; + pub const DRAW_AIINFO: FunctionDef = FunctionDef{address: 0x005ff9e8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x005ff9eb, function_type: PhantomData}; + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x005ff9eb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentity/get_events"))] - pub const GET_EVENTS: FunctionDef = FunctionDef{address: 0x005ffa19, function_type: PhantomData}; + pub const GET_EVENTS: FunctionDef = FunctionDef{address: 0x005ffa19, function_type: PhantomData}; } // BFEntityType class functions @@ -416,61 +412,61 @@ pub mod bfentitytype { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/find_anim"))] - pub const FIND_ANIM: FunctionDef *const i8> = FunctionDef{address: 0x00402062, function_type: PhantomData}; + pub const FIND_ANIM: FunctionDef u32> = FunctionDef{address: 0x00402062, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/is_user_type_id"))] pub const IS_USER_TYPE_ID: FunctionDef u32> = FunctionDef{address: 0x00404cb4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/is_user_type"))] - pub const IS_USER_TYPE: FunctionDef = FunctionDef{address: 0x004055e2, function_type: PhantomData}; + pub const IS_USER_TYPE: FunctionDef = FunctionDef{address: 0x004055e2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_base_anim"))] - pub const GET_BASE_ANIM: FunctionDef *const i8> = FunctionDef{address: 0x00412ac4, function_type: PhantomData}; + pub const GET_BASE_ANIM: FunctionDef u32> = FunctionDef{address: 0x00412ac4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/find_sound"))] - pub const FIND_SOUND: FunctionDef *const i32> = FunctionDef{address: 0x0044084b, function_type: PhantomData}; + pub const FIND_SOUND: FunctionDef u32> = FunctionDef{address: 0x0044084b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/load_data"))] - pub const LOAD_DATA: FunctionDef u32> = FunctionDef{address: 0x004b456c, function_type: PhantomData}; + pub const LOAD_DATA: FunctionDef u32> = FunctionDef{address: 0x004b456c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/load_sounds"))] - pub const LOAD_SOUNDS: FunctionDef u32> = FunctionDef{address: 0x004b473f, function_type: PhantomData}; + pub const LOAD_SOUNDS: FunctionDef u32> = FunctionDef{address: 0x004b473f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_int"))] - pub const GET_INT: FunctionDef u32> = FunctionDef{address: 0x004b4803, function_type: PhantomData}; + pub const GET_INT: FunctionDef u32> = FunctionDef{address: 0x004b4803, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_string"))] - pub const GET_STRING: FunctionDef u32> = FunctionDef{address: 0x004b486c, function_type: PhantomData}; + pub const GET_STRING: FunctionDef u32> = FunctionDef{address: 0x004b486c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/load_characteristics_0"))] - pub const LOAD_CHARACTERISTICS_0: FunctionDef *const i16> = FunctionDef{address: 0x004b4903, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004b4903, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/load_characteristics_1"))] - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b4c2a, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b4c2a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/load_color_rep_info"))] - pub const LOAD_COLOR_REP_INFO: FunctionDef u32> = FunctionDef{address: 0x004bb159, function_type: PhantomData}; + pub const LOAD_COLOR_REP_INFO: FunctionDef u32> = FunctionDef{address: 0x004bb159, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004be045, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004be045, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/set_type"))] - pub const SET_TYPE: FunctionDef = FunctionDef{address: 0x004be24e, function_type: PhantomData}; + pub const SET_TYPE: FunctionDef = FunctionDef{address: 0x004be24e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/check_type"))] - pub const CHECK_TYPE: FunctionDef u32> = FunctionDef{address: 0x004be3ec, function_type: PhantomData}; + pub const CHECK_TYPE: FunctionDef u32> = FunctionDef{address: 0x004be3ec, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/num_icons"))] - pub const NUM_ICONS: FunctionDef i32> = FunctionDef{address: 0x004e9e68, function_type: PhantomData}; + pub const NUM_ICONS: FunctionDef = FunctionDef{address: 0x004e9e68, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_icon_name"))] - pub const GET_ICON_NAME: FunctionDef u32> = FunctionDef{address: 0x004e9e74, function_type: PhantomData}; + pub const GET_ICON_NAME: FunctionDef u32> = FunctionDef{address: 0x004e9e74, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_unit_count"))] - pub const GET_UNIT_COUNT: FunctionDef i32> = FunctionDef{address: 0x004f6cc5, function_type: PhantomData}; + pub const GET_UNIT_COUNT: FunctionDef i32> = FunctionDef{address: 0x004f6cc5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/bfentity_type"))] - pub const BFENTITY_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x00500783, function_type: PhantomData}; + pub const BFENTITY_TYPE: FunctionDef u32> = FunctionDef{address: 0x00500783, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/unload_data"))] - pub const UNLOAD_DATA: FunctionDef = FunctionDef{address: 0x005008bb, function_type: PhantomData}; + pub const UNLOAD_DATA: FunctionDef = FunctionDef{address: 0x005008bb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/unload_animations"))] - pub const UNLOAD_ANIMATIONS: FunctionDef = FunctionDef{address: 0x005008e7, function_type: PhantomData}; + pub const UNLOAD_ANIMATIONS: FunctionDef = FunctionDef{address: 0x005008e7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/unload_sounds"))] - pub const UNLOAD_SOUNDS: FunctionDef = FunctionDef{address: 0x005008fe, function_type: PhantomData}; + pub const UNLOAD_SOUNDS: FunctionDef = FunctionDef{address: 0x005008fe, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/load_user_data"))] - pub const LOAD_USER_DATA: FunctionDef u32> = FunctionDef{address: 0x00597337, function_type: PhantomData}; + pub const LOAD_USER_DATA: FunctionDef u32> = FunctionDef{address: 0x00597337, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/set_available"))] - pub const SET_AVAILABLE: FunctionDef = FunctionDef{address: 0x005a111d, function_type: PhantomData}; + pub const SET_AVAILABLE: FunctionDef = FunctionDef{address: 0x005a111d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x005fe1c8, function_type: PhantomData}; + pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x005fe1c8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_user_data"))] - pub const GET_USER_DATA: FunctionDef *const i32> = FunctionDef{address: 0x005fe1ea, function_type: PhantomData}; + pub const GET_USER_DATA: FunctionDef u32> = FunctionDef{address: 0x005fe1ea, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_base_user_id"))] pub const GET_BASE_USER_ID: FunctionDef i32> = FunctionDef{address: 0x005fe25c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfentitytype/get_user_data_index"))] - pub const GET_USER_DATA_INDEX: FunctionDef u8> = FunctionDef{address: 0x005fe27a, function_type: PhantomData}; + pub const GET_USER_DATA_INDEX: FunctionDef = FunctionDef{address: 0x005fe27a, function_type: PhantomData}; } // BFEvent class functions @@ -478,7 +474,7 @@ pub mod bfevent { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfevent/load"))] - pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x00485f08, function_type: PhantomData}; + pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x00485f08, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfevent/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0060182e, function_type: PhantomData}; } @@ -488,7 +484,7 @@ pub mod bfeventinfo { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfeventinfo/load"))] - pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x00485e31, function_type: PhantomData}; + pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x00485e31, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfeventinfo/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00601768, function_type: PhantomData}; } @@ -500,11 +496,11 @@ pub mod bfeventmgr { #[cfg_attr(feature = "detour-validation", validate_detour("bfeventmgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047afa5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfeventmgr/init"))] - pub const INIT: FunctionDef u32> = FunctionDef{address: 0x00525f3e, function_type: PhantomData}; + pub const INIT: FunctionDef u32> = FunctionDef{address: 0x00525f3e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfeventmgr/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0052603f, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0052603f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfeventmgr/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00594d17, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00594d17, function_type: PhantomData}; } // BFFont class functions @@ -512,9 +508,9 @@ pub mod bffont { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bffont/create"))] - pub const CREATE: FunctionDef u32> = FunctionDef{address: 0x00510102, function_type: PhantomData}; + pub const CREATE: FunctionDef u32> = FunctionDef{address: 0x00510102, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bffont/bffont"))] - pub const BFFONT: FunctionDef *const u32> = FunctionDef{address: 0x00620bfa, function_type: PhantomData}; + pub const BFFONT: FunctionDef u32> = FunctionDef{address: 0x00620bfa, function_type: PhantomData}; } // BFFontCache class functions @@ -522,9 +518,9 @@ pub mod bffontcache { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bffontcache/remove_font"))] - pub const REMOVE_FONT: FunctionDef = FunctionDef{address: 0x005032a6, function_type: PhantomData}; + pub const REMOVE_FONT: FunctionDef = FunctionDef{address: 0x005032a6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bffontcache/get_font"))] - pub const GET_FONT: FunctionDef *const i32> = FunctionDef{address: 0x00510001, function_type: PhantomData}; + pub const GET_FONT: FunctionDef u32> = FunctionDef{address: 0x00510001, function_type: PhantomData}; } // BFFontDescription class functions @@ -532,17 +528,17 @@ pub mod bffontdescription { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bffontdescription/get_height_0"))] - pub const GET_HEIGHT_0: FunctionDef i32> = FunctionDef{address: 0x00418d4a, function_type: PhantomData}; + pub const GET_HEIGHT_0: FunctionDef i32> = FunctionDef{address: 0x00418d4a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bffontdescription/release"))] - pub const RELEASE: FunctionDef = FunctionDef{address: 0x0050241b, function_type: PhantomData}; + pub const RELEASE: FunctionDef = FunctionDef{address: 0x0050241b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bffontdescription/get_avg_char_width_0"))] - pub const GET_AVG_CHAR_WIDTH_0: FunctionDef i32> = FunctionDef{address: 0x00510668, function_type: PhantomData}; + pub const GET_AVG_CHAR_WIDTH_0: FunctionDef i32> = FunctionDef{address: 0x00510668, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bffontdescription/get_height_1"))] pub const GET_HEIGHT_1: FunctionDef u32> = FunctionDef{address: 0x00511c74, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bffontdescription/get_avg_char_width_1"))] pub const GET_AVG_CHAR_WIDTH_1: FunctionDef u32> = FunctionDef{address: 0x00511cc2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bffontdescription/create"))] - pub const CREATE: FunctionDef *const i16> = FunctionDef{address: 0x00511d39, function_type: PhantomData}; + pub const CREATE: FunctionDef u32> = FunctionDef{address: 0x00511d39, function_type: PhantomData}; } // BFGameApp class functions @@ -550,59 +546,53 @@ pub mod bfgameapp { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/get_graphics"))] - pub const GET_GRAPHICS: FunctionDef u32> = FunctionDef{address: 0x00401380, function_type: PhantomData}; + pub const GET_GRAPHICS: FunctionDef = FunctionDef{address: 0x00401380, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/handle_messages"))] - pub const HANDLE_MESSAGES: FunctionDef u32> = FunctionDef{address: 0x00418f97, function_type: PhantomData}; + pub const HANDLE_MESSAGES: FunctionDef i32> = FunctionDef{address: 0x00418f97, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/do_each_loop"))] - pub const DO_EACH_LOOP: FunctionDef = FunctionDef{address: 0x0041a5ff, function_type: PhantomData}; + pub const DO_EACH_LOOP: FunctionDef = FunctionDef{address: 0x0041a5ff, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/restart_graphics_mgr"))] - pub const RESTART_GRAPHICS_MGR: FunctionDef u32> = FunctionDef{address: 0x004ca9a4, function_type: PhantomData}; + pub const RESTART_GRAPHICS_MGR: FunctionDef u32> = FunctionDef{address: 0x004ca9a4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/toggle_fullscreen"))] - pub const TOGGLE_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d603b, function_type: PhantomData}; + pub const TOGGLE_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d603b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/resize_app"))] - pub const RESIZE_APP: FunctionDef u32> = FunctionDef{address: 0x004d6ce5, function_type: PhantomData}; + pub const RESIZE_APP: FunctionDef u32> = FunctionDef{address: 0x004d6ce5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/init_instance_0"))] - pub const INIT_INSTANCE_0: FunctionDef u32> = FunctionDef{address: 0x00533552, function_type: PhantomData}; + pub const INIT_INSTANCE_0: FunctionDef u32> = FunctionDef{address: 0x00533552, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x005786fb, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x005786fb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/get_sound"))] - pub const GET_SOUND: FunctionDef *const u32> = FunctionDef{address: 0x0057d5e1, function_type: PhantomData}; + pub const GET_SOUND: FunctionDef = FunctionDef{address: 0x0057d5e1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/exit_override"))] - pub const EXIT_OVERRIDE: FunctionDef = FunctionDef{address: 0x0057de27, function_type: PhantomData}; + pub const EXIT_OVERRIDE: FunctionDef = FunctionDef{address: 0x0057de27, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/bfgame_app"))] - pub const BFGAME_APP: FunctionDef *const u32> = FunctionDef{address: 0x00604487, function_type: PhantomData}; + pub const BFGAME_APP: FunctionDef u32> = FunctionDef{address: 0x00604487, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/init_instance_1"))] - pub const INIT_INSTANCE_1: FunctionDef = FunctionDef{address: 0x00620686, function_type: PhantomData}; + pub const INIT_INSTANCE_1: FunctionDef = FunctionDef{address: 0x00620686, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/get_update_time"))] - pub const GET_UPDATE_TIME: FunctionDef u32> = FunctionDef{address: 0x0062069f, function_type: PhantomData}; + pub const GET_UPDATE_TIME: FunctionDef = FunctionDef{address: 0x0062069f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/init_instance_2"))] - pub const INIT_INSTANCE_2: FunctionDef = FunctionDef{address: 0x006206a3, function_type: PhantomData}; + pub const INIT_INSTANCE_2: FunctionDef = FunctionDef{address: 0x006206a3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/load_typedata"))] - pub const LOAD_TYPEDATA: FunctionDef = FunctionDef{address: 0x006206d4, function_type: PhantomData}; + pub const LOAD_TYPEDATA: FunctionDef = FunctionDef{address: 0x006206d4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/get_update_handler"))] - pub const GET_UPDATE_HANDLER: FunctionDef *const u32> = FunctionDef{address: 0x00620708, function_type: PhantomData}; + pub const GET_UPDATE_HANDLER: FunctionDef u32> = FunctionDef{address: 0x00620708, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/inc_sim_speed"))] - pub const INC_SIM_SPEED: FunctionDef = FunctionDef{address: 0x00620745, function_type: PhantomData}; + pub const INC_SIM_SPEED: FunctionDef = FunctionDef{address: 0x00620745, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/dec_sim_speed"))] - pub const DEC_SIM_SPEED: FunctionDef = FunctionDef{address: 0x00620762, function_type: PhantomData}; + pub const DEC_SIM_SPEED: FunctionDef = FunctionDef{address: 0x00620762, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgameapp/reset_sim_speed"))] - pub const RESET_SIM_SPEED: FunctionDef = FunctionDef{address: 0x00620792, function_type: PhantomData}; + pub const RESET_SIM_SPEED: FunctionDef = FunctionDef{address: 0x00620792, function_type: PhantomData}; } // BFGameMgr class functions pub mod bfgamemgr { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("bfgamemgr/update_sim"))] - pub const UPDATE_SIM: FunctionDef = FunctionDef{address: 0x0043529d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgamemgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047aca5, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfgamemgr/bfgame_mgr"))] - pub const BFGAME_MGR: FunctionDef *const u32> = FunctionDef{address: 0x0057d7f5, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfgamemgr/set_new_game_defaults"))] - pub const SET_NEW_GAME_DEFAULTS: FunctionDef = FunctionDef{address: 0x00591a50, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgamemgr/load"))] - pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x00594cba, function_type: PhantomData}; + pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x00594cba, function_type: PhantomData}; } // BFGoal class functions @@ -610,15 +600,15 @@ pub mod bfgoal { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfgoal/set_goal_tile"))] - pub const SET_GOAL_TILE: FunctionDef = FunctionDef{address: 0x0042224d, function_type: PhantomData}; + pub const SET_GOAL_TILE: FunctionDef = FunctionDef{address: 0x0042224d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgoal/get_type"))] - pub const GET_TYPE: FunctionDef u32> = FunctionDef{address: 0x004781e5, function_type: PhantomData}; + pub const GET_TYPE: FunctionDef = FunctionDef{address: 0x004781e5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgoal/bfgoal"))] - pub const BFGOAL: FunctionDef *const u32> = FunctionDef{address: 0x004a4da2, function_type: PhantomData}; + pub const BFGOAL: FunctionDef u32> = FunctionDef{address: 0x004a4da2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgoal/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004a4e37, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004a4e37, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgoal/set_goal_target_pos"))] - pub const SET_GOAL_TARGET_POS: FunctionDef = FunctionDef{address: 0x004a722c, function_type: PhantomData}; + pub const SET_GOAL_TARGET_POS: FunctionDef = FunctionDef{address: 0x004a722c, function_type: PhantomData}; } // BFGoalFactory class functions @@ -626,15 +616,15 @@ pub mod bfgoalfactory { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfgoalfactory/create_0"))] - pub const CREATE_0: FunctionDef *const u32> = FunctionDef{address: 0x00413acd, function_type: PhantomData}; + pub const CREATE_0: FunctionDef u32> = FunctionDef{address: 0x00413acd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgoalfactory/create_1"))] - pub const CREATE_1: FunctionDef *const u32> = FunctionDef{address: 0x00413ba8, function_type: PhantomData}; + pub const CREATE_1: FunctionDef u32> = FunctionDef{address: 0x00413ba8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgoalfactory/constructor_0"))] - pub const CONSTRUCTOR_0: FunctionDef *const u32> = FunctionDef{address: 0x00502904, function_type: PhantomData}; + pub const CONSTRUCTOR_0: FunctionDef u32> = FunctionDef{address: 0x00502904, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgoalfactory/bfgoal_factory"))] - pub const BFGOAL_FACTORY: FunctionDef = FunctionDef{address: 0x0050290b, function_type: PhantomData}; + pub const BFGOAL_FACTORY: FunctionDef = FunctionDef{address: 0x0050290b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfgoalfactory/constructor_1"))] - pub const CONSTRUCTOR_1: FunctionDef *const u32> = FunctionDef{address: 0x00502915, function_type: PhantomData}; + pub const CONSTRUCTOR_1: FunctionDef u32> = FunctionDef{address: 0x00502915, function_type: PhantomData}; } // BFIniFile class functions @@ -642,9 +632,9 @@ pub mod bfinifile { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfinifile/read"))] - pub const READ: FunctionDef u32> = FunctionDef{address: 0x0041b55d, function_type: PhantomData}; + pub const READ: FunctionDef u32> = FunctionDef{address: 0x0041b55d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfinifile/write"))] - pub const WRITE: FunctionDef = FunctionDef{address: 0x004b298d, function_type: PhantomData}; + pub const WRITE: FunctionDef = FunctionDef{address: 0x004b298d, function_type: PhantomData}; } // BFLog class functions @@ -654,15 +644,15 @@ pub mod bflog { #[cfg_attr(feature = "detour-validation", validate_detour("bflog/log_message"))] pub const LOG_MESSAGE: FunctionDef = FunctionDef{address: 0x00401363, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bflog/constructor_0"))] - pub const CONSTRUCTOR_0: FunctionDef = FunctionDef{address: 0x00401386, function_type: PhantomData}; + pub const CONSTRUCTOR_0: FunctionDef = FunctionDef{address: 0x00401386, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bflog/constructor_1"))] - pub const CONSTRUCTOR_1: FunctionDef = FunctionDef{address: 0x0040514d, function_type: PhantomData}; + pub const CONSTRUCTOR_1: FunctionDef = FunctionDef{address: 0x0040514d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bflog/format_log_message"))] - pub const FORMAT_LOG_MESSAGE: FunctionDef u32> = FunctionDef{address: 0x0040667d, function_type: PhantomData}; + pub const FORMAT_LOG_MESSAGE: FunctionDef u32> = FunctionDef{address: 0x0040667d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bflog/process_log_options"))] - pub const PROCESS_LOG_OPTIONS: FunctionDef = FunctionDef{address: 0x0052b94a, function_type: PhantomData}; + pub const PROCESS_LOG_OPTIONS: FunctionDef = FunctionDef{address: 0x0052b94a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bflog/write_log_message"))] - pub const WRITE_LOG_MESSAGE: FunctionDef = FunctionDef{address: 0x0052b9a2, function_type: PhantomData}; + pub const WRITE_LOG_MESSAGE: FunctionDef = FunctionDef{address: 0x0052b9a2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bflog/set_log_level"))] pub const SET_LOG_LEVEL: FunctionDef = FunctionDef{address: 0x0052ba7b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bflog/write_log_to_file"))] @@ -674,119 +664,99 @@ pub mod bfmap { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/world_to_virtual_0"))] - pub const WORLD_TO_VIRTUAL_0: FunctionDef = FunctionDef{address: 0x0040f041, function_type: PhantomData}; + pub const WORLD_TO_VIRTUAL_0: FunctionDef = FunctionDef{address: 0x0040f041, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/tile_to_world"))] pub const TILE_TO_WORLD: FunctionDef *const i32> = FunctionDef{address: 0x0040f26c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_neighbor_0"))] - pub const GET_NEIGHBOR_0: FunctionDef u32> = FunctionDef{address: 0x0040fa92, function_type: PhantomData}; + pub const GET_NEIGHBOR_0: FunctionDef u32> = FunctionDef{address: 0x0040fa92, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_height_above_terrain"))] - pub const GET_HEIGHT_ABOVE_TERRAIN: FunctionDef i32> = FunctionDef{address: 0x00410183, function_type: PhantomData}; + pub const GET_HEIGHT_ABOVE_TERRAIN: FunctionDef i32> = FunctionDef{address: 0x00410183, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_direction_0"))] pub const GET_DIRECTION_0: FunctionDef i32> = FunctionDef{address: 0x00411654, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_direction_1"))] - pub const GET_DIRECTION_1: FunctionDef i32> = FunctionDef{address: 0x004116a9, function_type: PhantomData}; + pub const GET_DIRECTION_1: FunctionDef i32> = FunctionDef{address: 0x004116a9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/distance_cartesian"))] - pub const DISTANCE_CARTESIAN: FunctionDef i32> = FunctionDef{address: 0x0041180a, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/add_unit"))] - pub const ADD_UNIT: FunctionDef u32> = FunctionDef{address: 0x004137df, function_type: PhantomData}; + pub const DISTANCE_CARTESIAN: FunctionDef i32> = FunctionDef{address: 0x0041180a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/validate_not_blocked"))] - pub const VALIDATE_NOT_BLOCKED: FunctionDef u32> = FunctionDef{address: 0x00413f43, function_type: PhantomData}; + pub const VALIDATE_NOT_BLOCKED: FunctionDef u32> = FunctionDef{address: 0x00413f43, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/validate"))] - pub const VALIDATE: FunctionDef u32> = FunctionDef{address: 0x004140c6, function_type: PhantomData}; + pub const VALIDATE: FunctionDef u32> = FunctionDef{address: 0x004140c6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_neighbors"))] - pub const GET_NEIGHBORS: FunctionDef *const u32> = FunctionDef{address: 0x004171a1, function_type: PhantomData}; + pub const GET_NEIGHBORS: FunctionDef u32> = FunctionDef{address: 0x004171a1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_nearest_direction_0"))] - pub const GET_NEAREST_DIRECTION_0: FunctionDef u64> = FunctionDef{address: 0x00426c39, function_type: PhantomData}; + pub const GET_NEAREST_DIRECTION: FunctionDef u64> = FunctionDef{address: 0x00426c39, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_proper_direction"))] - pub const GET_PROPER_DIRECTION: FunctionDef *const c_void> = FunctionDef{address: 0x0042b79a, function_type: PhantomData}; + pub const GET_PROPER_DIRECTION: FunctionDef u32> = FunctionDef{address: 0x0042b79a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_neighbor_1"))] pub const GET_NEIGHBOR_1: FunctionDef u32> = FunctionDef{address: 0x00432236, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/draw"))] - pub const DRAW: FunctionDef = FunctionDef{address: 0x00432dcd, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_selection_for_drawing"))] - pub const GET_SELECTION_FOR_DRAWING: FunctionDef = FunctionDef{address: 0x00432e32, function_type: PhantomData}; + pub const DRAW: FunctionDef = FunctionDef{address: 0x00432dcd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_turning_direction"))] - pub const GET_TURNING_DIRECTION: FunctionDef i32> = FunctionDef{address: 0x0043a28c, function_type: PhantomData}; + pub const GET_TURNING_DIRECTION: FunctionDef i32> = FunctionDef{address: 0x0043a28c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/world_to_virtual_1"))] - pub const WORLD_TO_VIRTUAL_1: FunctionDef = FunctionDef{address: 0x004402ed, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_nearest_direction_1"))] - pub const GET_NEAREST_DIRECTION_1: FunctionDef u64> = FunctionDef{address: 0x00440b46, function_type: PhantomData}; + pub const WORLD_TO_VIRTUAL_1: FunctionDef = FunctionDef{address: 0x004402ed, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/virtual_to_world"))] - pub const VIRTUAL_TO_WORLD: FunctionDef = FunctionDef{address: 0x004441ab, function_type: PhantomData}; + pub const VIRTUAL_TO_WORLD: FunctionDef = FunctionDef{address: 0x004441ab, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/set_selection"))] - pub const SET_SELECTION: FunctionDef = FunctionDef{address: 0x004446f9, function_type: PhantomData}; + pub const SET_SELECTION: FunctionDef = FunctionDef{address: 0x004446f9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_selection"))] - pub const GET_SELECTION: FunctionDef = FunctionDef{address: 0x004447e5, function_type: PhantomData}; + pub const GET_SELECTION: FunctionDef = FunctionDef{address: 0x004447e5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/add_edge"))] - pub const ADD_EDGE: FunctionDef u32> = FunctionDef{address: 0x0044d4f8, function_type: PhantomData}; + pub const ADD_EDGE: FunctionDef u32> = FunctionDef{address: 0x0044d4f8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/save_tile_terrain"))] - pub const SAVE_TILE_TERRAIN: FunctionDef = FunctionDef{address: 0x00459245, function_type: PhantomData}; + pub const SAVE_TILE_TERRAIN: FunctionDef = FunctionDef{address: 0x00459245, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/adjust_cell"))] - pub const ADJUST_CELL: FunctionDef u32> = FunctionDef{address: 0x0045d935, function_type: PhantomData}; + pub const ADJUST_CELL: FunctionDef u32> = FunctionDef{address: 0x0045d935, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/adjust_cell_height"))] - pub const ADJUST_CELL_HEIGHT: FunctionDef = FunctionDef{address: 0x0045e04e, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/tile_in_selection"))] - pub const TILE_IN_SELECTION: FunctionDef i32> = FunctionDef{address: 0x0045e3c0, function_type: PhantomData}; + pub const ADJUST_CELL_HEIGHT: FunctionDef = FunctionDef{address: 0x0045e04e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004625af, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/adjust_left_neighbors"))] - pub const ADJUST_LEFT_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00481fa1, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/adjust_top_neighbors"))] - pub const ADJUST_TOP_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00482050, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/adjust_bottom_neighbors"))] - pub const ADJUST_BOTTOM_NEIGHBORS: FunctionDef = FunctionDef{address: 0x004820ff, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/adjust_right_neighbors"))] - pub const ADJUST_RIGHT_NEIGHBORS: FunctionDef = FunctionDef{address: 0x004822ab, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004625af, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/restore_terrain"))] - pub const RESTORE_TERRAIN: FunctionDef = FunctionDef{address: 0x00482978, function_type: PhantomData}; + pub const RESTORE_TERRAIN: FunctionDef = FunctionDef{address: 0x00482978, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/copy_full_to_single_tile_terrain"))] - pub const COPY_FULL_TO_SINGLE_TILE_TERRAIN: FunctionDef = FunctionDef{address: 0x00488fc7, function_type: PhantomData}; + pub const COPY_FULL_TO_SINGLE_TILE_TERRAIN: FunctionDef = FunctionDef{address: 0x00488fc7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_changed_elevations"))] - pub const GET_CHANGED_ELEVATIONS: FunctionDef *const u32> = FunctionDef{address: 0x004891d3, function_type: PhantomData}; + pub const GET_CHANGED_ELEVATIONS: FunctionDef u32> = FunctionDef{address: 0x004891d3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/set_height_above_terrain"))] - pub const SET_HEIGHT_ABOVE_TERRAIN: FunctionDef = FunctionDef{address: 0x00492a9f, function_type: PhantomData}; + pub const SET_HEIGHT_ABOVE_TERRAIN: FunctionDef = FunctionDef{address: 0x00492a9f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/draw_sorter_entity"))] - pub const DRAW_SORTER_ENTITY: FunctionDef = FunctionDef{address: 0x004a7272, function_type: PhantomData}; + pub const DRAW_SORTER_ENTITY: FunctionDef = FunctionDef{address: 0x004a7272, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/move_entity"))] - pub const MOVE_ENTITY: FunctionDef = FunctionDef{address: 0x004a746a, function_type: PhantomData}; + pub const MOVE_ENTITY: FunctionDef = FunctionDef{address: 0x004a746a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/compute_tiles"))] - pub const COMPUTE_TILES: FunctionDef = FunctionDef{address: 0x004af165, function_type: PhantomData}; + pub const COMPUTE_TILES: FunctionDef = FunctionDef{address: 0x004af165, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/set_zoom"))] - pub const SET_ZOOM: FunctionDef = FunctionDef{address: 0x004af19c, function_type: PhantomData}; + pub const SET_ZOOM: FunctionDef = FunctionDef{address: 0x004af19c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/clear"))] - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6b83, function_type: PhantomData}; + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6b83, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/set_map_dimensions"))] - pub const SET_MAP_DIMENSIONS: FunctionDef = FunctionDef{address: 0x004c84d3, function_type: PhantomData}; + pub const SET_MAP_DIMENSIONS: FunctionDef = FunctionDef{address: 0x004c84d3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004c8782, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004c8782, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/update_terrain_cost"))] - pub const UPDATE_TERRAIN_COST: FunctionDef f32> = FunctionDef{address: 0x004d9c0f, function_type: PhantomData}; + pub const UPDATE_TERRAIN_COST: FunctionDef f32> = FunctionDef{address: 0x004d9c0f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_terrain_paint_cost"))] - pub const GET_TERRAIN_PAINT_COST: FunctionDef f32> = FunctionDef{address: 0x004dc8a4, function_type: PhantomData}; + pub const GET_TERRAIN_PAINT_COST: FunctionDef f32> = FunctionDef{address: 0x004dc8a4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/add_entity"))] - pub const ADD_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004f3e7d, function_type: PhantomData}; + pub const ADD_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004f3e7d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/can_paint"))] - pub const CAN_PAINT: FunctionDef u32> = FunctionDef{address: 0x004f8f0b, function_type: PhantomData}; + pub const CAN_PAINT: FunctionDef u32> = FunctionDef{address: 0x004f8f0b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/paint_cell"))] - pub const PAINT_CELL: FunctionDef u32> = FunctionDef{address: 0x004f8fd8, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/add_shadow"))] - pub const ADD_SHADOW: FunctionDef u32> = FunctionDef{address: 0x004fc088, function_type: PhantomData}; + pub const PAINT_CELL: FunctionDef u32> = FunctionDef{address: 0x004f8fd8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/remove_entity"))] - pub const REMOVE_ENTITY: FunctionDef = FunctionDef{address: 0x004fe639, function_type: PhantomData}; + pub const REMOVE_ENTITY: FunctionDef = FunctionDef{address: 0x004fe639, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/remove_edge"))] - pub const REMOVE_EDGE: FunctionDef = FunctionDef{address: 0x004ffdd8, function_type: PhantomData}; + pub const REMOVE_EDGE: FunctionDef = FunctionDef{address: 0x004ffdd8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/validate_neighbors"))] - pub const VALIDATE_NEIGHBORS: FunctionDef u32> = FunctionDef{address: 0x0052d76a, function_type: PhantomData}; + pub const VALIDATE_NEIGHBORS: FunctionDef u32> = FunctionDef{address: 0x0052d76a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/validate_tiles"))] - pub const VALIDATE_TILES: FunctionDef = FunctionDef{address: 0x005b302a, function_type: PhantomData}; + pub const VALIDATE_TILES: FunctionDef = FunctionDef{address: 0x005b302a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/clear_tile_terrain"))] - pub const CLEAR_TILE_TERRAIN: FunctionDef = FunctionDef{address: 0x005b342e, function_type: PhantomData}; + pub const CLEAR_TILE_TERRAIN: FunctionDef = FunctionDef{address: 0x005b342e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/get_all_neighbors"))] - pub const GET_ALL_NEIGHBORS: FunctionDef *const u32> = FunctionDef{address: 0x005b3835, function_type: PhantomData}; + pub const GET_ALL_NEIGHBORS: FunctionDef u32> = FunctionDef{address: 0x005b3835, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/clear_saved_path"))] - pub const CLEAR_SAVED_PATH: FunctionDef = FunctionDef{address: 0x00600414, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfmap/move_entity_delta"))] - pub const MOVE_ENTITY_DELTA: FunctionDef = FunctionDef{address: 0x006005c3, function_type: PhantomData}; + pub const CLEAR_SAVED_PATH: FunctionDef = FunctionDef{address: 0x00600414, function_type: PhantomData}; } // BFMgr class functions @@ -794,9 +764,9 @@ pub mod bfmgr { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfmgr/lookup"))] - pub const LOOKUP: FunctionDef u32> = FunctionDef{address: 0x004bdd7a, function_type: PhantomData}; + pub const LOOKUP: FunctionDef u32> = FunctionDef{address: 0x004bdd7a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmgr/create_manager"))] - pub const CREATE_MANAGER: FunctionDef u32> = FunctionDef{address: 0x004bdd91, function_type: PhantomData}; + pub const CREATE_MANAGER: FunctionDef u32> = FunctionDef{address: 0x004bdd91, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfmgr/registerit"))] pub const REGISTERIT: FunctionDef u32> = FunctionDef{address: 0x005770e5, function_type: PhantomData}; } @@ -806,7 +776,7 @@ pub mod bfmovemod { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfmovemod/bfmove_mod"))] - pub const BFMOVE_MOD: FunctionDef *const u32> = FunctionDef{address: 0x004f9be0, function_type: PhantomData}; + pub const BFMOVE_MOD: FunctionDef u32> = FunctionDef{address: 0x004f9be0, function_type: PhantomData}; } // BFOldSubGoal class functions @@ -814,7 +784,7 @@ pub mod bfoldsubgoal { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfoldsubgoal/unknown_method"))] - pub const UNKNOWN_METHOD: FunctionDef *const u32> = FunctionDef{address: 0x00413a43, function_type: PhantomData}; + pub const UNKNOWN_METHOD: FunctionDef u32> = FunctionDef{address: 0x00413a43, function_type: PhantomData}; } // BFOverlay class functions @@ -822,19 +792,19 @@ pub mod bfoverlay { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlay/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x00420565, function_type: PhantomData}; + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x00420565, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlay/bfoverlay_0"))] - pub const BFOVERLAY_0: FunctionDef *const u32> = FunctionDef{address: 0x00420589, function_type: PhantomData}; + pub const BFOVERLAY_0: FunctionDef u32> = FunctionDef{address: 0x00420589, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlay/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0045024d, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0045024d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlay/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047a7ee, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlay/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004fc391, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004fc391, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlay/add_to_map"))] - pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x004fc3cd, function_type: PhantomData}; + pub const ADD_TO_MAP: FunctionDef = FunctionDef{address: 0x004fc3cd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlay/bfoverlay_1"))] - pub const BFOVERLAY_1: FunctionDef *const u32> = FunctionDef{address: 0x00624292, function_type: PhantomData}; + pub const BFOVERLAY_1: FunctionDef u32> = FunctionDef{address: 0x00624292, function_type: PhantomData}; } // BFOverlayType class functions @@ -842,11 +812,11 @@ pub mod bfoverlaytype { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlaytype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051cd5e, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051cd5e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlaytype/bfoverlay_type"))] - pub const BFOVERLAY_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x0057cc7a, function_type: PhantomData}; + pub const BFOVERLAY_TYPE: FunctionDef u32> = FunctionDef{address: 0x0057cc7a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfoverlaytype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x00624270, function_type: PhantomData}; + pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x00624270, function_type: PhantomData}; } // BFPathFinder class functions @@ -854,25 +824,25 @@ pub mod bfpathfinder { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/clear_lists"))] - pub const CLEAR_LISTS: FunctionDef = FunctionDef{address: 0x0041194a, function_type: PhantomData}; + pub const CLEAR_LISTS: FunctionDef = FunctionDef{address: 0x0041194a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/make_id"))] - pub const MAKE_ID: FunctionDef = FunctionDef{address: 0x00411a56, function_type: PhantomData}; + pub const MAKE_ID: FunctionDef = FunctionDef{address: 0x00411a56, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/find_path"))] - pub const FIND_PATH: FunctionDef u32> = FunctionDef{address: 0x00414d3f, function_type: PhantomData}; + pub const FIND_PATH: FunctionDef u32> = FunctionDef{address: 0x00414d3f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/validate"))] - pub const VALIDATE: FunctionDef u32> = FunctionDef{address: 0x00414fef, function_type: PhantomData}; + pub const VALIDATE: FunctionDef = FunctionDef{address: 0x00414fef, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/estimate"))] - pub const ESTIMATE: FunctionDef f32> = FunctionDef{address: 0x00415247, function_type: PhantomData}; + pub const ESTIMATE: FunctionDef f32> = FunctionDef{address: 0x00415247, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/cost"))] - pub const COST: FunctionDef f32> = FunctionDef{address: 0x004153e3, function_type: PhantomData}; + pub const COST: FunctionDef f32> = FunctionDef{address: 0x004153e3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/set_node_max"))] - pub const SET_NODE_MAX: FunctionDef = FunctionDef{address: 0x004c680d, function_type: PhantomData}; + pub const SET_NODE_MAX: FunctionDef = FunctionDef{address: 0x004c680d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/bfpath_finder"))] - pub const BFPATH_FINDER: FunctionDef *const u32> = FunctionDef{address: 0x00503905, function_type: PhantomData}; + pub const BFPATH_FINDER: FunctionDef u32> = FunctionDef{address: 0x00503905, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/init"))] - pub const INIT: FunctionDef = FunctionDef{address: 0x005265a6, function_type: PhantomData}; + pub const INIT: FunctionDef = FunctionDef{address: 0x005265a6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinder/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0052669c, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0052669c, function_type: PhantomData}; } // BFPathFinderInfo class functions @@ -880,7 +850,7 @@ pub mod bfpathfinderinfo { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinderinfo/init"))] - pub const INIT: FunctionDef u32> = FunctionDef{address: 0x0052609a, function_type: PhantomData}; + pub const INIT: FunctionDef u32> = FunctionDef{address: 0x0052609a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfpathfinderinfo/get"))] pub const GET: FunctionDef u32> = FunctionDef{address: 0x00526573, function_type: PhantomData}; } @@ -890,13 +860,13 @@ pub mod bfregistry { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfregistry/get"))] - pub const GET: FunctionDef *const u32> = FunctionDef{address: 0x004bdca9, function_type: PhantomData}; + pub const GET: FunctionDef u32> = FunctionDef{address: 0x004bdca9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfregistry/find"))] - pub const FIND: FunctionDef u32> = FunctionDef{address: 0x004bdcbf, function_type: PhantomData}; + pub const FIND: FunctionDef u32> = FunctionDef{address: 0x004bdcbf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfregistry/ptr_get"))] pub const PTR_GET: FunctionDef u32> = FunctionDef{address: 0x004bdd22, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfregistry/reg"))] - pub const REG: FunctionDef u32> = FunctionDef{address: 0x0057766f, function_type: PhantomData}; + pub const REG: FunctionDef u32> = FunctionDef{address: 0x0057766f, function_type: PhantomData}; } // BFResource class functions @@ -904,37 +874,31 @@ pub mod bfresource { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/release_0"))] - pub const RELEASE_0: FunctionDef = FunctionDef{address: 0x00402e14, function_type: PhantomData}; + pub const RELEASE_0: FunctionDef = FunctionDef{address: 0x00402e14, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/set_handle_0"))] - pub const SET_HANDLE_0: FunctionDef = FunctionDef{address: 0x00402e1d, function_type: PhantomData}; + pub const SET_HANDLE_0: FunctionDef = FunctionDef{address: 0x00402e1d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/attempt"))] pub const ATTEMPT: FunctionDef bool> = FunctionDef{address: 0x00403891, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/set_handle_1"))] - pub const SET_HANDLE_1: FunctionDef = FunctionDef{address: 0x004038af, function_type: PhantomData}; + pub const SET_HANDLE_1: FunctionDef = FunctionDef{address: 0x004038af, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/prepare"))] pub const PREPARE: FunctionDef bool> = FunctionDef{address: 0x004047f4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/set_handle_2"))] - pub const SET_HANDLE_2: FunctionDef = FunctionDef{address: 0x00404812, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/release_1"))] - pub const RELEASE_1: FunctionDef = FunctionDef{address: 0x004072b0, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/set_handle_3"))] - pub const SET_HANDLE_3: FunctionDef = FunctionDef{address: 0x004072b9, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/set_handle_4"))] - pub const SET_HANDLE_4: FunctionDef = FunctionDef{address: 0x00407306, function_type: PhantomData}; + pub const SET_HANDLE_2: FunctionDef = FunctionDef{address: 0x00404812, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/release_2"))] - pub const RELEASE_2: FunctionDef = FunctionDef{address: 0x0040bc8a, function_type: PhantomData}; + pub const RELEASE_1: FunctionDef = FunctionDef{address: 0x0040bc8a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/set_handle_5"))] - pub const SET_HANDLE_5: FunctionDef = FunctionDef{address: 0x0040bc93, function_type: PhantomData}; + pub const SET_HANDLE_3: FunctionDef = FunctionDef{address: 0x0040bc93, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/create_memory"))] - pub const CREATE_MEMORY: FunctionDef = FunctionDef{address: 0x004ad366, function_type: PhantomData}; + pub const CREATE_MEMORY: FunctionDef = FunctionDef{address: 0x004ad366, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/find_0"))] - pub const FIND_0: FunctionDef *const c_void> = FunctionDef{address: 0x004b41f2, function_type: PhantomData}; + pub const FIND_0: FunctionDef u32> = FunctionDef{address: 0x004b41f2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/find_1"))] - pub const FIND_1: FunctionDef *const c_void> = FunctionDef{address: 0x004bf910, function_type: PhantomData}; + pub const FIND_1: FunctionDef u32> = FunctionDef{address: 0x004bf910, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/shutdown"))] pub const SHUTDOWN: FunctionDef = FunctionDef{address: 0x0057e084, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresource/acquire"))] - pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x005fed7c, function_type: PhantomData}; + pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x005fed7c, function_type: PhantomData}; } // BFResourceDir class functions @@ -942,29 +906,29 @@ pub mod bfresourcedir { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/find_file"))] - pub const FIND_FILE: FunctionDef *const u8> = FunctionDef{address: 0x00403a59, function_type: PhantomData}; + pub const FIND_FILE: FunctionDef u32> = FunctionDef{address: 0x00403a59, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00403b82, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00403b82, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/prepare"))] - pub const PREPARE: FunctionDef u32> = FunctionDef{address: 0x00404926, function_type: PhantomData}; + pub const PREPARE: FunctionDef u32> = FunctionDef{address: 0x00404926, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/valid"))] - pub const VALID: FunctionDef u8> = FunctionDef{address: 0x00404fc8, function_type: PhantomData}; + pub const VALID: FunctionDef = FunctionDef{address: 0x00404fc8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/find_0"))] - pub const FIND_0: FunctionDef *const i32> = FunctionDef{address: 0x004b9e9f, function_type: PhantomData}; + pub const FIND_0: FunctionDef u32> = FunctionDef{address: 0x004b9e9f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/find_1"))] - pub const FIND_1: FunctionDef *const i32> = FunctionDef{address: 0x004bfc2f, function_type: PhantomData}; + pub const FIND_1: FunctionDef u32> = FunctionDef{address: 0x004bfc2f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/bfresource_dir_0"))] - pub const BFRESOURCE_DIR_0: FunctionDef *const u32> = FunctionDef{address: 0x004cbe92, function_type: PhantomData}; + pub const BFRESOURCE_DIR_0: FunctionDef u32> = FunctionDef{address: 0x004cbe92, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/bfresource_dir_1"))] - pub const BFRESOURCE_DIR_1: FunctionDef *const u32> = FunctionDef{address: 0x004cbff4, function_type: PhantomData}; + pub const BFRESOURCE_DIR_1: FunctionDef u32> = FunctionDef{address: 0x004cbff4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00529464, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00529464, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/tree_search"))] - pub const TREE_SEARCH: FunctionDef *const c_void> = FunctionDef{address: 0x00529796, function_type: PhantomData}; + pub const TREE_SEARCH: FunctionDef u32> = FunctionDef{address: 0x00529796, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/name"))] - pub const NAME: FunctionDef u32> = FunctionDef{address: 0x006030a0, function_type: PhantomData}; + pub const NAME: FunctionDef = FunctionDef{address: 0x006030a0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcedir/index"))] - pub const INDEX: FunctionDef *const u32> = FunctionDef{address: 0x006030a4, function_type: PhantomData}; + pub const INDEX: FunctionDef u32> = FunctionDef{address: 0x006030a4, function_type: PhantomData}; } // BFResourceMgr class functions @@ -974,25 +938,25 @@ pub mod bfresourcemgr { #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/get"))] pub const GET: FunctionDef u32> = FunctionDef{address: 0x00402e76, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00403817, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00403817, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/get_resource_ptr"))] - pub const GET_RESOURCE_PTR: FunctionDef i32> = FunctionDef{address: 0x004038f5, function_type: PhantomData}; + pub const GET_RESOURCE_PTR: FunctionDef i32> = FunctionDef{address: 0x004038f5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/make_name"))] - pub const MAKE_NAME: FunctionDef u32> = FunctionDef{address: 0x00403993, function_type: PhantomData}; + pub const MAKE_NAME: FunctionDef u32> = FunctionDef{address: 0x00403993, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/prepare"))] - pub const PREPARE: FunctionDef u32> = FunctionDef{address: 0x00404855, function_type: PhantomData}; + pub const PREPARE: FunctionDef u32> = FunctionDef{address: 0x00404855, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/create_memory"))] - pub const CREATE_MEMORY: FunctionDef *const u32> = FunctionDef{address: 0x004ad2fc, function_type: PhantomData}; + pub const CREATE_MEMORY: FunctionDef u32> = FunctionDef{address: 0x004ad2fc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/find_0"))] - pub const FIND_0: FunctionDef *const c_void> = FunctionDef{address: 0x004b9a40, function_type: PhantomData}; + pub const FIND_0: FunctionDef u32> = FunctionDef{address: 0x004b9a40, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/find_1"))] - pub const FIND_1: FunctionDef *const c_void> = FunctionDef{address: 0x004bf92b, function_type: PhantomData}; + pub const FIND_1: FunctionDef u32> = FunctionDef{address: 0x004bf92b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/add_path"))] pub const ADD_PATH: FunctionDef u32> = FunctionDef{address: 0x0052870b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/constructor"))] pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0052903f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/shutdown"))] - pub const SHUTDOWN: FunctionDef = FunctionDef{address: 0x0057e0c4, function_type: PhantomData}; + pub const SHUTDOWN: FunctionDef = FunctionDef{address: 0x0057e0c4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcemgr/bfresource_mgr"))] pub const BFRESOURCE_MGR: FunctionDef = FunctionDef{address: 0x0057e827, function_type: PhantomData}; } @@ -1008,13 +972,13 @@ pub mod bfresourceptr { #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_2"))] pub const DELREF_2: FunctionDef = FunctionDef{address: 0x00402e6a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/deallocate"))] - pub const DEALLOCATE: FunctionDef = FunctionDef{address: 0x00402ec7, function_type: PhantomData}; + pub const DEALLOCATE: FunctionDef = FunctionDef{address: 0x00402ec7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_3"))] pub const DELREF_3: FunctionDef = FunctionDef{address: 0x00402f76, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_4"))] pub const DELREF_4: FunctionDef = FunctionDef{address: 0x004038d9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/allocate"))] - pub const ALLOCATE: FunctionDef = FunctionDef{address: 0x004043f4, function_type: PhantomData}; + pub const ALLOCATE: FunctionDef = FunctionDef{address: 0x004043f4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_5"))] pub const DELREF_5: FunctionDef = FunctionDef{address: 0x0040483c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourceptr/delref_6"))] @@ -1072,25 +1036,25 @@ pub mod bfresourcezip { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/find_offset"))] - pub const FIND_OFFSET: FunctionDef i32> = FunctionDef{address: 0x00403a1c, function_type: PhantomData}; + pub const FIND_OFFSET: FunctionDef i32> = FunctionDef{address: 0x00403a1c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/load"))] - pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x00403b43, function_type: PhantomData}; + pub const LOAD: FunctionDef = FunctionDef{address: 0x00403b43, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/prepare"))] - pub const PREPARE: FunctionDef u32> = FunctionDef{address: 0x004048da, function_type: PhantomData}; + pub const PREPARE: FunctionDef u32> = FunctionDef{address: 0x004048da, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/find_0"))] - pub const FIND_0: FunctionDef *const i32> = FunctionDef{address: 0x004b9b73, function_type: PhantomData}; + pub const FIND_0: FunctionDef u32> = FunctionDef{address: 0x004b9b73, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/find_1"))] - pub const FIND_1: FunctionDef *const i32> = FunctionDef{address: 0x004bf9fb, function_type: PhantomData}; + pub const FIND_1: FunctionDef u32> = FunctionDef{address: 0x004bf9fb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00528ac1, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00528ac1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/valid"))] - pub const VALID: FunctionDef bool> = FunctionDef{address: 0x00528f94, function_type: PhantomData}; + pub const VALID: FunctionDef = FunctionDef{address: 0x00528f94, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/bfresource_zip_0"))] - pub const BFRESOURCE_ZIP_0: FunctionDef *const u32> = FunctionDef{address: 0x0057e21f, function_type: PhantomData}; + pub const BFRESOURCE_ZIP_0: FunctionDef u32> = FunctionDef{address: 0x0057e21f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/bfresource_zip_1"))] - pub const BFRESOURCE_ZIP_1: FunctionDef *const u32> = FunctionDef{address: 0x0057e351, function_type: PhantomData}; + pub const BFRESOURCE_ZIP_1: FunctionDef u32> = FunctionDef{address: 0x0057e351, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfresourcezip/index"))] - pub const INDEX: FunctionDef *const i32> = FunctionDef{address: 0x00602f65, function_type: PhantomData}; + pub const INDEX: FunctionDef u32> = FunctionDef{address: 0x00602f65, function_type: PhantomData}; } // BFScenarioMgr class functions @@ -1098,23 +1062,23 @@ pub mod bfscenariomgr { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00435a48, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00435a48, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/get_expansion_id"))] - pub const GET_EXPANSION_ID: FunctionDef u32> = FunctionDef{address: 0x00453530, function_type: PhantomData}; + pub const GET_EXPANSION_ID: FunctionDef u32> = FunctionDef{address: 0x00453530, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/end_scenario"))] - pub const END_SCENARIO: FunctionDef u32> = FunctionDef{address: 0x0048a726, function_type: PhantomData}; + pub const END_SCENARIO: FunctionDef u32> = FunctionDef{address: 0x0048a726, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/bfscenario_mgr"))] - pub const BFSCENARIO_MGR: FunctionDef *const u32> = FunctionDef{address: 0x00504e6a, function_type: PhantomData}; + pub const BFSCENARIO_MGR: FunctionDef u32> = FunctionDef{address: 0x00504e6a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0052428d, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0052428d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/get_crowd_ambients_name"))] - pub const GET_CROWD_AMBIENTS_NAME: FunctionDef *const u8> = FunctionDef{address: 0x00592632, function_type: PhantomData}; + pub const GET_CROWD_AMBIENTS_NAME: FunctionDef u32> = FunctionDef{address: 0x00592632, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/get_world_ambients_name"))] - pub const GET_WORLD_AMBIENTS_NAME: FunctionDef *const u8> = FunctionDef{address: 0x00592659, function_type: PhantomData}; + pub const GET_WORLD_AMBIENTS_NAME: FunctionDef u32> = FunctionDef{address: 0x00592659, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/get_crowd_config_name"))] - pub const GET_CROWD_CONFIG_NAME: FunctionDef *const u8> = FunctionDef{address: 0x00592680, function_type: PhantomData}; + pub const GET_CROWD_CONFIG_NAME: FunctionDef u32> = FunctionDef{address: 0x00592680, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/get_world_config_name"))] - pub const GET_WORLD_CONFIG_NAME: FunctionDef *const u8> = FunctionDef{address: 0x005926a7, function_type: PhantomData}; + pub const GET_WORLD_CONFIG_NAME: FunctionDef u32> = FunctionDef{address: 0x005926a7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfscenariomgr/unlock_all_scenarios"))] pub const UNLOCK_ALL_SCENARIOS: FunctionDef = FunctionDef{address: 0x006000d3, function_type: PhantomData}; } @@ -1124,7 +1088,7 @@ pub mod bfterrainimage { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfterrainimage/compute_image_size"))] - pub const COMPUTE_IMAGE_SIZE: FunctionDef = FunctionDef{address: 0x004aee5a, function_type: PhantomData}; + pub const COMPUTE_IMAGE_SIZE: FunctionDef = FunctionDef{address: 0x004aee5a, function_type: PhantomData}; } // BFTerrainMgr class functions @@ -1132,7 +1096,7 @@ pub mod bfterrainmgr { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfterrainmgr/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0052560a, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0052560a, function_type: PhantomData}; } // BFTerrainTypeInfo class functions @@ -1140,23 +1104,21 @@ pub mod bfterraintypeinfo { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfterraintypeinfo/initialize"))] - pub const INITIALIZE: FunctionDef *const i16> = FunctionDef{address: 0x00523c58, function_type: PhantomData}; + pub const INITIALIZE: FunctionDef u32> = FunctionDef{address: 0x00523c58, function_type: PhantomData}; } // BFText class functions pub mod bftext { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("bftext/length_in_bytes"))] - pub const LENGTH_IN_BYTES: FunctionDef i32> = FunctionDef{address: 0x00401523, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftext/length_in_characters"))] - pub const LENGTH_IN_CHARACTERS: FunctionDef = FunctionDef{address: 0x00418ccf, function_type: PhantomData}; + pub const LENGTH_IN_CHARACTERS: FunctionDef = FunctionDef{address: 0x00418ccf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftext/convert_to_bytes"))] - pub const CONVERT_TO_BYTES: FunctionDef = FunctionDef{address: 0x004ec1e3, function_type: PhantomData}; + pub const CONVERT_TO_BYTES: FunctionDef = FunctionDef{address: 0x004ec1e3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftext/substr"))] - pub const SUBSTR: FunctionDef *const i16> = FunctionDef{address: 0x004ec280, function_type: PhantomData}; + pub const SUBSTR: FunctionDef u32> = FunctionDef{address: 0x004ec280, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftext/erase"))] - pub const ERASE: FunctionDef *const i32> = FunctionDef{address: 0x006242b0, function_type: PhantomData}; + pub const ERASE: FunctionDef u32> = FunctionDef{address: 0x006242b0, function_type: PhantomData}; } // BFTile class functions @@ -1166,43 +1128,37 @@ pub mod bftile { #[cfg_attr(feature = "detour-validation", validate_detour("bftile/get_local_elevation"))] pub const GET_LOCAL_ELEVATION: FunctionDef i32> = FunctionDef{address: 0x0040f24d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/get_corner_elevation"))] - pub const GET_CORNER_ELEVATION: FunctionDef i32> = FunctionDef{address: 0x0040f4f9, function_type: PhantomData}; + pub const GET_CORNER_ELEVATION: FunctionDef i32> = FunctionDef{address: 0x0040f4f9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/is_in_zoo"))] - pub const IS_IN_ZOO: FunctionDef u32> = FunctionDef{address: 0x0040fb8d, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bftile/add_unit"))] - pub const ADD_UNIT: FunctionDef = FunctionDef{address: 0x00410b0f, function_type: PhantomData}; + pub const IS_IN_ZOO: FunctionDef u32> = FunctionDef{address: 0x0040fb8d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/validate_positions"))] - pub const VALIDATE_POSITIONS: FunctionDef = FunctionDef{address: 0x0044a0bf, function_type: PhantomData}; + pub const VALIDATE_POSITIONS: FunctionDef = FunctionDef{address: 0x0044a0bf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/get_max_elevation"))] - pub const GET_MAX_ELEVATION: FunctionDef i32> = FunctionDef{address: 0x0045d8b5, function_type: PhantomData}; + pub const GET_MAX_ELEVATION: FunctionDef i32> = FunctionDef{address: 0x0045d8b5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/can_change_elevation"))] - pub const CAN_CHANGE_ELEVATION: FunctionDef = FunctionDef{address: 0x0045d92d, function_type: PhantomData}; + pub const CAN_CHANGE_ELEVATION: FunctionDef = FunctionDef{address: 0x0045d92d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/can_change_shape"))] - pub const CAN_CHANGE_SHAPE: FunctionDef u32> = FunctionDef{address: 0x0045e028, function_type: PhantomData}; + pub const CAN_CHANGE_SHAPE: FunctionDef u32> = FunctionDef{address: 0x0045e028, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/raise"))] - pub const RAISE: FunctionDef = FunctionDef{address: 0x0045e416, function_type: PhantomData}; + pub const RAISE: FunctionDef = FunctionDef{address: 0x0045e416, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/lower"))] - pub const LOWER: FunctionDef = FunctionDef{address: 0x0045e70f, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bftile/adjust_corner"))] - pub const ADJUST_CORNER: FunctionDef u32> = FunctionDef{address: 0x0048235a, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bftile/set_corner_elevation"))] - pub const SET_CORNER_ELEVATION: FunctionDef u32> = FunctionDef{address: 0x00482485, function_type: PhantomData}; + pub const LOWER: FunctionDef = FunctionDef{address: 0x0045e70f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/get_min_elevation"))] - pub const GET_MIN_ELEVATION: FunctionDef i32> = FunctionDef{address: 0x00492d80, function_type: PhantomData}; + pub const GET_MIN_ELEVATION: FunctionDef i32> = FunctionDef{address: 0x00492d80, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/snap_to_edge"))] - pub const SNAP_TO_EDGE: FunctionDef = FunctionDef{address: 0x0049336d, function_type: PhantomData}; + pub const SNAP_TO_EDGE: FunctionDef = FunctionDef{address: 0x0049336d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/calculate_shape"))] - pub const CALCULATE_SHAPE: FunctionDef = FunctionDef{address: 0x004aea12, function_type: PhantomData}; + pub const CALCULATE_SHAPE: FunctionDef = FunctionDef{address: 0x004aea12, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/clear"))] - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6964, function_type: PhantomData}; + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6964, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/remove_all_edges"))] - pub const REMOVE_ALL_EDGES: FunctionDef = FunctionDef{address: 0x004c6a17, function_type: PhantomData}; + pub const REMOVE_ALL_EDGES: FunctionDef = FunctionDef{address: 0x004c6a17, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004c864e, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004c864e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/remove_edge"))] - pub const REMOVE_EDGE: FunctionDef u32> = FunctionDef{address: 0x004f165b, function_type: PhantomData}; + pub const REMOVE_EDGE: FunctionDef u32> = FunctionDef{address: 0x004f165b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bftile/set_terrain_type"))] - pub const SET_TERRAIN_TYPE: FunctionDef = FunctionDef{address: 0x004f17e0, function_type: PhantomData}; + pub const SET_TERRAIN_TYPE: FunctionDef = FunctionDef{address: 0x004f17e0, function_type: PhantomData}; } // BFUIMgr class functions @@ -1212,7 +1168,7 @@ pub mod bfuimgr { #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/get_element_0"))] pub const GET_ELEMENT_0: FunctionDef u32> = FunctionDef{address: 0x0040157d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/set_control_fore_color"))] - pub const SET_CONTROL_FORE_COLOR: FunctionDef = FunctionDef{address: 0x0040ee08, function_type: PhantomData}; + pub const SET_CONTROL_FORE_COLOR: FunctionDef = FunctionDef{address: 0x0040ee08, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/set_cursor"))] pub const SET_CURSOR: FunctionDef = FunctionDef{address: 0x00418e81, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/hide_busy_cursor"))] @@ -1220,39 +1176,39 @@ pub mod bfuimgr { #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/show_busy_cursor"))] pub const SHOW_BUSY_CURSOR: FunctionDef = FunctionDef{address: 0x00418f43, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/draw"))] - pub const DRAW: FunctionDef u32> = FunctionDef{address: 0x004193d8, function_type: PhantomData}; + pub const DRAW: FunctionDef u32> = FunctionDef{address: 0x004193d8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a16b, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a16b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/prepare_to_hide_element"))] - pub const PREPARE_TO_HIDE_ELEMENT: FunctionDef = FunctionDef{address: 0x0041ac35, function_type: PhantomData}; + pub const PREPARE_TO_HIDE_ELEMENT: FunctionDef = FunctionDef{address: 0x0041ac35, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/remove_timer_element"))] - pub const REMOVE_TIMER_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x0041ad6a, function_type: PhantomData}; + pub const REMOVE_TIMER_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x0041ad6a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/display_help_0"))] pub const DISPLAY_HELP_0: FunctionDef = FunctionDef{address: 0x0041b100, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/handle_messages"))] - pub const HANDLE_MESSAGES: FunctionDef i32> = FunctionDef{address: 0x00441d7b, function_type: PhantomData}; + pub const HANDLE_MESSAGES: FunctionDef i32> = FunctionDef{address: 0x00441d7b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/get_element_1"))] - pub const GET_ELEMENT_1: FunctionDef *const c_void> = FunctionDef{address: 0x0044232b, function_type: PhantomData}; + pub const GET_ELEMENT_1: FunctionDef u32> = FunctionDef{address: 0x0044232b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/get_max_tooltip_width"))] pub const GET_MAX_TOOLTIP_WIDTH: FunctionDef u32> = FunctionDef{address: 0x00442d19, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/focus_control"))] - pub const FOCUS_CONTROL: FunctionDef = FunctionDef{address: 0x0044316b, function_type: PhantomData}; + pub const FOCUS_CONTROL: FunctionDef = FunctionDef{address: 0x0044316b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/capture_element"))] - pub const CAPTURE_ELEMENT: FunctionDef = FunctionDef{address: 0x00443560, function_type: PhantomData}; + pub const CAPTURE_ELEMENT: FunctionDef = FunctionDef{address: 0x00443560, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/deselect_element"))] pub const DESELECT_ELEMENT: FunctionDef = FunctionDef{address: 0x00443dd0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/enable_element"))] pub const ENABLE_ELEMENT: FunctionDef = FunctionDef{address: 0x00443e3e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/translate_key"))] - pub const TRANSLATE_KEY: FunctionDef *const i8> = FunctionDef{address: 0x0046bbd3, function_type: PhantomData}; + pub const TRANSLATE_KEY: FunctionDef u32> = FunctionDef{address: 0x0046bbd3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/display_message_0"))] pub const DISPLAY_MESSAGE_0: FunctionDef = FunctionDef{address: 0x0049ccc3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/display_message_1"))] - pub const DISPLAY_MESSAGE_1: FunctionDef = FunctionDef{address: 0x0049cec0, function_type: PhantomData}; + pub const DISPLAY_MESSAGE_1: FunctionDef = FunctionDef{address: 0x0049cec0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/show_last_dialog"))] - pub const SHOW_LAST_DIALOG: FunctionDef = FunctionDef{address: 0x004a09cc, function_type: PhantomData}; + pub const SHOW_LAST_DIALOG: FunctionDef = FunctionDef{address: 0x004a09cc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/hide_persistent_text"))] - pub const HIDE_PERSISTENT_TEXT: FunctionDef = FunctionDef{address: 0x004b28df, function_type: PhantomData}; + pub const HIDE_PERSISTENT_TEXT: FunctionDef = FunctionDef{address: 0x004b28df, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/destroy_cursors"))] pub const DESTROY_CURSORS: FunctionDef = FunctionDef{address: 0x004b2caa, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/clear_messages"))] @@ -1262,47 +1218,47 @@ pub mod bfuimgr { #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/init_cursors"))] pub const INIT_CURSORS: FunctionDef = FunctionDef{address: 0x004d4118, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/resize"))] - pub const RESIZE: FunctionDef u32> = FunctionDef{address: 0x004d41f4, function_type: PhantomData}; + pub const RESIZE: FunctionDef u32> = FunctionDef{address: 0x004d41f4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/reload"))] - pub const RELOAD: FunctionDef u32> = FunctionDef{address: 0x004d594b, function_type: PhantomData}; + pub const RELOAD: FunctionDef u32> = FunctionDef{address: 0x004d594b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/reset_element_cursor"))] pub const RESET_ELEMENT_CURSOR: FunctionDef = FunctionDef{address: 0x004d5bea, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/disable_element"))] pub const DISABLE_ELEMENT: FunctionDef = FunctionDef{address: 0x004df425, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/remove_element"))] - pub const REMOVE_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004e0965, function_type: PhantomData}; + pub const REMOVE_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004e0965, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/delete_element"))] - pub const DELETE_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004e0e21, function_type: PhantomData}; + pub const DELETE_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004e0e21, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/display_help_1"))] pub const DISPLAY_HELP_1: FunctionDef = FunctionDef{address: 0x004fb613, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/confirm_dialog_0"))] - pub const CONFIRM_DIALOG_0: FunctionDef u32> = FunctionDef{address: 0x004ff63c, function_type: PhantomData}; + pub const CONFIRM_DIALOG_0: FunctionDef u32> = FunctionDef{address: 0x004ff63c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/confirm_dialog_1"))] - pub const CONFIRM_DIALOG_1: FunctionDef u32> = FunctionDef{address: 0x004fff2c, function_type: PhantomData}; + pub const CONFIRM_DIALOG_1: FunctionDef u32> = FunctionDef{address: 0x004fff2c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/delete_all_elements_0"))] - pub const DELETE_ALL_ELEMENTS_0: FunctionDef u32> = FunctionDef{address: 0x0050214c, function_type: PhantomData}; + pub const DELETE_ALL_ELEMENTS_0: FunctionDef u32> = FunctionDef{address: 0x0050214c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/stop"))] - pub const STOP: FunctionDef = FunctionDef{address: 0x005021bb, function_type: PhantomData}; + pub const STOP: FunctionDef = FunctionDef{address: 0x005021bb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/delete_all_elements_1"))] pub const DELETE_ALL_ELEMENTS_1: FunctionDef u32> = FunctionDef{address: 0x00502796, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/release_sounds"))] - pub const RELEASE_SOUNDS: FunctionDef = FunctionDef{address: 0x0050342a, function_type: PhantomData}; + pub const RELEASE_SOUNDS: FunctionDef = FunctionDef{address: 0x0050342a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00511054, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00511054, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/set_builtin_callback"))] - pub const SET_BUILTIN_CALLBACK: FunctionDef = FunctionDef{address: 0x00517d55, function_type: PhantomData}; + pub const SET_BUILTIN_CALLBACK: FunctionDef = FunctionDef{address: 0x00517d55, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/set_help_control"))] - pub const SET_HELP_CONTROL: FunctionDef = FunctionDef{address: 0x00519cc4, function_type: PhantomData}; + pub const SET_HELP_CONTROL: FunctionDef = FunctionDef{address: 0x00519cc4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/start"))] - pub const START: FunctionDef u32> = FunctionDef{address: 0x0051e3b8, function_type: PhantomData}; + pub const START: FunctionDef u32> = FunctionDef{address: 0x0051e3b8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00539a66, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00539a66, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/configure_and_show_dialog"))] - pub const CONFIGURE_AND_SHOW_DIALOG: FunctionDef *const i16> = FunctionDef{address: 0x005a1b15, function_type: PhantomData}; + pub const CONFIGURE_AND_SHOW_DIALOG: FunctionDef u32> = FunctionDef{address: 0x005a1b15, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/bfuimgr_0"))] - pub const BFUIMGR_0: FunctionDef *const u32> = FunctionDef{address: 0x00620515, function_type: PhantomData}; + pub const BFUIMGR_0: FunctionDef u32> = FunctionDef{address: 0x00620515, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfuimgr/bfuimgr_1"))] - pub const BFUIMGR_1: FunctionDef *const u32> = FunctionDef{address: 0x006207b1, function_type: PhantomData}; + pub const BFUIMGR_1: FunctionDef u32> = FunctionDef{address: 0x006207b1, function_type: PhantomData}; } // BFUnit class functions @@ -1310,115 +1266,103 @@ pub mod bfunit { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/validate_position"))] - pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x004102fc, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/add_to_map"))] - pub const ADD_TO_MAP: FunctionDef = FunctionDef{address: 0x00412cdc, function_type: PhantomData}; + pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x004102fc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_idle_anim"))] - pub const GET_IDLE_ANIM: FunctionDef i32> = FunctionDef{address: 0x004133d6, function_type: PhantomData}; + pub const GET_IDLE_ANIM: FunctionDef i32> = FunctionDef{address: 0x004133d6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/is_same_tile"))] - pub const IS_SAME_TILE: FunctionDef u8> = FunctionDef{address: 0x00414530, function_type: PhantomData}; + pub const IS_SAME_TILE: FunctionDef = FunctionDef{address: 0x00414530, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_path_cost"))] - pub const GET_PATH_COST: FunctionDef u32> = FunctionDef{address: 0x0041456c, function_type: PhantomData}; + pub const GET_PATH_COST: FunctionDef u32> = FunctionDef{address: 0x0041456c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/is_max_cost_for_all"))] - pub const IS_MAX_COST_FOR_ALL: FunctionDef u32> = FunctionDef{address: 0x004146d4, function_type: PhantomData}; + pub const IS_MAX_COST_FOR_ALL: FunctionDef u32> = FunctionDef{address: 0x004146d4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/idle"))] - pub const IDLE: FunctionDef = FunctionDef{address: 0x00421eb7, function_type: PhantomData}; + pub const IDLE: FunctionDef = FunctionDef{address: 0x00421eb7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/go_to_dest_0"))] - pub const GO_TO_DEST_0: FunctionDef u32> = FunctionDef{address: 0x00422072, function_type: PhantomData}; + pub const GO_TO_DEST_0: FunctionDef u32> = FunctionDef{address: 0x00422072, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/go_to_dest_1"))] - pub const GO_TO_DEST_1: FunctionDef u32> = FunctionDef{address: 0x00422127, function_type: PhantomData}; + pub const GO_TO_DEST_1: FunctionDef u32> = FunctionDef{address: 0x00422127, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_path"))] - pub const GET_PATH: FunctionDef u32> = FunctionDef{address: 0x004221c3, function_type: PhantomData}; + pub const GET_PATH: FunctionDef u32> = FunctionDef{address: 0x004221c3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/listen_0"))] - pub const LISTEN_0: FunctionDef = FunctionDef{address: 0x00423c03, function_type: PhantomData}; + pub const LISTEN_0: FunctionDef = FunctionDef{address: 0x00423c03, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_events_0"))] - pub const GET_EVENTS_0: FunctionDef = FunctionDef{address: 0x00423cee, function_type: PhantomData}; + pub const GET_EVENTS_0: FunctionDef = FunctionDef{address: 0x00423cee, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/face_toward_tile"))] - pub const FACE_TOWARD_TILE: FunctionDef = FunctionDef{address: 0x00426d1a, function_type: PhantomData}; + pub const FACE_TOWARD_TILE: FunctionDef = FunctionDef{address: 0x00426d1a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/face_toward_entity"))] - pub const FACE_TOWARD_ENTITY: FunctionDef = FunctionDef{address: 0x00426d4d, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x00427873, function_type: PhantomData}; + pub const FACE_TOWARD_ENTITY: FunctionDef = FunctionDef{address: 0x00426d4d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_aiinfo_on"))] - pub const GET_AIINFO_ON: FunctionDef u32> = FunctionDef{address: 0x0043358f, function_type: PhantomData}; + pub const GET_AIINFO_ON: FunctionDef = FunctionDef{address: 0x0043358f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_events_1"))] - pub const GET_EVENTS_1: FunctionDef = FunctionDef{address: 0x00434a04, function_type: PhantomData}; + pub const GET_EVENTS_1: FunctionDef = FunctionDef{address: 0x00434a04, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/update_animation"))] - pub const UPDATE_ANIMATION: FunctionDef = FunctionDef{address: 0x00435bbe, function_type: PhantomData}; + pub const UPDATE_ANIMATION: FunctionDef = FunctionDef{address: 0x00435bbe, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/update_position"))] - pub const UPDATE_POSITION: FunctionDef = FunctionDef{address: 0x00435bf8, function_type: PhantomData}; + pub const UPDATE_POSITION: FunctionDef = FunctionDef{address: 0x00435bf8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_events_2"))] - pub const GET_EVENTS_2: FunctionDef = FunctionDef{address: 0x00435cdb, function_type: PhantomData}; + pub const GET_EVENTS_2: FunctionDef = FunctionDef{address: 0x00435cdb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/listen_1"))] - pub const LISTEN_1: FunctionDef = FunctionDef{address: 0x00435cf1, function_type: PhantomData}; + pub const LISTEN_1: FunctionDef = FunctionDef{address: 0x00435cf1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/run_behavior_set"))] - pub const RUN_BEHAVIOR_SET: FunctionDef = FunctionDef{address: 0x00435cfb, function_type: PhantomData}; + pub const RUN_BEHAVIOR_SET: FunctionDef = FunctionDef{address: 0x00435cfb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/update_sub_goals"))] - pub const UPDATE_SUB_GOALS: FunctionDef = FunctionDef{address: 0x00436161, function_type: PhantomData}; + pub const UPDATE_SUB_GOALS: FunctionDef = FunctionDef{address: 0x00436161, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_dest_tile"))] - pub const GET_DEST_TILE: FunctionDef i32> = FunctionDef{address: 0x00436323, function_type: PhantomData}; + pub const GET_DEST_TILE: FunctionDef i32> = FunctionDef{address: 0x00436323, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/set_moving"))] - pub const SET_MOVING: FunctionDef = FunctionDef{address: 0x0043e5a5, function_type: PhantomData}; + pub const SET_MOVING: FunctionDef = FunctionDef{address: 0x0043e5a5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/stop"))] - pub const STOP: FunctionDef = FunctionDef{address: 0x0043e642, function_type: PhantomData}; + pub const STOP: FunctionDef = FunctionDef{address: 0x0043e642, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_events_3"))] - pub const GET_EVENTS_3: FunctionDef = FunctionDef{address: 0x0043f40d, function_type: PhantomData}; + pub const GET_EVENTS_3: FunctionDef = FunctionDef{address: 0x0043f40d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/cleanup_events"))] - pub const CLEANUP_EVENTS: FunctionDef = FunctionDef{address: 0x0043f4a0, function_type: PhantomData}; + pub const CLEANUP_EVENTS: FunctionDef = FunctionDef{address: 0x0043f4a0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/is_non_path_steep"))] pub const IS_NON_PATH_STEEP: FunctionDef u32> = FunctionDef{address: 0x0044045e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004547cc, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004547cc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00478252, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/set_world_dest"))] - pub const SET_WORLD_DEST: FunctionDef = FunctionDef{address: 0x0048bf55, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/set_height_above_terrain"))] - pub const SET_HEIGHT_ABOVE_TERRAIN: FunctionDef = FunctionDef{address: 0x00492a51, function_type: PhantomData}; + pub const SET_HEIGHT_ABOVE_TERRAIN: FunctionDef = FunctionDef{address: 0x00492a51, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/check_elevation"))] - pub const CHECK_ELEVATION: FunctionDef bool> = FunctionDef{address: 0x00493e1c, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_next_pos"))] - pub const GET_NEXT_POS: FunctionDef = FunctionDef{address: 0x00499be7, function_type: PhantomData}; + pub const CHECK_ELEVATION: FunctionDef bool> = FunctionDef{address: 0x00493e1c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/set_dest_tile"))] - pub const SET_DEST_TILE: FunctionDef = FunctionDef{address: 0x004a7a90, function_type: PhantomData}; + pub const SET_DEST_TILE: FunctionDef = FunctionDef{address: 0x004a7a90, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/set_selected"))] - pub const SET_SELECTED: FunctionDef = FunctionDef{address: 0x004ee4a4, function_type: PhantomData}; + pub const SET_SELECTED: FunctionDef = FunctionDef{address: 0x004ee4a4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004f568c, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004f568c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/bfunit"))] - pub const BFUNIT: FunctionDef *const u32> = FunctionDef{address: 0x004f9c33, function_type: PhantomData}; + pub const BFUNIT: FunctionDef u32> = FunctionDef{address: 0x004f9c33, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/send_event"))] - pub const SEND_EVENT: FunctionDef = FunctionDef{address: 0x0059def9, function_type: PhantomData}; + pub const SEND_EVENT: FunctionDef = FunctionDef{address: 0x0059def9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_cost"))] - pub const GET_COST: FunctionDef u32> = FunctionDef{address: 0x0060238f, function_type: PhantomData}; + pub const GET_COST: FunctionDef u32> = FunctionDef{address: 0x0060238f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_terrain_cost"))] - pub const GET_TERRAIN_COST: FunctionDef i32> = FunctionDef{address: 0x006023ac, function_type: PhantomData}; + pub const GET_TERRAIN_COST: FunctionDef i32> = FunctionDef{address: 0x006023ac, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/draw_aiinfo"))] - pub const DRAW_AIINFO: FunctionDef = FunctionDef{address: 0x00602481, function_type: PhantomData}; + pub const DRAW_AIINFO: FunctionDef = FunctionDef{address: 0x00602481, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/morph"))] - pub const MORPH: FunctionDef = FunctionDef{address: 0x00602929, function_type: PhantomData}; + pub const MORPH: FunctionDef = FunctionDef{address: 0x00602929, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunit/get_height_above_terrain"))] - pub const GET_HEIGHT_ABOVE_TERRAIN: FunctionDef = FunctionDef{address: 0x00602c74, function_type: PhantomData}; + pub const GET_HEIGHT_ABOVE_TERRAIN: FunctionDef = FunctionDef{address: 0x00602c74, function_type: PhantomData}; } // BFUnitType class functions pub mod bfunittype { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("bfunittype/set_idle_animation"))] - pub const SET_IDLE_ANIMATION: FunctionDef u32> = FunctionDef{address: 0x004b551d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunittype/load_characteristics_0"))] - pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004b5de3, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004b5de3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunittype/load_characteristics_1"))] - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b5faf, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b5faf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunittype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004be68c, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004be68c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunittype/bfunit_type_0"))] - pub const BFUNIT_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x00500b5b, function_type: PhantomData}; + pub const BFUNIT_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x00500b5b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfunittype/bfunit_type_1"))] - pub const BFUNIT_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x00500bda, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("bfunittype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x005ffe36, function_type: PhantomData}; + pub const BFUNIT_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x00500bda, function_type: PhantomData}; } // BFVersionInfo class functions @@ -1430,7 +1374,7 @@ pub mod bfversioninfo { #[cfg_attr(feature = "detour-validation", validate_detour("bfversioninfo/init_instance"))] pub const INIT_INSTANCE: FunctionDef u32> = FunctionDef{address: 0x005356ad, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfversioninfo/exit_instance_0"))] - pub const EXIT_INSTANCE_0: FunctionDef = FunctionDef{address: 0x0057e05d, function_type: PhantomData}; + pub const EXIT_INSTANCE_0: FunctionDef = FunctionDef{address: 0x0057e05d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfversioninfo/exit_instance_1"))] pub const EXIT_INSTANCE_1: FunctionDef = FunctionDef{address: 0x0057e0b3, function_type: PhantomData}; } @@ -1440,21 +1384,21 @@ pub mod bfwindow { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x004d60a8, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x004d60a8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/show"))] - pub const SHOW: FunctionDef bool> = FunctionDef{address: 0x004d60ff, function_type: PhantomData}; + pub const SHOW: FunctionDef bool> = FunctionDef{address: 0x004d60ff, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/resize"))] - pub const RESIZE: FunctionDef = FunctionDef{address: 0x004d6141, function_type: PhantomData}; + pub const RESIZE: FunctionDef = FunctionDef{address: 0x004d6141, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/center"))] - pub const CENTER: FunctionDef = FunctionDef{address: 0x004d61db, function_type: PhantomData}; + pub const CENTER: FunctionDef = FunctionDef{address: 0x004d61db, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/change_style"))] - pub const CHANGE_STYLE: FunctionDef u32> = FunctionDef{address: 0x004d62b3, function_type: PhantomData}; + pub const CHANGE_STYLE: FunctionDef u32> = FunctionDef{address: 0x004d62b3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/style_popup"))] - pub const STYLE_POPUP: FunctionDef = FunctionDef{address: 0x004d641d, function_type: PhantomData}; + pub const STYLE_POPUP: FunctionDef = FunctionDef{address: 0x004d641d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/style_fixed"))] - pub const STYLE_FIXED: FunctionDef = FunctionDef{address: 0x0052f150, function_type: PhantomData}; + pub const STYLE_FIXED: FunctionDef = FunctionDef{address: 0x0052f150, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/pointer"))] - pub const POINTER: FunctionDef bool> = FunctionDef{address: 0x005336d5, function_type: PhantomData}; + pub const POINTER: FunctionDef bool> = FunctionDef{address: 0x005336d5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfwindow/attach"))] pub const ATTACH: FunctionDef bool> = FunctionDef{address: 0x00536486, function_type: PhantomData}; } @@ -1464,17 +1408,17 @@ pub mod bfwindowclass { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfwindowclass/create_window_0"))] - pub const CREATE_WINDOW_0: FunctionDef = FunctionDef{address: 0x005362a4, function_type: PhantomData}; + pub const CREATE_WINDOW_0: FunctionDef = FunctionDef{address: 0x005362a4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfwindowclass/create_window_1"))] - pub const CREATE_WINDOW_1: FunctionDef *const u32> = FunctionDef{address: 0x005364ea, function_type: PhantomData}; + pub const CREATE_WINDOW_1: FunctionDef u32> = FunctionDef{address: 0x005364ea, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfwindowclass/make_icon"))] - pub const MAKE_ICON: FunctionDef bool> = FunctionDef{address: 0x005379c1, function_type: PhantomData}; + pub const MAKE_ICON: FunctionDef = FunctionDef{address: 0x005379c1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfwindowclass/constructor_0"))] - pub const CONSTRUCTOR_0: FunctionDef *const u32> = FunctionDef{address: 0x005379f6, function_type: PhantomData}; + pub const CONSTRUCTOR_0: FunctionDef u32> = FunctionDef{address: 0x005379f6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfwindowclass/constructor_1"))] - pub const CONSTRUCTOR_1: FunctionDef *const u32> = FunctionDef{address: 0x00578c6f, function_type: PhantomData}; + pub const CONSTRUCTOR_1: FunctionDef u32> = FunctionDef{address: 0x00578c6f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfwindowclass/unregister_class"))] - pub const UNREGISTER_CLASS: FunctionDef bool> = FunctionDef{address: 0x00587672, function_type: PhantomData}; + pub const UNREGISTER_CLASS: FunctionDef bool> = FunctionDef{address: 0x00587672, function_type: PhantomData}; } // BFWorldMgr class functions @@ -1482,71 +1426,43 @@ pub mod bfworldmgr { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/verify_entity_0"))] - pub const VERIFY_ENTITY_0: FunctionDef u8> = FunctionDef{address: 0x00443ffa, function_type: PhantomData}; + pub const VERIFY_ENTITY_0: FunctionDef = FunctionDef{address: 0x00443ffa, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044f280, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044f280, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/init_unlocked_entities"))] - pub const INIT_UNLOCKED_ENTITIES: FunctionDef = FunctionDef{address: 0x004533bc, function_type: PhantomData}; + pub const INIT_UNLOCKED_ENTITIES: FunctionDef = FunctionDef{address: 0x004533bc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0046285b, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0046285b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00477b4e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/clear"))] - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6b18, function_type: PhantomData}; + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6b18, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/unlock_entity"))] - pub const UNLOCK_ENTITY: FunctionDef = FunctionDef{address: 0x00598cdc, function_type: PhantomData}; + pub const UNLOCK_ENTITY: FunctionDef = FunctionDef{address: 0x00598cdc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfworldmgr/verify_entity_1"))] pub const VERIFY_ENTITY_1: FunctionDef = FunctionDef{address: 0x005b66c4, function_type: PhantomData}; } -// DX8Sound class functions -pub mod dx8sound { - use super::*; - - #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00407010, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/set_volume"))] - pub const SET_VOLUME: FunctionDef = FunctionDef{address: 0x0040757b, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/bring_alive"))] - pub const BRING_ALIVE: FunctionDef u32> = FunctionDef{address: 0x0041c488, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/get_sound_resource"))] - pub const GET_SOUND_RESOURCE: FunctionDef u32> = FunctionDef{address: 0x0041c514, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/play_0"))] - pub const PLAY_0: FunctionDef = FunctionDef{address: 0x00440764, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/update_position"))] - pub const UPDATE_POSITION: FunctionDef = FunctionDef{address: 0x0044153b, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/play_looped_0"))] - pub const PLAY_LOOPED_0: FunctionDef = FunctionDef{address: 0x00441797, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/play_1"))] - pub const PLAY_1: FunctionDef = FunctionDef{address: 0x0044369a, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/play_looped_1"))] - pub const PLAY_LOOPED_1: FunctionDef = FunctionDef{address: 0x004fc592, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/play_2"))] - pub const PLAY_2: FunctionDef = FunctionDef{address: 0x0061fd4c, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("dx8sound/play_looped_2"))] - pub const PLAY_LOOPED_2: FunctionDef = FunctionDef{address: 0x0061fe0e, function_type: PhantomData}; -} - // GXCanvas class functions pub mod gxcanvas { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/get_dc"))] - pub const GET_DC: FunctionDef *const i32> = FunctionDef{address: 0x004014c8, function_type: PhantomData}; + pub const GET_DC: FunctionDef u32> = FunctionDef{address: 0x004014c8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/release_dc"))] - pub const RELEASE_DC: FunctionDef u32> = FunctionDef{address: 0x004014f5, function_type: PhantomData}; + pub const RELEASE_DC: FunctionDef u32> = FunctionDef{address: 0x004014f5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004050f7, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004050f7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/clear"))] - pub const CLEAR: FunctionDef u32> = FunctionDef{address: 0x00405792, function_type: PhantomData}; + pub const CLEAR: FunctionDef u32> = FunctionDef{address: 0x00405792, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/get_pixel"))] - pub const GET_PIXEL: FunctionDef u32> = FunctionDef{address: 0x0040710e, function_type: PhantomData}; + pub const GET_PIXEL: FunctionDef u32> = FunctionDef{address: 0x0040710e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/set_color_key"))] - pub const SET_COLOR_KEY: FunctionDef u32> = FunctionDef{address: 0x004071cd, function_type: PhantomData}; + pub const SET_COLOR_KEY: FunctionDef u32> = FunctionDef{address: 0x004071cd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/draw_clipped"))] - pub const DRAW_CLIPPED: FunctionDef u32> = FunctionDef{address: 0x0041981c, function_type: PhantomData}; + pub const DRAW_CLIPPED: FunctionDef u32> = FunctionDef{address: 0x0041981c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxcanvas/string"))] - pub const STRING: FunctionDef u32> = FunctionDef{address: 0x004b189d, function_type: PhantomData}; + pub const STRING: FunctionDef u32> = FunctionDef{address: 0x004b189d, function_type: PhantomData}; } // GXDynamicLLE class functions @@ -1556,9 +1472,9 @@ pub mod gxdynamiclle { #[cfg_attr(feature = "detour-validation", validate_detour("gxdynamiclle/clear"))] pub const CLEAR: FunctionDef = FunctionDef{address: 0x004abfd6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxdynamiclle/load"))] - pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x004aca7f, function_type: PhantomData}; + pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x004aca7f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxdynamiclle/build"))] - pub const BUILD: FunctionDef = FunctionDef{address: 0x004acdda, function_type: PhantomData}; + pub const BUILD: FunctionDef = FunctionDef{address: 0x004acdda, function_type: PhantomData}; } // GXGraphicsMgr class functions @@ -1566,19 +1482,19 @@ pub mod gxgraphicsmgr { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/load_palette_map"))] - pub const LOAD_PALETTE_MAP: FunctionDef i32> = FunctionDef{address: 0x00403600, function_type: PhantomData}; + pub const LOAD_PALETTE_MAP: FunctionDef i32> = FunctionDef{address: 0x00403600, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/create_uisurface_0"))] - pub const CREATE_UISURFACE_0: FunctionDef *const u32> = FunctionDef{address: 0x0041b98c, function_type: PhantomData}; + pub const CREATE_UISURFACE_0: FunctionDef u32> = FunctionDef{address: 0x0041b98c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/create_uisurface_1"))] - pub const CREATE_UISURFACE_1: FunctionDef u32> = FunctionDef{address: 0x0041ba54, function_type: PhantomData}; + pub const CREATE_UISURFACE_1: FunctionDef u32> = FunctionDef{address: 0x0041ba54, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/copy_palette_map"))] - pub const COPY_PALETTE_MAP: FunctionDef i32> = FunctionDef{address: 0x004abcac, function_type: PhantomData}; + pub const COPY_PALETTE_MAP: FunctionDef i32> = FunctionDef{address: 0x004abcac, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/toggle_fullscreen"))] - pub const TOGGLE_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d5fc6, function_type: PhantomData}; + pub const TOGGLE_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d5fc6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/start"))] - pub const START: FunctionDef u32> = FunctionDef{address: 0x004d6c59, function_type: PhantomData}; + pub const START: FunctionDef u32> = FunctionDef{address: 0x004d6c59, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/initialize"))] - pub const INITIALIZE: FunctionDef = FunctionDef{address: 0x00533e4b, function_type: PhantomData}; + pub const INITIALIZE: FunctionDef = FunctionDef{address: 0x00533e4b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/destroy"))] pub const DESTROY: FunctionDef = FunctionDef{address: 0x0057de67, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxgraphicsmgr/gxgraphics_mgr"))] @@ -1590,7 +1506,7 @@ pub mod gximage { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("gximage/draw"))] - pub const DRAW: FunctionDef u32> = FunctionDef{address: 0x0061f0c8, function_type: PhantomData}; + pub const DRAW: FunctionDef u32> = FunctionDef{address: 0x0061f0c8, function_type: PhantomData}; } // GXImageBMP class functions @@ -1598,7 +1514,7 @@ pub mod gximagebmp { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("gximagebmp/attempt"))] - pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x005234da, function_type: PhantomData}; + pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x005234da, function_type: PhantomData}; } // GXImageTGA class functions @@ -1606,7 +1522,7 @@ pub mod gximagetga { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("gximagetga/attempt"))] - pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x004b32a7, function_type: PhantomData}; + pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x004b32a7, function_type: PhantomData}; } // GXLLE class functions @@ -1614,9 +1530,9 @@ pub mod gxlle { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("gxlle/draw_dither"))] - pub const DRAW_DITHER: FunctionDef u32> = FunctionDef{address: 0x0047c948, function_type: PhantomData}; + pub const DRAW_DITHER: FunctionDef u32> = FunctionDef{address: 0x0047c948, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxlle/compress"))] - pub const COMPRESS: FunctionDef *const u32> = FunctionDef{address: 0x004ad3d6, function_type: PhantomData}; + pub const COMPRESS: FunctionDef u32> = FunctionDef{address: 0x004ad3d6, function_type: PhantomData}; } // GXLLEAnim class functions @@ -1624,15 +1540,15 @@ pub mod gxlleanim { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanim/release"))] - pub const RELEASE: FunctionDef = FunctionDef{address: 0x00402f13, function_type: PhantomData}; + pub const RELEASE: FunctionDef = FunctionDef{address: 0x00402f13, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanim/prepare"))] - pub const PREPARE: FunctionDef bool> = FunctionDef{address: 0x0040bbc1, function_type: PhantomData}; + pub const PREPARE: FunctionDef bool> = FunctionDef{address: 0x0040bbc1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanim/gxlleanim"))] - pub const GXLLEANIM: FunctionDef = FunctionDef{address: 0x0040bc77, function_type: PhantomData}; + pub const GXLLEANIM: FunctionDef = FunctionDef{address: 0x0040bc77, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanim/attempt"))] - pub const ATTEMPT: FunctionDef bool> = FunctionDef{address: 0x00411e21, function_type: PhantomData}; + pub const ATTEMPT: FunctionDef bool> = FunctionDef{address: 0x00411e21, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanim/acquire"))] - pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x00411eb8, function_type: PhantomData}; + pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x00411eb8, function_type: PhantomData}; } // GXLLEAnimSet class functions @@ -1640,17 +1556,17 @@ pub mod gxlleanimset { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanimset/release_0"))] - pub const RELEASE_0: FunctionDef = FunctionDef{address: 0x004069d0, function_type: PhantomData}; + pub const RELEASE_0: FunctionDef = FunctionDef{address: 0x004069d0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanimset/attempt_0"))] - pub const ATTEMPT_0: FunctionDef bool> = FunctionDef{address: 0x00406a22, function_type: PhantomData}; + pub const ATTEMPT_0: FunctionDef bool> = FunctionDef{address: 0x00406a22, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanimset/release_1"))] - pub const RELEASE_1: FunctionDef = FunctionDef{address: 0x00406b0e, function_type: PhantomData}; + pub const RELEASE_1: FunctionDef = FunctionDef{address: 0x00406b0e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanimset/attempt_1"))] - pub const ATTEMPT_1: FunctionDef bool> = FunctionDef{address: 0x0040b967, function_type: PhantomData}; + pub const ATTEMPT_1: FunctionDef bool> = FunctionDef{address: 0x0040b967, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanimset/data_size"))] - pub const DATA_SIZE: FunctionDef i32> = FunctionDef{address: 0x0040bf92, function_type: PhantomData}; + pub const DATA_SIZE: FunctionDef i32> = FunctionDef{address: 0x0040bf92, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxlleanimset/acquire"))] - pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x004bddbc, function_type: PhantomData}; + pub const ACQUIRE: FunctionDef = FunctionDef{address: 0x004bddbc, function_type: PhantomData}; } // GXMixer class functions @@ -1658,27 +1574,27 @@ pub mod gxmixer { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/get_anim_set"))] - pub const GET_ANIM_SET: FunctionDef u32> = FunctionDef{address: 0x004010e7, function_type: PhantomData}; + pub const GET_ANIM_SET: FunctionDef u32> = FunctionDef{address: 0x004010e7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/set_set"))] - pub const SET_SET: FunctionDef = FunctionDef{address: 0x0040165f, function_type: PhantomData}; + pub const SET_SET: FunctionDef = FunctionDef{address: 0x0040165f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/set_base_0"))] - pub const SET_BASE_0: FunctionDef = FunctionDef{address: 0x0040de33, function_type: PhantomData}; + pub const SET_BASE_0: FunctionDef = FunctionDef{address: 0x0040de33, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/total_clear"))] - pub const TOTAL_CLEAR: FunctionDef = FunctionDef{address: 0x0040df80, function_type: PhantomData}; + pub const TOTAL_CLEAR: FunctionDef = FunctionDef{address: 0x0040df80, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0040e214, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0040e214, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0040e420, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0040e420, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/set_base_1"))] - pub const SET_BASE_1: FunctionDef = FunctionDef{address: 0x0040e6c1, function_type: PhantomData}; + pub const SET_BASE_1: FunctionDef = FunctionDef{address: 0x0040e6c1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/get_anim"))] - pub const GET_ANIM: FunctionDef *const c_void> = FunctionDef{address: 0x00411fed, function_type: PhantomData}; + pub const GET_ANIM: FunctionDef u32> = FunctionDef{address: 0x00411fed, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/draw"))] - pub const DRAW: FunctionDef = FunctionDef{address: 0x004325a9, function_type: PhantomData}; + pub const DRAW: FunctionDef = FunctionDef{address: 0x004325a9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/set_time"))] - pub const SET_TIME: FunctionDef = FunctionDef{address: 0x004340e1, function_type: PhantomData}; + pub const SET_TIME: FunctionDef = FunctionDef{address: 0x004340e1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxmixer/clear_all"))] - pub const CLEAR_ALL: FunctionDef = FunctionDef{address: 0x004b1e62, function_type: PhantomData}; + pub const CLEAR_ALL: FunctionDef = FunctionDef{address: 0x004b1e62, function_type: PhantomData}; } // GXMixerLink class functions @@ -1686,9 +1602,9 @@ pub mod gxmixerlink { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("gxmixerlink/gxmixer_link"))] - pub const GXMIXER_LINK: FunctionDef = FunctionDef{address: 0x004016c7, function_type: PhantomData}; + pub const GXMIXER_LINK: FunctionDef = FunctionDef{address: 0x004016c7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxmixerlink/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0040de05, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0040de05, function_type: PhantomData}; } // GXPalette class functions @@ -1696,7 +1612,7 @@ pub mod gxpalette { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("gxpalette/attempt"))] - pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x004abb26, function_type: PhantomData}; + pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x004abb26, function_type: PhantomData}; } // GXPaletteMap class functions @@ -1706,13 +1622,13 @@ pub mod gxpalettemap { #[cfg_attr(feature = "detour-validation", validate_detour("gxpalettemap/copy_colors"))] pub const COPY_COLORS: FunctionDef = FunctionDef{address: 0x00433f66, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxpalettemap/release"))] - pub const RELEASE: FunctionDef = FunctionDef{address: 0x004ab9b0, function_type: PhantomData}; + pub const RELEASE: FunctionDef = FunctionDef{address: 0x004ab9b0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxpalettemap/attempt"))] - pub const ATTEMPT: FunctionDef = FunctionDef{address: 0x004aba2d, function_type: PhantomData}; + pub const ATTEMPT: FunctionDef = FunctionDef{address: 0x004aba2d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxpalettemap/set_pixel_format_0"))] - pub const SET_PIXEL_FORMAT_0: FunctionDef = FunctionDef{address: 0x004abb05, function_type: PhantomData}; + pub const SET_PIXEL_FORMAT_0: FunctionDef = FunctionDef{address: 0x004abb05, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxpalettemap/set_pixel_format_1"))] - pub const SET_PIXEL_FORMAT_1: FunctionDef = FunctionDef{address: 0x004abb84, function_type: PhantomData}; + pub const SET_PIXEL_FORMAT_1: FunctionDef = FunctionDef{address: 0x004abb84, function_type: PhantomData}; } // GXVideoManager class functions @@ -1722,33 +1638,33 @@ pub mod gxvideomanager { #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/flip"))] pub const FLIP: FunctionDef bool> = FunctionDef{address: 0x004013bf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/create_surface"))] - pub const CREATE_SURFACE: FunctionDef *const c_void> = FunctionDef{address: 0x0041ba74, function_type: PhantomData}; + pub const CREATE_SURFACE: FunctionDef u32> = FunctionDef{address: 0x0041ba74, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/flip_to_gdi"))] pub const FLIP_TO_GDI: FunctionDef = FunctionDef{address: 0x004cc682, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/switch_mode"))] - pub const SWITCH_MODE: FunctionDef = FunctionDef{address: 0x004d601e, function_type: PhantomData}; + pub const SWITCH_MODE: FunctionDef = FunctionDef{address: 0x004d601e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/start"))] - pub const START: FunctionDef u32> = FunctionDef{address: 0x004d64ab, function_type: PhantomData}; + pub const START: FunctionDef u32> = FunctionDef{address: 0x004d64ab, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/release_surfaces"))] - pub const RELEASE_SURFACES: FunctionDef = FunctionDef{address: 0x004d67a2, function_type: PhantomData}; + pub const RELEASE_SURFACES: FunctionDef = FunctionDef{address: 0x004d67a2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/setup_fullscreen"))] - pub const SETUP_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d6894, function_type: PhantomData}; + pub const SETUP_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d6894, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/create_flipping_chain"))] - pub const CREATE_FLIPPING_CHAIN: FunctionDef u32> = FunctionDef{address: 0x004d6ae1, function_type: PhantomData}; + pub const CREATE_FLIPPING_CHAIN: FunctionDef u32> = FunctionDef{address: 0x004d6ae1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/setup_windowed"))] - pub const SETUP_WINDOWED: FunctionDef u32> = FunctionDef{address: 0x0052f1d0, function_type: PhantomData}; + pub const SETUP_WINDOWED: FunctionDef u32> = FunctionDef{address: 0x0052f1d0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/create_blt_surfaces"))] - pub const CREATE_BLT_SURFACES: FunctionDef u32> = FunctionDef{address: 0x0052f2a6, function_type: PhantomData}; + pub const CREATE_BLT_SURFACES: FunctionDef u32> = FunctionDef{address: 0x0052f2a6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/create_direct_draw"))] - pub const CREATE_DIRECT_DRAW: FunctionDef u32> = FunctionDef{address: 0x00533d0a, function_type: PhantomData}; + pub const CREATE_DIRECT_DRAW: FunctionDef u32> = FunctionDef{address: 0x00533d0a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/initialize"))] - pub const INITIALIZE: FunctionDef u32> = FunctionDef{address: 0x00533db5, function_type: PhantomData}; + pub const INITIALIZE: FunctionDef u32> = FunctionDef{address: 0x00533db5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/stop"))] - pub const STOP: FunctionDef = FunctionDef{address: 0x0057df69, function_type: PhantomData}; + pub const STOP: FunctionDef = FunctionDef{address: 0x0057df69, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/gxvideo_manager"))] pub const GXVIDEO_MANAGER: FunctionDef = FunctionDef{address: 0x0057dfc7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("gxvideomanager/release_direct_draw"))] - pub const RELEASE_DIRECT_DRAW: FunctionDef = FunctionDef{address: 0x0057e01e, function_type: PhantomData}; + pub const RELEASE_DIRECT_DRAW: FunctionDef = FunctionDef{address: 0x0057e01e, function_type: PhantomData}; } // HTTPCallbackInterface class functions @@ -1756,13 +1672,13 @@ pub mod httpcallbackinterface { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("httpcallbackinterface/check_completed"))] - pub const CHECK_COMPLETED: FunctionDef u8> = FunctionDef{address: 0x0059f93f, function_type: PhantomData}; + pub const CHECK_COMPLETED: FunctionDef = FunctionDef{address: 0x0059f93f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("httpcallbackinterface/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00626b1d, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00626b1d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("httpcallbackinterface/notify_done"))] - pub const NOTIFY_DONE: FunctionDef = FunctionDef{address: 0x00626b35, function_type: PhantomData}; + pub const NOTIFY_DONE: FunctionDef = FunctionDef{address: 0x00626b35, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("httpcallbackinterface/check_error"))] - pub const CHECK_ERROR: FunctionDef u32> = FunctionDef{address: 0x00626b4f, function_type: PhantomData}; + pub const CHECK_ERROR: FunctionDef u32> = FunctionDef{address: 0x00626b4f, function_type: PhantomData}; } // HTTPUtil class functions @@ -1770,23 +1686,23 @@ pub mod httputil { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("httputil/parse_url"))] - pub const PARSE_URL: FunctionDef = FunctionDef{address: 0x00627585, function_type: PhantomData}; + pub const PARSE_URL: FunctionDef = FunctionDef{address: 0x00627585, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("httputil/init_socket"))] - pub const INIT_SOCKET: FunctionDef u32> = FunctionDef{address: 0x00627699, function_type: PhantomData}; + pub const INIT_SOCKET: FunctionDef u32> = FunctionDef{address: 0x00627699, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("httputil/send_string"))] - pub const SEND_STRING: FunctionDef u32> = FunctionDef{address: 0x00627775, function_type: PhantomData}; + pub const SEND_STRING: FunctionDef u32> = FunctionDef{address: 0x00627775, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("httputil/get_httpmemory"))] - pub const GET_HTTPMEMORY: FunctionDef u32> = FunctionDef{address: 0x006277ea, function_type: PhantomData}; + pub const GET_HTTPMEMORY: FunctionDef u32> = FunctionDef{address: 0x006277ea, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("httputil/get_httpfile"))] - pub const GET_HTTPFILE: FunctionDef u32> = FunctionDef{address: 0x00627a17, function_type: PhantomData}; + pub const GET_HTTPFILE: FunctionDef u32> = FunctionDef{address: 0x00627a17, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("httputil/re_get_file"))] - pub const RE_GET_FILE: FunctionDef u32> = FunctionDef{address: 0x00627c0c, function_type: PhantomData}; + pub const RE_GET_FILE: FunctionDef u32> = FunctionDef{address: 0x00627c0c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("httputil/send_httpget"))] - pub const SEND_HTTPGET: FunctionDef u32> = FunctionDef{address: 0x00627c5d, function_type: PhantomData}; + pub const SEND_HTTPGET: FunctionDef u32> = FunctionDef{address: 0x00627c5d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("httputil/read_httpto_memory"))] - pub const READ_HTTPTO_MEMORY: FunctionDef *const i16> = FunctionDef{address: 0x00627cc4, function_type: PhantomData}; + pub const READ_HTTPTO_MEMORY: FunctionDef u32> = FunctionDef{address: 0x00627cc4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("httputil/read_httpto_file"))] - pub const READ_HTTPTO_FILE: FunctionDef u32> = FunctionDef{address: 0x00627ef2, function_type: PhantomData}; + pub const READ_HTTPTO_FILE: FunctionDef u32> = FunctionDef{address: 0x00627ef2, function_type: PhantomData}; } // IScroller class functions @@ -1794,9 +1710,9 @@ pub mod iscroller { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("iscroller/init_sb"))] - pub const INIT_SB: FunctionDef = FunctionDef{address: 0x004d4971, function_type: PhantomData}; + pub const INIT_SB: FunctionDef = FunctionDef{address: 0x004d4971, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("iscroller/load_sb"))] - pub const LOAD_SB: FunctionDef u32> = FunctionDef{address: 0x00510ba2, function_type: PhantomData}; + pub const LOAD_SB: FunctionDef u32> = FunctionDef{address: 0x00510ba2, function_type: PhantomData}; } // MenuMusicHandler class functions @@ -1804,37 +1720,23 @@ pub mod menumusichandler { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("menumusichandler/start_fade"))] - pub const START_FADE: FunctionDef = FunctionDef{address: 0x00592570, function_type: PhantomData}; + pub const START_FADE: FunctionDef = FunctionDef{address: 0x00592570, function_type: PhantomData}; } // SNDSoundResource class functions pub mod sndsoundresource { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresource/release"))] - pub const RELEASE: FunctionDef = FunctionDef{address: 0x004072fa, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresource/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0041c571, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresource/sndsound_resource"))] - pub const SNDSOUND_RESOURCE: FunctionDef *const u32> = FunctionDef{address: 0x0041e5e3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresource/attempt"))] - pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x0061ff52, function_type: PhantomData}; + pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x0061ff52, function_type: PhantomData}; } // SNDSoundResourceWAV class functions pub mod sndsoundresourcewav { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresourcewav/release"))] - pub const RELEASE: FunctionDef = FunctionDef{address: 0x004072a3, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresourcewav/release_inner"))] - pub const RELEASE_INNER: FunctionDef = FunctionDef{address: 0x004072f0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresourcewav/attempt"))] - pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x0041c4c2, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresourcewav/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0041c58a, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("sndsoundresourcewav/sndsound_resource_wav"))] - pub const SNDSOUND_RESOURCE_WAV: FunctionDef *const u32> = FunctionDef{address: 0x0041e63d, function_type: PhantomData}; + pub const ATTEMPT: FunctionDef u32> = FunctionDef{address: 0x0041c4c2, function_type: PhantomData}; } // Sorter class functions @@ -1842,15 +1744,15 @@ pub mod sorter { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("sorter/insert_map"))] - pub const INSERT_MAP: FunctionDef = FunctionDef{address: 0x00431c3e, function_type: PhantomData}; + pub const INSERT_MAP: FunctionDef = FunctionDef{address: 0x00431c3e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("sorter/point_in_entity"))] - pub const POINT_IN_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004333c2, function_type: PhantomData}; + pub const POINT_IN_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004333c2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("sorter/set_map"))] - pub const SET_MAP: FunctionDef = FunctionDef{address: 0x0044afe0, function_type: PhantomData}; + pub const SET_MAP: FunctionDef = FunctionDef{address: 0x0044afe0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("sorter/acquire_anis"))] - pub const ACQUIRE_ANIS: FunctionDef = FunctionDef{address: 0x00461609, function_type: PhantomData}; + pub const ACQUIRE_ANIS: FunctionDef = FunctionDef{address: 0x00461609, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("sorter/draw_tank1"))] - pub const DRAW_TANK1: FunctionDef = FunctionDef{address: 0x004cd3a8, function_type: PhantomData}; + pub const DRAW_TANK1: FunctionDef = FunctionDef{address: 0x004cd3a8, function_type: PhantomData}; } // SoundGroup class functions @@ -1858,7 +1760,7 @@ pub mod soundgroup { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("soundgroup/play"))] - pub const PLAY: FunctionDef u32> = FunctionDef{address: 0x0043f513, function_type: PhantomData}; + pub const PLAY: FunctionDef u32> = FunctionDef{address: 0x0043f513, function_type: PhantomData}; } // UIBarGraphRenderer class functions @@ -1866,13 +1768,13 @@ pub mod uibargraphrenderer { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uibargraphrenderer/render_graph_0"))] - pub const RENDER_GRAPH_0: FunctionDef = FunctionDef{address: 0x0053211d, function_type: PhantomData}; + pub const RENDER_GRAPH_0: FunctionDef = FunctionDef{address: 0x0053211d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uibargraphrenderer/point_to_graph_pos"))] - pub const POINT_TO_GRAPH_POS: FunctionDef = FunctionDef{address: 0x005324c5, function_type: PhantomData}; + pub const POINT_TO_GRAPH_POS: FunctionDef = FunctionDef{address: 0x005324c5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uibargraphrenderer/render_xlabels"))] - pub const RENDER_XLABELS: FunctionDef = FunctionDef{address: 0x005325f5, function_type: PhantomData}; + pub const RENDER_XLABELS: FunctionDef = FunctionDef{address: 0x005325f5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uibargraphrenderer/render_graph_1"))] - pub const RENDER_GRAPH_1: FunctionDef = FunctionDef{address: 0x006239d9, function_type: PhantomData}; + pub const RENDER_GRAPH_1: FunctionDef = FunctionDef{address: 0x006239d9, function_type: PhantomData}; } // UIButton class functions @@ -1880,15 +1782,15 @@ pub mod uibutton { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uibutton/validate_selected_button"))] - pub const VALIDATE_SELECTED_BUTTON: FunctionDef *const i32> = FunctionDef{address: 0x004179de, function_type: PhantomData}; + pub const VALIDATE_SELECTED_BUTTON: FunctionDef u32> = FunctionDef{address: 0x004179de, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uibutton/draw"))] - pub const DRAW: FunctionDef = FunctionDef{address: 0x004197a0, function_type: PhantomData}; + pub const DRAW: FunctionDef = FunctionDef{address: 0x004197a0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uibutton/load"))] - pub const LOAD: FunctionDef = FunctionDef{address: 0x004d35ab, function_type: PhantomData}; + pub const LOAD: FunctionDef = FunctionDef{address: 0x004d35ab, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uibutton/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004e9989, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004e9989, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uibutton/copy"))] - pub const COPY: FunctionDef *const u32> = FunctionDef{address: 0x004e99ee, function_type: PhantomData}; + pub const COPY: FunctionDef u32> = FunctionDef{address: 0x004e99ee, function_type: PhantomData}; } // UICallbackMgr class functions @@ -1896,103 +1798,81 @@ pub mod uicallbackmgr { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uicallbackmgr/do_action"))] - pub const DO_ACTION: FunctionDef = FunctionDef{address: 0x0041ab24, function_type: PhantomData}; + pub const DO_ACTION: FunctionDef = FunctionDef{address: 0x0041ab24, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicallbackmgr/stop"))] - pub const STOP: FunctionDef = FunctionDef{address: 0x004f1daf, function_type: PhantomData}; + pub const STOP: FunctionDef = FunctionDef{address: 0x004f1daf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicallbackmgr/add_action"))] - pub const ADD_ACTION: FunctionDef = FunctionDef{address: 0x00512687, function_type: PhantomData}; + pub const ADD_ACTION: FunctionDef = FunctionDef{address: 0x00512687, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicallbackmgr/start"))] - pub const START: FunctionDef u8> = FunctionDef{address: 0x0051f409, function_type: PhantomData}; + pub const START: FunctionDef = FunctionDef{address: 0x0051f409, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicallbackmgr/add_global_trigger"))] - pub const ADD_GLOBAL_TRIGGER: FunctionDef = FunctionDef{address: 0x0058ec81, function_type: PhantomData}; + pub const ADD_GLOBAL_TRIGGER: FunctionDef = FunctionDef{address: 0x0058ec81, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicallbackmgr/remove_action"))] - pub const REMOVE_ACTION: FunctionDef = FunctionDef{address: 0x00620891, function_type: PhantomData}; + pub const REMOVE_ACTION: FunctionDef = FunctionDef{address: 0x00620891, function_type: PhantomData}; } // UIControl class functions pub mod uicontrol { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/hide"))] - pub const HIDE: FunctionDef = FunctionDef{address: 0x004018d5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/get_dc"))] - pub const GET_DC: FunctionDef *const u32> = FunctionDef{address: 0x0040e969, function_type: PhantomData}; + pub const GET_DC: FunctionDef u32> = FunctionDef{address: 0x0040e969, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/release_dc"))] - pub const RELEASE_DC: FunctionDef = FunctionDef{address: 0x0040e9cd, function_type: PhantomData}; + pub const RELEASE_DC: FunctionDef = FunctionDef{address: 0x0040e9cd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/set_text_0"))] - pub const SET_TEXT_0: FunctionDef = FunctionDef{address: 0x0040eabf, function_type: PhantomData}; + pub const SET_TEXT_0: FunctionDef = FunctionDef{address: 0x0040eabf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/uiload_animation"))] - pub const UILOAD_ANIMATION: FunctionDef bool> = FunctionDef{address: 0x004176ce, function_type: PhantomData}; + pub const UILOAD_ANIMATION: FunctionDef bool> = FunctionDef{address: 0x004176ce, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/use_tooltip_id"))] - pub const USE_TOOLTIP_ID: FunctionDef = FunctionDef{address: 0x00418a49, function_type: PhantomData}; + pub const USE_TOOLTIP_ID: FunctionDef = FunctionDef{address: 0x00418a49, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/draw"))] - pub const DRAW: FunctionDef = FunctionDef{address: 0x004195ae, function_type: PhantomData}; + pub const DRAW: FunctionDef = FunctionDef{address: 0x004195ae, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/render"))] - pub const RENDER: FunctionDef = FunctionDef{address: 0x0041a808, function_type: PhantomData}; + pub const RENDER: FunctionDef = FunctionDef{address: 0x0041a808, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/show"))] - pub const SHOW: FunctionDef = FunctionDef{address: 0x0041acbb, function_type: PhantomData}; + pub const SHOW: FunctionDef = FunctionDef{address: 0x0041acbb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/set_text_1"))] - pub const SET_TEXT_1: FunctionDef = FunctionDef{address: 0x0041afb5, function_type: PhantomData}; + pub const SET_TEXT_1: FunctionDef = FunctionDef{address: 0x0041afb5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/fill_canvases"))] - pub const FILL_CANVASES: FunctionDef u32> = FunctionDef{address: 0x0041bce8, function_type: PhantomData}; + pub const FILL_CANVASES: FunctionDef u32> = FunctionDef{address: 0x0041bce8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/dynamic_render"))] - pub const DYNAMIC_RENDER: FunctionDef = FunctionDef{address: 0x004328ae, function_type: PhantomData}; + pub const DYNAMIC_RENDER: FunctionDef = FunctionDef{address: 0x004328ae, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/hit_test"))] - pub const HIT_TEST: FunctionDef i8> = FunctionDef{address: 0x004420b2, function_type: PhantomData}; + pub const HIT_TEST: FunctionDef i8> = FunctionDef{address: 0x004420b2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/handle_mouse_move"))] - pub const HANDLE_MOUSE_MOVE: FunctionDef u32> = FunctionDef{address: 0x00442493, function_type: PhantomData}; + pub const HANDLE_MOUSE_MOVE: FunctionDef u32> = FunctionDef{address: 0x00442493, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/select_trigger"))] - pub const SELECT_TRIGGER: FunctionDef = FunctionDef{address: 0x00443365, function_type: PhantomData}; + pub const SELECT_TRIGGER: FunctionDef = FunctionDef{address: 0x00443365, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/handle_left_button_up"))] - pub const HANDLE_LEFT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004435b9, function_type: PhantomData}; + pub const HANDLE_LEFT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004435b9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/handle_left_button_down"))] - pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x0044361a, function_type: PhantomData}; + pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x0044361a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/deselect_trigger"))] - pub const DESELECT_TRIGGER: FunctionDef = FunctionDef{address: 0x004438dd, function_type: PhantomData}; + pub const DESELECT_TRIGGER: FunctionDef = FunctionDef{address: 0x004438dd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/set_image_0"))] - pub const SET_IMAGE_0: FunctionDef = FunctionDef{address: 0x004b1a32, function_type: PhantomData}; + pub const SET_IMAGE_0: FunctionDef = FunctionDef{address: 0x004b1a32, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/set_animation"))] - pub const SET_ANIMATION: FunctionDef = FunctionDef{address: 0x004b1aa0, function_type: PhantomData}; + pub const SET_ANIMATION: FunctionDef = FunctionDef{address: 0x004b1aa0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/use_animation"))] - pub const USE_ANIMATION: FunctionDef = FunctionDef{address: 0x004b1f89, function_type: PhantomData}; + pub const USE_ANIMATION: FunctionDef = FunctionDef{address: 0x004b1f89, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/add_image_name"))] - pub const ADD_IMAGE_NAME: FunctionDef = FunctionDef{address: 0x004d2b40, function_type: PhantomData}; + pub const ADD_IMAGE_NAME: FunctionDef = FunctionDef{address: 0x004d2b40, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d32c9, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d32c9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/adjust_dimensions"))] - pub const ADJUST_DIMENSIONS: FunctionDef u32> = FunctionDef{address: 0x004d483e, function_type: PhantomData}; + pub const ADJUST_DIMENSIONS: FunctionDef u32> = FunctionDef{address: 0x004d483e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/init"))] - pub const INIT: FunctionDef u32> = FunctionDef{address: 0x004d4909, function_type: PhantomData}; + pub const INIT: FunctionDef u32> = FunctionDef{address: 0x004d4909, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/uicontrol"))] - pub const UICONTROL: FunctionDef *const u32> = FunctionDef{address: 0x004e0996, function_type: PhantomData}; + pub const UICONTROL: FunctionDef u32> = FunctionDef{address: 0x004e0996, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/constructor_0"))] - pub const CONSTRUCTOR_0: FunctionDef *const u32> = FunctionDef{address: 0x004e95ea, function_type: PhantomData}; + pub const CONSTRUCTOR_0: FunctionDef u32> = FunctionDef{address: 0x004e95ea, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/constructor_1"))] - pub const CONSTRUCTOR_1: FunctionDef *const u32> = FunctionDef{address: 0x0050fe83, function_type: PhantomData}; + pub const CONSTRUCTOR_1: FunctionDef u32> = FunctionDef{address: 0x0050fe83, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/get_text"))] - pub const GET_TEXT: FunctionDef u32> = FunctionDef{address: 0x0058c4aa, function_type: PhantomData}; + pub const GET_TEXT: FunctionDef = FunctionDef{address: 0x0058c4aa, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uicontrol/set_image_1"))] - pub const SET_IMAGE_1: FunctionDef = FunctionDef{address: 0x00620b61, function_type: PhantomData}; -} - -// UIEditableText class functions -pub mod uieditabletext { - use super::*; - - #[cfg_attr(feature = "detour-validation", validate_detour("uieditabletext/handle_char"))] - pub const HANDLE_CHAR: FunctionDef u32> = FunctionDef{address: 0x0046c7d9, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("uieditabletext/init_cursors"))] - pub const INIT_CURSORS: FunctionDef = FunctionDef{address: 0x004d41be, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("uieditabletext/handle_mouse_move"))] - pub const HANDLE_MOUSE_MOVE: FunctionDef u32> = FunctionDef{address: 0x0058c652, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("uieditabletext/handle_left_button_down"))] - pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x00620224, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("uieditabletext/find_character"))] - pub const FIND_CHARACTER: FunctionDef i32> = FunctionDef{address: 0x006202dd, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("uieditabletext/find_text_width"))] - pub const FIND_TEXT_WIDTH: FunctionDef i32> = FunctionDef{address: 0x00620487, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("uieditabletext/find_char_width"))] - pub const FIND_CHAR_WIDTH: FunctionDef = FunctionDef{address: 0x006204bf, function_type: PhantomData}; + pub const SET_IMAGE_1: FunctionDef = FunctionDef{address: 0x00620b61, function_type: PhantomData}; } // UIElement class functions @@ -2000,69 +1880,67 @@ pub mod uielement { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/set_flag"))] - pub const SET_FLAG: FunctionDef = FunctionDef{address: 0x004014ac, function_type: PhantomData}; + pub const SET_FLAG: FunctionDef = FunctionDef{address: 0x004014ac, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/dirty"))] - pub const DIRTY: FunctionDef = FunctionDef{address: 0x00401802, function_type: PhantomData}; + pub const DIRTY: FunctionDef = FunctionDef{address: 0x00401802, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/hide"))] - pub const HIDE: FunctionDef = FunctionDef{address: 0x004018c6, function_type: PhantomData}; + pub const HIDE: FunctionDef = FunctionDef{address: 0x004018c6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/get_element_0"))] - pub const GET_ELEMENT_0: FunctionDef u32> = FunctionDef{address: 0x0040760c, function_type: PhantomData}; + pub const GET_ELEMENT_0: FunctionDef = FunctionDef{address: 0x0040760c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/sort"))] - pub const SORT: FunctionDef = FunctionDef{address: 0x0040eab5, function_type: PhantomData}; + pub const SORT: FunctionDef = FunctionDef{address: 0x0040eab5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/load_state"))] - pub const LOAD_STATE: FunctionDef u8> = FunctionDef{address: 0x0041215f, function_type: PhantomData}; + pub const LOAD_STATE: FunctionDef = FunctionDef{address: 0x0041215f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/get_screen_pos"))] - pub const GET_SCREEN_POS: FunctionDef = FunctionDef{address: 0x00418c5f, function_type: PhantomData}; + pub const GET_SCREEN_POS: FunctionDef = FunctionDef{address: 0x00418c5f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/enable"))] - pub const ENABLE: FunctionDef = FunctionDef{address: 0x0041914b, function_type: PhantomData}; + pub const ENABLE: FunctionDef = FunctionDef{address: 0x0041914b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/disable"))] - pub const DISABLE: FunctionDef = FunctionDef{address: 0x00419191, function_type: PhantomData}; + pub const DISABLE: FunctionDef = FunctionDef{address: 0x00419191, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/show"))] - pub const SHOW: FunctionDef = FunctionDef{address: 0x0041ac49, function_type: PhantomData}; + pub const SHOW: FunctionDef = FunctionDef{address: 0x0041ac49, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041adf1, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041adf1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/handle_double_click"))] - pub const HANDLE_DOUBLE_CLICK: FunctionDef = FunctionDef{address: 0x0041eabe, function_type: PhantomData}; + pub const HANDLE_DOUBLE_CLICK: FunctionDef = FunctionDef{address: 0x0041eabe, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/handle_middle_button_down"))] - pub const HANDLE_MIDDLE_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x00429d0f, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("uielement/set_cursor"))] - pub const SET_CURSOR: FunctionDef = FunctionDef{address: 0x00432346, function_type: PhantomData}; + pub const HANDLE_MIDDLE_BUTTON_DOWN: FunctionDef = FunctionDef{address: 0x00429d0f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/get_element_1"))] - pub const GET_ELEMENT_1: FunctionDef *const i32> = FunctionDef{address: 0x004422fd, function_type: PhantomData}; + pub const GET_ELEMENT_1: FunctionDef u32> = FunctionDef{address: 0x004422fd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/unhighlight"))] - pub const UNHIGHLIGHT: FunctionDef = FunctionDef{address: 0x00442562, function_type: PhantomData}; + pub const UNHIGHLIGHT: FunctionDef = FunctionDef{address: 0x00442562, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/highlight"))] - pub const HIGHLIGHT: FunctionDef = FunctionDef{address: 0x004425ac, function_type: PhantomData}; + pub const HIGHLIGHT: FunctionDef = FunctionDef{address: 0x004425ac, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/unfocus"))] - pub const UNFOCUS: FunctionDef = FunctionDef{address: 0x004431f6, function_type: PhantomData}; + pub const UNFOCUS: FunctionDef = FunctionDef{address: 0x004431f6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/focus"))] - pub const FOCUS: FunctionDef = FunctionDef{address: 0x00443235, function_type: PhantomData}; + pub const FOCUS: FunctionDef = FunctionDef{address: 0x00443235, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/deselect"))] - pub const DESELECT: FunctionDef = FunctionDef{address: 0x004433d8, function_type: PhantomData}; + pub const DESELECT: FunctionDef = FunctionDef{address: 0x004433d8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/select"))] - pub const SELECT: FunctionDef = FunctionDef{address: 0x00443414, function_type: PhantomData}; + pub const SELECT: FunctionDef = FunctionDef{address: 0x00443414, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/handle_left_button_up"))] - pub const HANDLE_LEFT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004435a8, function_type: PhantomData}; + pub const HANDLE_LEFT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004435a8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/handle_left_button_down"))] - pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x0044360a, function_type: PhantomData}; + pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x0044360a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/set_tooltip_id"))] - pub const SET_TOOLTIP_ID: FunctionDef = FunctionDef{address: 0x00443bfc, function_type: PhantomData}; + pub const SET_TOOLTIP_ID: FunctionDef = FunctionDef{address: 0x00443bfc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/set_layout"))] - pub const SET_LAYOUT: FunctionDef = FunctionDef{address: 0x004b203f, function_type: PhantomData}; + pub const SET_LAYOUT: FunctionDef = FunctionDef{address: 0x004b203f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/reload"))] - pub const RELOAD: FunctionDef u8> = FunctionDef{address: 0x004d5777, function_type: PhantomData}; + pub const RELOAD: FunctionDef = FunctionDef{address: 0x004d5777, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/handle_mouse_wheel"))] - pub const HANDLE_MOUSE_WHEEL: FunctionDef u32> = FunctionDef{address: 0x004de381, function_type: PhantomData}; + pub const HANDLE_MOUSE_WHEEL: FunctionDef u32> = FunctionDef{address: 0x004de381, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/set_alias_element"))] - pub const SET_ALIAS_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004ffb8b, function_type: PhantomData}; + pub const SET_ALIAS_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004ffb8b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0050f8e7, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0050f8e7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/registerit"))] pub const REGISTERIT: FunctionDef u32> = FunctionDef{address: 0x005774bf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/set_global_grayed"))] - pub const SET_GLOBAL_GRAYED: FunctionDef = FunctionDef{address: 0x005a0d64, function_type: PhantomData}; + pub const SET_GLOBAL_GRAYED: FunctionDef = FunctionDef{address: 0x005a0d64, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uielement/handle_key_down"))] - pub const HANDLE_KEY_DOWN: FunctionDef u32> = FunctionDef{address: 0x00606ce7, function_type: PhantomData}; + pub const HANDLE_KEY_DOWN: FunctionDef = FunctionDef{address: 0x00606ce7, function_type: PhantomData}; } // UIGraphRenderer class functions @@ -2070,19 +1948,19 @@ pub mod uigraphrenderer { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uigraphrenderer/calc_display_ranges"))] - pub const CALC_DISPLAY_RANGES: FunctionDef = FunctionDef{address: 0x0052f46b, function_type: PhantomData}; + pub const CALC_DISPLAY_RANGES: FunctionDef = FunctionDef{address: 0x0052f46b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uigraphrenderer/round_up_max"))] pub const ROUND_UP_MAX: FunctionDef i32> = FunctionDef{address: 0x0052fe2d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uigraphrenderer/render"))] - pub const RENDER: FunctionDef = FunctionDef{address: 0x00531dbd, function_type: PhantomData}; + pub const RENDER: FunctionDef = FunctionDef{address: 0x00531dbd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uigraphrenderer/render_point_label"))] - pub const RENDER_POINT_LABEL: FunctionDef = FunctionDef{address: 0x00531ec5, function_type: PhantomData}; + pub const RENDER_POINT_LABEL: FunctionDef = FunctionDef{address: 0x00531ec5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uigraphrenderer/render_labels"))] - pub const RENDER_LABELS: FunctionDef = FunctionDef{address: 0x005325da, function_type: PhantomData}; + pub const RENDER_LABELS: FunctionDef = FunctionDef{address: 0x005325da, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uigraphrenderer/render_axis_lines"))] - pub const RENDER_AXIS_LINES: FunctionDef = FunctionDef{address: 0x005328f4, function_type: PhantomData}; + pub const RENDER_AXIS_LINES: FunctionDef = FunctionDef{address: 0x005328f4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uigraphrenderer/render_ylabels"))] - pub const RENDER_YLABELS: FunctionDef = FunctionDef{address: 0x0053296d, function_type: PhantomData}; + pub const RENDER_YLABELS: FunctionDef = FunctionDef{address: 0x0053296d, function_type: PhantomData}; } // UIImage class functions @@ -2090,13 +1968,13 @@ pub mod uiimage { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uiimage/render"))] - pub const RENDER: FunctionDef = FunctionDef{address: 0x00443cbf, function_type: PhantomData}; + pub const RENDER: FunctionDef = FunctionDef{address: 0x00443cbf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiimage/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d3509, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d3509, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiimage/uiimage"))] - pub const UIIMAGE: FunctionDef *const u32> = FunctionDef{address: 0x0050295e, function_type: PhantomData}; + pub const UIIMAGE: FunctionDef u32> = FunctionDef{address: 0x0050295e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiimage/create"))] - pub const CREATE: FunctionDef *const u32> = FunctionDef{address: 0x00606fd2, function_type: PhantomData}; + pub const CREATE: FunctionDef u32> = FunctionDef{address: 0x00606fd2, function_type: PhantomData}; } // UIImageSet class functions @@ -2104,7 +1982,7 @@ pub mod uiimageset { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uiimageset/set_status"))] - pub const SET_STATUS: FunctionDef = FunctionDef{address: 0x004f1b13, function_type: PhantomData}; + pub const SET_STATUS: FunctionDef = FunctionDef{address: 0x004f1b13, function_type: PhantomData}; } // UILayout class functions @@ -2112,23 +1990,21 @@ pub mod uilayout { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/draw"))] - pub const DRAW: FunctionDef = FunctionDef{address: 0x0041952b, function_type: PhantomData}; + pub const DRAW: FunctionDef = FunctionDef{address: 0x0041952b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/remove_element"))] - pub const REMOVE_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x0041ae42, function_type: PhantomData}; + pub const REMOVE_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x0041ae42, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/bring_to_front"))] - pub const BRING_TO_FRONT: FunctionDef = FunctionDef{address: 0x0041aeb1, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/hide"))] - pub const HIDE: FunctionDef = FunctionDef{address: 0x00443b70, function_type: PhantomData}; + pub const BRING_TO_FRONT: FunctionDef = FunctionDef{address: 0x0041aeb1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/show"))] - pub const SHOW: FunctionDef = FunctionDef{address: 0x004b1b86, function_type: PhantomData}; + pub const SHOW: FunctionDef = FunctionDef{address: 0x004b1b86, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/add_element"))] - pub const ADD_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004b206c, function_type: PhantomData}; + pub const ADD_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x004b206c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/load_element"))] - pub const LOAD_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x0050f61a, function_type: PhantomData}; + pub const LOAD_ELEMENT: FunctionDef u32> = FunctionDef{address: 0x0050f61a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/handle_left_button_up"))] - pub const HANDLE_LEFT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x0058c88e, function_type: PhantomData}; + pub const HANDLE_LEFT_BUTTON_UP: FunctionDef = FunctionDef{address: 0x0058c88e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilayout/handle_left_button_down"))] - pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x0058c8b4, function_type: PhantomData}; + pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x0058c8b4, function_type: PhantomData}; } // UIListBox class functions @@ -2136,57 +2012,49 @@ pub mod uilistbox { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/recalc_scroll_bar"))] - pub const RECALC_SCROLL_BAR: FunctionDef = FunctionDef{address: 0x00417645, function_type: PhantomData}; + pub const RECALC_SCROLL_BAR: FunctionDef = FunctionDef{address: 0x00417645, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/absolute_scroll"))] - pub const ABSOLUTE_SCROLL: FunctionDef = FunctionDef{address: 0x00417695, function_type: PhantomData}; + pub const ABSOLUTE_SCROLL: FunctionDef = FunctionDef{address: 0x00417695, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/local_render"))] - pub const LOCAL_RENDER: FunctionDef = FunctionDef{address: 0x00417a8e, function_type: PhantomData}; + pub const LOCAL_RENDER: FunctionDef = FunctionDef{address: 0x00417a8e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/add_string_0"))] - pub const ADD_STRING_0: FunctionDef = FunctionDef{address: 0x00417f79, function_type: PhantomData}; + pub const ADD_STRING_0: FunctionDef = FunctionDef{address: 0x00417f79, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/item_now_visible"))] - pub const ITEM_NOW_VISIBLE: FunctionDef = FunctionDef{address: 0x00418372, function_type: PhantomData}; + pub const ITEM_NOW_VISIBLE: FunctionDef = FunctionDef{address: 0x00418372, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/add_string_1"))] - pub const ADD_STRING_1: FunctionDef *const c_void> = FunctionDef{address: 0x00418504, function_type: PhantomData}; + pub const ADD_STRING_1: FunctionDef u32> = FunctionDef{address: 0x00418504, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/clear"))] - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004188de, function_type: PhantomData}; + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004188de, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/set_selected"))] - pub const SET_SELECTED: FunctionDef = FunctionDef{address: 0x004189e8, function_type: PhantomData}; + pub const SET_SELECTED: FunctionDef = FunctionDef{address: 0x004189e8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/show"))] - pub const SHOW: FunctionDef = FunctionDef{address: 0x00418a71, function_type: PhantomData}; + pub const SHOW: FunctionDef = FunctionDef{address: 0x00418a71, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/set_item_visible"))] - pub const SET_ITEM_VISIBLE: FunctionDef = FunctionDef{address: 0x00418bfb, function_type: PhantomData}; + pub const SET_ITEM_VISIBLE: FunctionDef = FunctionDef{address: 0x00418bfb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/get_item"))] - pub const GET_ITEM: FunctionDef u32> = FunctionDef{address: 0x0041ee59, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/hide"))] - pub const HIDE: FunctionDef = FunctionDef{address: 0x00443b9e, function_type: PhantomData}; + pub const GET_ITEM: FunctionDef u32> = FunctionDef{address: 0x0041ee59, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d393f, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/render"))] - pub const RENDER: FunctionDef = FunctionDef{address: 0x004ec999, function_type: PhantomData}; + pub const LOAD: FunctionDef = FunctionDef{address: 0x004d393f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/absolute_to_visible"))] - pub const ABSOLUTE_TO_VISIBLE: FunctionDef i32> = FunctionDef{address: 0x004ed6d2, function_type: PhantomData}; + pub const ABSOLUTE_TO_VISIBLE: FunctionDef i32> = FunctionDef{address: 0x004ed6d2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/restore_state"))] - pub const RESTORE_STATE: FunctionDef = FunctionDef{address: 0x004ef81c, function_type: PhantomData}; + pub const RESTORE_STATE: FunctionDef = FunctionDef{address: 0x004ef81c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/add_string_2"))] - pub const ADD_STRING_2: FunctionDef u32> = FunctionDef{address: 0x004f0331, function_type: PhantomData}; + pub const ADD_STRING_2: FunctionDef u32> = FunctionDef{address: 0x004f0331, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/get_item_string"))] - pub const GET_ITEM_STRING: FunctionDef *const i16> = FunctionDef{address: 0x004f05b2, function_type: PhantomData}; + pub const GET_ITEM_STRING: FunctionDef u32> = FunctionDef{address: 0x004f05b2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/item_now_invisible"))] - pub const ITEM_NOW_INVISIBLE: FunctionDef = FunctionDef{address: 0x004f984e, function_type: PhantomData}; + pub const ITEM_NOW_INVISIBLE: FunctionDef = FunctionDef{address: 0x004f984e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/remove_string"))] - pub const REMOVE_STRING: FunctionDef u32> = FunctionDef{address: 0x004f9908, function_type: PhantomData}; + pub const REMOVE_STRING: FunctionDef u32> = FunctionDef{address: 0x004f9908, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/increment"))] - pub const INCREMENT: FunctionDef u32> = FunctionDef{address: 0x004f9ffa, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/scroll"))] - pub const SCROLL: FunctionDef u32> = FunctionDef{address: 0x0053337e, function_type: PhantomData}; + pub const INCREMENT: FunctionDef u32> = FunctionDef{address: 0x004f9ffa, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/set_item_string"))] - pub const SET_ITEM_STRING: FunctionDef = FunctionDef{address: 0x005aecdc, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/set_item_icon"))] - pub const SET_ITEM_ICON: FunctionDef = FunctionDef{address: 0x005aed6d, function_type: PhantomData}; + pub const SET_ITEM_STRING: FunctionDef = FunctionDef{address: 0x005aecdc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/is_item_selected"))] - pub const IS_ITEM_SELECTED: FunctionDef u32> = FunctionDef{address: 0x00622dcb, function_type: PhantomData}; + pub const IS_ITEM_SELECTED: FunctionDef u32> = FunctionDef{address: 0x00622dcb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistbox/find_item_absolute_id"))] - pub const FIND_ITEM_ABSOLUTE_ID: FunctionDef i32> = FunctionDef{address: 0x00622e92, function_type: PhantomData}; + pub const FIND_ITEM_ABSOLUTE_ID: FunctionDef i32> = FunctionDef{address: 0x00622e92, function_type: PhantomData}; } // UIListBoxEntry class functions @@ -2194,45 +2062,39 @@ pub mod uilistboxentry { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxentry/calc_size"))] - pub const CALC_SIZE: FunctionDef = FunctionDef{address: 0x00417c8c, function_type: PhantomData}; + pub const CALC_SIZE: FunctionDef = FunctionDef{address: 0x00417c8c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxentry/set_normal_icon"))] - pub const SET_NORMAL_ICON: FunctionDef = FunctionDef{address: 0x00417e94, function_type: PhantomData}; + pub const SET_NORMAL_ICON: FunctionDef = FunctionDef{address: 0x00417e94, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxentry/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const i32> = FunctionDef{address: 0x004181f7, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004181f7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxentry/set_selected_icon"))] - pub const SET_SELECTED_ICON: FunctionDef = FunctionDef{address: 0x0047098b, function_type: PhantomData}; + pub const SET_SELECTED_ICON: FunctionDef = FunctionDef{address: 0x0047098b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxentry/set_grayed_icon"))] - pub const SET_GRAYED_ICON: FunctionDef = FunctionDef{address: 0x00474c26, function_type: PhantomData}; + pub const SET_GRAYED_ICON: FunctionDef = FunctionDef{address: 0x00474c26, function_type: PhantomData}; } // UIListBoxItem class functions pub mod uilistboxitem { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/find_entry"))] - pub const FIND_ENTRY: FunctionDef *const i32> = FunctionDef{address: 0x00417c59, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00418000, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00418000, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/calc_size"))] pub const CALC_SIZE: FunctionDef = FunctionDef{address: 0x0041848c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/set_justify"))] - pub const SET_JUSTIFY: FunctionDef = FunctionDef{address: 0x004185f6, function_type: PhantomData}; + pub const SET_JUSTIFY: FunctionDef = FunctionDef{address: 0x004185f6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/render_text_entries"))] - pub const RENDER_TEXT_ENTRIES: FunctionDef = FunctionDef{address: 0x004ecba7, function_type: PhantomData}; + pub const RENDER_TEXT_ENTRIES: FunctionDef = FunctionDef{address: 0x004ecba7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/render_icon_entries"))] - pub const RENDER_ICON_ENTRIES: FunctionDef = FunctionDef{address: 0x004ece25, function_type: PhantomData}; + pub const RENDER_ICON_ENTRIES: FunctionDef = FunctionDef{address: 0x004ece25, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/get_string"))] - pub const GET_STRING: FunctionDef *const i32> = FunctionDef{address: 0x004f0571, function_type: PhantomData}; + pub const GET_STRING: FunctionDef u32> = FunctionDef{address: 0x004f0571, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/add_entry"))] - pub const ADD_ENTRY: FunctionDef = FunctionDef{address: 0x00531863, function_type: PhantomData}; + pub const ADD_ENTRY: FunctionDef = FunctionDef{address: 0x00531863, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/disable"))] - pub const DISABLE: FunctionDef = FunctionDef{address: 0x0058f57c, function_type: PhantomData}; + pub const DISABLE: FunctionDef = FunctionDef{address: 0x0058f57c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/set_string"))] - pub const SET_STRING: FunctionDef = FunctionDef{address: 0x005aebf5, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/set_normal_icon"))] - pub const SET_NORMAL_ICON: FunctionDef = FunctionDef{address: 0x005aed23, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("uilistboxitem/set_selected_icon"))] - pub const SET_SELECTED_ICON: FunctionDef = FunctionDef{address: 0x00622b75, function_type: PhantomData}; + pub const SET_STRING: FunctionDef = FunctionDef{address: 0x005aebf5, function_type: PhantomData}; } // UIMessageQueue class functions @@ -2240,13 +2102,13 @@ pub mod uimessagequeue { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uimessagequeue/draw"))] - pub const DRAW: FunctionDef = FunctionDef{address: 0x004197fc, function_type: PhantomData}; + pub const DRAW: FunctionDef = FunctionDef{address: 0x004197fc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uimessagequeue/add_message"))] - pub const ADD_MESSAGE: FunctionDef u32> = FunctionDef{address: 0x0049cd46, function_type: PhantomData}; + pub const ADD_MESSAGE: FunctionDef u32> = FunctionDef{address: 0x0049cd46, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uimessagequeue/clear"))] - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6d4e, function_type: PhantomData}; + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6d4e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uimessagequeue/render"))] - pub const RENDER: FunctionDef = FunctionDef{address: 0x004fad0f, function_type: PhantomData}; + pub const RENDER: FunctionDef = FunctionDef{address: 0x004fad0f, function_type: PhantomData}; } // UIPointGraphRenderer class functions @@ -2254,7 +2116,7 @@ pub mod uipointgraphrenderer { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uipointgraphrenderer/render_graph"))] - pub const RENDER_GRAPH: FunctionDef = FunctionDef{address: 0x00623eb8, function_type: PhantomData}; + pub const RENDER_GRAPH: FunctionDef = FunctionDef{address: 0x00623eb8, function_type: PhantomData}; } // UIRadioSet class functions @@ -2262,7 +2124,7 @@ pub mod uiradioset { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uiradioset/select_button"))] - pub const SELECT_BUTTON: FunctionDef = FunctionDef{address: 0x004438fb, function_type: PhantomData}; + pub const SELECT_BUTTON: FunctionDef = FunctionDef{address: 0x004438fb, function_type: PhantomData}; } // UIScrollBar class functions @@ -2270,13 +2132,13 @@ pub mod uiscrollbar { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollbar/recalc_thumb_position"))] - pub const RECALC_THUMB_POSITION: FunctionDef = FunctionDef{address: 0x0041755a, function_type: PhantomData}; + pub const RECALC_THUMB_POSITION: FunctionDef = FunctionDef{address: 0x0041755a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollbar/render"))] - pub const RENDER: FunctionDef = FunctionDef{address: 0x004b22a2, function_type: PhantomData}; + pub const RENDER: FunctionDef = FunctionDef{address: 0x004b22a2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollbar/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00511212, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00511212, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollbar/copy"))] - pub const COPY: FunctionDef *const u32> = FunctionDef{address: 0x00620636, function_type: PhantomData}; + pub const COPY: FunctionDef u32> = FunctionDef{address: 0x00620636, function_type: PhantomData}; } // UIScrollingRegion class functions @@ -2284,31 +2146,31 @@ pub mod uiscrollingregion { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/vf_return0"))] - pub const VF_RETURN0: FunctionDef u32> = FunctionDef{address: 0x004010e1, function_type: PhantomData}; + pub const COPY: FunctionDef u32> = FunctionDef{address: 0x004010e1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/hide"))] - pub const HIDE: FunctionDef = FunctionDef{address: 0x00443981, function_type: PhantomData}; + pub const HIDE: FunctionDef = FunctionDef{address: 0x00443981, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d3e23, function_type: PhantomData}; + pub const LOAD: FunctionDef = FunctionDef{address: 0x004d3e23, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/init"))] - pub const INIT: FunctionDef u32> = FunctionDef{address: 0x004d4c85, function_type: PhantomData}; + pub const INIT: FunctionDef u32> = FunctionDef{address: 0x004d4c85, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/clear_selection"))] - pub const CLEAR_SELECTION: FunctionDef = FunctionDef{address: 0x004df638, function_type: PhantomData}; + pub const CLEAR_SELECTION: FunctionDef = FunctionDef{address: 0x004df638, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/depopulate"))] - pub const DEPOPULATE: FunctionDef u32> = FunctionDef{address: 0x004e0cd1, function_type: PhantomData}; + pub const DEPOPULATE: FunctionDef u32> = FunctionDef{address: 0x004e0cd1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/populate"))] - pub const POPULATE: FunctionDef u32> = FunctionDef{address: 0x004e90c2, function_type: PhantomData}; + pub const POPULATE: FunctionDef u32> = FunctionDef{address: 0x004e90c2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/show"))] - pub const SHOW: FunctionDef = FunctionDef{address: 0x004ea015, function_type: PhantomData}; + pub const SHOW: FunctionDef = FunctionDef{address: 0x004ea015, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/uiscrolling_region_0"))] - pub const UISCROLLING_REGION_0: FunctionDef *const u32> = FunctionDef{address: 0x00502fe5, function_type: PhantomData}; + pub const UISCROLLING_REGION_0: FunctionDef u32> = FunctionDef{address: 0x00502fe5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/uiscrolling_region_1"))] - pub const UISCROLLING_REGION_1: FunctionDef *const u32> = FunctionDef{address: 0x00503003, function_type: PhantomData}; + pub const UISCROLLING_REGION_1: FunctionDef u32> = FunctionDef{address: 0x00503003, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x005125d8, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x005125d8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/handle_char"))] - pub const HANDLE_CHAR: FunctionDef u32> = FunctionDef{address: 0x00622ef8, function_type: PhantomData}; + pub const HANDLE_CHAR: FunctionDef = FunctionDef{address: 0x00622ef8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiscrollingregion/select_next_button"))] - pub const SELECT_NEXT_BUTTON: FunctionDef = FunctionDef{address: 0x00622f18, function_type: PhantomData}; + pub const SELECT_NEXT_BUTTON: FunctionDef = FunctionDef{address: 0x00622f18, function_type: PhantomData}; } // UIStatusImage class functions @@ -2316,25 +2178,23 @@ pub mod uistatusimage { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uistatusimage/set_status"))] - pub const SET_STATUS: FunctionDef = FunctionDef{address: 0x0041cefc, function_type: PhantomData}; + pub const SET_STATUS: FunctionDef = FunctionDef{address: 0x0041cefc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uistatusimage/clear_for_load"))] - pub const CLEAR_FOR_LOAD: FunctionDef = FunctionDef{address: 0x004d3de0, function_type: PhantomData}; + pub const CLEAR_FOR_LOAD: FunctionDef = FunctionDef{address: 0x004d3de0, function_type: PhantomData}; } // UIText class functions pub mod uitext { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("uitext/set_text"))] - pub const SET_TEXT: FunctionDef *const u32> = FunctionDef{address: 0x0040495e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uitext/recalc_scroll_bar"))] - pub const RECALC_SCROLL_BAR: FunctionDef = FunctionDef{address: 0x0040eaa0, function_type: PhantomData}; + pub const RECALC_SCROLL_BAR: FunctionDef = FunctionDef{address: 0x0040eaa0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uitext/render"))] - pub const RENDER: FunctionDef = FunctionDef{address: 0x0041a476, function_type: PhantomData}; + pub const RENDER: FunctionDef = FunctionDef{address: 0x0041a476, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uitext/fit_to_text"))] - pub const FIT_TO_TEXT: FunctionDef = FunctionDef{address: 0x0041b0bb, function_type: PhantomData}; + pub const FIT_TO_TEXT: FunctionDef = FunctionDef{address: 0x0041b0bb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uitext/set_scroll_bar"))] - pub const SET_SCROLL_BAR: FunctionDef = FunctionDef{address: 0x004d4c5d, function_type: PhantomData}; + pub const SET_SCROLL_BAR: FunctionDef = FunctionDef{address: 0x004d4c5d, function_type: PhantomData}; } // UIView class functions @@ -2342,11 +2202,11 @@ pub mod uiview { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("uiview/constructor_0"))] - pub const CONSTRUCTOR_0: FunctionDef *const u32> = FunctionDef{address: 0x0052059c, function_type: PhantomData}; + pub const CONSTRUCTOR_0: FunctionDef u32> = FunctionDef{address: 0x0052059c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiview/copy"))] - pub const COPY: FunctionDef *const u32> = FunctionDef{address: 0x0060a8d2, function_type: PhantomData}; + pub const COPY: FunctionDef u32> = FunctionDef{address: 0x0060a8d2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("uiview/constructor_1"))] - pub const CONSTRUCTOR_1: FunctionDef *const u32> = FunctionDef{address: 0x00620a90, function_type: PhantomData}; + pub const CONSTRUCTOR_1: FunctionDef u32> = FunctionDef{address: 0x00620a90, function_type: PhantomData}; } // UpdateHandler class functions @@ -2354,33 +2214,31 @@ pub mod updatehandler { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/parse_index_0"))] - pub const PARSE_INDEX_0: FunctionDef = FunctionDef{address: 0x004ab2f7, function_type: PhantomData}; + pub const PARSE_INDEX_0: FunctionDef = FunctionDef{address: 0x004ab2f7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00624e20, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00624e20, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/prune_update_groups"))] - pub const PRUNE_UPDATE_GROUPS: FunctionDef = FunctionDef{address: 0x00624fb6, function_type: PhantomData}; + pub const PRUNE_UPDATE_GROUPS: FunctionDef = FunctionDef{address: 0x00624fb6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/destination_from_url"))] - pub const DESTINATION_FROM_URL: FunctionDef *const u32> = FunctionDef{address: 0x0062534b, function_type: PhantomData}; + pub const DESTINATION_FROM_URL: FunctionDef u32> = FunctionDef{address: 0x0062534b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/is_item_downloaded"))] pub const IS_ITEM_DOWNLOADED: FunctionDef u32> = FunctionDef{address: 0x006256d2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/finalize_updates"))] - pub const FINALIZE_UPDATES: FunctionDef = FunctionDef{address: 0x00625907, function_type: PhantomData}; + pub const FINALIZE_UPDATES: FunctionDef = FunctionDef{address: 0x00625907, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/move_file_from_tmp"))] - pub const MOVE_FILE_FROM_TMP: FunctionDef = FunctionDef{address: 0x00625a9b, function_type: PhantomData}; + pub const MOVE_FILE_FROM_TMP: FunctionDef = FunctionDef{address: 0x00625a9b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/parse_index_1"))] - pub const PARSE_INDEX_1: FunctionDef = FunctionDef{address: 0x00625d13, function_type: PhantomData}; + pub const PARSE_INDEX_1: FunctionDef = FunctionDef{address: 0x00625d13, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/start_index_download"))] - pub const START_INDEX_DOWNLOAD: FunctionDef = FunctionDef{address: 0x00626205, function_type: PhantomData}; + pub const START_INDEX_DOWNLOAD: FunctionDef = FunctionDef{address: 0x00626205, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/start_download"))] - pub const START_DOWNLOAD: FunctionDef = FunctionDef{address: 0x00626247, function_type: PhantomData}; + pub const START_DOWNLOAD: FunctionDef = FunctionDef{address: 0x00626247, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/download_file_group"))] - pub const DOWNLOAD_FILE_GROUP: FunctionDef = FunctionDef{address: 0x00626350, function_type: PhantomData}; + pub const DOWNLOAD_FILE_GROUP: FunctionDef = FunctionDef{address: 0x00626350, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/delete_bad_files"))] pub const DELETE_BAD_FILES: FunctionDef = FunctionDef{address: 0x006264bb, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/cancel_download"))] - pub const CANCEL_DOWNLOAD: FunctionDef = FunctionDef{address: 0x006265a0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("updatehandler/notify_done"))] - pub const NOTIFY_DONE: FunctionDef = FunctionDef{address: 0x006265c3, function_type: PhantomData}; + pub const NOTIFY_DONE: FunctionDef = FunctionDef{address: 0x006265c3, function_type: PhantomData}; } // ZLibControl class functions @@ -2388,9 +2246,9 @@ pub mod zlibcontrol { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("zlibcontrol/get_buffer"))] - pub const GET_BUFFER: FunctionDef = FunctionDef{address: 0x0040782e, function_type: PhantomData}; + pub const GET_BUFFER: FunctionDef = FunctionDef{address: 0x0040782e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zlibcontrol/decompress"))] - pub const DECOMPRESS: FunctionDef u32> = FunctionDef{address: 0x00408c1f, function_type: PhantomData}; + pub const DECOMPRESS: FunctionDef u32> = FunctionDef{address: 0x00408c1f, function_type: PhantomData}; } // ZTAIMgr class functions @@ -2400,71 +2258,71 @@ pub mod ztaimgr { #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_guest_routine_f"))] pub const F_GUEST_ROUTINE_F: FunctionDef = FunctionDef{address: 0x004224f5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_face_toward_food"))] - pub const F_FACE_TOWARD_FOOD: FunctionDef u32> = FunctionDef{address: 0x0042662c, function_type: PhantomData}; + pub const F_FACE_TOWARD_FOOD: FunctionDef u32> = FunctionDef{address: 0x0042662c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_face_toward_food_f"))] - pub const F_FACE_TOWARD_FOOD_F: FunctionDef = FunctionDef{address: 0x00426665, function_type: PhantomData}; + pub const F_FACE_TOWARD_FOOD_F: FunctionDef = FunctionDef{address: 0x00426665, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_face_toward_target"))] - pub const F_FACE_TOWARD_TARGET: FunctionDef u32> = FunctionDef{address: 0x00426e50, function_type: PhantomData}; + pub const F_FACE_TOWARD_TARGET: FunctionDef u32> = FunctionDef{address: 0x00426e50, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_face_toward_target_f"))] - pub const F_FACE_TOWARD_TARGET_F: FunctionDef = FunctionDef{address: 0x00426ed9, function_type: PhantomData}; + pub const F_FACE_TOWARD_TARGET_F: FunctionDef = FunctionDef{address: 0x00426ed9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_play_set_terrain_f"))] - pub const F_PLAY_SET_TERRAIN_F: FunctionDef u32> = FunctionDef{address: 0x004314d6, function_type: PhantomData}; + pub const F_PLAY_SET_TERRAIN_F: FunctionDef u32> = FunctionDef{address: 0x004314d6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/execute_call"))] - pub const EXECUTE_CALL: FunctionDef = FunctionDef{address: 0x00436065, function_type: PhantomData}; + pub const EXECUTE_CALL: FunctionDef = FunctionDef{address: 0x00436065, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_exit_building"))] - pub const F_EXIT_BUILDING: FunctionDef = FunctionDef{address: 0x004a7744, function_type: PhantomData}; + pub const F_EXIT_BUILDING: FunctionDef = FunctionDef{address: 0x004a7744, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_exit_building_f"))] - pub const F_EXIT_BUILDING_F: FunctionDef = FunctionDef{address: 0x004a777e, function_type: PhantomData}; + pub const F_EXIT_BUILDING_F: FunctionDef = FunctionDef{address: 0x004a777e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_keeper_routine_f"))] - pub const F_KEEPER_ROUTINE_F: FunctionDef = FunctionDef{address: 0x004a8763, function_type: PhantomData}; + pub const F_KEEPER_ROUTINE_F: FunctionDef = FunctionDef{address: 0x004a8763, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_maint_routine_f"))] pub const F_MAINT_ROUTINE_F: FunctionDef = FunctionDef{address: 0x004a945f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/ztaimgr"))] - pub const ZTAIMGR: FunctionDef *const u32> = FunctionDef{address: 0x00503857, function_type: PhantomData}; + pub const ZTAIMGR: FunctionDef u32> = FunctionDef{address: 0x00503857, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_show_predator"))] - pub const F_SHOW_PREDATOR: FunctionDef u32> = FunctionDef{address: 0x0050e6fa, function_type: PhantomData}; + pub const F_SHOW_PREDATOR: FunctionDef u32> = FunctionDef{address: 0x0050e6fa, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_show_predator_f"))] - pub const F_SHOW_PREDATOR_F: FunctionDef = FunctionDef{address: 0x0050e764, function_type: PhantomData}; + pub const F_SHOW_PREDATOR_F: FunctionDef = FunctionDef{address: 0x0050e764, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_hide_predator_f"))] - pub const F_HIDE_PREDATOR_F: FunctionDef = FunctionDef{address: 0x0050e879, function_type: PhantomData}; + pub const F_HIDE_PREDATOR_F: FunctionDef = FunctionDef{address: 0x0050e879, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/create"))] - pub const CREATE: FunctionDef u32> = FunctionDef{address: 0x00525961, function_type: PhantomData}; + pub const CREATE: FunctionDef = FunctionDef{address: 0x00525961, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/init_aiparams"))] - pub const INIT_AIPARAMS: FunctionDef u32> = FunctionDef{address: 0x0052599f, function_type: PhantomData}; + pub const INIT_AIPARAMS: FunctionDef = FunctionDef{address: 0x0052599f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_caught_prey"))] - pub const F_CAUGHT_PREY: FunctionDef u32> = FunctionDef{address: 0x00588c2d, function_type: PhantomData}; + pub const F_CAUGHT_PREY: FunctionDef u32> = FunctionDef{address: 0x00588c2d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_dust_ball"))] - pub const F_DUST_BALL: FunctionDef u32> = FunctionDef{address: 0x00588d47, function_type: PhantomData}; + pub const F_DUST_BALL: FunctionDef u32> = FunctionDef{address: 0x00588d47, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_dust_ball_f"))] - pub const F_DUST_BALL_F: FunctionDef = FunctionDef{address: 0x00588f69, function_type: PhantomData}; + pub const F_DUST_BALL_F: FunctionDef = FunctionDef{address: 0x00588f69, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_guide_routine_f"))] pub const F_GUIDE_ROUTINE_F: FunctionDef = FunctionDef{address: 0x0058a998, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_caught_prey_f"))] - pub const F_CAUGHT_PREY_F: FunctionDef = FunctionDef{address: 0x005a593f, function_type: PhantomData}; + pub const F_CAUGHT_PREY_F: FunctionDef = FunctionDef{address: 0x005a593f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_target_building_f"))] - pub const F_TARGET_BUILDING_F: FunctionDef u32> = FunctionDef{address: 0x005a5b71, function_type: PhantomData}; + pub const F_TARGET_BUILDING_F: FunctionDef u32> = FunctionDef{address: 0x005a5b71, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_end_trick_f"))] - pub const F_END_TRICK_F: FunctionDef = FunctionDef{address: 0x005a6a22, function_type: PhantomData}; + pub const F_END_TRICK_F: FunctionDef = FunctionDef{address: 0x005a6a22, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_enter_building_f"))] - pub const F_ENTER_BUILDING_F: FunctionDef = FunctionDef{address: 0x005ad42c, function_type: PhantomData}; + pub const F_ENTER_BUILDING_F: FunctionDef = FunctionDef{address: 0x005ad42c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_play_set_tank_f"))] - pub const F_PLAY_SET_TANK_F: FunctionDef u32> = FunctionDef{address: 0x005b2be5, function_type: PhantomData}; + pub const F_PLAY_SET_TANK_F: FunctionDef u32> = FunctionDef{address: 0x005b2be5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_spray_f"))] - pub const F_SPRAY_F: FunctionDef = FunctionDef{address: 0x0060caad, function_type: PhantomData}; + pub const F_SPRAY_F: FunctionDef = FunctionDef{address: 0x0060caad, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_hatch_f"))] - pub const F_HATCH_F: FunctionDef = FunctionDef{address: 0x0060cacb, function_type: PhantomData}; + pub const F_HATCH_F: FunctionDef = FunctionDef{address: 0x0060cacb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_hatch"))] - pub const F_HATCH: FunctionDef u32> = FunctionDef{address: 0x0060cae0, function_type: PhantomData}; + pub const F_HATCH: FunctionDef u32> = FunctionDef{address: 0x0060cae0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_kill_prey_f"))] - pub const F_KILL_PREY_F: FunctionDef = FunctionDef{address: 0x0060cb25, function_type: PhantomData}; + pub const F_KILL_PREY_F: FunctionDef = FunctionDef{address: 0x0060cb25, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_kill_prey"))] - pub const F_KILL_PREY: FunctionDef u32> = FunctionDef{address: 0x0060cb3a, function_type: PhantomData}; + pub const F_KILL_PREY: FunctionDef u32> = FunctionDef{address: 0x0060cb3a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_die_f"))] - pub const F_DIE_F: FunctionDef = FunctionDef{address: 0x0060cbb3, function_type: PhantomData}; + pub const F_DIE_F: FunctionDef = FunctionDef{address: 0x0060cbb3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_die"))] - pub const F_DIE: FunctionDef u32> = FunctionDef{address: 0x0060cbc8, function_type: PhantomData}; + pub const F_DIE: FunctionDef u32> = FunctionDef{address: 0x0060cbc8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztaimgr/f_return_to_building_f"))] - pub const F_RETURN_TO_BUILDING_F: FunctionDef = FunctionDef{address: 0x0060cc66, function_type: PhantomData}; + pub const F_RETURN_TO_BUILDING_F: FunctionDef = FunctionDef{address: 0x0060cc66, function_type: PhantomData}; } // ZTAdvTerrainMgr class functions @@ -2472,41 +2330,41 @@ pub mod ztadvterrainmgr { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00419e14, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00419e14, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/setup_render"))] - pub const SETUP_RENDER: FunctionDef u32> = FunctionDef{address: 0x00463e60, function_type: PhantomData}; + pub const SETUP_RENDER: FunctionDef u32> = FunctionDef{address: 0x00463e60, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/set_ground_image"))] - pub const SET_GROUND_IMAGE: FunctionDef i8> = FunctionDef{address: 0x004ac218, function_type: PhantomData}; + pub const SET_GROUND_IMAGE: FunctionDef i8> = FunctionDef{address: 0x004ac218, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/render_shape"))] - pub const RENDER_SHAPE: FunctionDef u32> = FunctionDef{address: 0x004adff8, function_type: PhantomData}; + pub const RENDER_SHAPE: FunctionDef u32> = FunctionDef{address: 0x004adff8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/render_pass"))] - pub const RENDER_PASS: FunctionDef u32> = FunctionDef{address: 0x004ae4b3, function_type: PhantomData}; + pub const RENDER_PASS: FunctionDef u32> = FunctionDef{address: 0x004ae4b3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/set_aux_image"))] - pub const SET_AUX_IMAGE: FunctionDef = FunctionDef{address: 0x004aecb2, function_type: PhantomData}; + pub const SET_AUX_IMAGE: FunctionDef = FunctionDef{address: 0x004aecb2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/set_image"))] - pub const SET_IMAGE: FunctionDef u32> = FunctionDef{address: 0x004aede5, function_type: PhantomData}; + pub const SET_IMAGE: FunctionDef u32> = FunctionDef{address: 0x004aede5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/stop"))] - pub const STOP: FunctionDef = FunctionDef{address: 0x005039cd, function_type: PhantomData}; + pub const STOP: FunctionDef = FunctionDef{address: 0x005039cd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/stop2d"))] - pub const STOP2D: FunctionDef = FunctionDef{address: 0x00503b7a, function_type: PhantomData}; + pub const STOP2D: FunctionDef = FunctionDef{address: 0x00503b7a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/ztadv_terrain_mgr_0"))] - pub const ZTADV_TERRAIN_MGR_0: FunctionDef *const u32> = FunctionDef{address: 0x0050435b, function_type: PhantomData}; + pub const ZTADV_TERRAIN_MGR_0: FunctionDef u32> = FunctionDef{address: 0x0050435b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/ztadv_terrain_mgr_1"))] - pub const ZTADV_TERRAIN_MGR_1: FunctionDef *const u32> = FunctionDef{address: 0x0050458d, function_type: PhantomData}; + pub const ZTADV_TERRAIN_MGR_1: FunctionDef u32> = FunctionDef{address: 0x0050458d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/start"))] - pub const START: FunctionDef u32> = FunctionDef{address: 0x00522470, function_type: PhantomData}; + pub const START: FunctionDef u32> = FunctionDef{address: 0x00522470, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/load_textures_0"))] - pub const LOAD_TEXTURES_0: FunctionDef u32> = FunctionDef{address: 0x005224b9, function_type: PhantomData}; + pub const LOAD_TEXTURES_0: FunctionDef u32> = FunctionDef{address: 0x005224b9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/load_textures_1"))] pub const LOAD_TEXTURES_1: FunctionDef = FunctionDef{address: 0x005228b3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/start2d"))] - pub const START2D: FunctionDef u32> = FunctionDef{address: 0x00522bd4, function_type: PhantomData}; + pub const START2D: FunctionDef u32> = FunctionDef{address: 0x00522bd4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/start_d3d"))] - pub const START_D3D: FunctionDef u32> = FunctionDef{address: 0x00523ba3, function_type: PhantomData}; + pub const START_D3D: FunctionDef u32> = FunctionDef{address: 0x00523ba3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/create"))] - pub const CREATE: FunctionDef u32> = FunctionDef{address: 0x00525470, function_type: PhantomData}; + pub const CREATE: FunctionDef = FunctionDef{address: 0x00525470, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztadvterrainmgr/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x005254af, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef = FunctionDef{address: 0x005254af, function_type: PhantomData}; } // ZTAmbient class functions @@ -2514,23 +2372,23 @@ pub mod ztambient { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/ztambient_0"))] - pub const ZTAMBIENT_0: FunctionDef *const u32> = FunctionDef{address: 0x00420519, function_type: PhantomData}; + pub const ZTAMBIENT_0: FunctionDef u32> = FunctionDef{address: 0x00420519, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/ztambient_1"))] - pub const ZTAMBIENT_1: FunctionDef *const u32> = FunctionDef{address: 0x00420547, function_type: PhantomData}; + pub const ZTAMBIENT_1: FunctionDef u32> = FunctionDef{address: 0x00420547, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/calc_shadow_world_position"))] - pub const CALC_SHADOW_WORLD_POSITION: FunctionDef = FunctionDef{address: 0x00433cad, function_type: PhantomData}; + pub const CALC_SHADOW_WORLD_POSITION: FunctionDef = FunctionDef{address: 0x00433cad, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/update_position"))] - pub const UPDATE_POSITION: FunctionDef = FunctionDef{address: 0x00434e9c, function_type: PhantomData}; + pub const UPDATE_POSITION: FunctionDef = FunctionDef{address: 0x00434e9c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00450261, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00450261, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047a7fd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/init"))] - pub const INIT: FunctionDef = FunctionDef{address: 0x004fc145, function_type: PhantomData}; + pub const INIT: FunctionDef = FunctionDef{address: 0x004fc145, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/init_status_vars"))] - pub const INIT_STATUS_VARS: FunctionDef = FunctionDef{address: 0x004fc160, function_type: PhantomData}; + pub const INIT_STATUS_VARS: FunctionDef = FunctionDef{address: 0x004fc160, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztambient/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004fc3aa, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004fc3aa, function_type: PhantomData}; } // ZTAmbientType class functions @@ -2538,17 +2396,17 @@ pub mod ztambienttype { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztambienttype/load_characteristics"))] - pub const LOAD_CHARACTERISTICS: FunctionDef u8> = FunctionDef{address: 0x004c2ec9, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x004c2ec9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztambienttype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x004fc358, function_type: PhantomData}; + pub const CREATE_ENTITY: FunctionDef = FunctionDef{address: 0x004fc358, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztambienttype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x0051ca20, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztambienttype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051cd83, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051cd83, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztambienttype/ztambient_type_0"))] - pub const ZTAMBIENT_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x0057cc85, function_type: PhantomData}; + pub const ZTAMBIENT_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x0057cc85, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztambienttype/ztambient_type_1"))] - pub const ZTAMBIENT_TYPE_1: FunctionDef *const i32> = FunctionDef{address: 0x0057cccb, function_type: PhantomData}; + pub const ZTAMBIENT_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x0057cccb, function_type: PhantomData}; } // ZTAnimal class functions @@ -2556,155 +2414,147 @@ pub mod ztanimal { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/calc_habitat"))] - pub const CALC_HABITAT: FunctionDef = FunctionDef{address: 0x00410675, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_swims"))] - pub const GET_SWIMS: FunctionDef u32> = FunctionDef{address: 0x004107d4, function_type: PhantomData}; + pub const CALC_HABITAT: FunctionDef = FunctionDef{address: 0x00410675, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_footprint"))] pub const GET_FOOTPRINT: FunctionDef *const u32> = FunctionDef{address: 0x00410803, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_habitat_rating"))] - pub const GET_HABITAT_RATING: FunctionDef i64> = FunctionDef{address: 0x00411afd, function_type: PhantomData}; + pub const GET_HABITAT_RATING: FunctionDef i32> = FunctionDef{address: 0x00411afd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/set_home_habitat"))] - pub const SET_HOME_HABITAT: FunctionDef = FunctionDef{address: 0x00411b92, function_type: PhantomData}; + pub const SET_HOME_HABITAT: FunctionDef = FunctionDef{address: 0x00411b92, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_idle_anim"))] - pub const GET_IDLE_ANIM: FunctionDef i32> = FunctionDef{address: 0x00413582, function_type: PhantomData}; + pub const GET_IDLE_ANIM: FunctionDef i32> = FunctionDef{address: 0x00413582, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/preys_on_man"))] - pub const PREYS_ON_MAN: FunctionDef u32> = FunctionDef{address: 0x004138f0, function_type: PhantomData}; + pub const PREYS_ON_MAN: FunctionDef u32> = FunctionDef{address: 0x004138f0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/is_in_prey_list"))] - pub const IS_IN_PREY_LIST: FunctionDef u32> = FunctionDef{address: 0x0041391d, function_type: PhantomData}; + pub const IS_IN_PREY_LIST: FunctionDef u32> = FunctionDef{address: 0x0041391d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/set_terrain_mode"))] - pub const SET_TERRAIN_MODE: FunctionDef = FunctionDef{address: 0x004139c9, function_type: PhantomData}; + pub const SET_TERRAIN_MODE: FunctionDef = FunctionDef{address: 0x004139c9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_terrain_cost"))] - pub const GET_TERRAIN_COST: FunctionDef u32> = FunctionDef{address: 0x00414b13, function_type: PhantomData}; + pub const GET_TERRAIN_COST: FunctionDef u32> = FunctionDef{address: 0x00414b13, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/is_walkable"))] - pub const IS_WALKABLE: FunctionDef u32> = FunctionDef{address: 0x00414c7f, function_type: PhantomData}; + pub const IS_WALKABLE: FunctionDef = FunctionDef{address: 0x00414c7f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/recalc_home_habitat"))] - pub const RECALC_HOME_HABITAT: FunctionDef = FunctionDef{address: 0x00416185, function_type: PhantomData}; + pub const RECALC_HOME_HABITAT: FunctionDef = FunctionDef{address: 0x00416185, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/is_unhappy_with_habitat"))] - pub const IS_UNHAPPY_WITH_HABITAT: FunctionDef u32> = FunctionDef{address: 0x00418b8c, function_type: PhantomData}; + pub const IS_UNHAPPY_WITH_HABITAT: FunctionDef u32> = FunctionDef{address: 0x00418b8c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/face_toward_food"))] - pub const FACE_TOWARD_FOOD: FunctionDef = FunctionDef{address: 0x0042661b, function_type: PhantomData}; + pub const FACE_TOWARD_FOOD: FunctionDef = FunctionDef{address: 0x0042661b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/is_preattack"))] - pub const IS_PREATTACK: FunctionDef u32> = FunctionDef{address: 0x0042fad3, function_type: PhantomData}; + pub const IS_PREATTACK: FunctionDef u32> = FunctionDef{address: 0x0042fad3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/f_check_reproduction"))] - pub const F_CHECK_REPRODUCTION: FunctionDef u32> = FunctionDef{address: 0x0043103b, function_type: PhantomData}; + pub const F_CHECK_REPRODUCTION: FunctionDef u32> = FunctionDef{address: 0x0043103b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/is_walkable_by"))] - pub const IS_WALKABLE_BY: FunctionDef u32> = FunctionDef{address: 0x00431696, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_only_swims"))] - pub const GET_ONLY_SWIMS: FunctionDef = FunctionDef{address: 0x00431b47, function_type: PhantomData}; + pub const IS_WALKABLE_BY: FunctionDef u32> = FunctionDef{address: 0x00431696, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/draw"))] - pub const DRAW: FunctionDef = FunctionDef{address: 0x00433933, function_type: PhantomData}; + pub const DRAW: FunctionDef = FunctionDef{address: 0x00433933, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00436f11, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00436f11, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/update_position"))] - pub const UPDATE_POSITION: FunctionDef = FunctionDef{address: 0x00436f32, function_type: PhantomData}; + pub const UPDATE_POSITION: FunctionDef = FunctionDef{address: 0x00436f32, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/update_goals"))] - pub const UPDATE_GOALS: FunctionDef = FunctionDef{address: 0x00436f5c, function_type: PhantomData}; + pub const UPDATE_GOALS: FunctionDef = FunctionDef{address: 0x00436f5c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_ambient_anims"))] - pub const DO_AMBIENT_ANIMS: FunctionDef = FunctionDef{address: 0x00437102, function_type: PhantomData}; + pub const DO_AMBIENT_ANIMS: FunctionDef = FunctionDef{address: 0x00437102, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_conditionals"))] - pub const DO_CONDITIONALS: FunctionDef = FunctionDef{address: 0x00437620, function_type: PhantomData}; + pub const DO_CONDITIONALS: FunctionDef = FunctionDef{address: 0x00437620, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_boxed_check"))] - pub const DO_BOXED_CHECK: FunctionDef *const u32> = FunctionDef{address: 0x004377fc, function_type: PhantomData}; + pub const DO_BOXED_CHECK: FunctionDef u32> = FunctionDef{address: 0x004377fc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_egg_check"))] - pub const DO_EGG_CHECK: FunctionDef = FunctionDef{address: 0x00437860, function_type: PhantomData}; + pub const DO_EGG_CHECK: FunctionDef = FunctionDef{address: 0x00437860, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/update_status_variables"))] - pub const UPDATE_STATUS_VARIABLES: FunctionDef = FunctionDef{address: 0x004378df, function_type: PhantomData}; + pub const UPDATE_STATUS_VARIABLES: FunctionDef = FunctionDef{address: 0x004378df, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_sleep_check"))] - pub const DO_SLEEP_CHECK: FunctionDef = FunctionDef{address: 0x004384ba, function_type: PhantomData}; + pub const DO_SLEEP_CHECK: FunctionDef = FunctionDef{address: 0x004384ba, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_escaped_check"))] - pub const DO_ESCAPED_CHECK: FunctionDef = FunctionDef{address: 0x00438514, function_type: PhantomData}; + pub const DO_ESCAPED_CHECK: FunctionDef = FunctionDef{address: 0x00438514, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_reproduce_check"))] - pub const DO_REPRODUCE_CHECK: FunctionDef = FunctionDef{address: 0x004385e5, function_type: PhantomData}; + pub const DO_REPRODUCE_CHECK: FunctionDef = FunctionDef{address: 0x004385e5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_baby_to_adult_check"))] - pub const DO_BABY_TO_ADULT_CHECK: FunctionDef = FunctionDef{address: 0x00438663, function_type: PhantomData}; + pub const DO_BABY_TO_ADULT_CHECK: FunctionDef = FunctionDef{address: 0x00438663, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_social_check"))] - pub const DO_SOCIAL_CHECK: FunctionDef = FunctionDef{address: 0x004386a9, function_type: PhantomData}; + pub const DO_SOCIAL_CHECK: FunctionDef = FunctionDef{address: 0x004386a9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_health_check"))] - pub const DO_HEALTH_CHECK: FunctionDef = FunctionDef{address: 0x004389aa, function_type: PhantomData}; + pub const DO_HEALTH_CHECK: FunctionDef = FunctionDef{address: 0x004389aa, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_breath_check"))] - pub const DO_BREATH_CHECK: FunctionDef = FunctionDef{address: 0x004389f7, function_type: PhantomData}; + pub const DO_BREATH_CHECK: FunctionDef = FunctionDef{address: 0x004389f7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_murky_water_check"))] - pub const DO_MURKY_WATER_CHECK: FunctionDef = FunctionDef{address: 0x00438a37, function_type: PhantomData}; + pub const DO_MURKY_WATER_CHECK: FunctionDef = FunctionDef{address: 0x00438a37, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_hunger_check"))] - pub const DO_HUNGER_CHECK: FunctionDef = FunctionDef{address: 0x00438a79, function_type: PhantomData}; + pub const DO_HUNGER_CHECK: FunctionDef = FunctionDef{address: 0x00438a79, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_bored_check"))] - pub const DO_BORED_CHECK: FunctionDef = FunctionDef{address: 0x00438ad7, function_type: PhantomData}; + pub const DO_BORED_CHECK: FunctionDef = FunctionDef{address: 0x00438ad7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_habitat_check"))] - pub const DO_HABITAT_CHECK: FunctionDef = FunctionDef{address: 0x00438c47, function_type: PhantomData}; + pub const DO_HABITAT_CHECK: FunctionDef = FunctionDef{address: 0x00438c47, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_keeper_check"))] - pub const DO_KEEPER_CHECK: FunctionDef = FunctionDef{address: 0x00438d31, function_type: PhantomData}; + pub const DO_KEEPER_CHECK: FunctionDef = FunctionDef{address: 0x00438d31, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_other_check"))] - pub const DO_OTHER_CHECK: FunctionDef = FunctionDef{address: 0x00438e70, function_type: PhantomData}; + pub const DO_OTHER_CHECK: FunctionDef = FunctionDef{address: 0x00438e70, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_zap_check"))] - pub const DO_ZAP_CHECK: FunctionDef u32> = FunctionDef{address: 0x00438ebc, function_type: PhantomData}; + pub const DO_ZAP_CHECK: FunctionDef u32> = FunctionDef{address: 0x00438ebc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_building_use_check"))] - pub const DO_BUILDING_USE_CHECK: FunctionDef u32> = FunctionDef{address: 0x00438f20, function_type: PhantomData}; + pub const DO_BUILDING_USE_CHECK: FunctionDef u32> = FunctionDef{address: 0x00438f20, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/do_water_check"))] - pub const DO_WATER_CHECK: FunctionDef *const c_void> = FunctionDef{address: 0x00438f6c, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/set_visible"))] - pub const SET_VISIBLE: FunctionDef = FunctionDef{address: 0x0043f0d5, function_type: PhantomData}; + pub const DO_WATER_CHECK: FunctionDef u32> = FunctionDef{address: 0x00438f6c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/set_escaped"))] - pub const SET_ESCAPED: FunctionDef = FunctionDef{address: 0x004409f8, function_type: PhantomData}; + pub const SET_ESCAPED: FunctionDef = FunctionDef{address: 0x004409f8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/add_to_map"))] - pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x00449c94, function_type: PhantomData}; + pub const ADD_TO_MAP: FunctionDef = FunctionDef{address: 0x00449c94, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00453cc6, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00453cc6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00455533, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00455533, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/save"))] pub const SAVE: FunctionDef = FunctionDef{address: 0x00478cff, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_undesirable_scenery_in_habitat"))] - pub const GET_UNDESIRABLE_SCENERY_IN_HABITAT: FunctionDef *const i32> = FunctionDef{address: 0x00483979, function_type: PhantomData}; + pub const GET_UNDESIRABLE_SCENERY_IN_HABITAT: FunctionDef u32> = FunctionDef{address: 0x00483979, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/chase_done"))] - pub const CHASE_DONE: FunctionDef = FunctionDef{address: 0x004a4d5f, function_type: PhantomData}; + pub const CHASE_DONE: FunctionDef = FunctionDef{address: 0x004a4d5f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/stop_chase"))] - pub const STOP_CHASE: FunctionDef = FunctionDef{address: 0x004a5e00, function_type: PhantomData}; + pub const STOP_CHASE: FunctionDef = FunctionDef{address: 0x004a5e00, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/put_down_dirt"))] - pub const PUT_DOWN_DIRT: FunctionDef bool> = FunctionDef{address: 0x004a8f89, function_type: PhantomData}; + pub const PUT_DOWN_DIRT: FunctionDef bool> = FunctionDef{address: 0x004a8f89, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/set_name"))] - pub const SET_NAME: FunctionDef = FunctionDef{address: 0x004e1d6b, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_icon_zoom"))] - pub const GET_ICON_ZOOM: FunctionDef i32> = FunctionDef{address: 0x004edb32, function_type: PhantomData}; + pub const SET_NAME: FunctionDef = FunctionDef{address: 0x004e1d6b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/get_icon_anim"))] - pub const GET_ICON_ANIM: FunctionDef u32> = FunctionDef{address: 0x004ee5be, function_type: PhantomData}; + pub const GET_ICON_ANIM: FunctionDef = FunctionDef{address: 0x004ee5be, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/ztanimal_0"))] - pub const ZTANIMAL_0: FunctionDef *const u32> = FunctionDef{address: 0x004f9d83, function_type: PhantomData}; + pub const ZTANIMAL_0: FunctionDef u32> = FunctionDef{address: 0x004f9d83, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/ztanimal_1"))] - pub const ZTANIMAL_1: FunctionDef *const u32> = FunctionDef{address: 0x004f9dac, function_type: PhantomData}; + pub const ZTANIMAL_1: FunctionDef u32> = FunctionDef{address: 0x004f9dac, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/ztanimal_2"))] - pub const ZTANIMAL_2: FunctionDef *const u32> = FunctionDef{address: 0x004f9e18, function_type: PhantomData}; + pub const ZTANIMAL_2: FunctionDef u32> = FunctionDef{address: 0x004f9e18, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/is_selectable"))] - pub const IS_SELECTABLE: FunctionDef bool> = FunctionDef{address: 0x004fb70d, function_type: PhantomData}; + pub const IS_SELECTABLE: FunctionDef = FunctionDef{address: 0x004fb70d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/stop_eating"))] - pub const STOP_EATING: FunctionDef = FunctionDef{address: 0x004fd86e, function_type: PhantomData}; + pub const STOP_EATING: FunctionDef = FunctionDef{address: 0x004fd86e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/f_eat"))] - pub const F_EAT: FunctionDef *const u32> = FunctionDef{address: 0x004fd951, function_type: PhantomData}; + pub const F_EAT: FunctionDef u32> = FunctionDef{address: 0x004fd951, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004fe296, function_type: PhantomData}; + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004fe296, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/box"))] - pub const BOX: FunctionDef u32> = FunctionDef{address: 0x00505941, function_type: PhantomData}; + pub const BOX: FunctionDef u32> = FunctionDef{address: 0x00505941, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/consume"))] - pub const CONSUME: FunctionDef = FunctionDef{address: 0x0050e648, function_type: PhantomData}; + pub const CONSUME: FunctionDef = FunctionDef{address: 0x0050e648, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/within_preattack_range"))] - pub const WITHIN_PREATTACK_RANGE: FunctionDef u32> = FunctionDef{address: 0x0050eae2, function_type: PhantomData}; + pub const WITHIN_PREATTACK_RANGE: FunctionDef u32> = FunctionDef{address: 0x0050eae2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/show_escaped_animal_alert"))] - pub const SHOW_ESCAPED_ANIMAL_ALERT: FunctionDef = FunctionDef{address: 0x0058cb88, function_type: PhantomData}; + pub const SHOW_ESCAPED_ANIMAL_ALERT: FunctionDef = FunctionDef{address: 0x0058cb88, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/drop_test_fence_chance"))] - pub const DROP_TEST_FENCE_CHANCE: FunctionDef = FunctionDef{address: 0x0059c4ba, function_type: PhantomData}; + pub const DROP_TEST_FENCE_CHANCE: FunctionDef = FunctionDef{address: 0x0059c4ba, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/set_egg"))] - pub const SET_EGG: FunctionDef = FunctionDef{address: 0x005a5283, function_type: PhantomData}; + pub const SET_EGG: FunctionDef = FunctionDef{address: 0x005a5283, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/set_dying"))] - pub const SET_DYING: FunctionDef = FunctionDef{address: 0x005a5606, function_type: PhantomData}; + pub const SET_DYING: FunctionDef = FunctionDef{address: 0x005a5606, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/draw_aiinfo"))] - pub const DRAW_AIINFO: FunctionDef = FunctionDef{address: 0x00613641, function_type: PhantomData}; + pub const DRAW_AIINFO: FunctionDef = FunctionDef{address: 0x00613641, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/break_escape_fence"))] - pub const BREAK_ESCAPE_FENCE: FunctionDef = FunctionDef{address: 0x006137fe, function_type: PhantomData}; + pub const BREAK_ESCAPE_FENCE: FunctionDef = FunctionDef{address: 0x006137fe, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/change_to_dirt"))] pub const CHANGE_TO_DIRT: FunctionDef = FunctionDef{address: 0x00613c0c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/hatch_egg"))] - pub const HATCH_EGG: FunctionDef = FunctionDef{address: 0x00613ca6, function_type: PhantomData}; + pub const HATCH_EGG: FunctionDef = FunctionDef{address: 0x00613ca6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimal/finish_hatch"))] - pub const FINISH_HATCH: FunctionDef = FunctionDef{address: 0x00613d24, function_type: PhantomData}; + pub const FINISH_HATCH: FunctionDef = FunctionDef{address: 0x00613d24, function_type: PhantomData}; } // ZTAnimalType class functions @@ -2712,21 +2562,17 @@ pub mod ztanimaltype { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x00453d41, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/load_data"))] - pub const LOAD_DATA: FunctionDef = FunctionDef{address: 0x004b6381, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/set_idle_animation"))] - pub const SET_IDLE_ANIMATION: FunctionDef u32> = FunctionDef{address: 0x004b6456, function_type: PhantomData}; + pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x00453d41, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/load_characteristics_0"))] - pub const LOAD_CHARACTERISTICS_0: FunctionDef u8> = FunctionDef{address: 0x004b659e, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_0: FunctionDef = FunctionDef{address: 0x004b659e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/load_characteristics_1"))] - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b6c51, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b6c51, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x004be6ff, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004bece3, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004bece3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztanimaltype/ztanimal_type"))] - pub const ZTANIMAL_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x00500be5, function_type: PhantomData}; + pub const ZTANIMAL_TYPE: FunctionDef u32> = FunctionDef{address: 0x00500be5, function_type: PhantomData}; } // ZTApp class functions @@ -2734,67 +2580,59 @@ pub mod ztapp { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_app"))] - pub const GET_APP: FunctionDef *const u32> = FunctionDef{address: 0x004010c7, function_type: PhantomData}; + pub const GET_APP: FunctionDef u32> = FunctionDef{address: 0x004010c7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/redraw_screen"))] - pub const REDRAW_SCREEN: FunctionDef = FunctionDef{address: 0x00419312, function_type: PhantomData}; + pub const REDRAW_SCREEN: FunctionDef = FunctionDef{address: 0x00419312, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/update_ui"))] - pub const UPDATE_UI: FunctionDef = FunctionDef{address: 0x00419d8c, function_type: PhantomData}; + pub const UPDATE_UI: FunctionDef = FunctionDef{address: 0x00419d8c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/do_each_loop"))] - pub const DO_EACH_LOOP: FunctionDef = FunctionDef{address: 0x0041a6cc, function_type: PhantomData}; + pub const DO_EACH_LOOP: FunctionDef = FunctionDef{address: 0x0041a6cc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/update_sim"))] pub const UPDATE_SIM: FunctionDef = FunctionDef{address: 0x0041a6d1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_screen_center"))] - pub const GET_SCREEN_CENTER: FunctionDef = FunctionDef{address: 0x0043f30d, function_type: PhantomData}; + pub const GET_SCREEN_CENTER: FunctionDef = FunctionDef{address: 0x0043f30d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/handle_messages"))] - pub const HANDLE_MESSAGES: FunctionDef u32> = FunctionDef{address: 0x00441880, function_type: PhantomData}; + pub const HANDLE_MESSAGES: FunctionDef i32> = FunctionDef{address: 0x00441880, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/handle_char2"))] pub const HANDLE_CHAR2: FunctionDef u32> = FunctionDef{address: 0x0046bdd6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/init_instance"))] - pub const INIT_INSTANCE: FunctionDef u32> = FunctionDef{address: 0x004bc17f, function_type: PhantomData}; + pub const INIT_INSTANCE: FunctionDef = FunctionDef{address: 0x004bc17f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/restart_graphics_mgr"))] - pub const RESTART_GRAPHICS_MGR: FunctionDef u32> = FunctionDef{address: 0x004caa0f, function_type: PhantomData}; + pub const RESTART_GRAPHICS_MGR: FunctionDef u32> = FunctionDef{address: 0x004caa0f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/reload_ui"))] pub const RELOAD_UI: FunctionDef = FunctionDef{address: 0x004d5a49, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/toggle_fullscreen"))] - pub const TOGGLE_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d5c7f, function_type: PhantomData}; + pub const TOGGLE_FULLSCREEN: FunctionDef u32> = FunctionDef{address: 0x004d5c7f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/force_redraw_0"))] - pub const FORCE_REDRAW_0: FunctionDef = FunctionDef{address: 0x004d5dfe, function_type: PhantomData}; + pub const FORCE_REDRAW_0: FunctionDef = FunctionDef{address: 0x004d5dfe, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/resize_app"))] - pub const RESIZE_APP: FunctionDef = FunctionDef{address: 0x004d6dce, function_type: PhantomData}; + pub const RESIZE_APP: FunctionDef = FunctionDef{address: 0x004d6dce, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/force_redraw_1"))] pub const FORCE_REDRAW_1: FunctionDef = FunctionDef{address: 0x004d6f85, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/handle_key_down"))] pub const HANDLE_KEY_DOWN: FunctionDef u32> = FunctionDef{address: 0x004f0b72, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/exit_override"))] - pub const EXIT_OVERRIDE: FunctionDef = FunctionDef{address: 0x00501303, function_type: PhantomData}; + pub const EXIT_OVERRIDE: FunctionDef = FunctionDef{address: 0x00501303, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_ai"))] - pub const GET_AI: FunctionDef *const u32> = FunctionDef{address: 0x00514ae1, function_type: PhantomData}; + pub const GET_AI: FunctionDef = FunctionDef{address: 0x00514ae1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/toggle_entity_visibility"))] pub const TOGGLE_ENTITY_VISIBILITY: FunctionDef = FunctionDef{address: 0x0052df81, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_next_screenshot_name"))] - pub const GET_NEXT_SCREENSHOT_NAME: FunctionDef = FunctionDef{address: 0x005330cd, function_type: PhantomData}; + pub const GET_NEXT_SCREENSHOT_NAME: FunctionDef = FunctionDef{address: 0x005330cd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/load_typedata"))] - pub const LOAD_TYPEDATA: FunctionDef = FunctionDef{address: 0x0053768a, function_type: PhantomData}; + pub const LOAD_TYPEDATA: FunctionDef = FunctionDef{address: 0x0053768a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/toggle_cursors"))] - pub const TOGGLE_CURSORS: FunctionDef = FunctionDef{address: 0x0060442d, function_type: PhantomData}; + pub const TOGGLE_CURSORS: FunctionDef = FunctionDef{address: 0x0060442d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_update_time"))] - pub const GET_UPDATE_TIME: FunctionDef u32> = FunctionDef{address: 0x00604480, function_type: PhantomData}; + pub const GET_UPDATE_TIME: FunctionDef = FunctionDef{address: 0x00604480, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_world"))] - pub const GET_WORLD: FunctionDef *const u32> = FunctionDef{address: 0x006206bc, function_type: PhantomData}; + pub const GET_WORLD: FunctionDef = FunctionDef{address: 0x006206bc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_game"))] - pub const GET_GAME: FunctionDef *const u32> = FunctionDef{address: 0x006206c2, function_type: PhantomData}; + pub const GET_GAME: FunctionDef = FunctionDef{address: 0x006206c2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_scenario"))] - pub const GET_SCENARIO: FunctionDef *const u32> = FunctionDef{address: 0x006206c8, function_type: PhantomData}; + pub const GET_SCENARIO: FunctionDef = FunctionDef{address: 0x006206c8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztapp/get_script"))] - pub const GET_SCRIPT: FunctionDef *const u32> = FunctionDef{address: 0x006206ce, function_type: PhantomData}; -} - -// ZTAssignHabitatMode class functions -pub mod ztassignhabitatmode { - use super::*; - - #[cfg_attr(feature = "detour-validation", validate_detour("ztassignhabitatmode/check_mouse_over_entity"))] - pub const CHECK_MOUSE_OVER_ENTITY: FunctionDef = FunctionDef{address: 0x00471d52, function_type: PhantomData}; + pub const GET_SCRIPT: FunctionDef = FunctionDef{address: 0x006206ce, function_type: PhantomData}; } // ZTAwardMgr class functions @@ -2804,11 +2642,11 @@ pub mod ztawardmgr { #[cfg_attr(feature = "detour-validation", validate_detour("ztawardmgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047a064, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztawardmgr/start"))] - pub const START: FunctionDef u32> = FunctionDef{address: 0x005141e1, function_type: PhantomData}; + pub const START: FunctionDef u32> = FunctionDef{address: 0x005141e1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztawardmgr/get_award"))] - pub const GET_AWARD: FunctionDef i32> = FunctionDef{address: 0x005a12ec, function_type: PhantomData}; + pub const GET_AWARD: FunctionDef i32> = FunctionDef{address: 0x005a12ec, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztawardmgr/add_award"))] - pub const ADD_AWARD: FunctionDef = FunctionDef{address: 0x005a13ed, function_type: PhantomData}; + pub const ADD_AWARD: FunctionDef = FunctionDef{address: 0x005a13ed, function_type: PhantomData}; } // ZTBuilding class functions @@ -2816,109 +2654,101 @@ pub mod ztbuilding { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/user_data_changed"))] - pub const USER_DATA_CHANGED: FunctionDef = FunctionDef{address: 0x00412513, function_type: PhantomData}; + pub const USER_DATA_CHANGED: FunctionDef = FunctionDef{address: 0x00412513, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/force_dead_anim"))] - pub const FORCE_DEAD_ANIM: FunctionDef = FunctionDef{address: 0x004174dd, function_type: PhantomData}; + pub const FORCE_DEAD_ANIM: FunctionDef = FunctionDef{address: 0x004174dd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/might_start_ambient_sound"))] - pub const MIGHT_START_AMBIENT_SOUND: FunctionDef = FunctionDef{address: 0x0041e3f8, function_type: PhantomData}; + pub const MIGHT_START_AMBIENT_SOUND: FunctionDef = FunctionDef{address: 0x0041e3f8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/has_open_slot"))] - pub const HAS_OPEN_SLOT: FunctionDef u32> = FunctionDef{address: 0x00429330, function_type: PhantomData}; + pub const HAS_OPEN_SLOT: FunctionDef u32> = FunctionDef{address: 0x00429330, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/gx_pos_from_xypos_0"))] - pub const GX_POS_FROM_XYPOS_0: FunctionDef = FunctionDef{address: 0x0042a10c, function_type: PhantomData}; + pub const GX_POS_FROM_XYPOS_0: FunctionDef = FunctionDef{address: 0x0042a10c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_valid_exit"))] - pub const GET_VALID_EXIT: FunctionDef u32> = FunctionDef{address: 0x0042aad5, function_type: PhantomData}; + pub const GET_VALID_EXIT: FunctionDef u32> = FunctionDef{address: 0x0042aad5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/can_add_user"))] - pub const CAN_ADD_USER: FunctionDef u32> = FunctionDef{address: 0x0042ac87, function_type: PhantomData}; + pub const CAN_ADD_USER: FunctionDef u32> = FunctionDef{address: 0x0042ac87, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/gx_pos_from_xypos_1"))] - pub const GX_POS_FROM_XYPOS_1: FunctionDef *const u32> = FunctionDef{address: 0x0042afd4, function_type: PhantomData}; + pub const GX_POS_FROM_XYPOS_1: FunctionDef u32> = FunctionDef{address: 0x0042afd4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_slot_entrances"))] - pub const GET_SLOT_ENTRANCES: FunctionDef *const u32> = FunctionDef{address: 0x0042b101, function_type: PhantomData}; + pub const GET_SLOT_ENTRANCES: FunctionDef u32> = FunctionDef{address: 0x0042b101, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_valid_entrance_for_exit"))] - pub const GET_VALID_ENTRANCE_FOR_EXIT: FunctionDef u32> = FunctionDef{address: 0x0042b350, function_type: PhantomData}; + pub const GET_VALID_ENTRANCE_FOR_EXIT: FunctionDef u32> = FunctionDef{address: 0x0042b350, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/find_nearest_open_slot"))] - pub const FIND_NEAREST_OPEN_SLOT: FunctionDef u32> = FunctionDef{address: 0x0042c02b, function_type: PhantomData}; + pub const FIND_NEAREST_OPEN_SLOT: FunctionDef u32> = FunctionDef{address: 0x0042c02b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/might_start_use_sound"))] - pub const MIGHT_START_USE_SOUND: FunctionDef = FunctionDef{address: 0x0042cc1a, function_type: PhantomData}; + pub const MIGHT_START_USE_SOUND: FunctionDef = FunctionDef{address: 0x0042cc1a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/add_user"))] - pub const ADD_USER: FunctionDef u32> = FunctionDef{address: 0x0042ce0a, function_type: PhantomData}; + pub const ADD_USER: FunctionDef u32> = FunctionDef{address: 0x0042ce0a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/might_start_use_animation"))] - pub const MIGHT_START_USE_ANIMATION: FunctionDef = FunctionDef{address: 0x0042d01c, function_type: PhantomData}; + pub const MIGHT_START_USE_ANIMATION: FunctionDef = FunctionDef{address: 0x0042d01c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/remove_items"))] - pub const REMOVE_ITEMS: FunctionDef u8> = FunctionDef{address: 0x0042d181, function_type: PhantomData}; + pub const REMOVE_ITEMS: FunctionDef u8> = FunctionDef{address: 0x0042d181, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/buy_item"))] - pub const BUY_ITEM: FunctionDef u32> = FunctionDef{address: 0x0042d1e2, function_type: PhantomData}; + pub const BUY_ITEM: FunctionDef u32> = FunctionDef{address: 0x0042d1e2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/remove_user"))] - pub const REMOVE_USER: FunctionDef u32> = FunctionDef{address: 0x0042d858, function_type: PhantomData}; + pub const REMOVE_USER: FunctionDef u32> = FunctionDef{address: 0x0042d858, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/yank_user"))] - pub const YANK_USER: FunctionDef u32> = FunctionDef{address: 0x0042da64, function_type: PhantomData}; + pub const YANK_USER: FunctionDef u32> = FunctionDef{address: 0x0042da64, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/draw_0"))] - pub const DRAW_0: FunctionDef = FunctionDef{address: 0x00433aaf, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_aiinfo_on"))] - pub const GET_AIINFO_ON: FunctionDef u32> = FunctionDef{address: 0x00433b0e, function_type: PhantomData}; + pub const DRAW_0: FunctionDef = FunctionDef{address: 0x00433aaf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00434c4b, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00434c4b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/update_random_use_timer"))] - pub const UPDATE_RANDOM_USE_TIMER: FunctionDef = FunctionDef{address: 0x00434d2a, function_type: PhantomData}; + pub const UPDATE_RANDOM_USE_TIMER: FunctionDef = FunctionDef{address: 0x00434d2a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/reset_info"))] - pub const RESET_INFO: FunctionDef = FunctionDef{address: 0x00450dbf, function_type: PhantomData}; + pub const RESET_INFO: FunctionDef = FunctionDef{address: 0x00450dbf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/reset_construction_date"))] - pub const RESET_CONSTRUCTION_DATE: FunctionDef = FunctionDef{address: 0x00450edd, function_type: PhantomData}; + pub const RESET_CONSTRUCTION_DATE: FunctionDef = FunctionDef{address: 0x00450edd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/init_status_vars"))] - pub const INIT_STATUS_VARS: FunctionDef = FunctionDef{address: 0x00450f17, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00451152, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/add_to_map"))] - pub const ADD_TO_MAP: FunctionDef u8> = FunctionDef{address: 0x0045158c, function_type: PhantomData}; + pub const INIT_STATUS_VARS: FunctionDef = FunctionDef{address: 0x00450f17, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/load"))] - pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x0045184a, function_type: PhantomData}; + pub const LOAD: FunctionDef = FunctionDef{address: 0x0045184a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/add_member"))] - pub const ADD_MEMBER: FunctionDef = FunctionDef{address: 0x0048cd9b, function_type: PhantomData}; + pub const ADD_MEMBER: FunctionDef = FunctionDef{address: 0x0048cd9b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/play_use_animation"))] - pub const PLAY_USE_ANIMATION: FunctionDef = FunctionDef{address: 0x004a067b, function_type: PhantomData}; + pub const PLAY_USE_ANIMATION: FunctionDef = FunctionDef{address: 0x004a067b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/receive_income"))] pub const RECEIVE_INCOME: FunctionDef = FunctionDef{address: 0x004a2e96, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_slot_exit"))] - pub const GET_SLOT_EXIT: FunctionDef = FunctionDef{address: 0x004a705e, function_type: PhantomData}; + pub const GET_SLOT_EXIT: FunctionDef = FunctionDef{address: 0x004a705e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/exit_via_exit"))] - pub const EXIT_VIA_EXIT: FunctionDef u8> = FunctionDef{address: 0x004a75bb, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/draw_underwater_section"))] - pub const DRAW_UNDERWATER_SECTION: FunctionDef = FunctionDef{address: 0x004a7972, function_type: PhantomData}; + pub const EXIT_VIA_EXIT: FunctionDef u8> = FunctionDef{address: 0x004a75bb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/init_random_use_timer"))] - pub const INIT_RANDOM_USE_TIMER: FunctionDef = FunctionDef{address: 0x004ab763, function_type: PhantomData}; + pub const INIT_RANDOM_USE_TIMER: FunctionDef = FunctionDef{address: 0x004ab763, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/might_stop_ambient_sound"))] - pub const MIGHT_STOP_AMBIENT_SOUND: FunctionDef = FunctionDef{address: 0x004b0bca, function_type: PhantomData}; + pub const MIGHT_STOP_AMBIENT_SOUND: FunctionDef = FunctionDef{address: 0x004b0bca, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/drop"))] - pub const DROP: FunctionDef = FunctionDef{address: 0x004e5282, function_type: PhantomData}; + pub const DROP: FunctionDef = FunctionDef{address: 0x004e5282, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x0050023a, function_type: PhantomData}; + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x0050023a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/calculate_water_capacity"))] - pub const CALCULATE_WATER_CAPACITY: FunctionDef i32> = FunctionDef{address: 0x0059398a, function_type: PhantomData}; + pub const CALCULATE_WATER_CAPACITY: FunctionDef i32> = FunctionDef{address: 0x0059398a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/init_after_load"))] - pub const INIT_AFTER_LOAD: FunctionDef = FunctionDef{address: 0x00593fd3, function_type: PhantomData}; + pub const INIT_AFTER_LOAD: FunctionDef = FunctionDef{address: 0x00593fd3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/remove_user_if_present"))] - pub const REMOVE_USER_IF_PRESENT: FunctionDef u32> = FunctionDef{address: 0x0059be7b, function_type: PhantomData}; + pub const REMOVE_USER_IF_PRESENT: FunctionDef u32> = FunctionDef{address: 0x0059be7b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_fun_gift_if_available"))] - pub const GET_FUN_GIFT_IF_AVAILABLE: FunctionDef u32> = FunctionDef{address: 0x0059cd02, function_type: PhantomData}; + pub const GET_FUN_GIFT_IF_AVAILABLE: FunctionDef u32> = FunctionDef{address: 0x0059cd02, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/draw_1"))] pub const DRAW_1: FunctionDef = FunctionDef{address: 0x0059fb8f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/remove_member"))] - pub const REMOVE_MEMBER: FunctionDef = FunctionDef{address: 0x005a08ac, function_type: PhantomData}; + pub const REMOVE_MEMBER: FunctionDef = FunctionDef{address: 0x005a08ac, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_slot_draw_loc"))] - pub const GET_SLOT_DRAW_LOC: FunctionDef = FunctionDef{address: 0x005a954d, function_type: PhantomData}; + pub const GET_SLOT_DRAW_LOC: FunctionDef = FunctionDef{address: 0x005a954d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_slot_facing"))] - pub const GET_SLOT_FACING: FunctionDef u32> = FunctionDef{address: 0x005ad288, function_type: PhantomData}; + pub const GET_SLOT_FACING: FunctionDef u32> = FunctionDef{address: 0x005ad288, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_slot_loc"))] - pub const GET_SLOT_LOC: FunctionDef = FunctionDef{address: 0x005ad347, function_type: PhantomData}; + pub const GET_SLOT_LOC: FunctionDef = FunctionDef{address: 0x005ad347, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/get_slot_has_draw_slots"))] - pub const GET_SLOT_HAS_DRAW_SLOTS: FunctionDef u32> = FunctionDef{address: 0x005ad441, function_type: PhantomData}; + pub const GET_SLOT_HAS_DRAW_SLOTS: FunctionDef u32> = FunctionDef{address: 0x005ad441, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/remove_all_users"))] - pub const REMOVE_ALL_USERS: FunctionDef = FunctionDef{address: 0x005ae745, function_type: PhantomData}; + pub const REMOVE_ALL_USERS: FunctionDef = FunctionDef{address: 0x005ae745, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/yank_user_if_present"))] - pub const YANK_USER_IF_PRESENT: FunctionDef u32> = FunctionDef{address: 0x00611a98, function_type: PhantomData}; + pub const YANK_USER_IF_PRESENT: FunctionDef u32> = FunctionDef{address: 0x00611a98, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/turn_to_rubble"))] - pub const TURN_TO_RUBBLE: FunctionDef = FunctionDef{address: 0x00611bd6, function_type: PhantomData}; + pub const TURN_TO_RUBBLE: FunctionDef = FunctionDef{address: 0x00611bd6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding/empty_grandstands"))] - pub const EMPTY_GRANDSTANDS: FunctionDef = FunctionDef{address: 0x006127b8, function_type: PhantomData}; + pub const EMPTY_GRANDSTANDS: FunctionDef = FunctionDef{address: 0x006127b8, function_type: PhantomData}; } // ZTBuilding::Slot class functions @@ -2926,15 +2756,13 @@ pub mod ztbuilding_slot { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding_slot/remove_draw_user"))] - pub const REMOVE_DRAW_USER: FunctionDef = FunctionDef{address: 0x0042dcd7, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding_slot/clear_draw_users"))] - pub const CLEAR_DRAW_USERS: FunctionDef = FunctionDef{address: 0x00450f08, function_type: PhantomData}; + pub const REMOVE_DRAW_USER: FunctionDef = FunctionDef{address: 0x0042dcd7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding_slot/get_top_user"))] - pub const GET_TOP_USER: FunctionDef u32> = FunctionDef{address: 0x004a7412, function_type: PhantomData}; + pub const GET_TOP_USER: FunctionDef u32> = FunctionDef{address: 0x004a7412, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding_slot/add_draw_user"))] - pub const ADD_DRAW_USER: FunctionDef = FunctionDef{address: 0x005a93fe, function_type: PhantomData}; + pub const ADD_DRAW_USER: FunctionDef = FunctionDef{address: 0x005a93fe, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuilding_slot/set_top_user"))] - pub const SET_TOP_USER: FunctionDef u32> = FunctionDef{address: 0x005ac37c, function_type: PhantomData}; + pub const SET_TOP_USER: FunctionDef u32> = FunctionDef{address: 0x005ac37c, function_type: PhantomData}; } // ZTBuildingType class functions @@ -2942,23 +2770,19 @@ pub mod ztbuildingtype { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/get_slot_entrances"))] - pub const GET_SLOT_ENTRANCES: FunctionDef *const u32> = FunctionDef{address: 0x0042b29f, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x0045134e, function_type: PhantomData}; + pub const GET_SLOT_ENTRANCES: FunctionDef u32> = FunctionDef{address: 0x0042b29f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x0045e8f2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0045ecdf, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0045ecdf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/get_slot_is_exit_on_water"))] - pub const GET_SLOT_IS_EXIT_ON_WATER: FunctionDef u32> = FunctionDef{address: 0x004a4a0f, function_type: PhantomData}; + pub const GET_SLOT_IS_EXIT_ON_WATER: FunctionDef u32> = FunctionDef{address: 0x004a4a0f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/load_characteristics"))] - pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004c042c, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/load_color_rep_info"))] - pub const LOAD_COLOR_REP_INFO: FunctionDef u32> = FunctionDef{address: 0x004c195d, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x004c042c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/add_upgrade"))] - pub const ADD_UPGRADE: FunctionDef = FunctionDef{address: 0x0058ff14, function_type: PhantomData}; + pub const ADD_UPGRADE: FunctionDef = FunctionDef{address: 0x0058ff14, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztbuildingtype/remove_upgrade"))] - pub const REMOVE_UPGRADE: FunctionDef = FunctionDef{address: 0x0059012d, function_type: PhantomData}; + pub const REMOVE_UPGRADE: FunctionDef = FunctionDef{address: 0x0059012d, function_type: PhantomData}; } // ZTCheat class functions @@ -2968,7 +2792,7 @@ pub mod ztcheat { #[cfg_attr(feature = "detour-validation", validate_detour("ztcheat/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x00435282, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztcheat/rename_entity"))] - pub const RENAME_ENTITY: FunctionDef = FunctionDef{address: 0x0044940b, function_type: PhantomData}; + pub const RENAME_ENTITY: FunctionDef = FunctionDef{address: 0x0044940b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztcheat/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047a10c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztcheat/clear"))] @@ -2982,7 +2806,7 @@ pub mod ztcheat { #[cfg_attr(feature = "detour-validation", validate_detour("ztcheat/start_of_game"))] pub const START_OF_GAME: FunctionDef = FunctionDef{address: 0x00591426, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztcheat/rename_exhibit"))] - pub const RENAME_EXHIBIT: FunctionDef = FunctionDef{address: 0x005aee66, function_type: PhantomData}; + pub const RENAME_EXHIBIT: FunctionDef = FunctionDef{address: 0x005aee66, function_type: PhantomData}; } // ZTFence class functions @@ -2990,51 +2814,51 @@ pub mod ztfence { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/set_animation"))] - pub const SET_ANIMATION: FunctionDef = FunctionDef{address: 0x00416ee8, function_type: PhantomData}; + pub const SET_ANIMATION: FunctionDef = FunctionDef{address: 0x00416ee8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/get_esthetic_bonus"))] - pub const GET_ESTHETIC_BONUS: FunctionDef *const i32> = FunctionDef{address: 0x0041fb50, function_type: PhantomData}; + pub const GET_ESTHETIC_BONUS: FunctionDef = FunctionDef{address: 0x0041fb50, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/update_animation"))] - pub const UPDATE_ANIMATION: FunctionDef = FunctionDef{address: 0x00434ad7, function_type: PhantomData}; + pub const UPDATE_ANIMATION: FunctionDef = FunctionDef{address: 0x00434ad7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00434b1d, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00434b1d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/ztfence_0"))] - pub const ZTFENCE_0: FunctionDef *const u32> = FunctionDef{address: 0x00443f37, function_type: PhantomData}; + pub const ZTFENCE_0: FunctionDef u32> = FunctionDef{address: 0x00443f37, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/ztfence_1"))] - pub const ZTFENCE_1: FunctionDef *const u32> = FunctionDef{address: 0x00443f57, function_type: PhantomData}; + pub const ZTFENCE_1: FunctionDef u32> = FunctionDef{address: 0x00443f57, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/dirty_habitat_escapability"))] - pub const DIRTY_HABITAT_ESCAPABILITY: FunctionDef = FunctionDef{address: 0x00449ab4, function_type: PhantomData}; + pub const DIRTY_HABITAT_ESCAPABILITY: FunctionDef = FunctionDef{address: 0x00449ab4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/validate_position"))] - pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x00449fb2, function_type: PhantomData}; + pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x00449fb2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/add_to_map"))] - pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x0044cb57, function_type: PhantomData}; + pub const ADD_TO_MAP: FunctionDef = FunctionDef{address: 0x0044cb57, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044ff2d, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044ff2d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/make_gate"))] - pub const MAKE_GATE: FunctionDef = FunctionDef{address: 0x0046600c, function_type: PhantomData}; + pub const MAKE_GATE: FunctionDef = FunctionDef{address: 0x0046600c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00477e25, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/can_deteriorate"))] - pub const CAN_DETERIORATE: FunctionDef u32> = FunctionDef{address: 0x004857b9, function_type: PhantomData}; + pub const CAN_DETERIORATE: FunctionDef u32> = FunctionDef{address: 0x004857b9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/set_broken"))] - pub const SET_BROKEN: FunctionDef = FunctionDef{address: 0x004858a4, function_type: PhantomData}; + pub const SET_BROKEN: FunctionDef = FunctionDef{address: 0x004858a4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/morph"))] - pub const MORPH: FunctionDef = FunctionDef{address: 0x0048676c, function_type: PhantomData}; + pub const MORPH: FunctionDef = FunctionDef{address: 0x0048676c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/get_mwtile"))] - pub const GET_MWTILE: FunctionDef *const c_void> = FunctionDef{address: 0x0049e3e2, function_type: PhantomData}; + pub const GET_MWTILE: FunctionDef u32> = FunctionDef{address: 0x0049e3e2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/make_fence"))] - pub const MAKE_FENCE: FunctionDef = FunctionDef{address: 0x004f93da, function_type: PhantomData}; + pub const MAKE_FENCE: FunctionDef = FunctionDef{address: 0x004f93da, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/get_sell_price"))] - pub const GET_SELL_PRICE: FunctionDef f32> = FunctionDef{address: 0x004f945b, function_type: PhantomData}; + pub const GET_SELL_PRICE: FunctionDef f32> = FunctionDef{address: 0x004f945b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004ffd6e, function_type: PhantomData}; + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004ffd6e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/init_after_load"))] - pub const INIT_AFTER_LOAD: FunctionDef = FunctionDef{address: 0x00594060, function_type: PhantomData}; + pub const INIT_AFTER_LOAD: FunctionDef = FunctionDef{address: 0x00594060, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/get_height"))] - pub const GET_HEIGHT: FunctionDef u32> = FunctionDef{address: 0x005997fa, function_type: PhantomData}; + pub const GET_HEIGHT: FunctionDef = FunctionDef{address: 0x005997fa, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/set_healthy"))] - pub const SET_HEALTHY: FunctionDef = FunctionDef{address: 0x005b391c, function_type: PhantomData}; + pub const SET_HEALTHY: FunctionDef = FunctionDef{address: 0x005b391c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfence/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x005b3a04, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x005b3a04, function_type: PhantomData}; } // ZTFenceType class functions @@ -3044,15 +2868,15 @@ pub mod ztfencetype { #[cfg_attr(feature = "detour-validation", validate_detour("ztfencetype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x004606f3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfencetype/load_characteristics_0"))] - pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004bb6f6, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004bb6f6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfencetype/load_characteristics_1"))] - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004bb8ed, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004bb8ed, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfencetype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004bf505, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004bf505, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfencetype/ztfence_type"))] - pub const ZTFENCE_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x0050118e, function_type: PhantomData}; + pub const ZTFENCE_TYPE: FunctionDef u32> = FunctionDef{address: 0x0050118e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfencetype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const i32> = FunctionDef{address: 0x005b3a55, function_type: PhantomData}; + pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x005b3a55, function_type: PhantomData}; } // ZTFood class functions @@ -3060,19 +2884,19 @@ pub mod ztfood { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztfood/ztfood_0"))] - pub const ZTFOOD_0: FunctionDef *const u32> = FunctionDef{address: 0x0041e080, function_type: PhantomData}; + pub const ZTFOOD_0: FunctionDef u32> = FunctionDef{address: 0x0041e080, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfood/ztfood_1"))] - pub const ZTFOOD_1: FunctionDef *const u32> = FunctionDef{address: 0x004f9f46, function_type: PhantomData}; + pub const ZTFOOD_1: FunctionDef u32> = FunctionDef{address: 0x004f9f46, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfood/ztfood_2"))] - pub const ZTFOOD_2: FunctionDef *const u32> = FunctionDef{address: 0x004f9f64, function_type: PhantomData}; + pub const ZTFOOD_2: FunctionDef u32> = FunctionDef{address: 0x004f9f64, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfood/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004fd1be, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004fd1be, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfood/changed_food_value"))] - pub const CHANGED_FOOD_VALUE: FunctionDef = FunctionDef{address: 0x004fd3c1, function_type: PhantomData}; + pub const CHANGED_FOOD_VALUE: FunctionDef = FunctionDef{address: 0x004fd3c1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfood/get_fullness"))] - pub const GET_FULLNESS: FunctionDef u32> = FunctionDef{address: 0x004fd494, function_type: PhantomData}; + pub const GET_FULLNESS: FunctionDef u32> = FunctionDef{address: 0x004fd494, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfood/set_animation"))] - pub const SET_ANIMATION: FunctionDef = FunctionDef{address: 0x004fd512, function_type: PhantomData}; + pub const SET_ANIMATION: FunctionDef = FunctionDef{address: 0x004fd512, function_type: PhantomData}; } // ZTFoodType class functions @@ -3080,19 +2904,19 @@ pub mod ztfoodtype { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztfoodtype/get_class"))] - pub const GET_CLASS: FunctionDef *const u32> = FunctionDef{address: 0x00401fa4, function_type: PhantomData}; + pub const GET_CLASS: FunctionDef = FunctionDef{address: 0x00401fa4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfoodtype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x004653d6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfoodtype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00465634, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00465634, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfoodtype/load_characteristics"))] - pub const LOAD_CHARACTERISTICS: FunctionDef u8> = FunctionDef{address: 0x004c2473, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x004c2473, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfoodtype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const i32> = FunctionDef{address: 0x004fd1de, function_type: PhantomData}; + pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004fd1de, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfoodtype/ztfood_type_0"))] - pub const ZTFOOD_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x00504c06, function_type: PhantomData}; + pub const ZTFOOD_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x00504c06, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztfoodtype/ztfood_type_1"))] - pub const ZTFOOD_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x00504c24, function_type: PhantomData}; + pub const ZTFOOD_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x00504c24, function_type: PhantomData}; } // ZTGameMgr class functions @@ -3100,21 +2924,21 @@ pub mod ztgamemgr { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/get_date"))] - pub const GET_DATE: FunctionDef *const i64> = FunctionDef{address: 0x0040e7e0, function_type: PhantomData}; + pub const GET_DATE: FunctionDef u32> = FunctionDef{address: 0x0040e7e0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/add_cash"))] - pub const ADD_CASH: FunctionDef = FunctionDef{address: 0x0040f018, function_type: PhantomData}; + pub const ADD_CASH: FunctionDef = FunctionDef{address: 0x0040f018, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/is_real_world_date"))] pub const IS_REAL_WORLD_DATE: FunctionDef u32> = FunctionDef{address: 0x00412c22, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a154, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a154, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/subtract_cash"))] - pub const SUBTRACT_CASH: FunctionDef = FunctionDef{address: 0x0041ef68, function_type: PhantomData}; + pub const SUBTRACT_CASH: FunctionDef = FunctionDef{address: 0x0041ef68, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/hours_ago"))] - pub const HOURS_AGO: FunctionDef u64> = FunctionDef{address: 0x0041f075, function_type: PhantomData}; + pub const HOURS_AGO: FunctionDef u64> = FunctionDef{address: 0x0041f075, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/time_ago"))] - pub const TIME_AGO: FunctionDef *const f32> = FunctionDef{address: 0x0042620a, function_type: PhantomData}; + pub const TIME_AGO: FunctionDef u32> = FunctionDef{address: 0x0042620a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/update_sim"))] - pub const UPDATE_SIM: FunctionDef = FunctionDef{address: 0x00435055, function_type: PhantomData}; + pub const UPDATE_SIM: FunctionDef = FunctionDef{address: 0x00435055, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047acc5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/removed_zoo_doo"))] @@ -3122,7 +2946,7 @@ pub mod ztgamemgr { #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/start_menu_music"))] pub const START_MENU_MUSIC: FunctionDef = FunctionDef{address: 0x004bded9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/start_menu_music_fade_0"))] - pub const START_MENU_MUSIC_FADE_0: FunctionDef = FunctionDef{address: 0x004c9d67, function_type: PhantomData}; + pub const START_MENU_MUSIC_FADE_0: FunctionDef = FunctionDef{address: 0x004c9d67, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/start_menu_music_fade_1"))] pub const START_MENU_MUSIC_FADE_1: FunctionDef = FunctionDef{address: 0x004ca478, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/start_menu_music_fade_2"))] @@ -3130,19 +2954,19 @@ pub mod ztgamemgr { #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/goto_start"))] pub const GOTO_START: FunctionDef u32> = FunctionDef{address: 0x004cc5b0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/is_game_date"))] - pub const IS_GAME_DATE: FunctionDef u32> = FunctionDef{address: 0x004f5f7a, function_type: PhantomData}; + pub const IS_GAME_DATE: FunctionDef u32> = FunctionDef{address: 0x004f5f7a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/stop"))] pub const STOP: FunctionDef = FunctionDef{address: 0x004fa123, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/ztgame_mgr_0"))] - pub const ZTGAME_MGR_0: FunctionDef *const u32> = FunctionDef{address: 0x00504dd8, function_type: PhantomData}; + pub const ZTGAME_MGR_0: FunctionDef u32> = FunctionDef{address: 0x00504dd8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/ztgame_mgr_1"))] - pub const ZTGAME_MGR_1: FunctionDef *const u32> = FunctionDef{address: 0x00504e4c, function_type: PhantomData}; + pub const ZTGAME_MGR_1: FunctionDef u32> = FunctionDef{address: 0x00504e4c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/set_new_game_defaults"))] - pub const SET_NEW_GAME_DEFAULTS: FunctionDef = FunctionDef{address: 0x0058f39c, function_type: PhantomData}; + pub const SET_NEW_GAME_DEFAULTS: FunctionDef = FunctionDef{address: 0x0058f39c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/start"))] pub const START: FunctionDef = FunctionDef{address: 0x00592283, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr/load"))] - pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x005948c6, function_type: PhantomData}; + pub const LOAD: FunctionDef = FunctionDef{address: 0x005948c6, function_type: PhantomData}; } // ZTGameMgr::MenuMusicHandler class functions @@ -3150,9 +2974,9 @@ pub mod ztgamemgr_menumusichandler { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr_menumusichandler/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a13a, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a13a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgamemgr_menumusichandler/menu_music_handler"))] - pub const MENU_MUSIC_HANDLER: FunctionDef = FunctionDef{address: 0x00504e27, function_type: PhantomData}; + pub const MENU_MUSIC_HANDLER: FunctionDef = FunctionDef{address: 0x00504e27, function_type: PhantomData}; } // ZTGoalAvoid class functions @@ -3160,15 +2984,15 @@ pub mod ztgoalavoid { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalavoid/ztgoal_avoid_0"))] - pub const ZTGOAL_AVOID_0: FunctionDef *const u32> = FunctionDef{address: 0x0041226c, function_type: PhantomData}; + pub const ZTGOAL_AVOID_0: FunctionDef u32> = FunctionDef{address: 0x0041226c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalavoid/exit_tank"))] - pub const EXIT_TANK: FunctionDef = FunctionDef{address: 0x00431834, function_type: PhantomData}; + pub const EXIT_TANK: FunctionDef = FunctionDef{address: 0x00431834, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalavoid/check_done"))] - pub const CHECK_DONE: FunctionDef = FunctionDef{address: 0x004a5471, function_type: PhantomData}; + pub const CHECK_DONE: FunctionDef = FunctionDef{address: 0x004a5471, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalavoid/decide"))] - pub const DECIDE: FunctionDef = FunctionDef{address: 0x004a557f, function_type: PhantomData}; + pub const DECIDE: FunctionDef = FunctionDef{address: 0x004a557f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalavoid/ztgoal_avoid_1"))] - pub const ZTGOAL_AVOID_1: FunctionDef *const u32> = FunctionDef{address: 0x00604185, function_type: PhantomData}; + pub const ZTGOAL_AVOID_1: FunctionDef u32> = FunctionDef{address: 0x00604185, function_type: PhantomData}; } // ZTGoalBagDoo class functions @@ -3176,7 +3000,7 @@ pub mod ztgoalbagdoo { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalbagdoo/complete"))] - pub const COMPLETE: FunctionDef = FunctionDef{address: 0x004a2c98, function_type: PhantomData}; + pub const COMPLETE: FunctionDef = FunctionDef{address: 0x004a2c98, function_type: PhantomData}; } // ZTGoalBuildingExit class functions @@ -3184,7 +3008,7 @@ pub mod ztgoalbuildingexit { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalbuildingexit/complete"))] - pub const COMPLETE: FunctionDef = FunctionDef{address: 0x0042dddf, function_type: PhantomData}; + pub const COMPLETE: FunctionDef = FunctionDef{address: 0x0042dddf, function_type: PhantomData}; } // ZTGoalChase class functions @@ -3192,15 +3016,15 @@ pub mod ztgoalchase { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalchase/get_type"))] - pub const GET_TYPE: FunctionDef u32> = FunctionDef{address: 0x004a4c06, function_type: PhantomData}; + pub const GET_TYPE: FunctionDef = FunctionDef{address: 0x004a4c06, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalchase/check_done"))] - pub const CHECK_DONE: FunctionDef = FunctionDef{address: 0x004a4c0c, function_type: PhantomData}; + pub const CHECK_DONE: FunctionDef = FunctionDef{address: 0x004a4c0c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalchase/decide"))] - pub const DECIDE: FunctionDef = FunctionDef{address: 0x004a4d6c, function_type: PhantomData}; + pub const DECIDE: FunctionDef = FunctionDef{address: 0x004a4d6c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalchase/ztgoal_chase"))] - pub const ZTGOAL_CHASE: FunctionDef = FunctionDef{address: 0x004a4d98, function_type: PhantomData}; + pub const ZTGOAL_CHASE: FunctionDef = FunctionDef{address: 0x004a4d98, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalchase/complete"))] - pub const COMPLETE: FunctionDef = FunctionDef{address: 0x004a4dd2, function_type: PhantomData}; + pub const COMPLETE: FunctionDef = FunctionDef{address: 0x004a4dd2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalchase/f_caught"))] pub const F_CAUGHT: FunctionDef = FunctionDef{address: 0x004a6043, function_type: PhantomData}; } @@ -3210,7 +3034,7 @@ pub mod ztgoalchaseanimal { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalchaseanimal/complete"))] - pub const COMPLETE: FunctionDef = FunctionDef{address: 0x0050db25, function_type: PhantomData}; + pub const COMPLETE: FunctionDef = FunctionDef{address: 0x0050db25, function_type: PhantomData}; } // ZTGoalEmptyTrash class functions @@ -3218,7 +3042,7 @@ pub mod ztgoalemptytrash { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalemptytrash/init"))] - pub const INIT: FunctionDef u32> = FunctionDef{address: 0x0048b3f2, function_type: PhantomData}; + pub const INIT: FunctionDef = FunctionDef{address: 0x0048b3f2, function_type: PhantomData}; } // ZTGoalFactory class functions @@ -3226,11 +3050,11 @@ pub mod ztgoalfactory { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalfactory/create_sub"))] - pub const CREATE_SUB: FunctionDef *const u32> = FunctionDef{address: 0x00413aa7, function_type: PhantomData}; + pub const CREATE_SUB: FunctionDef u32> = FunctionDef{address: 0x00413aa7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalfactory/create"))] - pub const CREATE: FunctionDef *const u32> = FunctionDef{address: 0x00413bec, function_type: PhantomData}; + pub const CREATE: FunctionDef u32> = FunctionDef{address: 0x00413bec, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalfactory/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const c_void> = FunctionDef{address: 0x00603e6b, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef = FunctionDef{address: 0x00603e6b, function_type: PhantomData}; } // ZTGoalFixFilter class functions @@ -3238,9 +3062,9 @@ pub mod ztgoalfixfilter { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalfixfilter/fix_filter"))] - pub const FIX_FILTER: FunctionDef u32> = FunctionDef{address: 0x00595cde, function_type: PhantomData}; + pub const FIX_FILTER: FunctionDef u32> = FunctionDef{address: 0x00595cde, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalfixfilter/complete"))] - pub const COMPLETE: FunctionDef = FunctionDef{address: 0x00595d17, function_type: PhantomData}; + pub const COMPLETE: FunctionDef = FunctionDef{address: 0x00595d17, function_type: PhantomData}; } // ZTGoalGawk class functions @@ -3248,17 +3072,9 @@ pub mod ztgoalgawk { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalgawk/complete"))] - pub const COMPLETE: FunctionDef = FunctionDef{address: 0x0042e9f9, function_type: PhantomData}; + pub const COMPLETE: FunctionDef = FunctionDef{address: 0x0042e9f9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalgawk/left_va"))] - pub const LEFT_VA: FunctionDef = FunctionDef{address: 0x0042ea14, function_type: PhantomData}; -} - -// ZTGoalHabitatDuties class functions -pub mod ztgoalhabitatduties { - use super::*; - - #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalhabitatduties/complete"))] - pub const COMPLETE: FunctionDef = FunctionDef{address: 0x0049ebe7, function_type: PhantomData}; + pub const LEFT_VA: FunctionDef = FunctionDef{address: 0x0042ea14, function_type: PhantomData}; } // ZTGoalHeliReturn class functions @@ -3266,7 +3082,7 @@ pub mod ztgoalhelireturn { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalhelireturn/check_done"))] - pub const CHECK_DONE: FunctionDef = FunctionDef{address: 0x005a4556, function_type: PhantomData}; + pub const CHECK_DONE: FunctionDef = FunctionDef{address: 0x005a4556, function_type: PhantomData}; } // ZTGoalLeave class functions @@ -3274,11 +3090,11 @@ pub mod ztgoalleave { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalleave/decide"))] - pub const DECIDE: FunctionDef = FunctionDef{address: 0x004233ea, function_type: PhantomData}; + pub const DECIDE: FunctionDef = FunctionDef{address: 0x004233ea, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalleave/find_exit"))] - pub const FIND_EXIT: FunctionDef u32> = FunctionDef{address: 0x004a6889, function_type: PhantomData}; + pub const FIND_EXIT: FunctionDef u32> = FunctionDef{address: 0x004a6889, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalleave/complete"))] - pub const COMPLETE: FunctionDef = FunctionDef{address: 0x004fa85d, function_type: PhantomData}; + pub const COMPLETE: FunctionDef = FunctionDef{address: 0x004fa85d, function_type: PhantomData}; } // ZTGoalPreattack class functions @@ -3286,7 +3102,7 @@ pub mod ztgoalpreattack { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalpreattack/init"))] - pub const INIT: FunctionDef u32> = FunctionDef{address: 0x0061b2d6, function_type: PhantomData}; + pub const INIT: FunctionDef = FunctionDef{address: 0x0061b2d6, function_type: PhantomData}; } // ZTGoalSite class functions @@ -3294,9 +3110,9 @@ pub mod ztgoalsite { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalsite/decide"))] - pub const DECIDE: FunctionDef = FunctionDef{address: 0x004281be, function_type: PhantomData}; + pub const DECIDE: FunctionDef = FunctionDef{address: 0x004281be, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalsite/set_site_goal"))] - pub const SET_SITE_GOAL: FunctionDef u32> = FunctionDef{address: 0x004282e1, function_type: PhantomData}; + pub const SET_SITE_GOAL: FunctionDef u32> = FunctionDef{address: 0x004282e1, function_type: PhantomData}; } // ZTGoalWaterDrown class functions @@ -3304,7 +3120,7 @@ pub mod ztgoalwaterdrown { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalwaterdrown/init"))] - pub const INIT: FunctionDef u8> = FunctionDef{address: 0x0061a705, function_type: PhantomData}; + pub const INIT: FunctionDef = FunctionDef{address: 0x0061a705, function_type: PhantomData}; } // ZTGoalZooDoo class functions @@ -3312,77 +3128,67 @@ pub mod ztgoalzoodoo { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztgoalzoodoo/get_type"))] - pub const GET_TYPE: FunctionDef u32> = FunctionDef{address: 0x004a2746, function_type: PhantomData}; + pub const GET_TYPE: FunctionDef = FunctionDef{address: 0x004a2746, function_type: PhantomData}; } // ZTGuest class functions pub mod ztguest { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/add_to_map"))] - pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x00412ba7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/seen_habitat"))] - pub const SEEN_HABITAT: FunctionDef u32> = FunctionDef{address: 0x0042281c, function_type: PhantomData}; + pub const SEEN_HABITAT: FunctionDef u32> = FunctionDef{address: 0x0042281c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/f_guest_thought"))] - pub const F_GUEST_THOUGHT: FunctionDef = FunctionDef{address: 0x004231c1, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x0042789a, function_type: PhantomData}; + pub const F_GUEST_THOUGHT: FunctionDef = FunctionDef{address: 0x004231c1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_nonseen_habitats"))] - pub const GET_NONSEEN_HABITATS: FunctionDef *const u32> = FunctionDef{address: 0x00427b08, function_type: PhantomData}; + pub const GET_NONSEEN_HABITATS: FunctionDef u32> = FunctionDef{address: 0x00427b08, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_num_nonseen_sites"))] - pub const GET_NUM_NONSEEN_SITES: FunctionDef i32> = FunctionDef{address: 0x00427c88, function_type: PhantomData}; + pub const GET_NUM_NONSEEN_SITES: FunctionDef i32> = FunctionDef{address: 0x00427c88, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_nonseen_attractions"))] - pub const GET_NONSEEN_ATTRACTIONS: FunctionDef *const i32> = FunctionDef{address: 0x00427d5c, function_type: PhantomData}; + pub const GET_NONSEEN_ATTRACTIONS: FunctionDef u32> = FunctionDef{address: 0x00427d5c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_num_nonseen_gawk_scenery"))] - pub const GET_NUM_NONSEEN_GAWK_SCENERY: FunctionDef *const i32> = FunctionDef{address: 0x00428039, function_type: PhantomData}; + pub const GET_NUM_NONSEEN_GAWK_SCENERY: FunctionDef u32> = FunctionDef{address: 0x00428039, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/seen_attraction"))] - pub const SEEN_ATTRACTION: FunctionDef u32> = FunctionDef{address: 0x004285e2, function_type: PhantomData}; + pub const SEEN_ATTRACTION: FunctionDef u32> = FunctionDef{address: 0x004285e2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/pick_gawk_scenery"))] - pub const PICK_GAWK_SCENERY: FunctionDef *const i32> = FunctionDef{address: 0x0042945f, function_type: PhantomData}; + pub const PICK_GAWK_SCENERY: FunctionDef u32> = FunctionDef{address: 0x0042945f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_nonseen_gawk_scenery"))] - pub const GET_NONSEEN_GAWK_SCENERY: FunctionDef *const i32> = FunctionDef{address: 0x0042956e, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/set_visible"))] - pub const SET_VISIBLE: FunctionDef = FunctionDef{address: 0x0042aa0a, function_type: PhantomData}; + pub const GET_NONSEEN_GAWK_SCENERY: FunctionDef u32> = FunctionDef{address: 0x0042956e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/consume_item"))] - pub const CONSUME_ITEM: FunctionDef u32> = FunctionDef{address: 0x0042d380, function_type: PhantomData}; + pub const CONSUME_ITEM: FunctionDef u32> = FunctionDef{address: 0x0042d380, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/remove_item"))] - pub const REMOVE_ITEM: FunctionDef bool> = FunctionDef{address: 0x0042d533, function_type: PhantomData}; + pub const REMOVE_ITEM: FunctionDef bool> = FunctionDef{address: 0x0042d533, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/add_item"))] - pub const ADD_ITEM: FunctionDef u32> = FunctionDef{address: 0x0042d54e, function_type: PhantomData}; + pub const ADD_ITEM: FunctionDef u32> = FunctionDef{address: 0x0042d54e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_need_item"))] - pub const GET_NEED_ITEM: FunctionDef *const i32> = FunctionDef{address: 0x0042d74e, function_type: PhantomData}; + pub const GET_NEED_ITEM: FunctionDef u32> = FunctionDef{address: 0x0042d74e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/check_predator"))] - pub const CHECK_PREDATOR: FunctionDef u32> = FunctionDef{address: 0x004302ea, function_type: PhantomData}; + pub const CHECK_PREDATOR: FunctionDef u32> = FunctionDef{address: 0x004302ea, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/draw"))] - pub const DRAW: FunctionDef = FunctionDef{address: 0x00434029, function_type: PhantomData}; + pub const DRAW: FunctionDef = FunctionDef{address: 0x00434029, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_color_rep_info"))] - pub const GET_COLOR_REP_INFO: FunctionDef i32> = FunctionDef{address: 0x0043408c, function_type: PhantomData}; + pub const GET_COLOR_REP_INFO: FunctionDef i32> = FunctionDef{address: 0x0043408c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/listen"))] - pub const LISTEN: FunctionDef = FunctionDef{address: 0x0043a698, function_type: PhantomData}; + pub const LISTEN: FunctionDef = FunctionDef{address: 0x0043a698, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/update_goals"))] - pub const UPDATE_GOALS: FunctionDef = FunctionDef{address: 0x0043a6e4, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/get_terrain_cost"))] - pub const GET_TERRAIN_COST: FunctionDef i32> = FunctionDef{address: 0x0043a8fb, function_type: PhantomData}; + pub const UPDATE_GOALS: FunctionDef = FunctionDef{address: 0x0043a6e4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/check_leave_zoo"))] - pub const CHECK_LEAVE_ZOO: FunctionDef u32> = FunctionDef{address: 0x004a6acc, function_type: PhantomData}; + pub const CHECK_LEAVE_ZOO: FunctionDef u32> = FunctionDef{address: 0x004a6acc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004f5fd5, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004f5fd5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/init_status_vars"))] - pub const INIT_STATUS_VARS: FunctionDef = FunctionDef{address: 0x004f6372, function_type: PhantomData}; + pub const INIT_STATUS_VARS: FunctionDef = FunctionDef{address: 0x004f6372, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/create_name"))] - pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x004f70e4, function_type: PhantomData}; + pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x004f70e4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/ztguest"))] - pub const ZTGUEST: FunctionDef *const u32> = FunctionDef{address: 0x004fa44c, function_type: PhantomData}; + pub const ZTGUEST: FunctionDef u32> = FunctionDef{address: 0x004fa44c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/do_angry_price_change"))] - pub const DO_ANGRY_PRICE_CHANGE: FunctionDef = FunctionDef{address: 0x00533480, function_type: PhantomData}; + pub const DO_ANGRY_PRICE_CHANGE: FunctionDef = FunctionDef{address: 0x00533480, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/add_trash"))] - pub const ADD_TRASH: FunctionDef = FunctionDef{address: 0x0059d2c9, function_type: PhantomData}; + pub const ADD_TRASH: FunctionDef = FunctionDef{address: 0x0059d2c9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/seen_show"))] - pub const SEEN_SHOW: FunctionDef u32> = FunctionDef{address: 0x005a2bcd, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/reset_ai"))] - pub const RESET_AI: FunctionDef = FunctionDef{address: 0x005ae78a, function_type: PhantomData}; + pub const SEEN_SHOW: FunctionDef u32> = FunctionDef{address: 0x005a2bcd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguest/do_happy_price_change"))] - pub const DO_HAPPY_PRICE_CHANGE: FunctionDef = FunctionDef{address: 0x00619245, function_type: PhantomData}; + pub const DO_HAPPY_PRICE_CHANGE: FunctionDef = FunctionDef{address: 0x00619245, function_type: PhantomData}; } // ZTGuestType class functions @@ -3390,35 +3196,25 @@ pub mod ztguesttype { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztguesttype/load_characteristics_0"))] - pub const LOAD_CHARACTERISTICS_0: FunctionDef u8> = FunctionDef{address: 0x004c47dd, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_0: FunctionDef = FunctionDef{address: 0x004c47dd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguesttype/load_characteristics_1"))] - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c4cb9, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c4cb9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguesttype/ztguest_type"))] - pub const ZTGUEST_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x004cbb9c, function_type: PhantomData}; + pub const ZTGUEST_TYPE: FunctionDef u32> = FunctionDef{address: 0x004cbb9c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguesttype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x004f6060, function_type: PhantomData}; + pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004f6060, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguesttype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x005213de, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguesttype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x005216f1, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x005216f1, function_type: PhantomData}; } // ZTGuide class functions pub mod ztguide { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("ztguide/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x0058952b, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztguide/remove_guest"))] - pub const REMOVE_GUEST: FunctionDef = FunctionDef{address: 0x0058aab4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguide/get_random_assigned_habitat"))] - pub const GET_RANDOM_ASSIGNED_HABITAT: FunctionDef u32> = FunctionDef{address: 0x0058af73, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztguide/release_guests"))] - pub const RELEASE_GUESTS: FunctionDef = FunctionDef{address: 0x0058b362, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztguide/get_terrain_cost"))] - pub const GET_TERRAIN_COST: FunctionDef i32> = FunctionDef{address: 0x0058cfd6, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztguide/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0059b50b, function_type: PhantomData}; + pub const GET_RANDOM_ASSIGNED_HABITAT: FunctionDef u32> = FunctionDef{address: 0x0058af73, function_type: PhantomData}; } // ZTGuideType class functions @@ -3426,17 +3222,15 @@ pub mod ztguidetype { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztguidetype/load_characteristics_0"))] - pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004c3ee2, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004c3ee2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguidetype/load_characteristics_1"))] - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c406f, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c406f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguidetype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051c2d6, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051c2d6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguidetype/ztguide_type_0"))] - pub const ZTGUIDE_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x0057cb67, function_type: PhantomData}; + pub const ZTGUIDE_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x0057cb67, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztguidetype/ztguide_type_1"))] - pub const ZTGUIDE_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x0057cb85, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztguidetype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x0059b550, function_type: PhantomData}; + pub const ZTGUIDE_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x0057cb85, function_type: PhantomData}; } // ZTHabitat class functions @@ -3444,113 +3238,109 @@ pub mod zthabitat { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/recalculate_viewing_areas"))] - pub const RECALCULATE_VIEWING_AREAS: FunctionDef = FunctionDef{address: 0x0040f55a, function_type: PhantomData}; + pub const RECALCULATE_VIEWING_AREAS: FunctionDef = FunctionDef{address: 0x0040f55a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/set_dirty_characteristics"))] - pub const SET_DIRTY_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x0040f5a9, function_type: PhantomData}; + pub const SET_DIRTY_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x0040f5a9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/is_show_tank"))] - pub const IS_SHOW_TANK: FunctionDef u32> = FunctionDef{address: 0x0040fba2, function_type: PhantomData}; + pub const IS_SHOW_TANK: FunctionDef u32> = FunctionDef{address: 0x0040fba2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_show_info_id"))] - pub const GET_SHOW_INFO_ID: FunctionDef u32> = FunctionDef{address: 0x0040fbc7, function_type: PhantomData}; + pub const GET_SHOW_INFO_ID: FunctionDef u32> = FunctionDef{address: 0x0040fbc7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_gate_tile_in"))] pub const GET_GATE_TILE_IN: FunctionDef *const u32> = FunctionDef{address: 0x00410349, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_all_animals"))] - pub const GET_ALL_ANIMALS: FunctionDef *const i32> = FunctionDef{address: 0x00410def, function_type: PhantomData}; + pub const GET_ALL_ANIMALS: FunctionDef u32> = FunctionDef{address: 0x00410def, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_gate_tile_out"))] - pub const GET_GATE_TILE_OUT: FunctionDef i32> = FunctionDef{address: 0x00411285, function_type: PhantomData}; + pub const GET_GATE_TILE_OUT: FunctionDef i32> = FunctionDef{address: 0x00411285, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_num_animals"))] - pub const GET_NUM_ANIMALS: FunctionDef i32> = FunctionDef{address: 0x00412167, function_type: PhantomData}; + pub const GET_NUM_ANIMALS: FunctionDef i32> = FunctionDef{address: 0x00412167, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_habitat_rating"))] - pub const GET_HABITAT_RATING: FunctionDef f32> = FunctionDef{address: 0x00415dd7, function_type: PhantomData}; + pub const GET_HABITAT_RATING: FunctionDef f32> = FunctionDef{address: 0x00415dd7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/clear_amphibious_neighbors"))] - pub const CLEAR_AMPHIBIOUS_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00417460, function_type: PhantomData}; + pub const CLEAR_AMPHIBIOUS_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00417460, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/set_is_not_show_exhibit"))] - pub const SET_IS_NOT_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x0041748d, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/block_service"))] - pub const BLOCK_SERVICE: FunctionDef u32> = FunctionDef{address: 0x00423e01, function_type: PhantomData}; + pub const SET_IS_NOT_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x0041748d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/accept_donation"))] - pub const ACCEPT_DONATION: FunctionDef = FunctionDef{address: 0x0042ec49, function_type: PhantomData}; + pub const ACCEPT_DONATION: FunctionDef = FunctionDef{address: 0x0042ec49, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/update_portals"))] - pub const UPDATE_PORTALS: FunctionDef = FunctionDef{address: 0x0043578f, function_type: PhantomData}; + pub const UPDATE_PORTALS: FunctionDef = FunctionDef{address: 0x0043578f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x004357c6, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x004357c6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_size"))] - pub const GET_SIZE: FunctionDef i32> = FunctionDef{address: 0x0044097c, function_type: PhantomData}; + pub const GET_SIZE: FunctionDef i32> = FunctionDef{address: 0x0044097c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/recalculate_characteristics"))] - pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x00444827, function_type: PhantomData}; + pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x00444827, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/revise_species_list"))] - pub const REVISE_SPECIES_LIST: FunctionDef = FunctionDef{address: 0x00447dc1, function_type: PhantomData}; + pub const REVISE_SPECIES_LIST: FunctionDef = FunctionDef{address: 0x00447dc1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/add_species"))] - pub const ADD_SPECIES: FunctionDef = FunctionDef{address: 0x00448f6b, function_type: PhantomData}; + pub const ADD_SPECIES: FunctionDef = FunctionDef{address: 0x00448f6b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/resize"))] - pub const RESIZE: FunctionDef = FunctionDef{address: 0x0044b900, function_type: PhantomData}; + pub const RESIZE: FunctionDef = FunctionDef{address: 0x0044b900, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/create_edge_pairs"))] - pub const CREATE_EDGE_PAIRS: FunctionDef = FunctionDef{address: 0x0044b95c, function_type: PhantomData}; + pub const CREATE_EDGE_PAIRS: FunctionDef = FunctionDef{address: 0x0044b95c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/create_viewing_areas"))] - pub const CREATE_VIEWING_AREAS: FunctionDef = FunctionDef{address: 0x0044ba57, function_type: PhantomData}; + pub const CREATE_VIEWING_AREAS: FunctionDef = FunctionDef{address: 0x0044ba57, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0044dc0d, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0044dc0d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/create_name"))] - pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x0044df34, function_type: PhantomData}; + pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x0044df34, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/path_placed"))] - pub const PATH_PLACED: FunctionDef = FunctionDef{address: 0x0044ea19, function_type: PhantomData}; + pub const PATH_PLACED: FunctionDef = FunctionDef{address: 0x0044ea19, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/add_viewing_area"))] - pub const ADD_VIEWING_AREA: FunctionDef = FunctionDef{address: 0x0044efa4, function_type: PhantomData}; + pub const ADD_VIEWING_AREA: FunctionDef = FunctionDef{address: 0x0044efa4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/add_show_unit"))] - pub const ADD_SHOW_UNIT: FunctionDef u32> = FunctionDef{address: 0x00458610, function_type: PhantomData}; + pub const ADD_SHOW_UNIT: FunctionDef u32> = FunctionDef{address: 0x00458610, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/remove_show_unit"))] - pub const REMOVE_SHOW_UNIT: FunctionDef u8> = FunctionDef{address: 0x004586b9, function_type: PhantomData}; + pub const REMOVE_SHOW_UNIT: FunctionDef = FunctionDef{address: 0x004586b9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/clear_show_neighbors"))] - pub const CLEAR_SHOW_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00458a88, function_type: PhantomData}; + pub const CLEAR_SHOW_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00458a88, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/move_gate_to"))] - pub const MOVE_GATE_TO: FunctionDef u32> = FunctionDef{address: 0x00466236, function_type: PhantomData}; + pub const MOVE_GATE_TO: FunctionDef u32> = FunctionDef{address: 0x00466236, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/has_keeper_assigned"))] - pub const HAS_KEEPER_ASSIGNED: FunctionDef u8> = FunctionDef{address: 0x00468454, function_type: PhantomData}; + pub const HAS_KEEPER_ASSIGNED: FunctionDef = FunctionDef{address: 0x00468454, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_popularity"))] - pub const GET_POPULARITY: FunctionDef i32> = FunctionDef{address: 0x00468732, function_type: PhantomData}; + pub const GET_POPULARITY: FunctionDef i32> = FunctionDef{address: 0x00468732, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00479b73, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_undesirable_scenery"))] - pub const GET_UNDESIRABLE_SCENERY: FunctionDef = FunctionDef{address: 0x00483a67, function_type: PhantomData}; + pub const GET_UNDESIRABLE_SCENERY: FunctionDef = FunctionDef{address: 0x00483a67, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_gate"))] - pub const GET_GATE: FunctionDef i32> = FunctionDef{address: 0x00492ca3, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/set_time_last_serviced"))] - pub const SET_TIME_LAST_SERVICED: FunctionDef = FunctionDef{address: 0x0049e950, function_type: PhantomData}; + pub const GET_GATE: FunctionDef i32> = FunctionDef{address: 0x00492ca3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_species_rating"))] - pub const GET_SPECIES_RATING: FunctionDef f32> = FunctionDef{address: 0x004d92db, function_type: PhantomData}; + pub const GET_SPECIES_RATING: FunctionDef f32> = FunctionDef{address: 0x004d92db, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_surrounding_species"))] - pub const GET_SURROUNDING_SPECIES: FunctionDef *const i32> = FunctionDef{address: 0x004fb11c, function_type: PhantomData}; + pub const GET_SURROUNDING_SPECIES: FunctionDef u32> = FunctionDef{address: 0x004fb11c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/remove_species"))] - pub const REMOVE_SPECIES: FunctionDef = FunctionDef{address: 0x004fbe4f, function_type: PhantomData}; + pub const REMOVE_SPECIES: FunctionDef = FunctionDef{address: 0x004fbe4f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/add_amphibious_neighbor"))] - pub const ADD_AMPHIBIOUS_NEIGHBOR: FunctionDef u8> = FunctionDef{address: 0x005078d3, function_type: PhantomData}; + pub const ADD_AMPHIBIOUS_NEIGHBOR: FunctionDef = FunctionDef{address: 0x005078d3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/remove_amphibious_neighbor"))] - pub const REMOVE_AMPHIBIOUS_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x00507a90, function_type: PhantomData}; + pub const REMOVE_AMPHIBIOUS_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x00507a90, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/remove_from_all_vas"))] - pub const REMOVE_FROM_ALL_VAS: FunctionDef = FunctionDef{address: 0x0050bb53, function_type: PhantomData}; + pub const REMOVE_FROM_ALL_VAS: FunctionDef = FunctionDef{address: 0x0050bb53, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/remove_viewing_area"))] - pub const REMOVE_VIEWING_AREA: FunctionDef = FunctionDef{address: 0x0050bc94, function_type: PhantomData}; + pub const REMOVE_VIEWING_AREA: FunctionDef = FunctionDef{address: 0x0050bc94, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/get_show_portal"))] - pub const GET_SHOW_PORTAL: FunctionDef i32> = FunctionDef{address: 0x0059e0a9, function_type: PhantomData}; + pub const GET_SHOW_PORTAL: FunctionDef i32> = FunctionDef{address: 0x0059e0a9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/remove_show_portal"))] - pub const REMOVE_SHOW_PORTAL: FunctionDef = FunctionDef{address: 0x005aa4d9, function_type: PhantomData}; + pub const REMOVE_SHOW_PORTAL: FunctionDef = FunctionDef{address: 0x005aa4d9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/remove_show_neighbor"))] - pub const REMOVE_SHOW_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005aa75e, function_type: PhantomData}; + pub const REMOVE_SHOW_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005aa75e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/add_show_neighbor"))] - pub const ADD_SHOW_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005ab1e7, function_type: PhantomData}; + pub const ADD_SHOW_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005ab1e7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/add_show_portal"))] - pub const ADD_SHOW_PORTAL: FunctionDef u32> = FunctionDef{address: 0x005ab354, function_type: PhantomData}; + pub const ADD_SHOW_PORTAL: FunctionDef u32> = FunctionDef{address: 0x005ab354, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/set_is_show_exhibit"))] - pub const SET_IS_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x005ab661, function_type: PhantomData}; + pub const SET_IS_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x005ab661, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/set_name"))] - pub const SET_NAME: FunctionDef = FunctionDef{address: 0x005aedbd, function_type: PhantomData}; + pub const SET_NAME: FunctionDef = FunctionDef{address: 0x005aedbd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/recreate_oas"))] - pub const RECREATE_OAS: FunctionDef = FunctionDef{address: 0x005b2ffb, function_type: PhantomData}; + pub const RECREATE_OAS: FunctionDef = FunctionDef{address: 0x005b2ffb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/trigger_death_arrived"))] - pub const TRIGGER_DEATH_ARRIVED: FunctionDef = FunctionDef{address: 0x00605b8e, function_type: PhantomData}; + pub const TRIGGER_DEATH_ARRIVED: FunctionDef = FunctionDef{address: 0x00605b8e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/hilite_show_neighbors"))] - pub const HILITE_SHOW_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00605c02, function_type: PhantomData}; + pub const HILITE_SHOW_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00605c02, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitat/hilite_amphibious_neighbors"))] - pub const HILITE_AMPHIBIOUS_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00605c80, function_type: PhantomData}; + pub const HILITE_AMPHIBIOUS_NEIGHBORS: FunctionDef = FunctionDef{address: 0x00605c80, function_type: PhantomData}; } // ZTHabitatMgr class functions @@ -3558,133 +3348,121 @@ pub mod zthabitatmgr { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/get_habitat"))] - pub const GET_HABITAT: FunctionDef u32> = FunctionDef{address: 0x00410bf9, function_type: PhantomData}; + pub const GET_HABITAT: FunctionDef u32> = FunctionDef{address: 0x00410bf9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/get_zoo_entrance_tile"))] - pub const GET_ZOO_ENTRANCE_TILE: FunctionDef i32> = FunctionDef{address: 0x00410d04, function_type: PhantomData}; + pub const GET_ZOO_ENTRANCE_TILE: FunctionDef i32> = FunctionDef{address: 0x00410d04, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/scenery_entity_change"))] - pub const SCENERY_ENTITY_CHANGE: FunctionDef = FunctionDef{address: 0x00417295, function_type: PhantomData}; + pub const SCENERY_ENTITY_CHANGE: FunctionDef = FunctionDef{address: 0x00417295, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/replace_gate"))] - pub const REPLACE_GATE: FunctionDef = FunctionDef{address: 0x0041ec94, function_type: PhantomData}; + pub const REPLACE_GATE: FunctionDef = FunctionDef{address: 0x0041ec94, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/get_nonempty_non_world_habitats"))] - pub const GET_NONEMPTY_NON_WORLD_HABITATS: FunctionDef = FunctionDef{address: 0x00440d9a, function_type: PhantomData}; + pub const GET_NONEMPTY_NON_WORLD_HABITATS: FunctionDef = FunctionDef{address: 0x00440d9a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/recalculate_deterioration"))] - pub const RECALCULATE_DETERIORATION: FunctionDef = FunctionDef{address: 0x00449920, function_type: PhantomData}; + pub const RECALCULATE_DETERIORATION: FunctionDef = FunctionDef{address: 0x00449920, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/add_habitat"))] - pub const ADD_HABITAT: FunctionDef = FunctionDef{address: 0x0044c7b2, function_type: PhantomData}; + pub const ADD_HABITAT: FunctionDef = FunctionDef{address: 0x0044c7b2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/do_tank_check"))] pub const DO_TANK_CHECK: FunctionDef u32> = FunctionDef{address: 0x0044c8ab, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/morph_exhibit"))] - pub const MORPH_EXHIBIT: FunctionDef = FunctionDef{address: 0x0044ca8c, function_type: PhantomData}; + pub const MORPH_EXHIBIT: FunctionDef = FunctionDef{address: 0x0044ca8c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/fence_placed"))] - pub const FENCE_PLACED: FunctionDef = FunctionDef{address: 0x0044ce67, function_type: PhantomData}; + pub const FENCE_PLACED: FunctionDef = FunctionDef{address: 0x0044ce67, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/can_find_path"))] - pub const CAN_FIND_PATH: FunctionDef u32> = FunctionDef{address: 0x0044d598, function_type: PhantomData}; + pub const CAN_FIND_PATH: FunctionDef u32> = FunctionDef{address: 0x0044d598, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/clear_pathfinding"))] - pub const CLEAR_PATHFINDING: FunctionDef = FunctionDef{address: 0x0044dab9, function_type: PhantomData}; + pub const CLEAR_PATHFINDING: FunctionDef = FunctionDef{address: 0x0044dab9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/do_show_check"))] - pub const DO_SHOW_CHECK: FunctionDef u32> = FunctionDef{address: 0x0044e1e8, function_type: PhantomData}; + pub const DO_SHOW_CHECK: FunctionDef u32> = FunctionDef{address: 0x0044e1e8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/create_habitat"))] - pub const CREATE_HABITAT: FunctionDef = FunctionDef{address: 0x0044e389, function_type: PhantomData}; + pub const CREATE_HABITAT: FunctionDef = FunctionDef{address: 0x0044e389, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/name_habitat"))] - pub const NAME_HABITAT: FunctionDef = FunctionDef{address: 0x0044e43e, function_type: PhantomData}; + pub const NAME_HABITAT: FunctionDef = FunctionDef{address: 0x0044e43e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/place_gate"))] - pub const PLACE_GATE: FunctionDef u32> = FunctionDef{address: 0x0044e4eb, function_type: PhantomData}; + pub const PLACE_GATE: FunctionDef u32> = FunctionDef{address: 0x0044e4eb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/get_next_num"))] - pub const GET_NEXT_NUM: FunctionDef u32> = FunctionDef{address: 0x0044e9f9, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/path_placed"))] - pub const PATH_PLACED: FunctionDef = FunctionDef{address: 0x00451d6d, function_type: PhantomData}; + pub const GET_NEXT_NUM: FunctionDef u32> = FunctionDef{address: 0x0044e9f9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/decrement_habitat_num"))] - pub const DECREMENT_HABITAT_NUM: FunctionDef = FunctionDef{address: 0x0045bbf6, function_type: PhantomData}; + pub const DECREMENT_HABITAT_NUM: FunctionDef = FunctionDef{address: 0x0045bbf6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/snap_tank_walls_inward"))] - pub const SNAP_TANK_WALLS_INWARD: FunctionDef u32> = FunctionDef{address: 0x0045c80a, function_type: PhantomData}; + pub const SNAP_TANK_WALLS_INWARD: FunctionDef u32> = FunctionDef{address: 0x0045c80a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/check_exhibit_morph"))] - pub const CHECK_EXHIBIT_MORPH: FunctionDef = FunctionDef{address: 0x0045ce9a, function_type: PhantomData}; + pub const CHECK_EXHIBIT_MORPH: FunctionDef = FunctionDef{address: 0x0045ce9a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/update_amphibious_neighbors_0"))] - pub const UPDATE_AMPHIBIOUS_NEIGHBORS_0: FunctionDef = FunctionDef{address: 0x0045cf03, function_type: PhantomData}; + pub const UPDATE_AMPHIBIOUS_NEIGHBORS_0: FunctionDef = FunctionDef{address: 0x0045cf03, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/update_show_neighbors_0"))] - pub const UPDATE_SHOW_NEIGHBORS_0: FunctionDef = FunctionDef{address: 0x0045cf65, function_type: PhantomData}; + pub const UPDATE_SHOW_NEIGHBORS_0: FunctionDef = FunctionDef{address: 0x0045cf65, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/instantiate"))] - pub const INSTANTIATE: FunctionDef *const i16> = FunctionDef{address: 0x004635aa, function_type: PhantomData}; + pub const INSTANTIATE: FunctionDef u32> = FunctionDef{address: 0x004635aa, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/replace_fence_with_gate"))] - pub const REPLACE_FENCE_WITH_GATE: FunctionDef u32> = FunctionDef{address: 0x004666c5, function_type: PhantomData}; + pub const REPLACE_FENCE_WITH_GATE: FunctionDef u32> = FunctionDef{address: 0x004666c5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00479a54, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/enter_new_month"))] - pub const ENTER_NEW_MONTH: FunctionDef = FunctionDef{address: 0x0048430c, function_type: PhantomData}; + pub const ENTER_NEW_MONTH: FunctionDef = FunctionDef{address: 0x0048430c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/merge_tanks"))] - pub const MERGE_TANKS: FunctionDef = FunctionDef{address: 0x0048712c, function_type: PhantomData}; + pub const MERGE_TANKS: FunctionDef = FunctionDef{address: 0x0048712c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/get_merge_tank_walls"))] - pub const GET_MERGE_TANK_WALLS: FunctionDef = FunctionDef{address: 0x00487498, function_type: PhantomData}; + pub const GET_MERGE_TANK_WALLS: FunctionDef = FunctionDef{address: 0x00487498, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/split_tank"))] - pub const SPLIT_TANK: FunctionDef u32> = FunctionDef{address: 0x004877bf, function_type: PhantomData}; + pub const SPLIT_TANK: FunctionDef u32> = FunctionDef{address: 0x004877bf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/get_next_fence_pair"))] - pub const GET_NEXT_FENCE_PAIR: FunctionDef u32> = FunctionDef{address: 0x00487f34, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/get_needy_nested_tank"))] - pub const GET_NEEDY_NESTED_TANK: FunctionDef *const i32> = FunctionDef{address: 0x0049e8fa, function_type: PhantomData}; + pub const GET_NEXT_FENCE_PAIR: FunctionDef u32> = FunctionDef{address: 0x00487f34, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/clear"))] - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6b2c, function_type: PhantomData}; + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6b2c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004c7e6c, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/create_world_habitat_0"))] - pub const CREATE_WORLD_HABITAT_0: FunctionDef = FunctionDef{address: 0x004c842e, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004c7e6c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/before_entity_change"))] - pub const BEFORE_ENTITY_CHANGE: FunctionDef = FunctionDef{address: 0x004d8a4d, function_type: PhantomData}; + pub const BEFORE_ENTITY_CHANGE: FunctionDef = FunctionDef{address: 0x004d8a4d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/entity_about_to_be_placed"))] - pub const ENTITY_ABOUT_TO_BE_PLACED: FunctionDef = FunctionDef{address: 0x004d8cd2, function_type: PhantomData}; + pub const ENTITY_ABOUT_TO_BE_PLACED: FunctionDef = FunctionDef{address: 0x004d8cd2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/terrain_about_to_be_changed"))] - pub const TERRAIN_ABOUT_TO_BE_CHANGED: FunctionDef = FunctionDef{address: 0x004db967, function_type: PhantomData}; + pub const TERRAIN_ABOUT_TO_BE_CHANGED: FunctionDef = FunctionDef{address: 0x004db967, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/terrain_changed"))] - pub const TERRAIN_CHANGED: FunctionDef = FunctionDef{address: 0x004dbc79, function_type: PhantomData}; + pub const TERRAIN_CHANGED: FunctionDef = FunctionDef{address: 0x004dbc79, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/zthabitat_mgr"))] - pub const ZTHABITAT_MGR: FunctionDef *const u32> = FunctionDef{address: 0x0050363d, function_type: PhantomData}; + pub const ZTHABITAT_MGR: FunctionDef u32> = FunctionDef{address: 0x0050363d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/entity_about_to_be_removed"))] - pub const ENTITY_ABOUT_TO_BE_REMOVED: FunctionDef = FunctionDef{address: 0x0050a5db, function_type: PhantomData}; + pub const ENTITY_ABOUT_TO_BE_REMOVED: FunctionDef = FunctionDef{address: 0x0050a5db, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/replace_gate_with_fence"))] - pub const REPLACE_GATE_WITH_FENCE: FunctionDef bool> = FunctionDef{address: 0x0050b0c8, function_type: PhantomData}; + pub const REPLACE_GATE_WITH_FENCE: FunctionDef bool> = FunctionDef{address: 0x0050b0c8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/path_removed"))] - pub const PATH_REMOVED: FunctionDef = FunctionDef{address: 0x0050bae5, function_type: PhantomData}; + pub const PATH_REMOVED: FunctionDef = FunctionDef{address: 0x0050bae5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/fence_removed"))] - pub const FENCE_REMOVED: FunctionDef = FunctionDef{address: 0x0050c3d8, function_type: PhantomData}; + pub const FENCE_REMOVED: FunctionDef = FunctionDef{address: 0x0050c3d8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/remove_habitat_0"))] - pub const REMOVE_HABITAT_0: FunctionDef = FunctionDef{address: 0x0050c515, function_type: PhantomData}; + pub const REMOVE_HABITAT_0: FunctionDef = FunctionDef{address: 0x0050c515, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/clear_staff_habitat"))] - pub const CLEAR_STAFF_HABITAT: FunctionDef = FunctionDef{address: 0x0050c6b8, function_type: PhantomData}; + pub const CLEAR_STAFF_HABITAT: FunctionDef = FunctionDef{address: 0x0050c6b8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/empty_grandstands"))] - pub const EMPTY_GRANDSTANDS: FunctionDef = FunctionDef{address: 0x0050c813, function_type: PhantomData}; + pub const EMPTY_GRANDSTANDS: FunctionDef = FunctionDef{address: 0x0050c813, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/create_world_habitat_1"))] - pub const CREATE_WORLD_HABITAT_1: FunctionDef = FunctionDef{address: 0x0058e607, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/name_loaded_habitats"))] - pub const NAME_LOADED_HABITATS: FunctionDef = FunctionDef{address: 0x005939fb, function_type: PhantomData}; + pub const CREATE_WORLD_HABITAT: FunctionDef = FunctionDef{address: 0x0058e607, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/mark_zoo_exterior"))] - pub const MARK_ZOO_EXTERIOR: FunctionDef = FunctionDef{address: 0x00594729, function_type: PhantomData}; + pub const MARK_ZOO_EXTERIOR: FunctionDef = FunctionDef{address: 0x00594729, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/fill_zoo_exterior"))] - pub const FILL_ZOO_EXTERIOR: FunctionDef = FunctionDef{address: 0x00594848, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/highlight_habitat"))] - pub const HIGHLIGHT_HABITAT: FunctionDef = FunctionDef{address: 0x0059a6b7, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/unhighlight_habitat"))] - pub const UNHIGHLIGHT_HABITAT: FunctionDef = FunctionDef{address: 0x0059a735, function_type: PhantomData}; + pub const FILL_ZOO_EXTERIOR: FunctionDef = FunctionDef{address: 0x00594848, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/can_see_habitat_from_building"))] pub const CAN_SEE_HABITAT_FROM_BUILDING: FunctionDef u32> = FunctionDef{address: 0x0059e349, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/habitat_seen_from_building"))] - pub const HABITAT_SEEN_FROM_BUILDING: FunctionDef *const i32> = FunctionDef{address: 0x005a2b61, function_type: PhantomData}; + pub const HABITAT_SEEN_FROM_BUILDING: FunctionDef u32> = FunctionDef{address: 0x005a2b61, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/check_show_neighbor"))] - pub const CHECK_SHOW_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005aaed2, function_type: PhantomData}; + pub const CHECK_SHOW_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005aaed2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/remove_all_habitats"))] - pub const REMOVE_ALL_HABITATS: FunctionDef = FunctionDef{address: 0x005b11d2, function_type: PhantomData}; + pub const REMOVE_ALL_HABITATS: FunctionDef = FunctionDef{address: 0x005b11d2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/update_show_neighbors_1"))] - pub const UPDATE_SHOW_NEIGHBORS_1: FunctionDef = FunctionDef{address: 0x005b2d3a, function_type: PhantomData}; + pub const UPDATE_SHOW_NEIGHBORS_1: FunctionDef = FunctionDef{address: 0x005b2d3a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/update_amphibious_neighbors_1"))] - pub const UPDATE_AMPHIBIOUS_NEIGHBORS_1: FunctionDef = FunctionDef{address: 0x005b2e8a, function_type: PhantomData}; + pub const UPDATE_AMPHIBIOUS_NEIGHBORS_1: FunctionDef = FunctionDef{address: 0x005b2e8a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/check_amphibious_neighbor"))] - pub const CHECK_AMPHIBIOUS_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005b2fa1, function_type: PhantomData}; + pub const CHECK_AMPHIBIOUS_NEIGHBOR: FunctionDef u32> = FunctionDef{address: 0x005b2fa1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/habitat_tile_changed"))] - pub const HABITAT_TILE_CHANGED: FunctionDef = FunctionDef{address: 0x005b3a77, function_type: PhantomData}; + pub const HABITAT_TILE_CHANGED: FunctionDef = FunctionDef{address: 0x005b3a77, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/remove_habitat_1"))] pub const REMOVE_HABITAT_1: FunctionDef = FunctionDef{address: 0x005b66ea, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/split_tank_into_land"))] - pub const SPLIT_TANK_INTO_LAND: FunctionDef u32> = FunctionDef{address: 0x006044a5, function_type: PhantomData}; + pub const SPLIT_TANK_INTO_LAND: FunctionDef u32> = FunctionDef{address: 0x006044a5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthabitatmgr/terrain_tile_changed"))] - pub const TERRAIN_TILE_CHANGED: FunctionDef = FunctionDef{address: 0x0060497a, function_type: PhantomData}; + pub const TERRAIN_TILE_CHANGED: FunctionDef = FunctionDef{address: 0x0060497a, function_type: PhantomData}; } // ZTHelicopter class functions @@ -3692,23 +3470,15 @@ pub mod zthelicopter { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/init_after_load"))] - pub const INIT_AFTER_LOAD: FunctionDef = FunctionDef{address: 0x00482cf1, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/set_world_dest"))] - pub const SET_WORLD_DEST: FunctionDef = FunctionDef{address: 0x0048bf41, function_type: PhantomData}; + pub const INIT_AFTER_LOAD: FunctionDef = FunctionDef{address: 0x00482cf1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/get_next_pos"))] - pub const GET_NEXT_POS: FunctionDef = FunctionDef{address: 0x0048c0c6, function_type: PhantomData}; + pub const GET_NEXT_POS: FunctionDef = FunctionDef{address: 0x0048c0c6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/start_loop_sound"))] - pub const START_LOOP_SOUND: FunctionDef = FunctionDef{address: 0x0048d645, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004e56e9, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/validate_position"))] - pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x005066ff, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/validate_position_inner"))] - pub const VALIDATE_POSITION_INNER: FunctionDef = FunctionDef{address: 0x0050675f, function_type: PhantomData}; + pub const START_LOOP_SOUND: FunctionDef = FunctionDef{address: 0x0048d645, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/validate_tank_position"))] - pub const VALIDATE_TANK_POSITION: FunctionDef = FunctionDef{address: 0x005067be, function_type: PhantomData}; + pub const VALIDATE_TANK_POSITION: FunctionDef = FunctionDef{address: 0x005067be, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthelicopter/set_dest_tile"))] - pub const SET_DEST_TILE: FunctionDef = FunctionDef{address: 0x0061a117, function_type: PhantomData}; + pub const SET_DEST_TILE: FunctionDef = FunctionDef{address: 0x0061a117, function_type: PhantomData}; } // ZTHelicopterType class functions @@ -3716,15 +3486,13 @@ pub mod zthelicoptertype { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("zthelicoptertype/load_characteristics"))] - pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004c42ff, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("zthelicoptertype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x004e5725, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004c42ff, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthelicoptertype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051c7b5, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051c7b5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthelicoptertype/zthelicopter_type_0"))] - pub const ZTHELICOPTER_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x0057cb90, function_type: PhantomData}; + pub const ZTHELICOPTER_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x0057cb90, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zthelicoptertype/zthelicopter_type_1"))] - pub const ZTHELICOPTER_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x0057cbae, function_type: PhantomData}; + pub const ZTHELICOPTER_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x0057cbae, function_type: PhantomData}; } // ZTItem class functions @@ -3734,45 +3502,37 @@ pub mod ztitem { #[cfg_attr(feature = "detour-validation", validate_detour("ztitem/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x00464b90, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztitem/load_characteristics"))] - pub const LOAD_CHARACTERISTICS: FunctionDef *const i16> = FunctionDef{address: 0x00464f00, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x00464f00, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztitem/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const c_void> = FunctionDef{address: 0x004651cf, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004651cf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztitem/get_item"))] - pub const GET_ITEM: FunctionDef u32> = FunctionDef{address: 0x004a84f3, function_type: PhantomData}; + pub const GET_ITEM: FunctionDef u32> = FunctionDef{address: 0x004a84f3, function_type: PhantomData}; } // ZTKeeper class functions pub mod ztkeeper { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("ztkeeper/get_terrain_cost"))] - pub const GET_TERRAIN_COST: FunctionDef i32> = FunctionDef{address: 0x00423b28, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztkeeper/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00457b2e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztkeeper/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x00458759, function_type: PhantomData}; + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x00458759, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztkeeper/notify_habitat_not_coming"))] - pub const NOTIFY_HABITAT_NOT_COMING: FunctionDef = FunctionDef{address: 0x004a879f, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztkeeper/reset_ai"))] - pub const RESET_AI: FunctionDef = FunctionDef{address: 0x005ae772, function_type: PhantomData}; + pub const NOTIFY_HABITAT_NOT_COMING: FunctionDef = FunctionDef{address: 0x004a879f, function_type: PhantomData}; } // ZTKeeperType class functions pub mod ztkeepertype { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("ztkeepertype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x00457b4e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztkeepertype/load_characteristics_0"))] - pub const LOAD_CHARACTERISTICS_0: FunctionDef u8> = FunctionDef{address: 0x004c32bd, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_0: FunctionDef = FunctionDef{address: 0x004c32bd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztkeepertype/load_characteristics_1"))] - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c34ae, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c34ae, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztkeepertype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051bde7, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051bde7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztkeepertype/ztkeeper_type_0"))] - pub const ZTKEEPER_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x0057ca95, function_type: PhantomData}; + pub const ZTKEEPER_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x0057ca95, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztkeepertype/ztkeeper_type_1"))] - pub const ZTKEEPER_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x0057cae0, function_type: PhantomData}; + pub const ZTKEEPER_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x0057cae0, function_type: PhantomData}; } // ZTMVTempEntityList class functions @@ -3780,9 +3540,9 @@ pub mod ztmvtempentitylist { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztmvtempentitylist/clear"))] - pub const CLEAR: FunctionDef = FunctionDef{address: 0x00443e12, function_type: PhantomData}; + pub const CLEAR: FunctionDef = FunctionDef{address: 0x00443e12, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmvtempentitylist/add_entity"))] - pub const ADD_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x004df44e, function_type: PhantomData}; + pub const ADD_ENTITY: FunctionDef u32> = FunctionDef{address: 0x004df44e, function_type: PhantomData}; } // ZTMaint class functions @@ -3790,13 +3550,9 @@ pub mod ztmaint { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztmaint/get_terrain_cost"))] - pub const GET_TERRAIN_COST: FunctionDef = FunctionDef{address: 0x00439c73, function_type: PhantomData}; + pub const GET_TERRAIN_COST: FunctionDef = FunctionDef{address: 0x00439c73, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmaint/finish_task"))] - pub const FINISH_TASK: FunctionDef = FunctionDef{address: 0x004a97e5, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztmaint/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const i32> = FunctionDef{address: 0x004c5ecf, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztmaint/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x00502078, function_type: PhantomData}; + pub const FINISH_TASK: FunctionDef = FunctionDef{address: 0x004a97e5, function_type: PhantomData}; } // ZTMaintTaskPool class functions @@ -3804,7 +3560,7 @@ pub mod ztmainttaskpool { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztmainttaskpool/clear"))] - pub const CLEAR: FunctionDef = FunctionDef{address: 0x005b11a2, function_type: PhantomData}; + pub const CLEAR: FunctionDef = FunctionDef{address: 0x005b11a2, function_type: PhantomData}; } // ZTMaintType class functions @@ -3812,17 +3568,15 @@ pub mod ztmainttype { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztmainttype/load_characteristics_0"))] - pub const LOAD_CHARACTERISTICS_0: FunctionDef u8> = FunctionDef{address: 0x004c3bb3, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_0: FunctionDef = FunctionDef{address: 0x004c3bb3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmainttype/load_characteristics_1"))] - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c3d44, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztmainttype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x004c5ead, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c3d44, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmainttype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const i32> = FunctionDef{address: 0x0051bf9e, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051bf9e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmainttype/ztmaint_type_0"))] - pub const ZTMAINT_TYPE_0: FunctionDef *const i32> = FunctionDef{address: 0x0057cafe, function_type: PhantomData}; + pub const ZTMAINT_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x0057cafe, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmainttype/ztmaint_type_1"))] - pub const ZTMAINT_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x0057cb49, function_type: PhantomData}; + pub const ZTMAINT_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x0057cb49, function_type: PhantomData}; } // ZTMapView class functions @@ -3830,157 +3584,153 @@ pub mod ztmapview { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/clear_conflicting_entities"))] - pub const CLEAR_CONFLICTING_ENTITIES: FunctionDef = FunctionDef{address: 0x0040248a, function_type: PhantomData}; + pub const CLEAR_CONFLICTING_ENTITIES: FunctionDef = FunctionDef{address: 0x0040248a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_highlighted_entity"))] - pub const SET_HIGHLIGHTED_ENTITY: FunctionDef = FunctionDef{address: 0x0040fcdb, function_type: PhantomData}; + pub const SET_HIGHLIGHTED_ENTITY: FunctionDef = FunctionDef{address: 0x0040fcdb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/scroll_map"))] - pub const SCROLL_MAP: FunctionDef = FunctionDef{address: 0x00418da5, function_type: PhantomData}; + pub const SCROLL_MAP: FunctionDef = FunctionDef{address: 0x00418da5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/draw"))] - pub const DRAW: FunctionDef = FunctionDef{address: 0x00419729, function_type: PhantomData}; + pub const DRAW: FunctionDef = FunctionDef{address: 0x00419729, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00419eb2, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00419eb2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/prepare_to_delete_entity"))] - pub const PREPARE_TO_DELETE_ENTITY: FunctionDef = FunctionDef{address: 0x0041e145, function_type: PhantomData}; + pub const PREPARE_TO_DELETE_ENTITY: FunctionDef = FunctionDef{address: 0x0041e145, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/use_cursor"))] pub const USE_CURSOR_0: FunctionDef = FunctionDef{address: 0x0043231a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/render_0"))] - pub const RENDER_0: FunctionDef = FunctionDef{address: 0x00432bd7, function_type: PhantomData}; + pub const RENDER_0: FunctionDef = FunctionDef{address: 0x00432bd7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/show_current_cost"))] - pub const SHOW_CURRENT_COST: FunctionDef = FunctionDef{address: 0x00433918, function_type: PhantomData}; + pub const SHOW_CURRENT_COST: FunctionDef = FunctionDef{address: 0x00433918, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/check_mouse_over_entity"))] pub const CHECK_MOUSE_OVER_ENTITY: FunctionDef = FunctionDef{address: 0x00433b34, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_current_cost"))] - pub const SET_CURRENT_COST: FunctionDef = FunctionDef{address: 0x00443d97, function_type: PhantomData}; + pub const USE_CURSOR_1: FunctionDef = FunctionDef{address: 0x00443d97, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/highlight_map"))] - pub const HIGHLIGHT_MAP: FunctionDef = FunctionDef{address: 0x00443daf, function_type: PhantomData}; + pub const HIGHLIGHT_MAP: FunctionDef = FunctionDef{address: 0x00443daf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/cancel_entity_move"))] - pub const CANCEL_ENTITY_MOVE: FunctionDef = FunctionDef{address: 0x00443df7, function_type: PhantomData}; + pub const CANCEL_ENTITY_MOVE: FunctionDef = FunctionDef{address: 0x00443df7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_map_selection_size"))] - pub const SET_MAP_SELECTION_SIZE: FunctionDef *const u8> = FunctionDef{address: 0x00449739, function_type: PhantomData}; + pub const SET_MAP_SELECTION_SIZE: FunctionDef u32> = FunctionDef{address: 0x00449739, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/has_undo_action"))] - pub const HAS_UNDO_ACTION: FunctionDef u32> = FunctionDef{address: 0x00458b5f, function_type: PhantomData}; + pub const HAS_UNDO_ACTION: FunctionDef u32> = FunctionDef{address: 0x00458b5f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/get_habitat"))] - pub const GET_HABITAT: FunctionDef i32> = FunctionDef{address: 0x00468a7d, function_type: PhantomData}; + pub const GET_HABITAT: FunctionDef i32> = FunctionDef{address: 0x00468a7d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/pick_up_selected_entity"))] - pub const PICK_UP_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x0046ab75, function_type: PhantomData}; + pub const PICK_UP_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x0046ab75, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/handle_char"))] - pub const HANDLE_CHAR: FunctionDef u32> = FunctionDef{address: 0x0046bd7d, function_type: PhantomData}; + pub const HANDLE_CHAR: FunctionDef u32> = FunctionDef{address: 0x0046bd7d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/save_state"))] pub const SAVE_STATE: FunctionDef u32> = FunctionDef{address: 0x0047abeb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/place_entity_on_map_0"))] pub const PLACE_ENTITY_ON_MAP_0: FunctionDef u32> = FunctionDef{address: 0x004868cf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/follow_selected_entity"))] - pub const FOLLOW_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x0048c5e9, function_type: PhantomData}; + pub const FOLLOW_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x0048c5e9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/remove_selected_entity"))] - pub const REMOVE_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x0048d065, function_type: PhantomData}; + pub const REMOVE_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x0048d065, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/do_snake"))] - pub const DO_SNAKE: FunctionDef = FunctionDef{address: 0x0048e56c, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/do_ysnake"))] - pub const DO_YSNAKE: FunctionDef = FunctionDef{address: 0x0048eb89, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/do_xsnake"))] - pub const DO_XSNAKE: FunctionDef = FunctionDef{address: 0x0048ec4b, function_type: PhantomData}; + pub const DO_SNAKE: FunctionDef = FunctionDef{address: 0x0048e56c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_map_view"))] - pub const SET_MAP_VIEW: FunctionDef = FunctionDef{address: 0x004b0384, function_type: PhantomData}; + pub const SET_MAP_VIEW: FunctionDef = FunctionDef{address: 0x004b0384, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_map_selection"))] - pub const SET_MAP_SELECTION: FunctionDef = FunctionDef{address: 0x004b05ab, function_type: PhantomData}; + pub const SET_MAP_SELECTION: FunctionDef = FunctionDef{address: 0x004b05ab, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/rotate_map"))] - pub const ROTATE_MAP: FunctionDef = FunctionDef{address: 0x004b06be, function_type: PhantomData}; + pub const ROTATE_MAP: FunctionDef = FunctionDef{address: 0x004b06be, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/zoom_map"))] pub const ZOOM_MAP: FunctionDef = FunctionDef{address: 0x004b072d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_selected_entity_0"))] - pub const SET_SELECTED_ENTITY_0: FunctionDef = FunctionDef{address: 0x004b2322, function_type: PhantomData}; + pub const SET_SELECTED_ENTITY_0: FunctionDef = FunctionDef{address: 0x004b2322, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/check_zoom_options"))] - pub const CHECK_ZOOM_OPTIONS: FunctionDef = FunctionDef{address: 0x004b2868, function_type: PhantomData}; + pub const CHECK_ZOOM_OPTIONS: FunctionDef = FunctionDef{address: 0x004b2868, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/destroy_cursors"))] pub const DESTROY_CURSORS: FunctionDef = FunctionDef{address: 0x004b2c84, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/clear"))] - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6c4c, function_type: PhantomData}; + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6c4c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d3f9e, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004d3f9e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/init_cursors"))] pub const INIT_CURSORS: FunctionDef = FunctionDef{address: 0x004d40c4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/handle_left_button_down"))] - pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x004d83d7, function_type: PhantomData}; + pub const HANDLE_LEFT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x004d83d7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/handle_left_button_up"))] - pub const HANDLE_LEFT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004d8533, function_type: PhantomData}; + pub const HANDLE_LEFT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004d8533, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/place_entity_on_map_1"))] pub const PLACE_ENTITY_ON_MAP_1: FunctionDef *const i32> = FunctionDef{address: 0x004d9088, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/commit_terraform"))] - pub const COMMIT_TERRAFORM: FunctionDef = FunctionDef{address: 0x004da19c, function_type: PhantomData}; + pub const COMMIT_TERRAFORM: FunctionDef = FunctionDef{address: 0x004da19c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/undo_last_action_0"))] - pub const UNDO_LAST_ACTION_0: FunctionDef = FunctionDef{address: 0x004de527, function_type: PhantomData}; + pub const UNDO_LAST_ACTION_0: FunctionDef = FunctionDef{address: 0x004de527, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_entity_position"))] - pub const SET_ENTITY_POSITION: FunctionDef = FunctionDef{address: 0x004ded90, function_type: PhantomData}; + pub const SET_ENTITY_POSITION: FunctionDef = FunctionDef{address: 0x004ded90, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/check_tank_placement"))] pub const CHECK_TANK_PLACEMENT: FunctionDef bool> = FunctionDef{address: 0x004df688, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/render_1"))] pub const RENDER_1: FunctionDef = FunctionDef{address: 0x004df7e8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_place_gate_mode"))] - pub const SET_PLACE_GATE_MODE: FunctionDef = FunctionDef{address: 0x004e1064, function_type: PhantomData}; + pub const SET_PLACE_GATE_MODE: FunctionDef = FunctionDef{address: 0x004e1064, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/fill_canvases"))] - pub const FILL_CANVASES: FunctionDef = FunctionDef{address: 0x004ec8bf, function_type: PhantomData}; + pub const FILL_CANVASES: FunctionDef = FunctionDef{address: 0x004ec8bf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/handle_key_up"))] - pub const HANDLE_KEY_UP: FunctionDef u32> = FunctionDef{address: 0x004f0b1e, function_type: PhantomData}; + pub const HANDLE_KEY_UP: FunctionDef = FunctionDef{address: 0x004f0b1e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/handle_key_down"))] - pub const HANDLE_KEY_DOWN: FunctionDef u32> = FunctionDef{address: 0x004f0ee4, function_type: PhantomData}; + pub const HANDLE_KEY_DOWN: FunctionDef = FunctionDef{address: 0x004f0ee4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/clear_undo_actions"))] - pub const CLEAR_UNDO_ACTIONS: FunctionDef = FunctionDef{address: 0x004f16f0, function_type: PhantomData}; + pub const CLEAR_UNDO_ACTIONS: FunctionDef = FunctionDef{address: 0x004f16f0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_temp_entity"))] - pub const SET_TEMP_ENTITY: FunctionDef = FunctionDef{address: 0x004f189a, function_type: PhantomData}; + pub const SET_TEMP_ENTITY: FunctionDef = FunctionDef{address: 0x004f189a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/remove_entity_from_map_0"))] - pub const REMOVE_ENTITY_FROM_MAP_0: FunctionDef = FunctionDef{address: 0x004f94be, function_type: PhantomData}; + pub const REMOVE_ENTITY_FROM_MAP_0: FunctionDef = FunctionDef{address: 0x004f94be, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/handle_right_button_down"))] - pub const HANDLE_RIGHT_BUTTON_DOWN: FunctionDef u32> = FunctionDef{address: 0x004f95e4, function_type: PhantomData}; + pub const HANDLE_RIGHT_BUTTON_DOWN: FunctionDef = FunctionDef{address: 0x004f95e4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/cancel_current_operation"))] - pub const CANCEL_CURRENT_OPERATION: FunctionDef = FunctionDef{address: 0x004f9621, function_type: PhantomData}; + pub const CANCEL_CURRENT_OPERATION: FunctionDef = FunctionDef{address: 0x004f9621, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/handle_right_button_up"))] - pub const HANDLE_RIGHT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004f96fd, function_type: PhantomData}; + pub const HANDLE_RIGHT_BUTTON_UP: FunctionDef u32> = FunctionDef{address: 0x004f96fd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/check_undo_buffer"))] - pub const CHECK_UNDO_BUFFER: FunctionDef = FunctionDef{address: 0x004fa68c, function_type: PhantomData}; + pub const CHECK_UNDO_BUFFER: FunctionDef = FunctionDef{address: 0x004fa68c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/render_current_cost"))] - pub const RENDER_CURRENT_COST: FunctionDef = FunctionDef{address: 0x004fb175, function_type: PhantomData}; + pub const RENDER_CURRENT_COST: FunctionDef = FunctionDef{address: 0x004fb175, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/cancel_drag"))] - pub const CANCEL_DRAG: FunctionDef = FunctionDef{address: 0x004ffa6b, function_type: PhantomData}; + pub const CANCEL_DRAG: FunctionDef = FunctionDef{address: 0x004ffa6b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/ztmap_view_0"))] - pub const ZTMAP_VIEW_0: FunctionDef *const u32> = FunctionDef{address: 0x00502431, function_type: PhantomData}; + pub const ZTMAP_VIEW_0: FunctionDef u32> = FunctionDef{address: 0x00502431, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/ztmap_view_1"))] - pub const ZTMAP_VIEW_1: FunctionDef *const u32> = FunctionDef{address: 0x005026cf, function_type: PhantomData}; + pub const ZTMAP_VIEW_1: FunctionDef u32> = FunctionDef{address: 0x005026cf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_bulldozer"))] - pub const SET_BULLDOZER: FunctionDef = FunctionDef{address: 0x005096e8, function_type: PhantomData}; + pub const SET_BULLDOZER: FunctionDef = FunctionDef{address: 0x005096e8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/remove_entity_from_map_1"))] - pub const REMOVE_ENTITY_FROM_MAP_1: FunctionDef = FunctionDef{address: 0x0050a0b0, function_type: PhantomData}; + pub const REMOVE_ENTITY_FROM_MAP_1: FunctionDef = FunctionDef{address: 0x0050a0b0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/remove_entity"))] - pub const REMOVE_ENTITY: FunctionDef = FunctionDef{address: 0x0050a432, function_type: PhantomData}; + pub const REMOVE_ENTITY: FunctionDef = FunctionDef{address: 0x0050a432, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/add_habitat_name_undo_actions"))] - pub const ADD_HABITAT_NAME_UNDO_ACTIONS: FunctionDef = FunctionDef{address: 0x0050ae37, function_type: PhantomData}; + pub const ADD_HABITAT_NAME_UNDO_ACTIONS: FunctionDef = FunctionDef{address: 0x0050ae37, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_map"))] - pub const SET_MAP: FunctionDef = FunctionDef{address: 0x00519ba0, function_type: PhantomData}; + pub const SET_MAP: FunctionDef = FunctionDef{address: 0x00519ba0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051f80c, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051f80c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/create"))] - pub const CREATE: FunctionDef *const u32> = FunctionDef{address: 0x005205bc, function_type: PhantomData}; + pub const CREATE: FunctionDef = FunctionDef{address: 0x005205bc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/take_snapshot"))] pub const TAKE_SNAPSHOT: FunctionDef = FunctionDef{address: 0x00532c75, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/load_state"))] - pub const LOAD_STATE: FunctionDef bool> = FunctionDef{address: 0x00592907, function_type: PhantomData}; + pub const LOAD_STATE: FunctionDef = FunctionDef{address: 0x00592907, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_view_center"))] - pub const SET_VIEW_CENTER: FunctionDef = FunctionDef{address: 0x0059b90c, function_type: PhantomData}; + pub const SET_VIEW_CENTER: FunctionDef = FunctionDef{address: 0x0059b90c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/add_undo_action"))] - pub const ADD_UNDO_ACTION: FunctionDef = FunctionDef{address: 0x005b32de, function_type: PhantomData}; + pub const ADD_UNDO_ACTION: FunctionDef = FunctionDef{address: 0x005b32de, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/set_selected_entity_1"))] pub const SET_SELECTED_ENTITY_1: FunctionDef = FunctionDef{address: 0x005b669e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/undo_last_action_1"))] - pub const UNDO_LAST_ACTION_1: FunctionDef = FunctionDef{address: 0x005b6710, function_type: PhantomData}; + pub const UNDO_LAST_ACTION_1: FunctionDef = FunctionDef{address: 0x005b6710, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/cancel_terraform"))] - pub const CANCEL_TERRAFORM: FunctionDef = FunctionDef{address: 0x006097ef, function_type: PhantomData}; + pub const CANCEL_TERRAFORM: FunctionDef = FunctionDef{address: 0x006097ef, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/draw_back_cube"))] - pub const DRAW_BACK_CUBE: FunctionDef = FunctionDef{address: 0x00609ae0, function_type: PhantomData}; + pub const DRAW_BACK_CUBE: FunctionDef = FunctionDef{address: 0x00609ae0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/draw_front_cube"))] - pub const DRAW_FRONT_CUBE: FunctionDef = FunctionDef{address: 0x00609ee1, function_type: PhantomData}; + pub const DRAW_FRONT_CUBE: FunctionDef = FunctionDef{address: 0x00609ee1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/draw_left_cube"))] - pub const DRAW_LEFT_CUBE: FunctionDef = FunctionDef{address: 0x0060a2e2, function_type: PhantomData}; + pub const DRAW_LEFT_CUBE: FunctionDef = FunctionDef{address: 0x0060a2e2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmapview/draw_right_cube"))] - pub const DRAW_RIGHT_CUBE: FunctionDef = FunctionDef{address: 0x0060a5da, function_type: PhantomData}; + pub const DRAW_RIGHT_CUBE: FunctionDef = FunctionDef{address: 0x0060a5da, function_type: PhantomData}; } // ZTMegatileMgr class functions @@ -3988,11 +3738,11 @@ pub mod ztmegatilemgr { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztmegatilemgr/recalculate_characteristics"))] - pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x0041ffdc, function_type: PhantomData}; + pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x0041ffdc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmegatilemgr/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0043525b, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0043525b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztmegatilemgr/init"))] - pub const INIT: FunctionDef = FunctionDef{address: 0x0058e82d, function_type: PhantomData}; + pub const INIT: FunctionDef = FunctionDef{address: 0x0058e82d, function_type: PhantomData}; } // ZTMiniMap class functions @@ -4000,21 +3750,21 @@ pub mod ztminimap { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/rotate_xy"))] - pub const ROTATE_XY: FunctionDef = FunctionDef{address: 0x0044458a, function_type: PhantomData}; + pub const ROTATE_XY: FunctionDef = FunctionDef{address: 0x0044458a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x004445ca, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x004445ca, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/get_tile_color"))] - pub const GET_TILE_COLOR: FunctionDef u32> = FunctionDef{address: 0x0048ff22, function_type: PhantomData}; + pub const GET_TILE_COLOR: FunctionDef u32> = FunctionDef{address: 0x0048ff22, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/set_center"))] - pub const SET_CENTER: FunctionDef = FunctionDef{address: 0x004aff88, function_type: PhantomData}; + pub const SET_CENTER: FunctionDef = FunctionDef{address: 0x004aff88, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/ztmini_map"))] - pub const ZTMINI_MAP: FunctionDef *const u32> = FunctionDef{address: 0x00503494, function_type: PhantomData}; + pub const ZTMINI_MAP: FunctionDef u32> = FunctionDef{address: 0x00503494, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/set_dimensions"))] - pub const SET_DIMENSIONS: FunctionDef = FunctionDef{address: 0x0058e416, function_type: PhantomData}; + pub const SET_DIMENSIONS: FunctionDef = FunctionDef{address: 0x0058e416, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00619477, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00619477, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztminimap/copy"))] - pub const COPY: FunctionDef *const u32> = FunctionDef{address: 0x006198d7, function_type: PhantomData}; + pub const COPY: FunctionDef u32> = FunctionDef{address: 0x006198d7, function_type: PhantomData}; } // ZTObservableArea class functions @@ -4022,49 +3772,35 @@ pub mod ztobservablearea { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztobservablearea/recalculate_characteristics"))] - pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x00447a00, function_type: PhantomData}; + pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x00447a00, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztobservablearea/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0044ef63, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0044ef63, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztobservablearea/add_tile"))] - pub const ADD_TILE: FunctionDef = FunctionDef{address: 0x004f3b00, function_type: PhantomData}; + pub const ADD_TILE: FunctionDef = FunctionDef{address: 0x004f3b00, function_type: PhantomData}; } // ZTPath class functions pub mod ztpath { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("ztpath/shape_to_set"))] - pub const SHAPE_TO_SET: FunctionDef u32> = FunctionDef{address: 0x0044a1a5, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztpath/set_shape"))] - pub const SET_SHAPE: FunctionDef = FunctionDef{address: 0x0044a20a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztpath/validate_position"))] - pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x0044a261, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztpath/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00451b68, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztpath/add_to_map"))] - pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x00451c0b, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztpath/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x00500184, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztpath/verify_shape"))] - pub const VERIFY_SHAPE: FunctionDef bool> = FunctionDef{address: 0x00619f4a, function_type: PhantomData}; + pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x0044a261, function_type: PhantomData}; } // ZTPathType class functions pub mod ztpathtype { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("ztpathtype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x00451b8a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztpathtype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x00465a0a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztpathtype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00465c62, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00465c62, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztpathtype/load_characteristics"))] - pub const LOAD_CHARACTERISTICS: FunctionDef u8> = FunctionDef{address: 0x004c24cf, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x004c24cf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztpathtype/ztpath_type_0"))] - pub const ZTPATH_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x00504c2f, function_type: PhantomData}; + pub const ZTPATH_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x00504c2f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztpathtype/ztpath_type_1"))] - pub const ZTPATH_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x00504ce0, function_type: PhantomData}; + pub const ZTPATH_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x00504ce0, function_type: PhantomData}; } // ZTResearchBranch class functions @@ -4121,7 +3857,6 @@ pub mod ztresearchmgr { pub const ZTRESEARCH_MGR_0: FunctionDef *const u32> = FunctionDef{address: 0x00504d37, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchmgr/ztresearch_mgr_1"))] pub const ZTRESEARCH_MGR_1: FunctionDef *const u32> = FunctionDef{address: 0x00504d55, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztresearchmgr/load"))] // Confirmed against ZTResearchMgr_load.asm: the function ends `RET 0x8`, popping 2 stack dwords // beyond `this`/ECX. Param 1 is the file/stream pointer (passed straight through to `deallocate` // as its 4th arg). Param 2 is a version value: `CMP [param2], 0x28; JC ` gates whether the @@ -4162,25 +3897,19 @@ pub mod ztrubble { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztrubble/play_explosion_sound"))] - pub const PLAY_EXPLOSION_SOUND: FunctionDef = FunctionDef{address: 0x0047c863, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztrubble/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0048e343, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztrubble/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x0048e50d, function_type: PhantomData}; + pub const PLAY_EXPLOSION_SOUND: FunctionDef = FunctionDef{address: 0x0047c863, function_type: PhantomData}; } // ZTRubbleType class functions pub mod ztrubbletype { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("ztrubbletype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x0048e370, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztrubbletype/load_characteristics"))] - pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004c42a2, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004c42a2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztrubbletype/load_type_members"))] - pub const LOAD_TYPE_MEMBERS: FunctionDef u8> = FunctionDef{address: 0x0051ce38, function_type: PhantomData}; + pub const LOAD_TYPE_MEMBERS: FunctionDef = FunctionDef{address: 0x0051ce38, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztrubbletype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051d2cb, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051d2cb, function_type: PhantomData}; } // ZTScenarioMgr class functions @@ -4188,15 +3917,15 @@ pub mod ztscenariomgr { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariomgr/end_scenario"))] - pub const END_SCENARIO: FunctionDef u32> = FunctionDef{address: 0x0048a408, function_type: PhantomData}; + pub const END_SCENARIO: FunctionDef = FunctionDef{address: 0x0048a408, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariomgr/begin_scenario"))] - pub const BEGIN_SCENARIO: FunctionDef u32> = FunctionDef{address: 0x004c998b, function_type: PhantomData}; + pub const BEGIN_SCENARIO: FunctionDef = FunctionDef{address: 0x004c998b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariomgr/common_setup"))] - pub const COMMON_SETUP: FunctionDef = FunctionDef{address: 0x0058ed1f, function_type: PhantomData}; + pub const COMMON_SETUP: FunctionDef = FunctionDef{address: 0x0058ed1f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariomgr/set_cash"))] pub const SET_CASH: FunctionDef = FunctionDef{address: 0x005b0f17, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariomgr/add_cash"))] - pub const ADD_CASH: FunctionDef = FunctionDef{address: 0x0060ccc2, function_type: PhantomData}; + pub const ADD_CASH: FunctionDef = FunctionDef{address: 0x0060ccc2, function_type: PhantomData}; } // ZTScenarioSimpleGoal class functions @@ -4204,35 +3933,35 @@ pub mod ztscenariosimplegoal { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/eval"))] - pub const EVAL: FunctionDef i32> = FunctionDef{address: 0x0041d665, function_type: PhantomData}; + pub const EVAL: FunctionDef i32> = FunctionDef{address: 0x0041d665, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/eval00"))] pub const EVAL00: FunctionDef u32> = FunctionDef{address: 0x0041da81, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger10"))] pub const TRIGGER10: FunctionDef = FunctionDef{address: 0x0047e76a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger"))] - pub const TRIGGER: FunctionDef = FunctionDef{address: 0x004fc783, function_type: PhantomData}; + pub const TRIGGER: FunctionDef = FunctionDef{address: 0x004fc783, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/do_dialog"))] - pub const DO_DIALOG: FunctionDef = FunctionDef{address: 0x004fc812, function_type: PhantomData}; + pub const DO_DIALOG: FunctionDef = FunctionDef{address: 0x004fc812, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger02"))] - pub const TRIGGER02: FunctionDef = FunctionDef{address: 0x005a0a10, function_type: PhantomData}; + pub const TRIGGER02: FunctionDef = FunctionDef{address: 0x005a0a10, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger04"))] - pub const TRIGGER04: FunctionDef = FunctionDef{address: 0x005a0fc2, function_type: PhantomData}; + pub const TRIGGER04: FunctionDef = FunctionDef{address: 0x005a0fc2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger07"))] - pub const TRIGGER07: FunctionDef = FunctionDef{address: 0x005a1139, function_type: PhantomData}; + pub const TRIGGER07: FunctionDef = FunctionDef{address: 0x005a1139, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger03"))] - pub const TRIGGER03: FunctionDef = FunctionDef{address: 0x005a13c5, function_type: PhantomData}; + pub const TRIGGER03: FunctionDef = FunctionDef{address: 0x005a13c5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger06"))] - pub const TRIGGER06: FunctionDef = FunctionDef{address: 0x005a154a, function_type: PhantomData}; + pub const TRIGGER06: FunctionDef = FunctionDef{address: 0x005a154a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger05"))] - pub const TRIGGER05: FunctionDef = FunctionDef{address: 0x005a17a8, function_type: PhantomData}; + pub const TRIGGER05: FunctionDef = FunctionDef{address: 0x005a17a8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/eval11"))] pub const EVAL11: FunctionDef u32> = FunctionDef{address: 0x0061bb06, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger01"))] - pub const TRIGGER01: FunctionDef = FunctionDef{address: 0x0061c139, function_type: PhantomData}; + pub const TRIGGER01: FunctionDef = FunctionDef{address: 0x0061c139, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger08"))] - pub const TRIGGER08: FunctionDef = FunctionDef{address: 0x0061c27d, function_type: PhantomData}; + pub const TRIGGER08: FunctionDef = FunctionDef{address: 0x0061c27d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariosimplegoal/trigger09"))] - pub const TRIGGER09: FunctionDef = FunctionDef{address: 0x0061c408, function_type: PhantomData}; + pub const TRIGGER09: FunctionDef = FunctionDef{address: 0x0061c408, function_type: PhantomData}; } // ZTScenarioTimer class functions @@ -4240,27 +3969,27 @@ pub mod ztscenariotimer { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/get_state"))] - pub const GET_STATE: FunctionDef u32> = FunctionDef{address: 0x0040f121, function_type: PhantomData}; + pub const GET_STATE: FunctionDef u32> = FunctionDef{address: 0x0040f121, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/size"))] - pub const SIZE: FunctionDef u32> = FunctionDef{address: 0x004113d7, function_type: PhantomData}; + pub const SIZE: FunctionDef = FunctionDef{address: 0x004113d7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0042425d, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0042425d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/save"))] pub const SAVE: FunctionDef = FunctionDef{address: 0x0047a04c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/display_goal"))] - pub const DISPLAY_GOAL: FunctionDef = FunctionDef{address: 0x004f042c, function_type: PhantomData}; + pub const DISPLAY_GOAL: FunctionDef = FunctionDef{address: 0x004f042c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/get_text"))] - pub const GET_TEXT: FunctionDef u32> = FunctionDef{address: 0x004f0484, function_type: PhantomData}; + pub const GET_TEXT: FunctionDef u32> = FunctionDef{address: 0x004f0484, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/get_icon_name"))] - pub const GET_ICON_NAME: FunctionDef u32> = FunctionDef{address: 0x004f0488, function_type: PhantomData}; + pub const GET_ICON_NAME: FunctionDef = FunctionDef{address: 0x004f0488, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0058e218, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0058e218, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/load"))] - pub const LOAD: FunctionDef = FunctionDef{address: 0x005950ab, function_type: PhantomData}; + pub const LOAD: FunctionDef = FunctionDef{address: 0x005950ab, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/ztscenario_timer"))] - pub const ZTSCENARIO_TIMER: FunctionDef *const u32> = FunctionDef{address: 0x005b130f, function_type: PhantomData}; + pub const ZTSCENARIO_TIMER: FunctionDef u32> = FunctionDef{address: 0x005b130f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenariotimer/load_state"))] - pub const LOAD_STATE: FunctionDef = FunctionDef{address: 0x0061c430, function_type: PhantomData}; + pub const LOAD_STATE: FunctionDef = FunctionDef{address: 0x0061c430, function_type: PhantomData}; } // ZTScenery class functions @@ -4268,7 +3997,7 @@ pub mod ztscenery { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenery/force_idle_anim"))] - pub const FORCE_IDLE_ANIM: FunctionDef = FunctionDef{address: 0x00410540, function_type: PhantomData}; + pub const FORCE_IDLE_ANIM: FunctionDef = FunctionDef{address: 0x00410540, function_type: PhantomData}; } // ZTSceneryType class functions @@ -4276,77 +4005,77 @@ pub mod ztscenerytype { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_purchase_cost"))] - pub const GET_PURCHASE_COST: FunctionDef f32> = FunctionDef{address: 0x0040fbb6, function_type: PhantomData}; + pub const GET_PURCHASE_COST: FunctionDef = FunctionDef{address: 0x0040fbb6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/check_dead_state"))] - pub const CHECK_DEAD_STATE: FunctionDef u32> = FunctionDef{address: 0x0041038b, function_type: PhantomData}; + pub const CHECK_DEAD_STATE: FunctionDef u32> = FunctionDef{address: 0x0041038b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_tank"))] - pub const GET_TANK: FunctionDef *const i32> = FunctionDef{address: 0x00410460, function_type: PhantomData}; + pub const GET_TANK: FunctionDef u32> = FunctionDef{address: 0x00410460, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/is_snap_to_ground"))] - pub const IS_SNAP_TO_GROUND: FunctionDef u8> = FunctionDef{address: 0x004104ca, function_type: PhantomData}; + pub const IS_SNAP_TO_GROUND: FunctionDef = FunctionDef{address: 0x004104ca, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/validate_position"))] - pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x004104cd, function_type: PhantomData}; + pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x004104cd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/ztscenery_0"))] - pub const ZTSCENERY_0: FunctionDef *const u32> = FunctionDef{address: 0x0041294b, function_type: PhantomData}; + pub const ZTSCENERY_0: FunctionDef u32> = FunctionDef{address: 0x0041294b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/init_status_vars"))] - pub const INIT_STATUS_VARS: FunctionDef u32> = FunctionDef{address: 0x00412972, function_type: PhantomData}; + pub const INIT_STATUS_VARS: FunctionDef u32> = FunctionDef{address: 0x00412972, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x00412977, function_type: PhantomData}; + pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x00412977, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/init"))] - pub const INIT: FunctionDef = FunctionDef{address: 0x00412999, function_type: PhantomData}; + pub const INIT: FunctionDef = FunctionDef{address: 0x00412999, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/ztscenery_1"))] - pub const ZTSCENERY_1: FunctionDef *const u32> = FunctionDef{address: 0x0041e075, function_type: PhantomData}; + pub const ZTSCENERY_1: FunctionDef u32> = FunctionDef{address: 0x0041e075, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_sell_price"))] - pub const GET_SELL_PRICE: FunctionDef f32> = FunctionDef{address: 0x0041ec7f, function_type: PhantomData}; + pub const GET_SELL_PRICE: FunctionDef = FunctionDef{address: 0x0041ec7f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_esthetic_bonus"))] - pub const GET_ESTHETIC_BONUS: FunctionDef = FunctionDef{address: 0x0041f05c, function_type: PhantomData}; + pub const GET_ESTHETIC_BONUS: FunctionDef = FunctionDef{address: 0x0041f05c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/create_name"))] - pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x00427340, function_type: PhantomData}; + pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x00427340, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/draw"))] - pub const DRAW: FunctionDef = FunctionDef{address: 0x0043306b, function_type: PhantomData}; + pub const DRAW: FunctionDef = FunctionDef{address: 0x0043306b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00434a75, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00434a75, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/set_name"))] - pub const SET_NAME: FunctionDef = FunctionDef{address: 0x00449515, function_type: PhantomData}; + pub const SET_NAME: FunctionDef = FunctionDef{address: 0x00449515, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/force_dead_anim"))] - pub const FORCE_DEAD_ANIM: FunctionDef = FunctionDef{address: 0x0044a6ae, function_type: PhantomData}; + pub const FORCE_DEAD_ANIM: FunctionDef = FunctionDef{address: 0x0044a6ae, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044f625, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0044f625, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/save"))] - pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00477b03, function_type: PhantomData}; + pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00477b03, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/turn_to_rubble"))] - pub const TURN_TO_RUBBLE: FunctionDef = FunctionDef{address: 0x0047c2ac, function_type: PhantomData}; + pub const TURN_TO_RUBBLE: FunctionDef = FunctionDef{address: 0x0047c2ac, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/morph"))] - pub const MORPH: FunctionDef = FunctionDef{address: 0x0048663a, function_type: PhantomData}; + pub const MORPH: FunctionDef = FunctionDef{address: 0x0048663a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_height"))] - pub const GET_HEIGHT: FunctionDef u32> = FunctionDef{address: 0x004937a4, function_type: PhantomData}; + pub const GET_HEIGHT: FunctionDef = FunctionDef{address: 0x004937a4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/is_zoo_gate"))] - pub const IS_ZOO_GATE: FunctionDef u32> = FunctionDef{address: 0x004a4389, function_type: PhantomData}; + pub const IS_ZOO_GATE: FunctionDef u32> = FunctionDef{address: 0x004a4389, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/load_characteristics"))] - pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004ba5b0, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004ba5b0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004bf2d4, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004bf2d4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_help_id"))] pub const GET_HELP_ID: FunctionDef u32> = FunctionDef{address: 0x004e9e89, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/add_to_map"))] - pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x004f40af, function_type: PhantomData}; + pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x004f40af, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/set_food_units"))] - pub const SET_FOOD_UNITS: FunctionDef = FunctionDef{address: 0x004f429d, function_type: PhantomData}; + pub const SET_FOOD_UNITS: FunctionDef = FunctionDef{address: 0x004f429d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_only_swims"))] - pub const GET_ONLY_SWIMS: FunctionDef = FunctionDef{address: 0x004f84b0, function_type: PhantomData}; + pub const GET_ONLY_SWIMS: FunctionDef = FunctionDef{address: 0x004f84b0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_swims"))] - pub const GET_SWIMS: FunctionDef = FunctionDef{address: 0x004f84c2, function_type: PhantomData}; + pub const GET_SWIMS: FunctionDef = FunctionDef{address: 0x004f84c2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/is_selectable"))] - pub const IS_SELECTABLE: FunctionDef u32> = FunctionDef{address: 0x004fb59e, function_type: PhantomData}; + pub const IS_SELECTABLE: FunctionDef = FunctionDef{address: 0x004fb59e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004fe778, function_type: PhantomData}; + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004fe778, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/ztscenery_type"))] - pub const ZTSCENERY_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x00501080, function_type: PhantomData}; + pub const ZTSCENERY_TYPE: FunctionDef u32> = FunctionDef{address: 0x00501080, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x0051b091, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/init_after_load"))] - pub const INIT_AFTER_LOAD: FunctionDef u32> = FunctionDef{address: 0x00593f72, function_type: PhantomData}; + pub const INIT_AFTER_LOAD: FunctionDef u32> = FunctionDef{address: 0x00593f72, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztscenerytype/get_habitat"))] - pub const GET_HABITAT: FunctionDef u32> = FunctionDef{address: 0x006067d1, function_type: PhantomData}; + pub const GET_HABITAT: FunctionDef = FunctionDef{address: 0x006067d1, function_type: PhantomData}; } // ZTShow class functions @@ -4354,35 +4083,35 @@ pub mod ztshow { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0046df38, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0046df38, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004cca2c, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004cca2c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/update"))] - pub const UPDATE: FunctionDef *const u32> = FunctionDef{address: 0x0059e773, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0059e773, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/clear_show_script_states"))] - pub const CLEAR_SHOW_SCRIPT_STATES: FunctionDef = FunctionDef{address: 0x0059f79e, function_type: PhantomData}; + pub const CLEAR_SHOW_SCRIPT_STATES: FunctionDef = FunctionDef{address: 0x0059f79e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/stop_0"))] - pub const STOP_0: FunctionDef = FunctionDef{address: 0x005a3db4, function_type: PhantomData}; + pub const STOP_0: FunctionDef = FunctionDef{address: 0x005a3db4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/stop_1"))] - pub const STOP_1: FunctionDef = FunctionDef{address: 0x005a4057, function_type: PhantomData}; + pub const STOP_1: FunctionDef = FunctionDef{address: 0x005a4057, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/gather_units"))] - pub const GATHER_UNITS: FunctionDef u32> = FunctionDef{address: 0x005a4519, function_type: PhantomData}; + pub const GATHER_UNITS: FunctionDef u32> = FunctionDef{address: 0x005a4519, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/send_event_generic"))] - pub const SEND_EVENT_GENERIC: FunctionDef = FunctionDef{address: 0x005a6f37, function_type: PhantomData}; + pub const SEND_EVENT_GENERIC: FunctionDef = FunctionDef{address: 0x005a6f37, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/start"))] - pub const START: FunctionDef u32> = FunctionDef{address: 0x005a85e9, function_type: PhantomData}; + pub const START: FunctionDef = FunctionDef{address: 0x005a85e9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/clear_unit_goals"))] - pub const CLEAR_UNIT_GOALS: FunctionDef = FunctionDef{address: 0x005a8a93, function_type: PhantomData}; + pub const CLEAR_UNIT_GOALS: FunctionDef = FunctionDef{address: 0x005a8a93, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/reinit"))] - pub const REINIT: FunctionDef = FunctionDef{address: 0x005a8b25, function_type: PhantomData}; + pub const REINIT: FunctionDef = FunctionDef{address: 0x005a8b25, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/ztshow"))] - pub const ZTSHOW: FunctionDef *const u32> = FunctionDef{address: 0x00604d36, function_type: PhantomData}; + pub const ZTSHOW: FunctionDef u32> = FunctionDef{address: 0x00604d36, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/init"))] - pub const INIT: FunctionDef u32> = FunctionDef{address: 0x00612c6e, function_type: PhantomData}; + pub const INIT: FunctionDef = FunctionDef{address: 0x00612c6e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/clear"))] - pub const CLEAR: FunctionDef = FunctionDef{address: 0x00612c8c, function_type: PhantomData}; + pub const CLEAR: FunctionDef = FunctionDef{address: 0x00612c8c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshow/abort_show"))] - pub const ABORT_SHOW: FunctionDef u32> = FunctionDef{address: 0x00612d20, function_type: PhantomData}; + pub const ABORT_SHOW: FunctionDef u32> = FunctionDef{address: 0x00612d20, function_type: PhantomData}; } // ZTShowInfo class functions @@ -4390,33 +4119,33 @@ pub mod ztshowinfo { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/load"))] - pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x0046d779, function_type: PhantomData}; + pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x0046d779, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/update_from_load"))] - pub const UPDATE_FROM_LOAD: FunctionDef = FunctionDef{address: 0x00484ec8, function_type: PhantomData}; + pub const UPDATE_FROM_LOAD: FunctionDef = FunctionDef{address: 0x00484ec8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/enter_new_month"))] - pub const ENTER_NEW_MONTH: FunctionDef = FunctionDef{address: 0x0048b57e, function_type: PhantomData}; + pub const ENTER_NEW_MONTH: FunctionDef = FunctionDef{address: 0x0048b57e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/set_show_frequency"))] - pub const SET_SHOW_FREQUENCY: FunctionDef = FunctionDef{address: 0x004cc86a, function_type: PhantomData}; + pub const SET_SHOW_FREQUENCY: FunctionDef = FunctionDef{address: 0x004cc86a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004cc890, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004cc890, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/recalculate_schedule"))] - pub const RECALCULATE_SCHEDULE: FunctionDef = FunctionDef{address: 0x004f2947, function_type: PhantomData}; + pub const RECALCULATE_SCHEDULE: FunctionDef = FunctionDef{address: 0x004f2947, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/get_scheduled_show_script"))] - pub const GET_SCHEDULED_SHOW_SCRIPT: FunctionDef u32> = FunctionDef{address: 0x0059dff6, function_type: PhantomData}; + pub const GET_SCHEDULED_SHOW_SCRIPT: FunctionDef u32> = FunctionDef{address: 0x0059dff6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/is_started"))] - pub const IS_STARTED: FunctionDef u32> = FunctionDef{address: 0x0059fa05, function_type: PhantomData}; + pub const IS_STARTED: FunctionDef u32> = FunctionDef{address: 0x0059fa05, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/get_show_unit_list"))] - pub const GET_SHOW_UNIT_LIST: FunctionDef i32> = FunctionDef{address: 0x005a20ae, function_type: PhantomData}; + pub const GET_SHOW_UNIT_LIST: FunctionDef i32> = FunctionDef{address: 0x005a20ae, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/increment_receipts"))] - pub const INCREMENT_RECEIPTS: FunctionDef = FunctionDef{address: 0x005a95be, function_type: PhantomData}; + pub const INCREMENT_RECEIPTS: FunctionDef = FunctionDef{address: 0x005a95be, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/increment_attendance"))] - pub const INCREMENT_ATTENDANCE: FunctionDef = FunctionDef{address: 0x005a9826, function_type: PhantomData}; + pub const INCREMENT_ATTENDANCE: FunctionDef = FunctionDef{address: 0x005a9826, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/add_unit_to_list"))] - pub const ADD_UNIT_TO_LIST: FunctionDef u32> = FunctionDef{address: 0x005a9a48, function_type: PhantomData}; + pub const ADD_UNIT_TO_LIST: FunctionDef u32> = FunctionDef{address: 0x005a9a48, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/add_unit"))] - pub const ADD_UNIT: FunctionDef u32> = FunctionDef{address: 0x005a9c81, function_type: PhantomData}; + pub const ADD_UNIT: FunctionDef u32> = FunctionDef{address: 0x005a9c81, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/remove_unit"))] - pub const REMOVE_UNIT: FunctionDef = FunctionDef{address: 0x005a9c96, function_type: PhantomData}; + pub const REMOVE_UNIT: FunctionDef = FunctionDef{address: 0x005a9c96, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowinfo/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00610076, function_type: PhantomData}; } @@ -4426,19 +4155,19 @@ pub mod ztshowmgr { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowmgr/get_show_info"))] - pub const GET_SHOW_INFO: FunctionDef u32> = FunctionDef{address: 0x0041ebfd, function_type: PhantomData}; + pub const GET_SHOW_INFO: FunctionDef u32> = FunctionDef{address: 0x0041ebfd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowmgr/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00479fa4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowmgr/enter_new_month"))] - pub const ENTER_NEW_MONTH: FunctionDef = FunctionDef{address: 0x004842a2, function_type: PhantomData}; + pub const ENTER_NEW_MONTH: FunctionDef = FunctionDef{address: 0x004842a2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowmgr/init_show_params"))] - pub const INIT_SHOW_PARAMS: FunctionDef u32> = FunctionDef{address: 0x0051f59b, function_type: PhantomData}; + pub const INIT_SHOW_PARAMS: FunctionDef u32> = FunctionDef{address: 0x0051f59b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowmgr/destroy"))] pub const DESTROY: FunctionDef = FunctionDef{address: 0x0057db2e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowmgr/unregister_show"))] - pub const UNREGISTER_SHOW: FunctionDef u32> = FunctionDef{address: 0x005aaa95, function_type: PhantomData}; + pub const UNREGISTER_SHOW: FunctionDef u32> = FunctionDef{address: 0x005aaa95, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowmgr/register_show"))] - pub const REGISTER_SHOW: FunctionDef u32> = FunctionDef{address: 0x005abb26, function_type: PhantomData}; + pub const REGISTER_SHOW: FunctionDef u32> = FunctionDef{address: 0x005abb26, function_type: PhantomData}; } // ZTShowScript class functions @@ -4454,9 +4183,9 @@ pub mod ztshowscriptitem { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowscriptitem/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004b9024, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004b9024, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowscriptitem/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004b9690, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x004b9690, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowscriptitem/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0061c471, function_type: PhantomData}; } @@ -4474,13 +4203,13 @@ pub mod ztshowstate { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowstate/load"))] - pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x0046de22, function_type: PhantomData}; + pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x0046de22, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowstate/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004cc9c6, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004cc9c6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowstate/ztshow_state"))] - pub const ZTSHOW_STATE: FunctionDef *const u32> = FunctionDef{address: 0x004f28c3, function_type: PhantomData}; + pub const ZTSHOW_STATE: FunctionDef u32> = FunctionDef{address: 0x004f28c3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztshowstate/clear"))] - pub const CLEAR: FunctionDef u32> = FunctionDef{address: 0x0059f72f, function_type: PhantomData}; + pub const CLEAR: FunctionDef u32> = FunctionDef{address: 0x0059f72f, function_type: PhantomData}; } // ZTSoundscape class functions @@ -4488,13 +4217,13 @@ pub mod ztsoundscape { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztsoundscape/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x004352dd, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x004352dd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztsoundscape/ztsoundscape"))] - pub const ZTSOUNDSCAPE: FunctionDef *const u32> = FunctionDef{address: 0x005003e2, function_type: PhantomData}; + pub const ZTSOUNDSCAPE: FunctionDef u32> = FunctionDef{address: 0x005003e2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztsoundscape/init"))] - pub const INIT: FunctionDef = FunctionDef{address: 0x005922fd, function_type: PhantomData}; + pub const INIT: FunctionDef = FunctionDef{address: 0x005922fd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztsoundscape/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00592596, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00592596, function_type: PhantomData}; } // ZTStaff class functions @@ -4502,19 +4231,17 @@ pub mod ztstaff { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztstaff/get_terrain_cost"))] - pub const GET_TERRAIN_COST: FunctionDef i32> = FunctionDef{address: 0x00439c80, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztstaff/add_to_map"))] - pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x00449ed0, function_type: PhantomData}; + pub const GET_TERRAIN_COST: FunctionDef i32> = FunctionDef{address: 0x00439c80, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztstaff/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00457a0c, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00457a0c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztstaff/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004586f6, function_type: PhantomData}; + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004586f6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztstaff/ztstaff"))] - pub const ZTSTAFF: FunctionDef *const u32> = FunctionDef{address: 0x004f9d09, function_type: PhantomData}; + pub const ZTSTAFF: FunctionDef u32> = FunctionDef{address: 0x004f9d09, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztstaff/reassign_habitats"))] - pub const REASSIGN_HABITATS: FunctionDef u32> = FunctionDef{address: 0x00595237, function_type: PhantomData}; + pub const REASSIGN_HABITATS: FunctionDef u32> = FunctionDef{address: 0x00595237, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztstaff/init_after_load"))] - pub const INIT_AFTER_LOAD: FunctionDef u32> = FunctionDef{address: 0x005952dc, function_type: PhantomData}; + pub const INIT_AFTER_LOAD: FunctionDef u32> = FunctionDef{address: 0x005952dc, function_type: PhantomData}; } // ZTStaffType class functions @@ -4522,17 +4249,17 @@ pub mod ztstafftype { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztstafftype/load_characteristics_0"))] - pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004c3081, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004c3081, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztstafftype/load_characteristics_1"))] - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c3783, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004c3783, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztstafftype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x0051b581, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztstafftype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051bd29, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051bd29, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztstafftype/ztstaff_type"))] - pub const ZTSTAFF_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x0057ca11, function_type: PhantomData}; + pub const ZTSTAFF_TYPE: FunctionDef u32> = FunctionDef{address: 0x0057ca11, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztstafftype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x006112d9, function_type: PhantomData}; + pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x006112d9, function_type: PhantomData}; } // ZTTankExhibit class functions @@ -4540,89 +4267,87 @@ pub mod zttankexhibit { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/get_water_level"))] - pub const GET_WATER_LEVEL: FunctionDef u32> = FunctionDef{address: 0x004110fd, function_type: PhantomData}; + pub const GET_WATER_LEVEL: FunctionDef u32> = FunctionDef{address: 0x004110fd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/get_tank_height"))] - pub const GET_TANK_HEIGHT: FunctionDef u32> = FunctionDef{address: 0x00411111, function_type: PhantomData}; + pub const GET_TANK_HEIGHT: FunctionDef u32> = FunctionDef{address: 0x00411111, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/is_pure_water"))] - pub const IS_PURE_WATER: FunctionDef bool> = FunctionDef{address: 0x004111a9, function_type: PhantomData}; + pub const IS_PURE_WATER: FunctionDef bool> = FunctionDef{address: 0x004111a9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/is_extremely_murky_water"))] - pub const IS_EXTREMELY_MURKY_WATER: FunctionDef bool> = FunctionDef{address: 0x00411254, function_type: PhantomData}; + pub const IS_EXTREMELY_MURKY_WATER: FunctionDef bool> = FunctionDef{address: 0x00411254, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_base_terrain_type"))] - pub const SET_BASE_TERRAIN_TYPE: FunctionDef = FunctionDef{address: 0x00458bea, function_type: PhantomData}; + pub const SET_BASE_TERRAIN_TYPE: FunctionDef = FunctionDef{address: 0x00458bea, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/remove_illegal_entities"))] - pub const REMOVE_ILLEGAL_ENTITIES: FunctionDef u32> = FunctionDef{address: 0x00458c2b, function_type: PhantomData}; + pub const REMOVE_ILLEGAL_ENTITIES: FunctionDef u32> = FunctionDef{address: 0x00458c2b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_base_level"))] - pub const SET_BASE_LEVEL: FunctionDef = FunctionDef{address: 0x00458c6a, function_type: PhantomData}; + pub const SET_BASE_LEVEL: FunctionDef = FunctionDef{address: 0x00458c6a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/get_all_entities"))] - pub const GET_ALL_ENTITIES: FunctionDef = FunctionDef{address: 0x004599a0, function_type: PhantomData}; + pub const GET_ALL_ENTITIES: FunctionDef = FunctionDef{address: 0x004599a0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/update_tank_wall_info"))] - pub const UPDATE_TANK_WALL_INFO: FunctionDef = FunctionDef{address: 0x00459ab2, function_type: PhantomData}; + pub const UPDATE_TANK_WALL_INFO: FunctionDef = FunctionDef{address: 0x00459ab2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/update_adjustment_costs"))] - pub const UPDATE_ADJUSTMENT_COSTS: FunctionDef = FunctionDef{address: 0x00459b19, function_type: PhantomData}; + pub const UPDATE_ADJUSTMENT_COSTS: FunctionDef = FunctionDef{address: 0x00459b19, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/fill"))] - pub const FILL: FunctionDef = FunctionDef{address: 0x00459d94, function_type: PhantomData}; + pub const FILL: FunctionDef = FunctionDef{address: 0x00459d94, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/check_entities_for_fill"))] - pub const CHECK_ENTITIES_FOR_FILL: FunctionDef u32> = FunctionDef{address: 0x00459e09, function_type: PhantomData}; + pub const CHECK_ENTITIES_FOR_FILL: FunctionDef u32> = FunctionDef{address: 0x00459e09, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/can_be_in_tank"))] - pub const CAN_BE_IN_TANK: FunctionDef u8> = FunctionDef{address: 0x00459f52, function_type: PhantomData}; + pub const CAN_BE_IN_TANK: FunctionDef = FunctionDef{address: 0x00459f52, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_is_not_show_exhibit"))] - pub const SET_IS_NOT_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x0045b7ec, function_type: PhantomData}; + pub const SET_IS_NOT_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x0045b7ec, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0045b92f, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0045b92f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/level_all_tiles"))] - pub const LEVEL_ALL_TILES: FunctionDef = FunctionDef{address: 0x0045bbbb, function_type: PhantomData}; + pub const LEVEL_ALL_TILES: FunctionDef = FunctionDef{address: 0x0045bbbb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/update_tank_info"))] - pub const UPDATE_TANK_INFO: FunctionDef = FunctionDef{address: 0x0045bc0f, function_type: PhantomData}; + pub const UPDATE_TANK_INFO: FunctionDef = FunctionDef{address: 0x0045bc0f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/is_illegal_entity"))] - pub const IS_ILLEGAL_ENTITY: FunctionDef u32> = FunctionDef{address: 0x0045da65, function_type: PhantomData}; + pub const IS_ILLEGAL_ENTITY: FunctionDef u32> = FunctionDef{address: 0x0045da65, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/get_illegal_entities"))] - pub const GET_ILLEGAL_ENTITIES: FunctionDef = FunctionDef{address: 0x0045da8b, function_type: PhantomData}; + pub const GET_ILLEGAL_ENTITIES: FunctionDef = FunctionDef{address: 0x0045da8b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/reclaim_tiles"))] - pub const RECLAIM_TILES: FunctionDef = FunctionDef{address: 0x00487a63, function_type: PhantomData}; + pub const RECLAIM_TILES: FunctionDef = FunctionDef{address: 0x00487a63, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_water_purity"))] - pub const SET_WATER_PURITY: FunctionDef = FunctionDef{address: 0x0049340d, function_type: PhantomData}; + pub const SET_WATER_PURITY: FunctionDef = FunctionDef{address: 0x0049340d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0049625f, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x0049625f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/get_ladder_base_inside_pos"))] - pub const GET_LADDER_BASE_INSIDE_POS: FunctionDef = FunctionDef{address: 0x0049b1cc, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/clean_water_amount"))] - pub const CLEAN_WATER_AMOUNT: FunctionDef = FunctionDef{address: 0x0049bd60, function_type: PhantomData}; + pub const GET_LADDER_BASE_INSIDE_POS: FunctionDef = FunctionDef{address: 0x0049b1cc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/remove_owned_transients"))] - pub const REMOVE_OWNED_TRANSIENTS: FunctionDef = FunctionDef{address: 0x00505099, function_type: PhantomData}; + pub const REMOVE_OWNED_TRANSIENTS: FunctionDef = FunctionDef{address: 0x00505099, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/remove_all_sparkles"))] - pub const REMOVE_ALL_SPARKLES: FunctionDef = FunctionDef{address: 0x005050e2, function_type: PhantomData}; + pub const REMOVE_ALL_SPARKLES: FunctionDef = FunctionDef{address: 0x005050e2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/zttank_exhibit"))] - pub const ZTTANK_EXHIBIT: FunctionDef *const u32> = FunctionDef{address: 0x00505148, function_type: PhantomData}; + pub const ZTTANK_EXHIBIT: FunctionDef u32> = FunctionDef{address: 0x00505148, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_water_clean"))] - pub const SET_WATER_CLEAN: FunctionDef = FunctionDef{address: 0x005052b1, function_type: PhantomData}; + pub const SET_WATER_CLEAN: FunctionDef = FunctionDef{address: 0x005052b1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/remove_all_sparkles_by_id"))] - pub const REMOVE_ALL_SPARKLES_BY_ID: FunctionDef = FunctionDef{address: 0x005052bd, function_type: PhantomData}; + pub const REMOVE_ALL_SPARKLES_BY_ID: FunctionDef = FunctionDef{address: 0x005052bd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_is_show_exhibit"))] - pub const SET_IS_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x005ab683, function_type: PhantomData}; + pub const SET_IS_SHOW_EXHIBIT: FunctionDef = FunctionDef{address: 0x005ab683, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_water_level"))] - pub const SET_WATER_LEVEL: FunctionDef = FunctionDef{address: 0x005ae565, function_type: PhantomData}; + pub const SET_WATER_LEVEL: FunctionDef = FunctionDef{address: 0x005ae565, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/remove_water_ripples"))] - pub const REMOVE_WATER_RIPPLES: FunctionDef = FunctionDef{address: 0x005ae615, function_type: PhantomData}; + pub const REMOVE_WATER_RIPPLES: FunctionDef = FunctionDef{address: 0x005ae615, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/get_min_depth"))] - pub const GET_MIN_DEPTH: FunctionDef i32> = FunctionDef{address: 0x005af226, function_type: PhantomData}; + pub const GET_MIN_DEPTH: FunctionDef i32> = FunctionDef{address: 0x005af226, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_tank_height"))] - pub const SET_TANK_HEIGHT: FunctionDef = FunctionDef{address: 0x005af39e, function_type: PhantomData}; + pub const SET_TANK_HEIGHT: FunctionDef = FunctionDef{address: 0x005af39e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/do_depth_suitability"))] - pub const DO_DEPTH_SUITABILITY: FunctionDef = FunctionDef{address: 0x005af4b9, function_type: PhantomData}; + pub const DO_DEPTH_SUITABILITY: FunctionDef = FunctionDef{address: 0x005af4b9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/add_water_ripples"))] - pub const ADD_WATER_RIPPLES: FunctionDef = FunctionDef{address: 0x005af78f, function_type: PhantomData}; + pub const ADD_WATER_RIPPLES: FunctionDef = FunctionDef{address: 0x005af78f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/add_water_ripple"))] - pub const ADD_WATER_RIPPLE: FunctionDef = FunctionDef{address: 0x005af81a, function_type: PhantomData}; + pub const ADD_WATER_RIPPLE: FunctionDef = FunctionDef{address: 0x005af81a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00606398, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/set_salinity"))] - pub const SET_SALINITY: FunctionDef u32> = FunctionDef{address: 0x0060644b, function_type: PhantomData}; + pub const SET_SALINITY: FunctionDef u32> = FunctionDef{address: 0x0060644b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/drain"))] - pub const DRAIN: FunctionDef = FunctionDef{address: 0x006064ed, function_type: PhantomData}; + pub const DRAIN: FunctionDef = FunctionDef{address: 0x006064ed, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/check_entities_for_drain"))] - pub const CHECK_ENTITIES_FOR_DRAIN: FunctionDef i32> = FunctionDef{address: 0x0060656e, function_type: PhantomData}; + pub const CHECK_ENTITIES_FOR_DRAIN: FunctionDef i32> = FunctionDef{address: 0x0060656e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankexhibit/restore_owned_transients"))] - pub const RESTORE_OWNED_TRANSIENTS: FunctionDef = FunctionDef{address: 0x006066eb, function_type: PhantomData}; + pub const RESTORE_OWNED_TRANSIENTS: FunctionDef = FunctionDef{address: 0x006066eb, function_type: PhantomData}; } // ZTTankFilter class functions @@ -4630,57 +4355,53 @@ pub mod zttankfilter { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/set_current_animation"))] - pub const SET_CURRENT_ANIMATION: FunctionDef = FunctionDef{address: 0x0045d234, function_type: PhantomData}; + pub const SET_CURRENT_ANIMATION: FunctionDef = FunctionDef{address: 0x0045d234, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/add_to_map"))] - pub const ADD_TO_MAP: FunctionDef *const c_void> = FunctionDef{address: 0x0045d384, function_type: PhantomData}; + pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x0045d384, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/load"))] - pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x0045d468, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0045d55f, function_type: PhantomData}; + pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x0045d468, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x00497e0f, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x00497e0f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/start_appropriate_sound"))] - pub const START_APPROPRIATE_SOUND: FunctionDef = FunctionDef{address: 0x00497f5c, function_type: PhantomData}; + pub const START_APPROPRIATE_SOUND: FunctionDef = FunctionDef{address: 0x00497f5c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/update_sound_volumes"))] - pub const UPDATE_SOUND_VOLUMES: FunctionDef = FunctionDef{address: 0x00497fb2, function_type: PhantomData}; + pub const UPDATE_SOUND_VOLUMES: FunctionDef = FunctionDef{address: 0x00497fb2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/start_decayed_sound"))] - pub const START_DECAYED_SOUND: FunctionDef = FunctionDef{address: 0x004980be, function_type: PhantomData}; + pub const START_DECAYED_SOUND: FunctionDef = FunctionDef{address: 0x004980be, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/stop_all_sounds"))] - pub const STOP_ALL_SOUNDS: FunctionDef = FunctionDef{address: 0x00498270, function_type: PhantomData}; + pub const STOP_ALL_SOUNDS: FunctionDef = FunctionDef{address: 0x00498270, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/start_healthy_sound"))] - pub const START_HEALTHY_SOUND: FunctionDef = FunctionDef{address: 0x004a7a38, function_type: PhantomData}; + pub const START_HEALTHY_SOUND: FunctionDef = FunctionDef{address: 0x004a7a38, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/remove_bubbles"))] - pub const REMOVE_BUBBLES: FunctionDef = FunctionDef{address: 0x004fb151, function_type: PhantomData}; + pub const REMOVE_BUBBLES: FunctionDef = FunctionDef{address: 0x004fb151, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x0050558c, function_type: PhantomData}; + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x0050558c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/set_healthy"))] - pub const SET_HEALTHY: FunctionDef = FunctionDef{address: 0x00595c8e, function_type: PhantomData}; + pub const SET_HEALTHY: FunctionDef = FunctionDef{address: 0x00595c8e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/service"))] - pub const SERVICE: FunctionDef = FunctionDef{address: 0x00595cad, function_type: PhantomData}; + pub const SERVICE: FunctionDef = FunctionDef{address: 0x00595cad, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00615b31, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/set_broken"))] - pub const SET_BROKEN: FunctionDef = FunctionDef{address: 0x00615c0f, function_type: PhantomData}; + pub const SET_BROKEN: FunctionDef = FunctionDef{address: 0x00615c0f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfilter/decay"))] - pub const DECAY: FunctionDef = FunctionDef{address: 0x00615c29, function_type: PhantomData}; + pub const DECAY: FunctionDef = FunctionDef{address: 0x00615c29, function_type: PhantomData}; } // ZTTankFilterType class functions pub mod zttankfiltertype { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("zttankfiltertype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x0045d893, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfiltertype/load_characteristics"))] - pub const LOAD_CHARACTERISTICS: FunctionDef u32> = FunctionDef{address: 0x004c44aa, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x004c44aa, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfiltertype/load_type_members"))] - pub const LOAD_TYPE_MEMBERS: FunctionDef u8> = FunctionDef{address: 0x0051d8b0, function_type: PhantomData}; + pub const LOAD_TYPE_MEMBERS: FunctionDef = FunctionDef{address: 0x0051d8b0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfiltertype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0051de26, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0051de26, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfiltertype/zttank_filter_type_0"))] - pub const ZTTANK_FILTER_TYPE_0: FunctionDef *const u32> = FunctionDef{address: 0x0057d29e, function_type: PhantomData}; + pub const ZTTANK_FILTER_TYPE_0: FunctionDef u32> = FunctionDef{address: 0x0057d29e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankfiltertype/zttank_filter_type_1"))] - pub const ZTTANK_FILTER_TYPE_1: FunctionDef *const u32> = FunctionDef{address: 0x0057d2bc, function_type: PhantomData}; + pub const ZTTANK_FILTER_TYPE_1: FunctionDef u32> = FunctionDef{address: 0x0057d2bc, function_type: PhantomData}; } // ZTTankWall class functions @@ -4688,45 +4409,45 @@ pub mod zttankwall { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_images"))] - pub const SET_IMAGES: FunctionDef = FunctionDef{address: 0x0044a8b1, function_type: PhantomData}; + pub const SET_IMAGES: FunctionDef = FunctionDef{address: 0x0044a8b1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/update_mixer_facing"))] - pub const UPDATE_MIXER_FACING: FunctionDef = FunctionDef{address: 0x0044aadb, function_type: PhantomData}; + pub const UPDATE_MIXER_FACING: FunctionDef = FunctionDef{address: 0x0044aadb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_wall_height"))] - pub const SET_WALL_HEIGHT: FunctionDef = FunctionDef{address: 0x0044ac6e, function_type: PhantomData}; + pub const SET_WALL_HEIGHT: FunctionDef = FunctionDef{address: 0x0044ac6e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/validate_position"))] - pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x0044ac9c, function_type: PhantomData}; + pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x0044ac9c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_is_combined_connector"))] - pub const SET_IS_COMBINED_CONNECTOR: FunctionDef = FunctionDef{address: 0x00458b9f, function_type: PhantomData}; + pub const SET_IS_COMBINED_CONNECTOR: FunctionDef = FunctionDef{address: 0x00458b9f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_gate_mixers"))] - pub const SET_GATE_MIXERS: FunctionDef = FunctionDef{address: 0x00458bc4, function_type: PhantomData}; + pub const SET_GATE_MIXERS: FunctionDef = FunctionDef{address: 0x00458bc4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_middle_fence"))] - pub const SET_MIDDLE_FENCE: FunctionDef = FunctionDef{address: 0x00459fdf, function_type: PhantomData}; + pub const SET_MIDDLE_FENCE: FunctionDef = FunctionDef{address: 0x00459fdf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_right_edge_fence"))] - pub const SET_RIGHT_EDGE_FENCE: FunctionDef = FunctionDef{address: 0x0045a409, function_type: PhantomData}; + pub const SET_RIGHT_EDGE_FENCE: FunctionDef = FunctionDef{address: 0x0045a409, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_left_edge_fence"))] - pub const SET_LEFT_EDGE_FENCE: FunctionDef = FunctionDef{address: 0x0045a833, function_type: PhantomData}; + pub const SET_LEFT_EDGE_FENCE: FunctionDef = FunctionDef{address: 0x0045a833, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_both_edges_fence"))] - pub const SET_BOTH_EDGES_FENCE: FunctionDef = FunctionDef{address: 0x0045afed, function_type: PhantomData}; + pub const SET_BOTH_EDGES_FENCE: FunctionDef = FunctionDef{address: 0x0045afed, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0045cd8d, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0045cd8d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/morph"))] - pub const MORPH: FunctionDef = FunctionDef{address: 0x004868a9, function_type: PhantomData}; + pub const MORPH: FunctionDef = FunctionDef{address: 0x004868a9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/draw"))] - pub const DRAW: FunctionDef = FunctionDef{address: 0x00492bd9, function_type: PhantomData}; + pub const DRAW: FunctionDef = FunctionDef{address: 0x00492bd9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/draw_platform"))] - pub const DRAW_PLATFORM: FunctionDef = FunctionDef{address: 0x00495007, function_type: PhantomData}; + pub const DRAW_PLATFORM: FunctionDef = FunctionDef{address: 0x00495007, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_is_open_portal"))] - pub const SET_IS_OPEN_PORTAL: FunctionDef = FunctionDef{address: 0x0059ea94, function_type: PhantomData}; + pub const SET_IS_OPEN_PORTAL: FunctionDef = FunctionDef{address: 0x0059ea94, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/set_portal_animation"))] - pub const SET_PORTAL_ANIMATION: FunctionDef = FunctionDef{address: 0x0059f39e, function_type: PhantomData}; + pub const SET_PORTAL_ANIMATION: FunctionDef = FunctionDef{address: 0x0059f39e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/start_portal_close_sound"))] - pub const START_PORTAL_CLOSE_SOUND: FunctionDef = FunctionDef{address: 0x005a333b, function_type: PhantomData}; + pub const START_PORTAL_CLOSE_SOUND: FunctionDef = FunctionDef{address: 0x005a333b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/start_portal_open_sound"))] - pub const START_PORTAL_OPEN_SOUND: FunctionDef = FunctionDef{address: 0x005a35e1, function_type: PhantomData}; + pub const START_PORTAL_OPEN_SOUND: FunctionDef = FunctionDef{address: 0x005a35e1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/zttank_wall_0"))] - pub const ZTTANK_WALL_0: FunctionDef *const u32> = FunctionDef{address: 0x005ae7a0, function_type: PhantomData}; + pub const ZTTANK_WALL_0: FunctionDef u32> = FunctionDef{address: 0x005ae7a0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/zttank_wall_1"))] - pub const ZTTANK_WALL_1: FunctionDef *const u32> = FunctionDef{address: 0x005ae9e4, function_type: PhantomData}; + pub const ZTTANK_WALL_1: FunctionDef u32> = FunctionDef{address: 0x005ae9e4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwall/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00605b38, function_type: PhantomData}; } @@ -4736,7 +4457,7 @@ pub mod zttankwalltype { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwalltype/load_characteristics"))] - pub const LOAD_CHARACTERISTICS: FunctionDef u8> = FunctionDef{address: 0x004c2c4d, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x004c2c4d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zttankwalltype/load_type_members"))] pub const LOAD_TYPE_MEMBERS: FunctionDef u32> = FunctionDef{address: 0x0051d2fe, function_type: PhantomData}; } @@ -4745,22 +4466,12 @@ pub mod zttankwalltype { pub mod ztterraformmode { use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("ztterraformmode/handle_mouse_move"))] - pub const HANDLE_MOUSE_MOVE: FunctionDef u32> = FunctionDef{address: 0x004dc202, function_type: PhantomData}; -} - -// ZTTerraformMode_old class functions -pub mod ztterraformmode_old { - use super::*; - #[cfg_attr(feature = "detour-validation", validate_detour("ztterraformmode_old/commit_terraform"))] - pub const COMMIT_TERRAFORM: FunctionDef = FunctionDef{address: 0x004da252, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztterraformmode_old/hilite_habitats"))] - pub const HILITE_HABITATS: FunctionDef = FunctionDef{address: 0x004dc362, function_type: PhantomData}; + pub const COMMIT_TERRAFORM: FunctionDef = FunctionDef{address: 0x004da252, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztterraformmode_old/do_terrain_paint"))] - pub const DO_TERRAIN_PAINT: FunctionDef = FunctionDef{address: 0x004dce9a, function_type: PhantomData}; + pub const DO_TERRAIN_PAINT: FunctionDef = FunctionDef{address: 0x004dce9a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztterraformmode_old/cancel_terraform"))] - pub const CANCEL_TERRAFORM: FunctionDef = FunctionDef{address: 0x00619368, function_type: PhantomData}; + pub const CANCEL_TERRAFORM: FunctionDef = FunctionDef{address: 0x00619368, function_type: PhantomData}; } // ZTThought class functions @@ -4768,9 +4479,9 @@ pub mod ztthought { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztthought/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x00423043, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x00423043, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztthought/get_string"))] - pub const GET_STRING: FunctionDef *const u32> = FunctionDef{address: 0x004edbfc, function_type: PhantomData}; + pub const GET_STRING: FunctionDef u32> = FunctionDef{address: 0x004edbfc, function_type: PhantomData}; } // ZTThoughtMgr class functions @@ -4778,17 +4489,15 @@ pub mod ztthoughtmgr { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztthoughtmgr/get_thoughts_by_habitat"))] - pub const GET_THOUGHTS_BY_HABITAT: FunctionDef *const i32> = FunctionDef{address: 0x0046863a, function_type: PhantomData}; + pub const GET_THOUGHTS_BY_HABITAT: FunctionDef u32> = FunctionDef{address: 0x0046863a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztthoughtmgr/save"))] pub const SAVE: FunctionDef bool> = FunctionDef{address: 0x0047a1a2, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztthoughtmgr/remove_thoughts_by_thinker"))] - pub const REMOVE_THOUGHTS_BY_THINKER: FunctionDef = FunctionDef{address: 0x004fa377, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztthoughtmgr/remove_thoughts_by_habitat"))] - pub const REMOVE_THOUGHTS_BY_HABITAT: FunctionDef = FunctionDef{address: 0x004ffe56, function_type: PhantomData}; + pub const REMOVE_THOUGHTS_BY_HABITAT: FunctionDef = FunctionDef{address: 0x004ffe56, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztthoughtmgr/ztthought_mgr"))] - pub const ZTTHOUGHT_MGR: FunctionDef *const u32> = FunctionDef{address: 0x0057d815, function_type: PhantomData}; + pub const ZTTHOUGHT_MGR: FunctionDef u32> = FunctionDef{address: 0x0057d815, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztthoughtmgr/load"))] - pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x0059435b, function_type: PhantomData}; + pub const LOAD: FunctionDef bool> = FunctionDef{address: 0x0059435b, function_type: PhantomData}; } // ZTUI class functions @@ -4822,9 +4531,7 @@ pub mod ztui_animalinfo { #[cfg_attr(feature = "detour-validation", validate_detour("ztui_animalinfo/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a76f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_animalinfo/force_update"))] - pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x00427996, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztui_animalinfo/set_animal_visible"))] - pub const SET_ANIMAL_VISIBLE: FunctionDef = FunctionDef{address: 0x0043f0c5, function_type: PhantomData}; + pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x00427996, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_animalinfo/show"))] pub const SHOW: FunctionDef = FunctionDef{address: 0x004ee820, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_animalinfo/set_can_sell"))] @@ -4838,7 +4545,7 @@ pub mod ztui_buya { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buya/update_display_list"))] - pub const UPDATE_DISPLAY_LIST: FunctionDef = FunctionDef{address: 0x004eb68b, function_type: PhantomData}; + pub const UPDATE_DISPLAY_LIST: FunctionDef = FunctionDef{address: 0x004eb68b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buya/clear_selections"))] pub const CLEAR_SELECTIONS: FunctionDef = FunctionDef{address: 0x004f0a84, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buya/get_info_plaque"))] @@ -4862,7 +4569,7 @@ pub mod ztui_buyobj { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buyobj/update_display_list"))] - pub const UPDATE_DISPLAY_LIST: FunctionDef = FunctionDef{address: 0x004eb401, function_type: PhantomData}; + pub const UPDATE_DISPLAY_LIST: FunctionDef = FunctionDef{address: 0x004eb401, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buyobj/clear_selections"))] pub const CLEAR_SELECTIONS: FunctionDef = FunctionDef{address: 0x004f0abf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_buyobj/add_callbacks"))] @@ -4908,7 +4615,7 @@ pub mod ztui_expansionselect { #[cfg_attr(feature = "detour-validation", validate_detour("ztui_expansionselect/get_any_expansions_disabled"))] pub const GET_ANY_EXPANSIONS_DISABLED: FunctionDef u32> = FunctionDef{address: 0x0041eee3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_expansionselect/is_expansion_disabled"))] - pub const IS_EXPANSION_DISABLED: FunctionDef u8> = FunctionDef{address: 0x0041ef86, function_type: PhantomData}; + pub const IS_EXPANSION_DISABLED: FunctionDef = FunctionDef{address: 0x0041ef86, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_expansionselect/get_expansion_list"))] pub const GET_EXPANSION_LIST: FunctionDef u32> = FunctionDef{address: 0x004b1d62, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_expansionselect/hide"))] @@ -4928,7 +4635,7 @@ pub mod ztui_gameopts { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_gameopts/load_file"))] - pub const LOAD_FILE: FunctionDef u32> = FunctionDef{address: 0x00453000, function_type: PhantomData}; + pub const LOAD_FILE: FunctionDef u32> = FunctionDef{address: 0x00453000, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_gameopts/save_game"))] pub const SAVE_GAME: FunctionDef u32> = FunctionDef{address: 0x004769ac, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_gameopts/start_new_game"))] @@ -4966,7 +4673,7 @@ pub mod ztui_general { #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/get_mapview"))] pub const GET_MAPVIEW: FunctionDef u32> = FunctionDef{address: 0x004017e5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/update_display_lists"))] - pub const UPDATE_DISPLAY_LISTS: FunctionDef = FunctionDef{address: 0x0040d37f, function_type: PhantomData}; + pub const UPDATE_DISPLAY_LISTS: FunctionDef = FunctionDef{address: 0x0040d37f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/get_selected_entity"))] pub const GET_SELECTED_ENTITY: FunctionDef u32> = FunctionDef{address: 0x00410f84, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_general/hide_misc_panels"))] @@ -4999,8 +4706,6 @@ pub mod ztui_guestinfo { #[cfg_attr(feature = "detour-validation", validate_detour("ztui_guestinfo/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a78a, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztui_guestinfo/set_guest_visible"))] - pub const SET_GUEST_VISIBLE: FunctionDef = FunctionDef{address: 0x0042a9fa, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_guestinfo/show"))] pub const SHOW: FunctionDef = FunctionDef{address: 0x0046aa50, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_guestinfo/unfollow"))] @@ -5014,15 +4719,15 @@ pub mod ztui_habitatinfo { #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/update"))] pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a384, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/add_habitat"))] - pub const ADD_HABITAT: FunctionDef = FunctionDef{address: 0x0044e48a, function_type: PhantomData}; + pub const ADD_HABITAT: FunctionDef = FunctionDef{address: 0x0044e48a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/select_tank_button"))] pub const SELECT_TANK_BUTTON: FunctionDef = FunctionDef{address: 0x00468b9d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/remove_habitat"))] - pub const REMOVE_HABITAT: FunctionDef = FunctionDef{address: 0x0050c715, function_type: PhantomData}; + pub const REMOVE_HABITAT: FunctionDef = FunctionDef{address: 0x0050c715, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/add_callbacks"))] pub const ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x0051512d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/set_habitat"))] - pub const SET_HABITAT: FunctionDef = FunctionDef{address: 0x0058b5ce, function_type: PhantomData}; + pub const SET_HABITAT: FunctionDef = FunctionDef{address: 0x0058b5ce, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/set_tank_button_enabled"))] pub const SET_TANK_BUTTON_ENABLED: FunctionDef = FunctionDef{address: 0x0058b5f2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/refill_habitat_list"))] @@ -5030,7 +4735,7 @@ pub mod ztui_habitatinfo { #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/remove_all_habitats"))] pub const REMOVE_ALL_HABITATS: FunctionDef = FunctionDef{address: 0x005b1244, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_habitatinfo/get_icon_name"))] - pub const GET_ICON_NAME: FunctionDef *const u8> = FunctionDef{address: 0x005b3149, function_type: PhantomData}; + pub const GET_ICON_NAME: FunctionDef u32> = FunctionDef{address: 0x005b3149, function_type: PhantomData}; } // ZTUI::heliinfo class functions @@ -5046,7 +4751,7 @@ pub mod ztui_help { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_help/show"))] - pub const SHOW: FunctionDef = FunctionDef{address: 0x00484a32, function_type: PhantomData}; + pub const SHOW: FunctionDef = FunctionDef{address: 0x00484a32, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_help/hide"))] pub const HIDE: FunctionDef = FunctionDef{address: 0x004b2972, function_type: PhantomData}; } @@ -5060,7 +4765,7 @@ pub mod ztui_hirestaff { #[cfg_attr(feature = "detour-validation", validate_detour("ztui_hirestaff/randomize_sex"))] pub const RANDOMIZE_SEX: FunctionDef = FunctionDef{address: 0x004e770d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_hirestaff/update_display_list"))] - pub const UPDATE_DISPLAY_LIST: FunctionDef = FunctionDef{address: 0x004eb4cd, function_type: PhantomData}; + pub const UPDATE_DISPLAY_LIST: FunctionDef = FunctionDef{address: 0x004eb4cd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_hirestaff/get_info_plaque"))] pub const GET_INFO_PLAQUE: FunctionDef = FunctionDef{address: 0x004f188a, function_type: PhantomData}; } @@ -5084,7 +4789,7 @@ pub mod ztui_keeperinfo { #[cfg_attr(feature = "detour-validation", validate_detour("ztui_keeperinfo/hide"))] pub const HIDE: FunctionDef = FunctionDef{address: 0x004440f1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_keeperinfo/set_animal"))] - pub const SET_ANIMAL: FunctionDef = FunctionDef{address: 0x004831b2, function_type: PhantomData}; + pub const SET_ANIMAL: FunctionDef = FunctionDef{address: 0x004831b2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_keeperinfo/force_update"))] pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x00483714, function_type: PhantomData}; } @@ -5130,31 +4835,9 @@ pub mod ztui_multianimal { #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multianimal/force_update"))] pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x00418c35, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multianimal/add_entity"))] - pub const ADD_ENTITY: FunctionDef = FunctionDef{address: 0x00453b38, function_type: PhantomData}; + pub const ADD_ENTITY: FunctionDef = FunctionDef{address: 0x00453b38, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multianimal/remove_entity"))] - pub const REMOVE_ENTITY: FunctionDef = FunctionDef{address: 0x004fe532, function_type: PhantomData}; -} - -// ZTUI::multiguest class functions -pub mod ztui_multiguest { - use super::*; - - #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multiguest/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a316, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multiguest/add_entity"))] - pub const ADD_ENTITY: FunctionDef = FunctionDef{address: 0x004f5eb2, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multiguest/remove_entity"))] - pub const REMOVE_ENTITY: FunctionDef = FunctionDef{address: 0x004fa3a1, function_type: PhantomData}; -} - -// ZTUI::multistaff class functions -pub mod ztui_multistaff { - use super::*; - - #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multistaff/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x0041a39f, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztui_multistaff/add_entity"))] - pub const ADD_ENTITY: FunctionDef = FunctionDef{address: 0x00457f81, function_type: PhantomData}; + pub const REMOVE_ENTITY: FunctionDef = FunctionDef{address: 0x004fe532, function_type: PhantomData}; } // ZTUI::ncbuildinginfo class functions @@ -5206,7 +4889,7 @@ pub mod ztui_showpanel { #[cfg_attr(feature = "detour-validation", validate_detour("ztui_showpanel/set_exhibit"))] pub const SET_EXHIBIT: FunctionDef = FunctionDef{address: 0x00468a5b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_showpanel/fill_exhibit_info_1"))] - pub const FILL_EXHIBIT_INFO_1: FunctionDef = FunctionDef{address: 0x00474400, function_type: PhantomData}; + pub const FILL_EXHIBIT_INFO_1: FunctionDef = FunctionDef{address: 0x00474400, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_showpanel/select_show_tab"))] pub const SELECT_SHOW_TAB: FunctionDef = FunctionDef{address: 0x00474646, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_showpanel/show_1"))] @@ -5230,7 +4913,7 @@ pub mod ztui_staffinfo { #[cfg_attr(feature = "detour-validation", validate_detour("ztui_staffinfo/show"))] pub const SHOW: FunctionDef = FunctionDef{address: 0x00471813, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_staffinfo/force_update"))] - pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x005b0f93, function_type: PhantomData}; + pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x005b0f93, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztui_staffinfo/unfollow"))] pub const UNFOLLOW: FunctionDef = FunctionDef{address: 0x00618847, function_type: PhantomData}; } @@ -5296,13 +4979,13 @@ pub mod ztundobuffer { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztundobuffer/clear"))] - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004f15c8, function_type: PhantomData}; + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004f15c8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztundobuffer/add_action"))] - pub const ADD_ACTION: FunctionDef = FunctionDef{address: 0x004f8a1f, function_type: PhantomData}; + pub const ADD_ACTION: FunctionDef = FunctionDef{address: 0x004f8a1f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztundobuffer/remove_action"))] - pub const REMOVE_ACTION: FunctionDef u32> = FunctionDef{address: 0x004fa670, function_type: PhantomData}; + pub const REMOVE_ACTION: FunctionDef u32> = FunctionDef{address: 0x004fa670, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztundobuffer/ztundo_buffer"))] - pub const ZTUNDO_BUFFER: FunctionDef *const u32> = FunctionDef{address: 0x00502713, function_type: PhantomData}; + pub const ZTUNDO_BUFFER: FunctionDef u32> = FunctionDef{address: 0x00502713, function_type: PhantomData}; } // ZTUnit class functions @@ -5310,79 +4993,75 @@ pub mod ztunit { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/validate_position"))] - pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x004102b3, function_type: PhantomData}; + pub const VALIDATE_POSITION: FunctionDef = FunctionDef{address: 0x004102b3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_footprint"))] pub const GET_FOOTPRINT: FunctionDef *const u32> = FunctionDef{address: 0x0041070b, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_swims"))] - pub const GET_SWIMS: FunctionDef = FunctionDef{address: 0x00410764, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/is_on_water"))] - pub const IS_ON_WATER: FunctionDef u32> = FunctionDef{address: 0x00410fe0, function_type: PhantomData}; + pub const IS_ON_WATER: FunctionDef u32> = FunctionDef{address: 0x00410fe0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_predator_unit"))] - pub const GET_PREDATOR_UNIT: FunctionDef i32> = FunctionDef{address: 0x00412259, function_type: PhantomData}; + pub const GET_PREDATOR_UNIT: FunctionDef i32> = FunctionDef{address: 0x00412259, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/add_to_map"))] - pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x00412c70, function_type: PhantomData}; + pub const ADD_TO_MAP: FunctionDef u32> = FunctionDef{address: 0x00412c70, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_idle_anim"))] - pub const GET_IDLE_ANIM: FunctionDef i32> = FunctionDef{address: 0x0041338a, function_type: PhantomData}; + pub const GET_IDLE_ANIM: FunctionDef i32> = FunctionDef{address: 0x0041338a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/face_toward_target"))] - pub const FACE_TOWARD_TARGET: FunctionDef = FunctionDef{address: 0x00426f21, function_type: PhantomData}; + pub const FACE_TOWARD_TARGET: FunctionDef = FunctionDef{address: 0x00426f21, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/remove_from_map"))] - pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004277c9, function_type: PhantomData}; + pub const REMOVE_FROM_MAP: FunctionDef = FunctionDef{address: 0x004277c9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/find_nearest_satisfier"))] - pub const FIND_NEAREST_SATISFIER: FunctionDef u32> = FunctionDef{address: 0x004290f3, function_type: PhantomData}; + pub const FIND_NEAREST_SATISFIER: FunctionDef u32> = FunctionDef{address: 0x004290f3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/face_toward_target_unit"))] - pub const FACE_TOWARD_TARGET_UNIT: FunctionDef = FunctionDef{address: 0x0042fa2c, function_type: PhantomData}; + pub const FACE_TOWARD_TARGET_UNIT: FunctionDef = FunctionDef{address: 0x0042fa2c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/abort_show"))] - pub const ABORT_SHOW: FunctionDef = FunctionDef{address: 0x0042fa42, function_type: PhantomData}; + pub const ABORT_SHOW: FunctionDef = FunctionDef{address: 0x0042fa42, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/update_building_tiles"))] - pub const UPDATE_BUILDING_TILES: FunctionDef u32> = FunctionDef{address: 0x0043b2f6, function_type: PhantomData}; + pub const UPDATE_BUILDING_TILES: FunctionDef u32> = FunctionDef{address: 0x0043b2f6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00454488, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x00454488, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x00478501, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/f_zoo_message_tile_0"))] - pub const F_ZOO_MESSAGE_TILE_0: FunctionDef = FunctionDef{address: 0x004807c2, function_type: PhantomData}; + pub const F_ZOO_MESSAGE_TILE_0: FunctionDef = FunctionDef{address: 0x004807c2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/f_zoo_message_tile_1"))] - pub const F_ZOO_MESSAGE_TILE_1: FunctionDef = FunctionDef{address: 0x0048083d, function_type: PhantomData}; + pub const F_ZOO_MESSAGE_TILE_1: FunctionDef = FunctionDef{address: 0x0048083d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/f_exit_building"))] pub const F_EXIT_BUILDING: FunctionDef = FunctionDef{address: 0x0048c522, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/check_elevation"))] - pub const CHECK_ELEVATION: FunctionDef bool> = FunctionDef{address: 0x004935aa, function_type: PhantomData}; + pub const CHECK_ELEVATION: FunctionDef bool> = FunctionDef{address: 0x004935aa, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/format_name_message"))] - pub const FORMAT_NAME_MESSAGE: FunctionDef *const u32> = FunctionDef{address: 0x0049cfeb, function_type: PhantomData}; + pub const FORMAT_NAME_MESSAGE: FunctionDef u32> = FunctionDef{address: 0x0049cfeb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/f_zoo_message_name"))] - pub const F_ZOO_MESSAGE_NAME: FunctionDef = FunctionDef{address: 0x0049d18e, function_type: PhantomData}; + pub const F_ZOO_MESSAGE_NAME: FunctionDef = FunctionDef{address: 0x0049d18e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/do_random_walk"))] - pub const DO_RANDOM_WALK: FunctionDef i8> = FunctionDef{address: 0x0049dafe, function_type: PhantomData}; + pub const DO_RANDOM_WALK: FunctionDef = FunctionDef{address: 0x0049dafe, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_target_unit"))] - pub const GET_TARGET_UNIT: FunctionDef i32> = FunctionDef{address: 0x004a4b53, function_type: PhantomData}; + pub const GET_TARGET_UNIT: FunctionDef i32> = FunctionDef{address: 0x004a4b53, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/in_friendly_chase"))] - pub const IN_FRIENDLY_CHASE: FunctionDef u32> = FunctionDef{address: 0x004a4bb7, function_type: PhantomData}; + pub const IN_FRIENDLY_CHASE: FunctionDef u32> = FunctionDef{address: 0x004a4bb7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/chase_done"))] - pub const CHASE_DONE: FunctionDef bool> = FunctionDef{address: 0x004a4ca0, function_type: PhantomData}; + pub const CHASE_DONE: FunctionDef bool> = FunctionDef{address: 0x004a4ca0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/avoid_done"))] - pub const AVOID_DONE: FunctionDef u32> = FunctionDef{address: 0x004a5508, function_type: PhantomData}; + pub const AVOID_DONE: FunctionDef u32> = FunctionDef{address: 0x004a5508, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_path_to_target"))] - pub const GET_PATH_TO_TARGET: FunctionDef u32> = FunctionDef{address: 0x004a5b4d, function_type: PhantomData}; + pub const GET_PATH_TO_TARGET: FunctionDef u32> = FunctionDef{address: 0x004a5b4d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_path_away_from_target"))] - pub const GET_PATH_AWAY_FROM_TARGET: FunctionDef = FunctionDef{address: 0x004a639e, function_type: PhantomData}; + pub const GET_PATH_AWAY_FROM_TARGET: FunctionDef = FunctionDef{address: 0x004a639e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/create_name"))] - pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x004e1b58, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_icon_anim"))] - pub const GET_ICON_ANIM: FunctionDef = FunctionDef{address: 0x004ee499, function_type: PhantomData}; + pub const CREATE_NAME: FunctionDef = FunctionDef{address: 0x004e1b58, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004f578d, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004f578d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/ztunit"))] - pub const ZTUNIT: FunctionDef *const u32> = FunctionDef{address: 0x004f9cf0, function_type: PhantomData}; + pub const ZTUNIT: FunctionDef u32> = FunctionDef{address: 0x004f9cf0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/set_is_removed"))] - pub const SET_IS_REMOVED: FunctionDef = FunctionDef{address: 0x004fa78e, function_type: PhantomData}; + pub const SET_IS_REMOVED: FunctionDef = FunctionDef{address: 0x004fa78e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/init_after_load"))] - pub const INIT_AFTER_LOAD: FunctionDef u32> = FunctionDef{address: 0x005951b3, function_type: PhantomData}; + pub const INIT_AFTER_LOAD: FunctionDef u32> = FunctionDef{address: 0x005951b3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/remove_from_building_if_present"))] - pub const REMOVE_FROM_BUILDING_IF_PRESENT: FunctionDef = FunctionDef{address: 0x005ae65f, function_type: PhantomData}; + pub const REMOVE_FROM_BUILDING_IF_PRESENT: FunctionDef = FunctionDef{address: 0x005ae65f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/reset_ai"))] - pub const RESET_AI: FunctionDef u32> = FunctionDef{address: 0x005ae68b, function_type: PhantomData}; + pub const RESET_AI: FunctionDef u32> = FunctionDef{address: 0x005ae68b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunit/get_terrain_cost"))] - pub const GET_TERRAIN_COST: FunctionDef = FunctionDef{address: 0x00612f15, function_type: PhantomData}; + pub const GET_TERRAIN_COST: FunctionDef = FunctionDef{address: 0x00612f15, function_type: PhantomData}; } // ZTUnitType class functions @@ -5390,29 +5069,23 @@ pub mod ztunittype { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/set_available"))] - pub const SET_AVAILABLE: FunctionDef = FunctionDef{address: 0x0040d3ac, function_type: PhantomData}; + pub const SET_AVAILABLE: FunctionDef = FunctionDef{address: 0x0040d3ac, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/get_dirt_type"))] pub const GET_DIRT_TYPE: FunctionDef i32> = FunctionDef{address: 0x00410438, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/get_dino_dirt_type"))] pub const GET_DINO_DIRT_TYPE: FunctionDef i32> = FunctionDef{address: 0x0041044c, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/set_idle_animation"))] - pub const SET_IDLE_ANIMATION: FunctionDef u32> = FunctionDef{address: 0x004b54ea, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/load_characteristics_0"))] - pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004b5681, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_0: FunctionDef u32> = FunctionDef{address: 0x004b5681, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/load_characteristics_1"))] - pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b5c71, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/load_data"))] - pub const LOAD_DATA: FunctionDef = FunctionDef{address: 0x004bb628, function_type: PhantomData}; + pub const LOAD_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x004b5c71, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004be558, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004be558, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/ztunit_type"))] - pub const ZTUNIT_TYPE: FunctionDef *const u32> = FunctionDef{address: 0x00500a69, function_type: PhantomData}; + pub const ZTUNIT_TYPE: FunctionDef u32> = FunctionDef{address: 0x00500a69, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/get_trash_type"))] pub const GET_TRASH_TYPE: FunctionDef i32> = FunctionDef{address: 0x0052cfbe, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/set_trick_available"))] - pub const SET_TRICK_AVAILABLE: FunctionDef = FunctionDef{address: 0x0059b599, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztunittype/create_entity"))] - pub const CREATE_ENTITY: FunctionDef *const u32> = FunctionDef{address: 0x006151b3, function_type: PhantomData}; + pub const CREATE_ENTITY: FunctionDef u32> = FunctionDef{address: 0x006151b3, function_type: PhantomData}; } // ZTViewingArea class functions @@ -5420,27 +5093,27 @@ pub mod ztviewingarea { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/update_ambients"))] - pub const UPDATE_AMBIENTS: FunctionDef = FunctionDef{address: 0x004358f2, function_type: PhantomData}; + pub const UPDATE_AMBIENTS: FunctionDef = FunctionDef{address: 0x004358f2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/recalculate_characteristics"))] - pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x00447957, function_type: PhantomData}; + pub const RECALCULATE_CHARACTERISTICS: FunctionDef = FunctionDef{address: 0x00447957, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/recalculate_oa"))] - pub const RECALCULATE_OA: FunctionDef = FunctionDef{address: 0x004479fd, function_type: PhantomData}; + pub const RECALCULATE_OA: FunctionDef = FunctionDef{address: 0x004479fd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/add_tile"))] - pub const ADD_TILE: FunctionDef = FunctionDef{address: 0x0044ebe6, function_type: PhantomData}; + pub const ADD_TILE: FunctionDef = FunctionDef{address: 0x0044ebe6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/get_ewextent"))] - pub const GET_EWEXTENT: FunctionDef = FunctionDef{address: 0x0044ee46, function_type: PhantomData}; + pub const GET_EWEXTENT: FunctionDef = FunctionDef{address: 0x0044ee46, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x0044ee8e, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x0044ee8e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/get_nsextent"))] - pub const GET_NSEXTENT: FunctionDef = FunctionDef{address: 0x0044f0f2, function_type: PhantomData}; + pub const GET_NSEXTENT: FunctionDef = FunctionDef{address: 0x0044f0f2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/clear_tile_of_va"))] - pub const CLEAR_TILE_OF_VA: FunctionDef = FunctionDef{address: 0x004590c7, function_type: PhantomData}; + pub const CLEAR_TILE_OF_VA: FunctionDef = FunctionDef{address: 0x004590c7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/ztviewing_area"))] - pub const ZTVIEWING_AREA: FunctionDef = FunctionDef{address: 0x00459196, function_type: PhantomData}; + pub const ZTVIEWING_AREA: FunctionDef = FunctionDef{address: 0x00459196, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/create_oa"))] - pub const CREATE_OA: FunctionDef = FunctionDef{address: 0x004f380b, function_type: PhantomData}; + pub const CREATE_OA: FunctionDef = FunctionDef{address: 0x004f380b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztviewingarea/remove_tile"))] - pub const REMOVE_TILE: FunctionDef = FunctionDef{address: 0x0050bc1a, function_type: PhantomData}; + pub const REMOVE_TILE: FunctionDef = FunctionDef{address: 0x0050bc1a, function_type: PhantomData}; } // ZTWorldMgr class functions @@ -5448,29 +5121,29 @@ pub mod ztworldmgr { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/satisfies"))] - pub const SATISFIES: FunctionDef u32> = FunctionDef{address: 0x0041239d, function_type: PhantomData}; + pub const SATISFIES: FunctionDef u32> = FunctionDef{address: 0x0041239d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/get_building_list"))] - pub const GET_BUILDING_LIST: FunctionDef = FunctionDef{address: 0x00413db8, function_type: PhantomData}; + pub const GET_BUILDING_LIST: FunctionDef = FunctionDef{address: 0x00413db8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/get_attractions"))] - pub const GET_ATTRACTIONS: FunctionDef = FunctionDef{address: 0x00427f43, function_type: PhantomData}; + pub const GET_ATTRACTIONS: FunctionDef = FunctionDef{address: 0x00427f43, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/get_gawk_scenery"))] - pub const GET_GAWK_SCENERY: FunctionDef = FunctionDef{address: 0x00427fd9, function_type: PhantomData}; + pub const GET_GAWK_SCENERY: FunctionDef = FunctionDef{address: 0x00427fd9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/get_num_sites"))] pub const GET_NUM_SITES: FunctionDef i32> = FunctionDef{address: 0x004281fd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/get_need_from_index"))] - pub const GET_NEED_FROM_INDEX: FunctionDef *const u32> = FunctionDef{address: 0x0042aeaf, function_type: PhantomData}; + pub const GET_NEED_FROM_INDEX: FunctionDef u32> = FunctionDef{address: 0x0042aeaf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/get_need_index"))] - pub const GET_NEED_INDEX: FunctionDef i8> = FunctionDef{address: 0x0043aa46, function_type: PhantomData}; + pub const GET_NEED_INDEX: FunctionDef i8> = FunctionDef{address: 0x0043aa46, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/find_nearest_unseen_starting_show"))] - pub const FIND_NEAREST_UNSEEN_STARTING_SHOW: FunctionDef u32> = FunctionDef{address: 0x00440f0c, function_type: PhantomData}; + pub const FIND_NEAREST_UNSEEN_STARTING_SHOW: FunctionDef u32> = FunctionDef{address: 0x00440f0c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/add_to_gawk_scenery_list"))] pub const ADD_TO_GAWK_SCENERY_LIST: FunctionDef bool> = FunctionDef{address: 0x00451785, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/load"))] - pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x00452e13, function_type: PhantomData}; + pub const LOAD: FunctionDef u8> = FunctionDef{address: 0x00452e13, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/constructor"))] - pub const CONSTRUCTOR: FunctionDef *const u32> = FunctionDef{address: 0x004611d4, function_type: PhantomData}; + pub const CONSTRUCTOR: FunctionDef u32> = FunctionDef{address: 0x004611d4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/create"))] - pub const CREATE: FunctionDef *const u32> = FunctionDef{address: 0x0046498e, function_type: PhantomData}; + pub const CREATE: FunctionDef = FunctionDef{address: 0x0046498e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/save"))] pub const SAVE: FunctionDef u8> = FunctionDef{address: 0x0047704c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/remove_all_tank_owned_transients"))] @@ -5482,13 +5155,13 @@ pub mod ztworldmgr { #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/restore_all_tank_owned_transients"))] pub const RESTORE_ALL_TANK_OWNED_TRANSIENTS: FunctionDef = FunctionDef{address: 0x0047a162, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/load_types"))] - pub const LOAD_TYPES: FunctionDef u32> = FunctionDef{address: 0x004bf19a, function_type: PhantomData}; + pub const LOAD_TYPES: FunctionDef u32> = FunctionDef{address: 0x004bf19a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/clear"))] - pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6a77, function_type: PhantomData}; + pub const CLEAR: FunctionDef = FunctionDef{address: 0x004c6a77, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/init_building_map"))] pub const INIT_BUILDING_MAP: FunctionDef u32> = FunctionDef{address: 0x004c75ae, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/guesticide"))] - pub const GUESTICIDE: FunctionDef = FunctionDef{address: 0x004c9d8c, function_type: PhantomData}; + pub const GUESTICIDE: FunctionDef = FunctionDef{address: 0x004c9d8c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/reset_guests_without_removing"))] pub const RESET_GUESTS_WITHOUT_REMOVING: FunctionDef = FunctionDef{address: 0x004c9eae, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/reset_scenery"))] @@ -5496,19 +5169,19 @@ pub mod ztworldmgr { #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/reset_animal_counts"))] pub const RESET_ANIMAL_COUNTS: FunctionDef = FunctionDef{address: 0x004c9fd4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/add_to_object_list"))] - pub const ADD_TO_OBJECT_LIST: FunctionDef = FunctionDef{address: 0x004fdf04, function_type: PhantomData}; + pub const ADD_TO_OBJECT_LIST: FunctionDef = FunctionDef{address: 0x004fdf04, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/remove_from_all_building_lists"))] - pub const REMOVE_FROM_ALL_BUILDING_LISTS: FunctionDef u32> = FunctionDef{address: 0x005002ac, function_type: PhantomData}; + pub const REMOVE_FROM_ALL_BUILDING_LISTS: FunctionDef u32> = FunctionDef{address: 0x005002ac, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/remove_from_building_list"))] - pub const REMOVE_FROM_BUILDING_LIST: FunctionDef u32> = FunctionDef{address: 0x00500339, function_type: PhantomData}; + pub const REMOVE_FROM_BUILDING_LIST: FunctionDef u32> = FunctionDef{address: 0x00500339, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/ztworld_mgr"))] - pub const ZTWORLD_MGR: FunctionDef *const u32> = FunctionDef{address: 0x0057cce9, function_type: PhantomData}; + pub const ZTWORLD_MGR: FunctionDef u32> = FunctionDef{address: 0x0057cce9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/add_ambient_effect"))] - pub const ADD_AMBIENT_EFFECT: FunctionDef = FunctionDef{address: 0x0059148e, function_type: PhantomData}; + pub const ADD_AMBIENT_EFFECT: FunctionDef = FunctionDef{address: 0x0059148e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/rubble_all_cars"))] pub const RUBBLE_ALL_CARS: FunctionDef = FunctionDef{address: 0x0060d8e3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("ztworldmgr/box_up_and_find_aplace_for_animal"))] - pub const BOX_UP_AND_FIND_APLACE_FOR_ANIMAL: FunctionDef u32> = FunctionDef{address: 0x0060da6b, function_type: PhantomData}; + pub const BOX_UP_AND_FIND_APLACE_FOR_ANIMAL: FunctionDef u32> = FunctionDef{address: 0x0060da6b, function_type: PhantomData}; } // ZooStatus class functions @@ -5516,63 +5189,63 @@ pub mod zoostatus { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/calculate_sums"))] - pub const CALCULATE_SUMS: FunctionDef = FunctionDef{address: 0x0041f881, function_type: PhantomData}; + pub const CALCULATE_SUMS: FunctionDef = FunctionDef{address: 0x0041f881, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/rating_checks"))] - pub const RATING_CHECKS: FunctionDef = FunctionDef{address: 0x0041fcc1, function_type: PhantomData}; + pub const RATING_CHECKS: FunctionDef = FunctionDef{address: 0x0041fcc1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/message_checks"))] - pub const MESSAGE_CHECKS: FunctionDef = FunctionDef{address: 0x00420347, function_type: PhantomData}; + pub const MESSAGE_CHECKS: FunctionDef = FunctionDef{address: 0x00420347, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/newguest_checks"))] - pub const NEWGUEST_CHECKS: FunctionDef = FunctionDef{address: 0x00424375, function_type: PhantomData}; + pub const NEWGUEST_CHECKS: FunctionDef = FunctionDef{address: 0x00424375, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/f_chance"))] pub const F_CHANCE: FunctionDef u32> = FunctionDef{address: 0x004244ab, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/admission_message"))] - pub const ADMISSION_MESSAGE: FunctionDef = FunctionDef{address: 0x00429d68, function_type: PhantomData}; + pub const ADMISSION_MESSAGE: FunctionDef = FunctionDef{address: 0x00429d68, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/buy_people_food"))] - pub const BUY_PEOPLE_FOOD: FunctionDef = FunctionDef{address: 0x0042df22, function_type: PhantomData}; + pub const BUY_PEOPLE_FOOD: FunctionDef = FunctionDef{address: 0x0042df22, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/increase_donations"))] - pub const INCREASE_DONATIONS: FunctionDef = FunctionDef{address: 0x0042ebbe, function_type: PhantomData}; + pub const INCREASE_DONATIONS: FunctionDef = FunctionDef{address: 0x0042ebbe, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/update"))] - pub const UPDATE: FunctionDef = FunctionDef{address: 0x004351a9, function_type: PhantomData}; + pub const UPDATE: FunctionDef = FunctionDef{address: 0x004351a9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/save"))] pub const SAVE: FunctionDef u32> = FunctionDef{address: 0x0047ad4e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/spend_maint_wages"))] - pub const SPEND_MAINT_WAGES: FunctionDef = FunctionDef{address: 0x00483d34, function_type: PhantomData}; + pub const SPEND_MAINT_WAGES: FunctionDef = FunctionDef{address: 0x00483d34, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/finance_checks"))] - pub const FINANCE_CHECKS: FunctionDef = FunctionDef{address: 0x00483f11, function_type: PhantomData}; + pub const FINANCE_CHECKS: FunctionDef = FunctionDef{address: 0x00483f11, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/increase_endowment"))] - pub const INCREASE_ENDOWMENT: FunctionDef = FunctionDef{address: 0x0048442b, function_type: PhantomData}; + pub const INCREASE_ENDOWMENT: FunctionDef = FunctionDef{address: 0x0048442b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/spend_guide_wages"))] - pub const SPEND_GUIDE_WAGES: FunctionDef = FunctionDef{address: 0x0048bd8b, function_type: PhantomData}; + pub const SPEND_GUIDE_WAGES: FunctionDef = FunctionDef{address: 0x0048bd8b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/refund_animal_cost"))] - pub const REFUND_ANIMAL_COST: FunctionDef = FunctionDef{address: 0x0048d2da, function_type: PhantomData}; + pub const REFUND_ANIMAL_COST: FunctionDef = FunctionDef{address: 0x0048d2da, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/spend_building_upkeep"))] - pub const SPEND_BUILDING_UPKEEP: FunctionDef = FunctionDef{address: 0x0049bd80, function_type: PhantomData}; + pub const SPEND_BUILDING_UPKEEP: FunctionDef = FunctionDef{address: 0x0049bd80, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/f_zoo_message"))] - pub const F_ZOO_MESSAGE: FunctionDef = FunctionDef{address: 0x0049ce6b, function_type: PhantomData}; + pub const F_ZOO_MESSAGE: FunctionDef = FunctionDef{address: 0x0049ce6b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/init"))] - pub const INIT: FunctionDef = FunctionDef{address: 0x004c2683, function_type: PhantomData}; + pub const INIT: FunctionDef = FunctionDef{address: 0x004c2683, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/reset_finance_info"))] - pub const RESET_FINANCE_INFO: FunctionDef = FunctionDef{address: 0x004c9f13, function_type: PhantomData}; + pub const RESET_FINANCE_INFO: FunctionDef = FunctionDef{address: 0x004c9f13, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/spend_construction"))] - pub const SPEND_CONSTRUCTION: FunctionDef = FunctionDef{address: 0x004d9250, function_type: PhantomData}; + pub const SPEND_CONSTRUCTION: FunctionDef = FunctionDef{address: 0x004d9250, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/spend_keeper_wages_0"))] - pub const SPEND_KEEPER_WAGES_0: FunctionDef = FunctionDef{address: 0x004e1fde, function_type: PhantomData}; + pub const SPEND_KEEPER_WAGES_0: FunctionDef = FunctionDef{address: 0x004e1fde, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/f_create_guest"))] - pub const F_CREATE_GUEST: FunctionDef = FunctionDef{address: 0x004f6e3c, function_type: PhantomData}; + pub const F_CREATE_GUEST: FunctionDef = FunctionDef{address: 0x004f6e3c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/refund_construction"))] - pub const REFUND_CONSTRUCTION: FunctionDef = FunctionDef{address: 0x004f9329, function_type: PhantomData}; + pub const REFUND_CONSTRUCTION: FunctionDef = FunctionDef{address: 0x004f9329, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/animal_escaped"))] pub const ANIMAL_ESCAPED: FunctionDef = FunctionDef{address: 0x0050cde4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/load"))] - pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0059497f, function_type: PhantomData}; + pub const LOAD: FunctionDef u32> = FunctionDef{address: 0x0059497f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/increase_show_admission"))] - pub const INCREASE_SHOW_ADMISSION: FunctionDef = FunctionDef{address: 0x005a9718, function_type: PhantomData}; + pub const INCREASE_SHOW_ADMISSION: FunctionDef = FunctionDef{address: 0x005a9718, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/spend_keeper_wages_1"))] - pub const SPEND_KEEPER_WAGES_1: FunctionDef = FunctionDef{address: 0x005ad038, function_type: PhantomData}; + pub const SPEND_KEEPER_WAGES_1: FunctionDef = FunctionDef{address: 0x005ad038, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/change_endowment_members"))] - pub const CHANGE_ENDOWMENT_MEMBERS: FunctionDef = FunctionDef{address: 0x005ad160, function_type: PhantomData}; + pub const CHANGE_ENDOWMENT_MEMBERS: FunctionDef = FunctionDef{address: 0x005ad160, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("zoostatus/f_grant_donation"))] - pub const F_GRANT_DONATION: FunctionDef = FunctionDef{address: 0x00613e4a, function_type: PhantomData}; + pub const F_GRANT_DONATION: FunctionDef = FunctionDef{address: 0x00613e4a, function_type: PhantomData}; } // bfinternat class functions @@ -5580,29 +5253,29 @@ pub mod bfinternat { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/get_money_text_0"))] - pub const GET_MONEY_TEXT_0: FunctionDef *const u32> = FunctionDef{address: 0x0040eca1, function_type: PhantomData}; + pub const GET_MONEY_TEXT_0: FunctionDef u32> = FunctionDef{address: 0x0040eca1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/set_money_text_0"))] pub const SET_MONEY_TEXT_0: FunctionDef = FunctionDef{address: 0x0040ed88, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/get_number_text"))] - pub const GET_NUMBER_TEXT: FunctionDef *const u32> = FunctionDef{address: 0x00417879, function_type: PhantomData}; + pub const GET_NUMBER_TEXT: FunctionDef u32> = FunctionDef{address: 0x00417879, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/get_date_text"))] - pub const GET_DATE_TEXT: FunctionDef *const u32> = FunctionDef{address: 0x0041d39c, function_type: PhantomData}; + pub const GET_DATE_TEXT: FunctionDef u32> = FunctionDef{address: 0x0041d39c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/set_date_text"))] - pub const SET_DATE_TEXT: FunctionDef = FunctionDef{address: 0x0041d4df, function_type: PhantomData}; + pub const SET_DATE_TEXT: FunctionDef = FunctionDef{address: 0x0041d4df, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/get_money_text_1"))] - pub const GET_MONEY_TEXT_1: FunctionDef *const u32> = FunctionDef{address: 0x004ef4d4, function_type: PhantomData}; + pub const GET_MONEY_TEXT_1: FunctionDef u32> = FunctionDef{address: 0x004ef4d4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/set_money_text_1"))] pub const SET_MONEY_TEXT_1: FunctionDef = FunctionDef{address: 0x004ef5eb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/set_number_text"))] pub const SET_NUMBER_TEXT: FunctionDef = FunctionDef{address: 0x004efe4f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/get_text_resource"))] - pub const GET_TEXT_RESOURCE: FunctionDef *const u32> = FunctionDef{address: 0x004f00f6, function_type: PhantomData}; + pub const GET_TEXT_RESOURCE: FunctionDef u32> = FunctionDef{address: 0x004f00f6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/set_text_resource"))] - pub const SET_TEXT_RESOURCE: FunctionDef = FunctionDef{address: 0x004f0264, function_type: PhantomData}; + pub const SET_TEXT_RESOURCE: FunctionDef = FunctionDef{address: 0x004f0264, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/init"))] pub const INIT: FunctionDef = FunctionDef{address: 0x005358b7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("bfinternat/get_currency_symbol"))] - pub const GET_CURRENCY_SYMBOL: FunctionDef *const u32> = FunctionDef{address: 0x005fe02d, function_type: PhantomData}; + pub const GET_CURRENCY_SYMBOL: FunctionDef u32> = FunctionDef{address: 0x005fe02d, function_type: PhantomData}; } // ph_BFPathMove class functions @@ -5610,7 +5283,7 @@ pub mod ph_bfpathmove { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("ph_bfpathmove/do_progress"))] - pub const DO_PROGRESS: FunctionDef i8> = FunctionDef{address: 0x00439cee, function_type: PhantomData}; + pub const DO_PROGRESS: FunctionDef i8> = FunctionDef{address: 0x00439cee, function_type: PhantomData}; } // sndutil class functions @@ -5618,7 +5291,7 @@ pub mod sndutil { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("sndutil/compute_volume_and_pan"))] - pub const COMPUTE_VOLUME_AND_PAN: FunctionDef = FunctionDef{address: 0x0043f5ba, function_type: PhantomData}; + pub const COMPUTE_VOLUME_AND_PAN: FunctionDef = FunctionDef{address: 0x0043f5ba, function_type: PhantomData}; } // std::__vector_deleter<> class functions @@ -5626,7 +5299,7 @@ pub mod std_vector_deleter { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("std_vector_deleter/vector_deleter"))] - pub const VECTOR_DELETER: FunctionDef *const u32> = FunctionDef{address: 0x0060e4f5, function_type: PhantomData}; + pub const VECTOR_DELETER: FunctionDef u32> = FunctionDef{address: 0x0060e4f5, function_type: PhantomData}; } // std::basic_string<> class functions @@ -5634,13 +5307,9 @@ pub mod std_basic_string { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("std_basic_string/basic_string_0"))] - pub const BASIC_STRING_0: FunctionDef = FunctionDef{address: 0x004012ba, function_type: PhantomData}; + pub const BASIC_STRING: FunctionDef = FunctionDef{address: 0x004012ba, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("std_basic_string/compare"))] - pub const COMPARE: FunctionDef = FunctionDef{address: 0x00401a94, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("std_basic_string/basic_string_1"))] - pub const BASIC_STRING_1: FunctionDef = FunctionDef{address: 0x00401da8, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("std_basic_string/basic_string_2"))] - pub const BASIC_STRING_2: FunctionDef *const i32> = FunctionDef{address: 0x00404cf4, function_type: PhantomData}; + pub const COMPARE: FunctionDef = FunctionDef{address: 0x00401a94, function_type: PhantomData}; } // Standalone functions @@ -5648,35 +5317,35 @@ pub mod standalone { use super::*; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_0"))] - pub const NULLSUB_0: FunctionDef = FunctionDef{address: 0x0040100b, function_type: PhantomData}; + pub const NULLSUB_0: FunctionDef = FunctionDef{address: 0x0040100b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_1"))] - pub const NULLSUB_1: FunctionDef = FunctionDef{address: 0x0040100c, function_type: PhantomData}; + pub const NULLSUB_1: FunctionDef = FunctionDef{address: 0x0040100c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/vf_return_true_0"))] - pub const VF_RETURN_TRUE_0: FunctionDef u8> = FunctionDef{address: 0x00401302, function_type: PhantomData}; + pub const VF_RETURN_TRUE_0: FunctionDef = FunctionDef{address: 0x00401302, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/vf_return_false"))] - pub const VF_RETURN_FALSE: FunctionDef u8> = FunctionDef{address: 0x004016d1, function_type: PhantomData}; + pub const VF_RETURN_FALSE: FunctionDef = FunctionDef{address: 0x004016d1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/find_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std722_tree_q23std135pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding_q33std380map_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding_q23std73less_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std155allocator_q23std135pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding13value_compare_q23std155allocator_q23std135pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding_frcq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q33std722_tree_q23std135pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding_q33std380map_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding_q23std73less_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std155allocator_q23std135pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding13value_compare_q23std155allocator_q23std135pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std52list_p10ztbuilding_q23std24allocator_p10ztbuilding21_generic_iterator0"))] - pub const FIND_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD722_TREE_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q33STD380MAP_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING13VALUE_COMPARE_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_FRCQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q33STD722_TREE_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q33STD380MAP_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING13VALUE_COMPARE_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING21_GENERIC_ITERATOR0: FunctionDef = FunctionDef{address: 0x00401b9f, function_type: PhantomData}; + pub const FIND_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD722_TREE_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q33STD380MAP_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING13VALUE_COMPARE_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_FRCQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q33STD722_TREE_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q33STD380MAP_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING13VALUE_COMPARE_Q23STD155ALLOCATOR_Q23STD135PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD52LIST_P10ZTBUILDING_Q23STD24ALLOCATOR_P10ZTBUILDING21_GENERIC_ITERATOR0: FunctionDef = FunctionDef{address: 0x00401b9f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/search_config_method"))] - pub const SEARCH_CONFIG_METHOD: FunctionDef = FunctionDef{address: 0x00401eb1, function_type: PhantomData}; + pub const SEARCH_CONFIG_METHOD: FunctionDef = FunctionDef{address: 0x00401eb1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/operator_new"))] - pub const OPERATOR_NEW: FunctionDef *const c_void> = FunctionDef{address: 0x00402a5a, function_type: PhantomData}; + pub const OPERATOR_NEW: FunctionDef u32> = FunctionDef{address: 0x00402a5a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_2"))] pub const NULLSUB_2: FunctionDef = FunctionDef{address: 0x00402e53, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_3"))] pub const NULLSUB_3: FunctionDef = FunctionDef{address: 0x00402f82, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/crc32"))] - pub const CRC32: FunctionDef u32> = FunctionDef{address: 0x004036cc, function_type: PhantomData}; + pub const CRC32: FunctionDef u32> = FunctionDef{address: 0x004036cc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/bfresource_hash_key"))] - pub const BFRESOURCE_HASH_KEY: FunctionDef = FunctionDef{address: 0x00403802, function_type: PhantomData}; + pub const BFRESOURCE_HASH_KEY: FunctionDef = FunctionDef{address: 0x00403802, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/deallocate"))] pub const DEALLOCATE: FunctionDef u32> = FunctionDef{address: 0x00403e06, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/vf_return_true_1"))] - pub const VF_RETURN_TRUE_1: FunctionDef u8> = FunctionDef{address: 0x00404a7e, function_type: PhantomData}; + pub const VF_RETURN_TRUE_1: FunctionDef = FunctionDef{address: 0x00404a7e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/load_string_from_resource"))] - pub const LOAD_STRING_FROM_RESOURCE: FunctionDef i32> = FunctionDef{address: 0x00404e72, function_type: PhantomData}; + pub const LOAD_STRING_FROM_RESOURCE: FunctionDef i32> = FunctionDef{address: 0x00404e72, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_4"))] - pub const NULLSUB_4: FunctionDef = FunctionDef{address: 0x00404fcf, function_type: PhantomData}; + pub const NULLSUB_4: FunctionDef = FunctionDef{address: 0x00404fcf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_5"))] pub const NULLSUB_5: FunctionDef = FunctionDef{address: 0x004072ef, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_6"))] @@ -5686,65 +5355,55 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_8"))] pub const NULLSUB_8: FunctionDef = FunctionDef{address: 0x0040bcc9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/ver_query_value_a"))] - pub const VER_QUERY_VALUE_A: FunctionDef bool> = FunctionDef{address: 0x0040dcfb, function_type: PhantomData}; + pub const VER_QUERY_VALUE_A: FunctionDef bool> = FunctionDef{address: 0x0040dcfb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_needs_order_recalculate"))] pub const SET_NEEDS_ORDER_RECALCULATE: FunctionDef = FunctionDef{address: 0x0040f15b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/scale_rect"))] - pub const SCALE_RECT: FunctionDef *const i32> = FunctionDef{address: 0x0040f33d, function_type: PhantomData}; + pub const SCALE_RECT: FunctionDef u32> = FunctionDef{address: 0x0040f33d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/expand_rect"))] - pub const EXPAND_RECT: FunctionDef = FunctionDef{address: 0x0040f38d, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/is_snap_to_ground"))] - pub const IS_SNAP_TO_GROUND: FunctionDef u32> = FunctionDef{address: 0x00410309, function_type: PhantomData}; + pub const EXPAND_RECT: FunctionDef = FunctionDef{address: 0x0040f38d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_rotate_ccw"))] pub const CLICK_ROTATE_CCW: FunctionDef = FunctionDef{address: 0x00416cb7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/listable_object"))] - pub const LISTABLE_OBJECT: FunctionDef u32> = FunctionDef{address: 0x004172e3, function_type: PhantomData}; + pub const LISTABLE_OBJECT: FunctionDef u32> = FunctionDef{address: 0x004172e3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_9"))] pub const NULLSUB_9: FunctionDef = FunctionDef{address: 0x00418d1e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/null_startup"))] pub const NULL_STARTUP: FunctionDef = FunctionDef{address: 0x004190ff, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/uirender_text_0"))] - pub const UIRENDER_TEXT_0: FunctionDef = FunctionDef{address: 0x00419b0c, function_type: PhantomData}; + pub const UIRENDER_TEXT_0: FunctionDef = FunctionDef{address: 0x00419b0c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/uirender_text_1"))] - pub const UIRENDER_TEXT_1: FunctionDef = FunctionDef{address: 0x00419c3d, function_type: PhantomData}; + pub const UIRENDER_TEXT_1: FunctionDef = FunctionDef{address: 0x00419c3d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/startup_update"))] pub const STARTUP_UPDATE: FunctionDef = FunctionDef{address: 0x0041a3d5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/maybe_snprintf"))] - pub const MAYBE_SNPRINTF: FunctionDef u32> = FunctionDef{address: 0x0041b460, function_type: PhantomData}; + pub const MAYBE_SNPRINTF: FunctionDef u32> = FunctionDef{address: 0x0041b460, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/load_ini_value_string"))] - pub const LOAD_INI_VALUE_STRING: FunctionDef *const u32> = FunctionDef{address: 0x0041b4bc, function_type: PhantomData}; + pub const LOAD_INI_VALUE_STRING: FunctionDef u32> = FunctionDef{address: 0x0041b4bc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/maybe_sscanf"))] - pub const MAYBE_SSCANF: FunctionDef = FunctionDef{address: 0x0041b958, function_type: PhantomData}; + pub const MAYBE_SSCANF: FunctionDef = FunctionDef{address: 0x0041b958, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_status"))] pub const SET_STATUS: FunctionDef = FunctionDef{address: 0x0041d058, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_10"))] pub const NULLSUB_10: FunctionDef = FunctionDef{address: 0x0041e63a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/tile_within_ava"))] pub const TILE_WITHIN_AVA: FunctionDef u32> = FunctionDef{address: 0x0044ed0c, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/validate_neighbor_paths"))] - pub const VALIDATE_NEIGHBOR_PATHS: FunctionDef = FunctionDef{address: 0x00451aa6, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/can_put_path"))] - pub const CAN_PUT_PATH: FunctionDef u32> = FunctionDef{address: 0x00451e44, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/showpanel_update_available_trick_list"))] - pub const SHOWPANEL_UPDATE_AVAILABLE_TRICK_LIST: FunctionDef = FunctionDef{address: 0x004522ae, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/check_characteristics_0"))] - pub const CHECK_CHARACTERISTICS_0: FunctionDef bool> = FunctionDef{address: 0x004537fe, function_type: PhantomData}; + pub const CHECK_CHARACTERISTICS: FunctionDef bool> = FunctionDef{address: 0x004537fe, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/refill_animal_display"))] pub const REFILL_ANIMAL_DISPLAY: FunctionDef = FunctionDef{address: 0x0045390c, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/check_characteristics_1"))] - pub const CHECK_CHARACTERISTICS_1: FunctionDef u32> = FunctionDef{address: 0x00457d70, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/make_shape_idx"))] pub const MAKE_SHAPE_IDX: FunctionDef u32> = FunctionDef{address: 0x0045e493, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztmegatile_mgr"))] - pub const CREATE_ZTMEGATILE_MGR: FunctionDef *const u32> = FunctionDef{address: 0x00463e1e, function_type: PhantomData}; + pub const CREATE_ZTMEGATILE_MGR: FunctionDef = FunctionDef{address: 0x00463e1e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_zthabitat_mgr"))] - pub const CREATE_ZTHABITAT_MGR: FunctionDef *const u32> = FunctionDef{address: 0x00464925, function_type: PhantomData}; + pub const CREATE_ZTHABITAT_MGR: FunctionDef = FunctionDef{address: 0x00464925, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztthought_mgr"))] - pub const CREATE_ZTTHOUGHT_MGR: FunctionDef *const u32> = FunctionDef{address: 0x00464b34, function_type: PhantomData}; + pub const CREATE_ZTTHOUGHT_MGR: FunctionDef = FunctionDef{address: 0x00464b34, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_info_0"))] - pub const UPDATE_INFO_0: FunctionDef = FunctionDef{address: 0x004673b5, function_type: PhantomData}; + pub const UPDATE_INFO_0: FunctionDef = FunctionDef{address: 0x004673b5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/fill_list_box_0"))] - pub const FILL_LIST_BOX_0: FunctionDef = FunctionDef{address: 0x00467a33, function_type: PhantomData}; + pub const FILL_LIST_BOX_0: FunctionDef = FunctionDef{address: 0x00467a33, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/refill_habitat_info"))] pub const REFILL_HABITAT_INFO: FunctionDef = FunctionDef{address: 0x00467c6f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/refill_thoughts_list"))] @@ -5771,20 +5430,16 @@ pub mod standalone { pub const CLICK_DONATIONS_TAB: FunctionDef = FunctionDef{address: 0x004699d2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_animals_tab"))] pub const CLICK_ANIMALS_TAB: FunctionDef = FunctionDef{address: 0x00469af2, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/refill_staff_display"))] - pub const REFILL_STAFF_DISPLAY: FunctionDef = FunctionDef{address: 0x00469e10, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/fill_list_box_1"))] - pub const FILL_LIST_BOX_1: FunctionDef = FunctionDef{address: 0x0046a040, function_type: PhantomData}; + pub const FILL_LIST_BOX_1: FunctionDef = FunctionDef{address: 0x0046a040, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_grab_animal"))] pub const CLICK_GRAB_ANIMAL: FunctionDef = FunctionDef{address: 0x0046af10, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_cursor_quality"))] - pub const SET_CURSOR_QUALITY: FunctionDef u32> = FunctionDef{address: 0x0046bb82, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_conservation"))] pub const CLICK_CONSERVATION: FunctionDef = FunctionDef{address: 0x00470a71, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_research"))] pub const CLICK_RESEARCH: FunctionDef = FunctionDef{address: 0x0047104b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_info_1"))] - pub const UPDATE_INFO_1: FunctionDef = FunctionDef{address: 0x0047108a, function_type: PhantomData}; + pub const UPDATE_INFO_1: FunctionDef = FunctionDef{address: 0x0047108a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_exhibit_info"))] pub const UPDATE_EXHIBIT_INFO: FunctionDef = FunctionDef{address: 0x00473b1f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_stats"))] @@ -5798,7 +5453,7 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_save_1"))] pub const CLICK_SAVE_1: FunctionDef = FunctionDef{address: 0x00477041, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_save_file_name_a"))] - pub const GET_SAVE_FILE_NAME_A: FunctionDef bool> = FunctionDef{address: 0x00477046, function_type: PhantomData}; + pub const GET_SAVE_FILE_NAME_A: FunctionDef bool> = FunctionDef{address: 0x00477046, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/write_bytes_to_file"))] pub const WRITE_BYTES_TO_FILE: FunctionDef bool> = FunctionDef{address: 0x0047772e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/force_research"))] @@ -5818,7 +5473,7 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_developer_list"))] pub const CLICK_DEVELOPER_LIST: FunctionDef = FunctionDef{address: 0x0047ee74, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/repopulate_obj_list_0"))] - pub const REPOPULATE_OBJ_LIST_0: FunctionDef = FunctionDef{address: 0x0047ee98, function_type: PhantomData}; + pub const REPOPULATE_OBJ_LIST_0: FunctionDef = FunctionDef{address: 0x0047ee98, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_developer_list"))] pub const SHOW_DEVELOPER_LIST: FunctionDef = FunctionDef{address: 0x0047f0a2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/staffplaque_set_staff"))] @@ -5830,7 +5485,7 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_info_plaque"))] pub const CLICK_INFO_PLAQUE: FunctionDef = FunctionDef{address: 0x004833e3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_main_text"))] - pub const SET_MAIN_TEXT: FunctionDef = FunctionDef{address: 0x00483481, function_type: PhantomData}; + pub const SET_MAIN_TEXT: FunctionDef = FunctionDef{address: 0x00483481, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_general_info"))] pub const SHOW_GENERAL_INFO: FunctionDef = FunctionDef{address: 0x004834b5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_info_2"))] @@ -5838,7 +5493,7 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_keeper_info"))] pub const CLICK_KEEPER_INFO: FunctionDef = FunctionDef{address: 0x00483b21, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_topic_list"))] - pub const CLICK_TOPIC_LIST: FunctionDef = FunctionDef{address: 0x0048482b, function_type: PhantomData}; + pub const CLICK_TOPIC_LIST: FunctionDef = FunctionDef{address: 0x0048482b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_about"))] pub const CLICK_ABOUT: FunctionDef = FunctionDef{address: 0x00484b9a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_cbuilding_info"))] @@ -5848,7 +5503,7 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_cbuilding_info"))] pub const SHOW_CBUILDING_INFO: FunctionDef = FunctionDef{address: 0x00488b79, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/s_set_key"))] - pub const S_SET_KEY: FunctionDef = FunctionDef{address: 0x0048a80a, function_type: PhantomData}; + pub const S_SET_KEY: FunctionDef = FunctionDef{address: 0x0048a80a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_animal_info_follow"))] pub const CLICK_ANIMAL_INFO_FOLLOW: FunctionDef = FunctionDef{address: 0x0048c7ef, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_sell_animal"))] @@ -5876,7 +5531,7 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_15"))] pub const NULLSUB_15: FunctionDef = FunctionDef{address: 0x004ac06c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_neighbor"))] - pub const SET_NEIGHBOR: FunctionDef = FunctionDef{address: 0x004ac3f9, function_type: PhantomData}; + pub const SET_NEIGHBOR: FunctionDef = FunctionDef{address: 0x004ac3f9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_16"))] pub const NULLSUB_16: FunctionDef = FunctionDef{address: 0x004ad05f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_rotate_cw"))] @@ -5888,11 +5543,11 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/fps"))] pub const FPS: FunctionDef u32> = FunctionDef{address: 0x004b1949, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/save_ini_value_string"))] - pub const SAVE_INI_VALUE_STRING: FunctionDef = FunctionDef{address: 0x004b294a, function_type: PhantomData}; + pub const SAVE_INI_VALUE_STRING: FunctionDef = FunctionDef{address: 0x004b294a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_17"))] pub const NULLSUB_17: FunctionDef = FunctionDef{address: 0x004b31cf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/time"))] - pub const TIME: FunctionDef = FunctionDef{address: 0x004bc0c7, function_type: PhantomData}; + pub const TIME: FunctionDef = FunctionDef{address: 0x004bc0c7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_18"))] pub const NULLSUB_18: FunctionDef = FunctionDef{address: 0x004c6761, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_19"))] @@ -5904,7 +5559,7 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_map_list"))] pub const CLICK_MAP_LIST: FunctionDef = FunctionDef{address: 0x004ca58e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/s_get_key"))] - pub const S_GET_KEY: FunctionDef u32> = FunctionDef{address: 0x004cab6a, function_type: PhantomData}; + pub const S_GET_KEY: FunctionDef u32> = FunctionDef{address: 0x004cab6a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/fill_scenario_list"))] pub const FILL_SCENARIO_LIST: FunctionDef = FunctionDef{address: 0x004cacf3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_scenario"))] @@ -5914,17 +5569,17 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_map_select"))] pub const SHOW_MAP_SELECT: FunctionDef = FunctionDef{address: 0x004cb4b1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/make_initial_dir"))] - pub const MAKE_INITIAL_DIR: FunctionDef u32> = FunctionDef{address: 0x004cb6b6, function_type: PhantomData}; + pub const MAKE_INITIAL_DIR: FunctionDef u32> = FunctionDef{address: 0x004cb6b6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_save_as_0"))] pub const CLICK_SAVE_AS_0: FunctionDef = FunctionDef{address: 0x004cb8ed, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_save_as_1"))] pub const CLICK_SAVE_AS_1: FunctionDef = FunctionDef{address: 0x004cb9b4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/imm_get_default_imewnd"))] - pub const IMM_GET_DEFAULT_IMEWND: FunctionDef *const u32> = FunctionDef{address: 0x004cc6cb, function_type: PhantomData}; + pub const IMM_GET_DEFAULT_IMEWND: FunctionDef u32> = FunctionDef{address: 0x004cc6cb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/make_file_filter"))] - pub const MAKE_FILE_FILTER: FunctionDef = FunctionDef{address: 0x004cc6eb, function_type: PhantomData}; + pub const MAKE_FILE_FILTER: FunctionDef = FunctionDef{address: 0x004cc6eb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_open_file_name_a"))] - pub const GET_OPEN_FILE_NAME_A: FunctionDef bool> = FunctionDef{address: 0x004cc7cb, function_type: PhantomData}; + pub const GET_OPEN_FILE_NAME_A: FunctionDef bool> = FunctionDef{address: 0x004cc7cb, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_load_0"))] pub const CLICK_LOAD_0: FunctionDef = FunctionDef{address: 0x004cc7d1, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/commit_if_possible"))] @@ -5932,13 +5587,13 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_terraform_layout"))] pub const SHOW_TERRAFORM_LAYOUT: FunctionDef = FunctionDef{address: 0x004da60d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/convert_terrain_type_vector"))] - pub const CONVERT_TERRAIN_TYPE_VECTOR: FunctionDef *const i32> = FunctionDef{address: 0x004da780, function_type: PhantomData}; + pub const CONVERT_TERRAIN_TYPE_VECTOR: FunctionDef u32> = FunctionDef{address: 0x004da780, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_buy_habitat_list"))] - pub const CLICK_BUY_HABITAT_LIST: FunctionDef = FunctionDef{address: 0x004da916, function_type: PhantomData}; + pub const CLICK_BUY_HABITAT_LIST: FunctionDef = FunctionDef{address: 0x004da916, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_info_0"))] - pub const SHOW_INFO_0: FunctionDef = FunctionDef{address: 0x004dab14, function_type: PhantomData}; + pub const SHOW_INFO_0: FunctionDef = FunctionDef{address: 0x004dab14, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/repopulate_obj_list_1"))] - pub const REPOPULATE_OBJ_LIST_1: FunctionDef = FunctionDef{address: 0x004dae5c, function_type: PhantomData}; + pub const REPOPULATE_OBJ_LIST_1: FunctionDef = FunctionDef{address: 0x004dae5c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_paint"))] pub const CLICK_PAINT: FunctionDef = FunctionDef{address: 0x004dcb50, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_modify"))] @@ -5980,13 +5635,13 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_buy_animal"))] pub const HIDE_BUY_ANIMAL: FunctionDef = FunctionDef{address: 0x004e2cdd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_buy_animal_list"))] - pub const CLICK_BUY_ANIMAL_LIST: FunctionDef = FunctionDef{address: 0x004e2cf8, function_type: PhantomData}; + pub const CLICK_BUY_ANIMAL_LIST: FunctionDef = FunctionDef{address: 0x004e2cf8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_info_1"))] - pub const SHOW_INFO_1: FunctionDef = FunctionDef{address: 0x004e2f17, function_type: PhantomData}; + pub const SHOW_INFO_1: FunctionDef = FunctionDef{address: 0x004e2f17, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_info_labels_0"))] pub const SHOW_INFO_LABELS_0: FunctionDef = FunctionDef{address: 0x004e32c6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/repopulate_obj_list_2"))] - pub const REPOPULATE_OBJ_LIST_2: FunctionDef = FunctionDef{address: 0x004e334b, function_type: PhantomData}; + pub const REPOPULATE_OBJ_LIST_2: FunctionDef = FunctionDef{address: 0x004e334b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_subtitle"))] pub const SET_SUBTITLE: FunctionDef = FunctionDef{address: 0x004e3842, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/deselected_tab_1"))] @@ -6014,9 +5669,9 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_buy_object"))] pub const HIDE_BUY_OBJECT: FunctionDef = FunctionDef{address: 0x004e40d9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_buy_object_list"))] - pub const CLICK_BUY_OBJECT_LIST: FunctionDef = FunctionDef{address: 0x004e40f4, function_type: PhantomData}; + pub const CLICK_BUY_OBJECT_LIST: FunctionDef = FunctionDef{address: 0x004e40f4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/repopulate_obj_list_3"))] - pub const REPOPULATE_OBJ_LIST_3: FunctionDef = FunctionDef{address: 0x004e4343, function_type: PhantomData}; + pub const REPOPULATE_OBJ_LIST_3: FunctionDef = FunctionDef{address: 0x004e4343, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_grouping_title"))] pub const SET_GROUPING_TITLE: FunctionDef = FunctionDef{address: 0x004e4890, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/deselected_tab_2"))] @@ -6054,23 +5709,15 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_hire_staff_list"))] pub const CLICK_HIRE_STAFF_LIST: FunctionDef = FunctionDef{address: 0x004e69b8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_info_2"))] - pub const SHOW_INFO_2: FunctionDef = FunctionDef{address: 0x004e6ad3, function_type: PhantomData}; + pub const SHOW_INFO_2: FunctionDef = FunctionDef{address: 0x004e6ad3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_info_labels_1"))] pub const SHOW_INFO_LABELS_1: FunctionDef = FunctionDef{address: 0x004e6b43, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/repopulate_obj_list_4"))] pub const REPOPULATE_OBJ_LIST_4: FunctionDef = FunctionDef{address: 0x004e6bbd, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_text"))] - pub const SET_TEXT: FunctionDef = FunctionDef{address: 0x004eae2f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_info_5"))] pub const UPDATE_INFO_5: FunctionDef = FunctionDef{address: 0x004eae69, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_time"))] - pub const SET_TIME: FunctionDef = FunctionDef{address: 0x004eb0a8, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_image"))] - pub const SET_IMAGE: FunctionDef = FunctionDef{address: 0x004eb173, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_tooltip"))] - pub const SET_TOOLTIP: FunctionDef = FunctionDef{address: 0x004eb19a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_branch"))] - pub const GET_BRANCH: FunctionDef *const i16> = FunctionDef{address: 0x004eb21b, function_type: PhantomData}; + pub const GET_BRANCH: FunctionDef u32> = FunctionDef{address: 0x004eb21b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/fill_list"))] pub const FILL_LIST: FunctionDef = FunctionDef{address: 0x004eb270, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/refilll_animal_display"))] @@ -6082,7 +5729,7 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_tab"))] pub const CLICK_TAB: FunctionDef = FunctionDef{address: 0x004ee81b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/general_set_selected_entity"))] - pub const GENERAL_SET_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x004ef75b, function_type: PhantomData}; + pub const GENERAL_SET_SELECTED_ENTITY: FunctionDef = FunctionDef{address: 0x004ef75b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_scenario_objectives"))] pub const SHOW_SCENARIO_OBJECTIVES: FunctionDef = FunctionDef{address: 0x004efdf6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_scenario_info"))] @@ -6091,12 +5738,8 @@ pub mod standalone { pub const CHECK_TRIGGER_ELE: FunctionDef u32> = FunctionDef{address: 0x004f052c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_multi_building_list"))] pub const UPDATE_MULTI_BUILDING_LIST: FunctionDef = FunctionDef{address: 0x004f0979, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_terraforming"))] - pub const SET_TERRAFORMING: FunctionDef = FunctionDef{address: 0x004f1e6e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_progress"))] pub const UPDATE_PROGRESS: FunctionDef = FunctionDef{address: 0x004f202e, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/check_characteristics_2"))] - pub const CHECK_CHARACTERISTICS_2: FunctionDef bool> = FunctionDef{address: 0x004f5d7f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_20"))] pub const NULLSUB_20: FunctionDef = FunctionDef{address: 0x00501634, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_new_0"))] @@ -6132,13 +5775,11 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_download_state"))] pub const SET_DOWNLOAD_STATE: FunctionDef = FunctionDef{address: 0x00512c87, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/clear_q23std539_tree_q23std90pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_13superkeeper_t_q33std289map_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_13superkeeper_t_q23std73less_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std109allocator_q23std90pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_13superkeeper_t13value_compare_q23std109allocator_q23std90pair_cq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_13superkeeper_t_fv"))] - pub const CLEAR_Q23STD539_TREE_Q23STD90PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T_Q33STD289MAP_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD109ALLOCATOR_Q23STD90PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T13VALUE_COMPARE_Q23STD109ALLOCATOR_Q23STD90PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T_FV: FunctionDef = FunctionDef{address: 0x005145cc, function_type: PhantomData}; + pub const CLEAR_Q23STD539_TREE_Q23STD90PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T_Q33STD289MAP_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD109ALLOCATOR_Q23STD90PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T13VALUE_COMPARE_Q23STD109ALLOCATOR_Q23STD90PAIR_CQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_13SUPERKEEPER_T_FV: FunctionDef = FunctionDef{address: 0x005145cc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/animalinfo_add_callbacks"))] pub const ANIMALINFO_ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00515f1f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/buyh_add_callbacks"))] pub const BUYH_ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x0051611c, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/zooitems_add_callbacks"))] - pub const ZOOITEMS_ADD_CALLBACKS: FunctionDef = FunctionDef{address: 0x00516c45, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/check_terrain_options"))] pub const CHECK_TERRAIN_OPTIONS: FunctionDef = FunctionDef{address: 0x00517854, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/save_terrain_options"))] @@ -6150,35 +5791,35 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/init_terrain_options"))] pub const INIT_TERRAIN_OPTIONS: FunctionDef = FunctionDef{address: 0x00518d7f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztscript_mgr"))] - pub const CREATE_ZTSCRIPT_MGR: FunctionDef *const u32> = FunctionDef{address: 0x0051e0d6, function_type: PhantomData}; + pub const CREATE_ZTSCRIPT_MGR: FunctionDef = FunctionDef{address: 0x0051e0d6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztresearch_mgr"))] - pub const CREATE_ZTRESEARCH_MGR: FunctionDef *const u32> = FunctionDef{address: 0x0051e293, function_type: PhantomData}; + pub const CREATE_ZTRESEARCH_MGR: FunctionDef = FunctionDef{address: 0x0051e293, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztshow_mgr"))] - pub const CREATE_ZTSHOW_MGR: FunctionDef *const u32> = FunctionDef{address: 0x0051f79e, function_type: PhantomData}; + pub const CREATE_ZTSHOW_MGR: FunctionDef = FunctionDef{address: 0x0051f79e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztmessage_queue"))] - pub const CREATE_ZTMESSAGE_QUEUE: FunctionDef *const u32> = FunctionDef{address: 0x00520b61, function_type: PhantomData}; + pub const CREATE_ZTMESSAGE_QUEUE: FunctionDef = FunctionDef{address: 0x00520b61, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztmini_map"))] - pub const CREATE_ZTMINI_MAP: FunctionDef *const u32> = FunctionDef{address: 0x00520d1c, function_type: PhantomData}; + pub const CREATE_ZTMINI_MAP: FunctionDef = FunctionDef{address: 0x00520d1c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/load_ini_value_float"))] - pub const LOAD_INI_VALUE_FLOAT: FunctionDef f32> = FunctionDef{address: 0x0052211d, function_type: PhantomData}; + pub const LOAD_INI_VALUE_FLOAT: FunctionDef f32> = FunctionDef{address: 0x0052211d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_alpha_surface"))] - pub const CREATE_ALPHA_SURFACE: FunctionDef bool> = FunctionDef{address: 0x00522a31, function_type: PhantomData}; + pub const CREATE_ALPHA_SURFACE: FunctionDef bool> = FunctionDef{address: 0x00522a31, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/load_image"))] pub const LOAD_IMAGE: FunctionDef = FunctionDef{address: 0x00523326, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztmarketing_mgr"))] - pub const CREATE_ZTMARKETING_MGR: FunctionDef *const u32> = FunctionDef{address: 0x005257e7, function_type: PhantomData}; + pub const CREATE_ZTMARKETING_MGR: FunctionDef = FunctionDef{address: 0x005257e7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztscenario_mgr"))] - pub const CREATE_ZTSCENARIO_MGR: FunctionDef *const u32> = FunctionDef{address: 0x00525e27, function_type: PhantomData}; + pub const CREATE_ZTSCENARIO_MGR: FunctionDef = FunctionDef{address: 0x00525e27, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_ztgame_mgr"))] - pub const CREATE_ZTGAME_MGR: FunctionDef *const u32> = FunctionDef{address: 0x00527dc7, function_type: PhantomData}; + pub const CREATE_ZTGAME_MGR: FunctionDef = FunctionDef{address: 0x00527dc7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/create_dxsnd_mgr"))] - pub const CREATE_DXSND_MGR: FunctionDef *const u32> = FunctionDef{address: 0x005280c3, function_type: PhantomData}; + pub const CREATE_DXSND_MGR: FunctionDef = FunctionDef{address: 0x005280c3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/dir_search"))] - pub const DIR_SEARCH: FunctionDef *const u32> = FunctionDef{address: 0x00529b75, function_type: PhantomData}; + pub const DIR_SEARCH: FunctionDef u32> = FunctionDef{address: 0x00529b75, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/setup_progress_bar"))] pub const SETUP_PROGRESS_BAR: FunctionDef = FunctionDef{address: 0x0052ae16, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_log_level_string"))] - pub const GET_LOG_LEVEL_STRING: FunctionDef *const i8> = FunctionDef{address: 0x0052ba65, function_type: PhantomData}; + pub const GET_LOG_LEVEL_STRING: FunctionDef u32> = FunctionDef{address: 0x0052ba65, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_marketing_info"))] pub const UPDATE_MARKETING_INFO: FunctionDef = FunctionDef{address: 0x0052f686, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/update_finance_info"))] @@ -6212,11 +5853,11 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/init_video_quality"))] pub const INIT_VIDEO_QUALITY: FunctionDef = FunctionDef{address: 0x00533a78, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/load_string_to_global_buffer"))] - pub const LOAD_STRING_TO_GLOBAL_BUFFER: FunctionDef *const u8> = FunctionDef{address: 0x005349b0, function_type: PhantomData}; + pub const LOAD_STRING_TO_GLOBAL_BUFFER: FunctionDef u32> = FunctionDef{address: 0x005349b0, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_file_version_info_size_a"))] - pub const GET_FILE_VERSION_INFO_SIZE_A: FunctionDef u32> = FunctionDef{address: 0x005357d6, function_type: PhantomData}; + pub const GET_FILE_VERSION_INFO_SIZE_A: FunctionDef i32> = FunctionDef{address: 0x005357d6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_file_version_info_a"))] - pub const GET_FILE_VERSION_INFO_A: FunctionDef bool> = FunctionDef{address: 0x005357dc, function_type: PhantomData}; + pub const GET_FILE_VERSION_INFO_A: FunctionDef bool> = FunctionDef{address: 0x005357dc, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/init_terrain_quality"))] pub const INIT_TERRAIN_QUALITY: FunctionDef = FunctionDef{address: 0x00536599, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/init_sound_quality"))] @@ -6224,7 +5865,7 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_dxversion"))] pub const GET_DXVERSION: FunctionDef u32> = FunctionDef{address: 0x00536bce, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/localtime"))] - pub const LOCALTIME: FunctionDef *const i32> = FunctionDef{address: 0x0053833a, function_type: PhantomData}; + pub const LOCALTIME: FunctionDef u32> = FunctionDef{address: 0x0053833a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/sinit_zt_cpp_0"))] pub const SINIT_ZT_CPP_0: FunctionDef = FunctionDef{address: 0x005784d3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/sinit_zt_cpp_1"))] @@ -6244,41 +5885,31 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_toggle_entity_tooltips"))] pub const SET_TOGGLE_ENTITY_TOOLTIPS: FunctionDef = FunctionDef{address: 0x0058b67d, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/force_update"))] - pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x0058c78e, function_type: PhantomData}; + pub const FORCE_UPDATE: FunctionDef = FunctionDef{address: 0x0058c78e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_avail"))] pub const SET_AVAIL: FunctionDef = FunctionDef{address: 0x0058fd9f, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_building_upgrade"))] - pub const SET_BUILDING_UPGRADE: FunctionDef u32> = FunctionDef{address: 0x0058feb7, function_type: PhantomData}; + pub const SET_BUILDING_UPGRADE: FunctionDef u32> = FunctionDef{address: 0x0058feb7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_startup"))] pub const HIDE_STARTUP: FunctionDef = FunctionDef{address: 0x0059274c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/is_zoo_wall"))] - pub const IS_ZOO_WALL: FunctionDef bool> = FunctionDef{address: 0x005947b2, function_type: PhantomData}; + pub const IS_ZOO_WALL: FunctionDef bool> = FunctionDef{address: 0x005947b2, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/is_zoo_gate"))] - pub const IS_ZOO_GATE: FunctionDef bool> = FunctionDef{address: 0x0059486c, function_type: PhantomData}; + pub const IS_ZOO_GATE: FunctionDef bool> = FunctionDef{address: 0x0059486c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_habitat_list"))] pub const CLICK_HABITAT_LIST: FunctionDef = FunctionDef{address: 0x00599ae7, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_family_characteristic"))] - pub const SET_FAMILY_CHARACTERISTIC: FunctionDef u32> = FunctionDef{address: 0x0059abd5, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_food_characteristic"))] - pub const SET_FOOD_CHARACTERISTIC: FunctionDef u32> = FunctionDef{address: 0x0059addb, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_entity_characteristic"))] - pub const SET_ENTITY_CHARACTERISTIC: FunctionDef u8> = FunctionDef{address: 0x0059af88, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_trick_available"))] - pub const SET_TRICK_AVAILABLE: FunctionDef u32> = FunctionDef{address: 0x0059b60a, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_effect_discount"))] pub const SET_EFFECT_DISCOUNT: FunctionDef u32> = FunctionDef{address: 0x0059b6b5, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_pause"))] pub const CLICK_PAUSE: FunctionDef = FunctionDef{address: 0x0059c7a4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/animalinfo_set_animal_dying"))] - pub const ANIMALINFO_SET_ANIMAL_DYING: FunctionDef = FunctionDef{address: 0x005a55f6, function_type: PhantomData}; + pub const ANIMALINFO_SET_ANIMAL_DYING: FunctionDef = FunctionDef{address: 0x005a55f6, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/flyingobject"))] - pub const FLYINGOBJECT: FunctionDef *const i32> = FunctionDef{address: 0x005a58ff, function_type: PhantomData}; + pub const FLYINGOBJECT: FunctionDef u32> = FunctionDef{address: 0x005a58ff, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/nullsub_28"))] pub const NULLSUB_28: FunctionDef = FunctionDef{address: 0x005aacaf, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_fullscreen"))] pub const SET_FULLSCREEN: FunctionDef = FunctionDef{address: 0x005ac651, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_depth"))] - pub const GET_DEPTH: FunctionDef i32> = FunctionDef{address: 0x005af19b, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_window"))] pub const SET_WINDOW: FunctionDef = FunctionDef{address: 0x005aff13, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_map_select"))] @@ -6288,9 +5919,9 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/check_name"))] pub const CHECK_NAME: FunctionDef = FunctionDef{address: 0x005b10f4, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/fast_error_exit"))] - pub const FAST_ERROR_EXIT: FunctionDef = FunctionDef{address: 0x005fcf1c, function_type: PhantomData}; + pub const FAST_ERROR_EXIT: FunctionDef = FunctionDef{address: 0x005fcf1c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/rtl_unwind"))] - pub const RTL_UNWIND: FunctionDef = FunctionDef{address: 0x005fd361, function_type: PhantomData}; + pub const RTL_UNWIND: FunctionDef = FunctionDef{address: 0x005fd361, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/george_w"))] pub const GEORGE_W: FunctionDef = FunctionDef{address: 0x00607174, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/colloseum"))] @@ -6302,17 +5933,11 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/permanentflyingobject"))] pub const PERMANENTFLYINGOBJECT: FunctionDef = FunctionDef{address: 0x00607a78, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/insert_one_q23std244_tree_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std73less_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_q23std78allocator_q23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc_frcq23std59basic_stringc_q23std14char_traitsc_q23std12allocatorc"))] - pub const INSERT_ONE_Q23STD244_TREE_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD78ALLOCATOR_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_FRCQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC: FunctionDef = FunctionDef{address: 0x00607ab7, function_type: PhantomData}; + pub const INSERT_ONE_Q23STD244_TREE_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD73LESS_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_Q23STD78ALLOCATOR_Q23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC_FRCQ23STD59BASIC_STRINGC_Q23STD14CHAR_TRAITSC_Q23STD12ALLOCATORC: FunctionDef = FunctionDef{address: 0x00607ab7, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/assign_if_positive"))] - pub const ASSIGN_IF_POSITIVE: FunctionDef = FunctionDef{address: 0x0060875c, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_cancel"))] - pub const CLICK_CANCEL: FunctionDef = FunctionDef{address: 0x0060b7d3, function_type: PhantomData}; + pub const ASSIGN_IF_POSITIVE: FunctionDef = FunctionDef{address: 0x0060875c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_download"))] pub const CLICK_DOWNLOAD: FunctionDef = FunctionDef{address: 0x0060b7f0, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_zoo_items"))] - pub const SHOW_ZOO_ITEMS: FunctionDef = FunctionDef{address: 0x0060baf0, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/hide_zoo_items"))] - pub const HIDE_ZOO_ITEMS: FunctionDef = FunctionDef{address: 0x0060baf8, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/download_completed"))] pub const DOWNLOAD_COMPLETED: FunctionDef = FunctionDef{address: 0x0060bb54, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_animal_list"))] @@ -6350,7 +5975,7 @@ pub mod standalone { #[cfg_attr(feature = "detour-validation", validate_detour("standalone/adjust_cash"))] pub const ADJUST_CASH: FunctionDef = FunctionDef{address: 0x00616b58, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/get_animal_unhappy_with_scenery_string"))] - pub const GET_ANIMAL_UNHAPPY_WITH_SCENERY_STRING: FunctionDef *const u32> = FunctionDef{address: 0x00616c3e, function_type: PhantomData}; + pub const GET_ANIMAL_UNHAPPY_WITH_SCENERY_STRING: FunctionDef u32> = FunctionDef{address: 0x00616c3e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/click_category_list"))] pub const CLICK_CATEGORY_LIST: FunctionDef = FunctionDef{address: 0x006173f3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/show_ncbuilding_info"))] @@ -6365,20 +5990,18 @@ pub mod standalone { pub const CLICK_ROTATE_LEFT_2: FunctionDef = FunctionDef{address: 0x00618c9c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/unclick_info_plaque"))] pub const UNCLICK_INFO_PLAQUE: FunctionDef = FunctionDef{address: 0x00618d57, function_type: PhantomData}; - #[cfg_attr(feature = "detour-validation", validate_detour("standalone/set_genus_characteristic"))] - pub const SET_GENUS_CHARACTERISTIC: FunctionDef u32> = FunctionDef{address: 0x00618d7c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/thread_download"))] - pub const THREAD_DOWNLOAD: FunctionDef bool> = FunctionDef{address: 0x0062671e, function_type: PhantomData}; + pub const THREAD_DOWNLOAD: FunctionDef bool> = FunctionDef{address: 0x0062671e, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/configure_keyboard_settings"))] pub const CONFIGURE_KEYBOARD_SETTINGS: FunctionDef = FunctionDef{address: 0x00629a38, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/exit_application_gracefully"))] pub const EXIT_APPLICATION_GRACEFULLY: FunctionDef = FunctionDef{address: 0x00629b1c, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/imm_release_context"))] - pub const IMM_RELEASE_CONTEXT: FunctionDef bool> = FunctionDef{address: 0x0062c7cd, function_type: PhantomData}; + pub const IMM_RELEASE_CONTEXT: FunctionDef bool> = FunctionDef{address: 0x0062c7cd, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/imm_notify_ime"))] - pub const IMM_NOTIFY_IME: FunctionDef bool> = FunctionDef{address: 0x0062c7d3, function_type: PhantomData}; + pub const IMM_NOTIFY_IME: FunctionDef bool> = FunctionDef{address: 0x0062c7d3, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/imm_get_open_status"))] - pub const IMM_GET_OPEN_STATUS: FunctionDef bool> = FunctionDef{address: 0x0062c7d9, function_type: PhantomData}; + pub const IMM_GET_OPEN_STATUS: FunctionDef bool> = FunctionDef{address: 0x0062c7d9, function_type: PhantomData}; #[cfg_attr(feature = "detour-validation", validate_detour("standalone/imm_get_context"))] - pub const IMM_GET_CONTEXT: FunctionDef *const u32> = FunctionDef{address: 0x0062c7df, function_type: PhantomData}; + pub const IMM_GET_CONTEXT: FunctionDef u32> = FunctionDef{address: 0x0062c7df, function_type: PhantomData}; } \ No newline at end of file diff --git a/openzt-detour/src/lib.rs b/openzt-detour/src/lib.rs index 98a791d..0a8a157 100644 --- a/openzt-detour/src/lib.rs +++ b/openzt-detour/src/lib.rs @@ -3,8 +3,7 @@ use std::marker::PhantomData; use retour::GenericDetour; pub mod generated; - -// pub mod structs; +pub mod structs; pub struct FunctionDef { pub address: u32, diff --git a/openzt/src/bfconfigfile.rs b/openzt/src/bfconfigfile.rs index eb66321..cf07209 100644 --- a/openzt/src/bfconfigfile.rs +++ b/openzt/src/bfconfigfile.rs @@ -1,7 +1,7 @@ //! `BFConfigFile` is the vanilla base class for anything that loads itself from a `.cfg`-style INI //! block via `getInt`/`getFloat`/`getString`/`getStringList` (e.g. `ZTResearchProgram`, -//! `ZTResearchCategory`, `ZTResearchBranch` - see `private/resources/decompiles/BFConfigFile_*` and -//! `private/resources/decompiles/ZTResearch*_load*`). Those classes inherit it directly (`this` gets cast +//! `ZTResearchCategory`, `ZTResearchBranch` - see `resources/decompiles/BFConfigFile_*` and +//! `resources/decompiles/ZTResearch*_load*`). Those classes inherit it directly (`this` gets cast //! straight to `BFConfigFile*` when calling its methods), so it occupies their first `0xc` bytes. //! //! Only the raw layout is modeled here, not `parse`/`getInt`/etc. themselves - callers that already @@ -9,7 +9,7 @@ use std::fmt; -/// Confirmed via `private/resources/decompiles/BFConfigFile_BFConfigFile.c`/`_attempt.c`/`_parse.c` and +/// Confirmed via `resources/decompiles/BFConfigFile_BFConfigFile.c`/`_attempt.c`/`_parse.c` and /// cross-checked against every `ZTResearch*::load*` function that inherits it. #[derive(Debug, Clone, Copy, Default)] #[repr(C)] diff --git a/openzt/src/bfentitytype.rs b/openzt/src/bfentitytype.rs index 70682bc..92dfe2c 100644 --- a/openzt/src/bfentitytype.rs +++ b/openzt/src/bfentitytype.rs @@ -80,9 +80,8 @@ pub struct BFEntityType { pub bf_config_file_ptr: u32, // 0x080 pad9: [u8; 0x098 - 0x084], // ----------------------- padding: 20 bytes pub zt_type: ZTBoundedString, // 0x098 - pub zt_sub_type: ZTBoundedString, // 0x0A4 - pad10: [u8; 0x0B4 - 0x0A8], // ----------------------- padding: 4 bytes - // pad10: [u8; 0x0B4 - 0x0B0], // ----------------------- padding: 4 bytes + pub zt_sub_type: ZTBoundedString, // 0x0A0 + pad10: [u8; 0x0B4 - 0x0A8], // ----------------------- padding: 12 bytes pub footprintx: i32, // 0x0B4 pub footprinty: i32, // 0x0B8 pub footprintz: i32, // 0x0BC @@ -93,6 +92,8 @@ pub struct BFEntityType { pad11: [u8; 0x100 - 0x0CD], // ----------------------- padding: 51 bytes } +const _: () = assert!(std::mem::size_of::() == 0x100); + impl BFEntityType { // returns the codename of the entity type pub fn get_codename(&self) -> String { @@ -766,6 +767,8 @@ pub struct BFUnitType { pad2: [u8; 0x144 - 0x138], // ----------------------- padding: 16 bytes } +const _: () = assert!(std::mem::size_of::() == 0x144); + impl EntityType for BFUnitType { fn print_config_integers(&self) -> String { format!( @@ -827,7 +830,29 @@ pub struct ZTUnitType { pub skip_trick_chance: i32, // 0x184 } +const _: () = assert!(std::mem::size_of::() == 0x188); + impl ZTUnitType { + /// Confirmed real vtable VA for `ZTUnitType` in zoo.exe (see `private/docs/vtables/ZTUnitType.md`). + /// `ZTUnitType` overrides `BFEntityType`'s `+0x1c` slot with a different function (confirmed by + /// the vtable diff docs), so fixtures must use this class's own vtable, not `BFEntityType`'s + /// - see `ztunit-ztanimal-footprint-crash-investigation.md`. + const VTABLE_PTR: u32 = 0x0062e404; + + /// Test-only fixture: a zero-filled `ZTUnitType` with a real vtable pointer, needed because + /// `ZTUnit::getFootprint` virtually dispatches through `entity_type`'s vtable (not its own) in + /// its `use_map_footprint=true` branch. `mem::zeroed()` is otherwise safe: every other field is + /// an integer/bool/byte-array. + pub fn new_for_test(footprint: IVec3, map_footprint: i32) -> Self { + let mut entity_type: ZTUnitType = unsafe { std::mem::zeroed() }; + entity_type.bfunit_type.bfentitytype.vtable = Self::VTABLE_PTR; + entity_type.bfunit_type.bfentitytype.footprintx = footprint.x; + entity_type.bfunit_type.bfentitytype.footprinty = footprint.y; + entity_type.bfunit_type.bfentitytype.footprintz = footprint.z; + entity_type.map_footprint = map_footprint; + entity_type + } + pub fn get_list_name(&self) -> String { let obj_ptr = self as *const ZTUnitType as u32; get_string_from_memory(get_from_memory::(obj_ptr + 0x168)) @@ -1141,6 +1166,8 @@ pub struct ZTAnimalType { pub egg_footprint: IVec3, // 0x410 } +const _: () = assert!(std::mem::size_of::() == 0x41c); + impl EntityType for ZTAnimalType { fn print_config_integers(&self) -> String { format!("{}\ncBoxFootprintX: {}\ncBoxFootprintY: {}\ncBoxFootprintZ: {}\ncFamily: {}\ncGenus: {}\ncHabitat: {}\ncLocation: {}\ncEra: {}\ncBreathThreshold: {}\ncBreathIncrement: {}\ncHungerThreshold: {}\ncHungryHealthChange: {}\ncHungerIncrement: {}\ncFoodUnitValue: {}\ncKeeperFoodUnitsEaten: {}\ncNeededFood: {}\ncNoFoodChange: {}\ncInitialHappiness: {}\ncMaxHits: {}\ncPctHits: {}\ncMaxEnergy: {}\ncMaxDirty: {}\ncMinDirty: {}\ncSickChange: {}\ncOtherAnimalSickChange: {}\ncSickChance: {}\ncSickRandomChance: {}\ncCrowd: {}\ncCrowdHappinessChange: {}\ncZapHappinessChange: {}\ncCaptivity: {}\ncReproductionChance: {}\ncReproductionInterval: {}\ncMatingType: {}\ncOffspring: {}\ncKeeperFrequency: {}\ncNotEnoughKeepersChange: {}\ncSocial: {}\ncHabitatSize: {}\ncNumberAnimalsMin: {}\ncNumberAnimalsMax: {}\ncNumberMinChange: {}\ncNumberMaxChange: {}\ncHabitatPreference: {}\ncBabyBornChange: {}\ncEnergyIncrement: {}\ncEnergyThreshold: {}\ncDirtyIncrement: {}\ncDirtyThreshold: {}\ncSickTime: {}\ncBabyToAdult: {}\ncOtherFood: {}\ncTreePref: {}\ncRockPref: {}\ncSpacePref: {}\ncElevationPref: {}\ncDepthMin: {}\ncDepthMax: {}\ncDepthChange: {}\ncSalinityChange: {}\ncSalinityHealthChange: {}\ncHappyReproduceThreshold: {}\ncBuildingUseChance: {}\ncNoMateChange: {}\ncTimeDeath: {}\ncDeathChance: {}\ncDirtChance: {}\ncWaterNeeded: {}\ncUnderwaterNeeded: {}\ncLandNeeded: {}\ncEnterWaterChance: {}\ncEnterTankChance: {}\ncEnterLandChance: {}\ncDrinkWaterChance: {}\ncChaseAnimalChance: {}\ncClimbsCliffs: {}\ncBashStrength: {}\ncAttractiveness: {}\ncKeeperFoodType: {}\ncIsClimber: {}\ncIsJumper: {}\ncSmallZoodoo: {}\ncDinoZoodoo: {}\ncGiantZoodoo: {}\ncIsSpecialAnimal: {}\ncNeedShelter: {}\ncNeedToys: {}\ncBabiesAttack: {}\n EggFootprintX: {}\ncEggFootprintY: {}\ncEggFootprintZ: {}\n", @@ -1252,6 +1279,25 @@ impl EntityType for ZTAnimalType { } } +impl ZTAnimalType { + /// Confirmed real vtable VA for `ZTAnimalType` in zoo.exe (see `private/docs/vtables/ZTAnimalType.md`). + /// See `ZTUnitType::VTABLE_PTR` for why the type's own vtable is required, not `BFEntityType`'s. + const VTABLE_PTR: u32 = 0x00630268; + + /// Test-only fixture, see `ZTUnitType::new_for_test`. + pub fn new_for_test(footprint: IVec3, map_footprint: i32, box_footprint: IVec3, egg_footprint: IVec3) -> Self { + let mut entity_type: ZTAnimalType = unsafe { std::mem::zeroed() }; + entity_type.ztunit_type.bfunit_type.bfentitytype.vtable = Self::VTABLE_PTR; + entity_type.ztunit_type.bfunit_type.bfentitytype.footprintx = footprint.x; + entity_type.ztunit_type.bfunit_type.bfentitytype.footprinty = footprint.y; + entity_type.ztunit_type.bfunit_type.bfentitytype.footprintz = footprint.z; + entity_type.ztunit_type.map_footprint = map_footprint; + entity_type.box_footprint = box_footprint; + entity_type.egg_footprint = egg_footprint; + entity_type + } +} + impl Deref for ZTAnimalType { type Target = ZTUnitType; @@ -2023,3 +2069,52 @@ pub fn command_make_sel(args: Vec<&str>) -> Result { Ok(format!("Entity type {} is now selectable", entity_type.bfentitytype.get_type_name())) } } + +#[cfg(test)] +mod tests { + use super::*; + + // Explicit list (not derived from the enum) so it visibly needs updating when a + // variant is added and the match arm in `FromStr` is forgotten. + const ZT_ENTITY_TYPE_CLASS_CASES: &[(ZTEntityTypeClass, &str)] = &[ + (ZTEntityTypeClass::Animal, "animal"), + (ZTEntityTypeClass::Ambient, "ambient"), + (ZTEntityTypeClass::Guest, "guest"), + (ZTEntityTypeClass::Fence, "fence"), + (ZTEntityTypeClass::TourGuide, "tourguide"), + (ZTEntityTypeClass::Building, "building"), + (ZTEntityTypeClass::Scenery, "scenery"), + (ZTEntityTypeClass::Food, "food"), + (ZTEntityTypeClass::TankFilter, "tankfilter"), + (ZTEntityTypeClass::Path, "path"), + (ZTEntityTypeClass::Rubble, "rubble"), + (ZTEntityTypeClass::TankWall, "tankwall"), + (ZTEntityTypeClass::Keeper, "keeper"), + (ZTEntityTypeClass::MaintenanceWorker, "maintenanceworker"), + (ZTEntityTypeClass::Drt, "drt"), + (ZTEntityTypeClass::BFOverlay, "bfoverlay"), + (ZTEntityTypeClass::BFUnit, "bfunit"), + (ZTEntityTypeClass::ZTUnit, "ztunit"), + (ZTEntityTypeClass::Staff, "staff"), + (ZTEntityTypeClass::BFEntity, "bfentity"), + ]; + + #[test] + fn test_zt_entity_type_class_from_str_round_trip() { + for (variant, s) in ZT_ENTITY_TYPE_CLASS_CASES { + assert_eq!(s.parse::().unwrap(), *variant, "failed to parse '{}'", s); + } + } + + #[test] + fn test_zt_entity_type_class_from_str_case_insensitive() { + assert_eq!("Animal".parse::().unwrap(), ZTEntityTypeClass::Animal); + assert_eq!("ANIMAL".parse::().unwrap(), ZTEntityTypeClass::Animal); + assert_eq!("aNiMaL".parse::().unwrap(), ZTEntityTypeClass::Animal); + } + + #[test] + fn test_zt_entity_type_class_from_str_unknown_is_err() { + assert!("not_a_real_entity_type_class".parse::().is_err()); + } +} diff --git a/openzt/src/reimplementation_tests/mod.rs b/openzt/src/reimplementation_tests/mod.rs index e9e57c8..b6062d0 100644 --- a/openzt/src/reimplementation_tests/mod.rs +++ b/openzt/src/reimplementation_tests/mod.rs @@ -17,9 +17,14 @@ mod io_redirect; pub fn init() { #[cfg(target_os = "windows")] { + #[cfg(feature = "tui")] + let tui_config: Option<&crate::tui_console::TuiConfig> = None; + #[cfg(not(feature = "tui"))] + let tui_config = None; + if let Err(e) = crate::logging::init_with_console( &crate::logging::LoggingConfig::default(), - #[cfg(feature = "tui")] None, + tui_config, ) { eprintln!("Failed to initialize logging: {}", e); } @@ -66,14 +71,19 @@ mod detour_zoo_main { #[cfg(target_os = "windows")] use openzt_detour::generated::bfapp::LOAD_LANG_DLLS; + use openzt_detour::generated::bfentity::GET_FOOTPRINT as BFENTITY_GET_FOOTPRINT; use openzt_detour::generated::bftile::GET_LOCAL_ELEVATION; + use openzt_detour::generated::ztanimal::GET_FOOTPRINT as ZTANIMAL_GET_FOOTPRINT; + use openzt_detour::generated::ztunit::GET_FOOTPRINT as ZTUNIT_GET_FOOTPRINT; + use openzt_detour::FunctionDef; use proptest::prelude::*; use tracing::{error, info}; use crate::{ + bfentitytype::{BFEntityType, ZTAnimalType, ZTUnitType}, ztmapview::BFTile, ztresearch::research_save_reimplementation::{self, live_support, SaveRecord}, - ztworldmgr::IVec3, + ztworldmgr::{BFEntity, IVec3, ZTAnimal, ZTUnit}, }; use super::io_redirect; @@ -206,7 +216,7 @@ mod detour_zoo_main { // TODO: Fix this so it works with a crate/mod prefix #[detour(LOAD_LANG_DLLS)] - unsafe extern "thiscall" fn detour_target(_this: *const u32) -> u32 { + unsafe extern "thiscall" fn detour_target(_this: u32) -> u32 { info!("Detour success"); // Read filepath from environment variable with default @@ -242,11 +252,13 @@ mod detour_zoo_main { let result = GET_LOCAL_ELEVATION.original()(&raw const tile as *const u32, &raw const pos as *const u32); assert_eq!( result, - reimplemented_result + 1, - "Failed for pos: {:?}, tile: {:?}, unknown_byte_2: {}", + reimplemented_result, + "Failed for pos: {:?}, tile: {:?}, unknown_byte_2: {}, real: {}, reimplemented: {}", pos, tile, - unknown_byte_2 + unknown_byte_2, + result, + reimplemented_result ); Ok(()) }) { @@ -256,7 +268,11 @@ mod detour_zoo_main { Err(e) => { error!("Proptest failed: {:?}", e); if let proptest::test_runner::TestError::Fail(r, (x, y)) = e { - let failure_line = format!("unknown_byte_2: {}, x: {}, y: {}\n", unknown_byte_2, x, y); + let pos = IVec3::new(x, y, 0); + let tile = BFTile::new(pos, unknown_byte_2); + let reimplemented_result = tile.get_local_elevation(pos); + let result = GET_LOCAL_ELEVATION.original()(&raw const tile as *const u32, &raw const pos as *const u32); + let failure_line = format!("unknown_byte_2: {}, x: {}, y: {}, real: {}, reimplemented: {}\n", unknown_byte_2, x, y, result, reimplemented_result); if let Some(ref mut log_file) = failure_log { if let Err(write_err) = log_file.write_all(failure_line.as_bytes()) { @@ -283,6 +299,10 @@ mod detour_zoo_main { } } + fail_flag |= run_bfentity_get_footprint_tests(&mut failure_log); + fail_flag |= run_ztunit_get_footprint_tests(&mut failure_log); + fail_flag |= run_ztanimal_get_footprint_tests(&mut failure_log); + // ZTRESEARCHMGR_SAVE: compares the real ZTResearchMgr::save's captured output against // research_save_reimplementation::serialize(&snapshot_mgr(mgr)) for generated synthetic trees. { @@ -383,8 +403,215 @@ mod detour_zoo_main { } if fail_flag { + error!("Proptest failed for some cases, check the failure log at: {}", failure_log_path); std::process::exit(1); } std::process::exit(0); } + + fn write_success_line(failure_log: &mut Option, test_name: &str) { + let success_line = format!("Test Passed {}\n", test_name); + if let Some(log_file) = failure_log { + if let Err(write_err) = log_file.write_all(success_line.as_bytes()) { + error!("Failed to write to failure log: {}", write_err); + } + } + } + + /// Calls the real GET_FOOTPRINT function at `entity_ptr` and reads the `IVec3` it writes back. + fn call_original_get_footprint( + original: FunctionDef *const u32>, + entity_ptr: *const u32, + use_map_footprint: bool, + ) -> IVec3 { + let mut result = IVec3::default(); + unsafe { + (original.original())(entity_ptr, &raw mut result as *const u32, use_map_footprint); + } + result + } + + fn run_bfentity_get_footprint_tests(failure_log: &mut Option) -> bool { + let runner_config = ProptestConfig { + failure_persistence: Some(Box::new(super::NoopFailurePersistence)), + ..ProptestConfig::default() + }; + let mut runner = proptest::test_runner::TestRunner::new(runner_config); + let test_name = "BFENTITY_GET_FOOTPRINT"; + let mut fail_flag = false; + + match runner.run( + &(-1000i32..1000i32, -1000i32..1000i32, -1000i32..1000i32, -8i32..8i32, proptest::bool::ANY), + |(fx, fy, fz, rotation, use_map_footprint)| { + let mut entity_type: BFEntityType = unsafe { std::mem::zeroed() }; + entity_type.footprintx = fx; + entity_type.footprinty = fy; + entity_type.footprintz = fz; + + let entity = BFEntity::new_for_test(&raw const entity_type as u32, rotation, 0); + + let reimplemented_result = entity.get_footprint(use_map_footprint); + let real_result = call_original_get_footprint(BFENTITY_GET_FOOTPRINT, &raw const entity as *const u32, use_map_footprint); + + assert_eq!( + (real_result.x, real_result.y, real_result.z), + (reimplemented_result.x, reimplemented_result.y, reimplemented_result.z), + "BFEntity::get_footprint mismatch: fx={}, fy={}, fz={}, rotation={}, use_map_footprint={}, real={:?}, reimplemented={:?}", + fx, fy, fz, rotation, use_map_footprint, real_result, reimplemented_result + ); + Ok(()) + }, + ) { + Ok(_) => { + info!("Proptest passed for {}", test_name); + write_success_line(failure_log, test_name); + } + Err(e) => { + error!("Proptest failed: {:?}", e); + if let proptest::test_runner::TestError::Fail(r, (fx, fy, fz, rotation, use_map_footprint)) = e { + let failure_line = format!( + "{}: fx={}, fy={}, fz={}, rotation={}, use_map_footprint={}, reason={}\n", + test_name, fx, fy, fz, rotation, use_map_footprint, r + ); + if let Some(log_file) = failure_log { + if let Err(write_err) = log_file.write_all(failure_line.as_bytes()) { + error!("Failed to write to failure log: {}", write_err); + } + } + fail_flag = true; + } + } + } + + fail_flag + } + + /// `ZTUnit::getFootprint`'s `use_map_footprint=true` branch virtual-dispatches through + /// `entity_type`'s vtable (not `this`'s own), so the fixture's `ZTUnitType` needs a real + /// vtable pointer - see `ZTUnitType::new_for_test` / `ztunit-ztanimal-footprint-crash-investigation.md`. + fn run_ztunit_get_footprint_tests(failure_log: &mut Option) -> bool { + let runner_config = ProptestConfig { + failure_persistence: Some(Box::new(super::NoopFailurePersistence)), + ..ProptestConfig::default() + }; + let mut runner = proptest::test_runner::TestRunner::new(runner_config); + let test_name = "ZTUNIT_GET_FOOTPRINT"; + let mut fail_flag = false; + + match runner.run( + &( + -1000i32..1000i32, + -1000i32..1000i32, + -1000i32..1000i32, + -1000i32..1000i32, + -8i32..8i32, + proptest::bool::ANY, + ), + |(fx, fy, fz, map_footprint, rotation, use_map_footprint)| { + let entity_type = ZTUnitType::new_for_test(IVec3::new(fx, fy, fz), map_footprint); + let entity = ZTUnit::new_for_test(&raw const entity_type as u32, rotation, 0); + + let reimplemented_result = entity.get_footprint(use_map_footprint); + let real_result = call_original_get_footprint(ZTUNIT_GET_FOOTPRINT, &raw const entity as *const u32, use_map_footprint); + + assert_eq!( + (real_result.x, real_result.y, real_result.z), + (reimplemented_result.x, reimplemented_result.y, reimplemented_result.z), + "ZTUnit::get_footprint mismatch: fx={}, fy={}, fz={}, map_footprint={}, rotation={}, use_map_footprint={}, real={:?}, reimplemented={:?}", + fx, fy, fz, map_footprint, rotation, use_map_footprint, real_result, reimplemented_result + ); + Ok(()) + }, + ) { + Ok(_) => { + info!("Proptest passed for {}", test_name); + write_success_line(failure_log, test_name); + } + Err(e) => { + error!("Proptest failed: {:?}", e); + if let proptest::test_runner::TestError::Fail(r, (fx, fy, fz, map_footprint, rotation, use_map_footprint)) = e { + let failure_line = format!( + "{}: fx={}, fy={}, fz={}, map_footprint={}, rotation={}, use_map_footprint={}, reason={}\n", + test_name, fx, fy, fz, map_footprint, rotation, use_map_footprint, r + ); + if let Some(log_file) = failure_log { + if let Err(write_err) = log_file.write_all(failure_line.as_bytes()) { + error!("Failed to write to failure log: {}", write_err); + } + } + fail_flag = true; + } + } + } + + fail_flag + } + + /// `ZTAnimal::getFootprint`'s `is_egg`/`is_boxed` branches virtual-dispatch through + /// `entity_type`'s vtable unconditionally (regardless of `use_map_footprint`) - same fixture + /// requirement as `ZTUnit` above. + fn run_ztanimal_get_footprint_tests(failure_log: &mut Option) -> bool { + let runner_config = ProptestConfig { + failure_persistence: Some(Box::new(super::NoopFailurePersistence)), + ..ProptestConfig::default() + }; + let mut runner = proptest::test_runner::TestRunner::new(runner_config); + let test_name = "ZTANIMAL_GET_FOOTPRINT"; + let mut fail_flag = false; + + match runner.run( + &( + (-1000i32..1000i32, -1000i32..1000i32, -1000i32..1000i32), + -1000i32..1000i32, + (-1000i32..1000i32, -1000i32..1000i32, -1000i32..1000i32), + (-1000i32..1000i32, -1000i32..1000i32, -1000i32..1000i32), + -8i32..8i32, + proptest::bool::ANY, + proptest::bool::ANY, + proptest::bool::ANY, + ), + |((fx, fy, fz), map_footprint, box_footprint, egg_footprint, rotation, use_map_footprint, is_egg, is_boxed)| { + let entity_type = ZTAnimalType::new_for_test( + IVec3::new(fx, fy, fz), + map_footprint, + IVec3::new(box_footprint.0, box_footprint.1, box_footprint.2), + IVec3::new(egg_footprint.0, egg_footprint.1, egg_footprint.2), + ); + let entity = ZTAnimal::new_for_test(&raw const entity_type as u32, rotation, 0, is_egg, is_boxed); + + let reimplemented_result = entity.get_footprint(use_map_footprint); + let real_result = call_original_get_footprint(ZTANIMAL_GET_FOOTPRINT, &raw const entity as *const u32, use_map_footprint); + + assert_eq!( + (real_result.x, real_result.y, real_result.z), + (reimplemented_result.x, reimplemented_result.y, reimplemented_result.z), + "ZTAnimal::get_footprint mismatch: is_egg={}, is_boxed={}, rotation={}, use_map_footprint={}, real={:?}, reimplemented={:?}", + is_egg, is_boxed, rotation, use_map_footprint, real_result, reimplemented_result + ); + Ok(()) + }, + ) { + Ok(_) => { + info!("Proptest passed for {}", test_name); + write_success_line(failure_log, test_name); + } + Err(e) => { + error!("Proptest failed: {:?}", e); + if let proptest::test_runner::TestError::Fail(r, ((fx, fy, fz), map_footprint, box_footprint, egg_footprint, rotation, use_map_footprint, is_egg, is_boxed)) = e { + let failure_line = format!( + "{}: fx={}, fy={}, fz={}, map_footprint={}, box_footprint={:?}, egg_footprint={:?}, rotation={}, use_map_footprint={}, is_egg={}, is_boxed={}, reason={}\n", + test_name, fx, fy, fz, map_footprint, box_footprint, egg_footprint, rotation, use_map_footprint, is_egg, is_boxed, r + ); + if let Some(log_file) = failure_log { + if let Err(write_err) = log_file.write_all(failure_line.as_bytes()) { + error!("Failed to write to failure log: {}", write_err); + } + } + fail_flag = true; + } + } + } + + fail_flag + } } diff --git a/openzt/src/zthabitatmgr.rs b/openzt/src/zthabitatmgr.rs index 7115f90..4560992 100644 --- a/openzt/src/zthabitatmgr.rs +++ b/openzt/src/zthabitatmgr.rs @@ -125,10 +125,15 @@ pub struct ZTHabitat { unknown_nt_time: FileTime, // 0x128 pad5: [u8; 0x24], // ----------------------- padding: 36 bytes exhibit_name: ZTBoundedString, // 0x154 - pad6: [u8; 0x28], // ----------------------- padding: 40 bytes - tank_height: u32, // 0x188 + pad6: [u8; 0x24], // ----------------------- padding: 36 bytes + tank_height: u32, // 0x184 // Actual structural tank height (ZTTankExhibit::getTankHeight/setTankHeight); not the field checkTankPlacement compares against, see water_level. + water_level: u32, // 0x188 // Current water level (ZTTankExhibit::getWaterLevel); this is what checkTankPlacement's height comparisons actually use. + pad7: [u8; 0xc], // ----------------------- padding: 12 bytes + is_filled: bool, // 0x198 // Set true by ZTTankExhibit::fill(), false by ZTTankExhibit::drain(). } +const _: () = assert!(std::mem::size_of::() == 0x198); + impl ZTHabitat { const TANK_VTABLE_PTR: u32 = 0x006312bc; pub fn get_gate_tile_in(&self) -> Option { diff --git a/openzt/src/ztmapview.rs b/openzt/src/ztmapview.rs index d4d01c9..c0be83d 100644 --- a/openzt/src/ztmapview.rs +++ b/openzt/src/ztmapview.rs @@ -218,7 +218,7 @@ impl BFTile { pub mod zoo_ztmapview { use tracing::{info, error}; - use crate::util::{get_from_memory, ref_from_memory}; + use crate::util::{get_from_memory, ref_from_memory, save_to_memory}; use crate::ztmapview::{BFTile, ZTMapView}; use crate::ztworldmgr::IVec3; use openzt_detour::generated::bftile::GET_LOCAL_ELEVATION; @@ -233,7 +233,7 @@ pub mod zoo_ztmapview { #[detour(CHECK_TANK_PLACEMENT)] // fn check_tank_placement(ZTMapView *other_this, BFEntity *param_2, BFTile *param_3, int *param_4) unsafe extern "stdcall" fn check_tank_placement(temp_entity_ptr: *const u32, tile: *const u32, response_ptr: *mut u32) -> bool { - let result = unsafe { CHECK_TANK_PLACEMENT_DETOUR.call(temp_entity_ptr, tile, response_ptr) }; + let _result = unsafe { CHECK_TANK_PLACEMENT_DETOUR.call(temp_entity_ptr, tile, response_ptr) }; // let entity = get_from_memory(temp_entity); @@ -247,17 +247,19 @@ pub mod zoo_ztmapview { if zt_result != reimplemented_result.clone() as u32 { error!("ZTMapView::checkTankPlacement mismatch between reimplementation and game result! Reimplementation: {:?}, Game: {:#x}", reimplemented_result, zt_result); } + + if !response_ptr.is_null() { + save_to_memory(response_ptr, reimplemented_result as u32); + } + false } Ok(()) => { if zt_result != 0 { error!("ZTMapView::checkTankPlacement mismatch: reimplementation returned Ok but game returned {:#x}", zt_result); } + true } } - - // info!("ZTMapView::checkTankPlacement {}, {:p} -> {:#x}", result, response_ptr, unsafe{*response_ptr}); - result - // true } // #[hook(unsafe extern "thiscall" BFUIMgr_display_message, offset = 0x0009ccc3)] @@ -329,7 +331,7 @@ impl ZTMapView { return Err(ErrorStringId::ObjectCannotBePlacedInTank); } - if scenery_entity_type.surface && *habitat.tank_height() < scenery_entity_type.depth { + if scenery_entity_type.surface && *habitat.water_level() < scenery_entity_type.depth { return Err(ErrorStringId::ObjectMustBePlacedInADeeperTank); } } @@ -342,12 +344,15 @@ impl ZTMapView { if *animal_entity.is_egg() && !animal_entity_type.underwater { return Err(ErrorStringId::EggsMustBePlacedOnLand); } - if *habitat.tank_height() < animal_entity_type.ztunit_type.bfunit_type.depth { + if *habitat.water_level() < animal_entity_type.ztunit_type.bfunit_type.depth { // TODO: Add an extra message for animals rather than objects return Err(ErrorStringId::ObjectMustBePlacedInADeeperTank); } // TankWithWater check; onlyUnderwater? - if animal_entity_type.underwater && *habitat.tank_height() < 1 { + if animal_entity_type.underwater + && !animal_entity.is_boxed() + && (!habitat.is_filled() || *habitat.water_level() < 1) + { return Err(ErrorStringId::AnimalMustBePlacedInATankWithWater); } } @@ -384,7 +389,7 @@ impl ZTMapView { let tile_entity_type_class = tile_entity.entity_type_class(); if zt_entity_type_class_is(&tile_entity_type_class, &ZTEntityTypeClass::Scenery) { let tile_scenery_type = unsafe { ref_from_memory::(*tile_entity.inner_class_ptr()) }; - if !tile_scenery_type.surface { + if tile_scenery_type.surface { // return Ok(()); // TODO: ZT doesn't set the error message code for this case, but does return false? return Err(ErrorStringId::UnknownError) diff --git a/openzt/src/ztresearch.rs b/openzt/src/ztresearch.rs index 9f6f870..1bdf74e 100644 --- a/openzt/src/ztresearch.rs +++ b/openzt/src/ztresearch.rs @@ -3,8 +3,8 @@ //! (e.g. "Animal Care") is currently working towards, tracking funding and progress, and applying a //! program's effect once it completes. //! -//! Field layouts below are derived from the decompiles in `private/resources/decompiles/ZTResearch*` and -//! `private/resources/decompiles/_forceResearch.c` / `_clickResearch.c`. Byte ranges with no decompiled +//! Field layouts below are derived from the decompiles in `resources/decompiles/ZTResearch*` and +//! `resources/decompiles/_forceResearch.c` / `_clickResearch.c`. Byte ranges with no decompiled //! evidence are left as `padN` placeholders. `ZTResearchMgr`'s layout is additionally confirmed by //! `openzt-detour/src/structs.rs` (size `0x18`). //! @@ -581,7 +581,7 @@ impl ZTResearchBranch { } /// The vanilla "$400 (Min)"-style formatted text for the *currently selected* funding level (per - /// `private/resources/decompiles/ZTResearchBranch_getFundingText.c`, this always uses + /// `resources/decompiles/ZTResearchBranch_getFundingText.c`, this always uses /// `current_funding_level` - there's no way to ask for an arbitrary level's text). Calls into the /// original implementation (money formatting + a `%s`-templated name) rather than reimplementing /// it, since it depends on an unconfirmed scale constant (`DAT_00635040`) that only matters if @@ -693,7 +693,7 @@ impl ZTResearchMgr { } /// Calls the vanilla `ZTResearchMgr::load` - the save-file counterpart to `save()`. Per - /// `private/resources/decompiles/ZTResearchMgr_load.c`/`.asm`, `load` always starts by resetting every + /// `resources/decompiles/ZTResearchMgr_load.c`/`.asm`, `load` always starts by resetting every /// branch's `current_funding_level` to `0`, every category's `enabled` to `1`, and calling /// `ZTResearchProgram::reset()` on every program (which itself zeroes `current_progress` and, for /// `UnlockEntity`/`BuildingUpgrade` effects, calls back into the building/entity managers) - @@ -739,7 +739,7 @@ impl fmt::Display for ZTResearchMgr { } /// Calls the vanilla standalone `forceResearch` cheat-console function - the one the in-game -/// "force research" cheat actually triggers, per `private/resources/decompiles/_forceResearch.c`. It calls +/// "force research" cheat actually triggers, per `resources/decompiles/_forceResearch.c`. It calls /// `ZTResearchMgr::forceResearch(GLOBAL_ZTResearchMgr, false)` (the `continue_program` flag is /// hardcoded `false` here - use `ZTResearchMgr::force_research` directly if you need `true`) and /// then notifies every `ZTWorldMgr` entity of the change, so the world/UI actually refreshes; plain @@ -2030,7 +2030,7 @@ mod research_config_reimplementation { /// Native reimplementation of `ZTResearchMgr::save`/`load`'s save-file persistence format - a small, /// self-describing stream of `(kind, id, value)` tuples capturing each branch's `current_funding_level`, /// each category's `enabled` flag, and each program's `current_progress`. Confirmed byte-for-byte from -/// `private/resources/decompiles/ZTResearchMgr_save.c` and cross-checked against `ZTResearchMgr_load.c`/`.asm`. +/// `resources/decompiles/ZTResearchMgr_save.c` and cross-checked against `ZTResearchMgr_load.c`/`.asm`. /// /// This is **shadow-mode only**: nothing here ever runs during real save/load (`ZTResearchMgr::save`/ /// `load` are not detoured), it exists purely to be exercised by the live proptest-vs-`.original()` diff --git a/openzt/src/ztworldmgr.rs b/openzt/src/ztworldmgr.rs index 51abb95..34f75ee 100644 --- a/openzt/src/ztworldmgr.rs +++ b/openzt/src/ztworldmgr.rs @@ -3,6 +3,7 @@ use itertools::Itertools; use num_enum::FromPrimitive; use openzt_detour_macro::detour_mod; use std::cmp::max; +use std::mem; use std::str::FromStr; use std::{collections::HashMap, fmt}; use tracing::{error, info}; @@ -161,6 +162,8 @@ pub struct BFEntity { // Full size is 0x154 bytes map_footprint: i32, // 0x150 } +const _: () = assert!(mem::size_of::() == 0x154); + impl fmt::Display for BFEntity { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( @@ -172,6 +175,16 @@ impl fmt::Display for BFEntity { } impl BFEntity { + /// Builds a zero-filled `BFEntity` for tests, with only the fields relevant to + /// pure (globals()-free) logic populated. Mirrors `BFTile::new` in `ztmapview.rs`. + pub fn new_for_test(inner_class_ptr: u32, rotation: i32, map_footprint: i32) -> Self { + let mut entity: BFEntity = unsafe { mem::zeroed() }; + entity.inner_class_ptr = inner_class_ptr; + entity.rotation = rotation; + entity.map_footprint = map_footprint; + entity + } + pub fn entity_type_class(&self) -> ZTEntityTypeClass { ZTEntityTypeClass::from(get_from_memory::(self.inner_class_ptr)) } @@ -267,10 +280,10 @@ impl BFEntity { // Check all tiles in a square of `radius` around the placement tile let world_mgr = globals().ztworldmgr(); - let x_min = tile.pos.x - radius as i32; - let x_max = tile.pos.x + radius as i32; - let y_min = tile.pos.y - radius as i32; - let y_max = tile.pos.y + radius as i32; + let x_min = tile.pos.x - radius; + let x_max = tile.pos.x + radius; + let y_min = tile.pos.y - radius; + let y_max = tile.pos.y + radius; for check_x in x_min..=x_max { for check_y in y_min..=y_max { @@ -299,6 +312,17 @@ pub(crate) struct BFUnit { padding: [u8; 0x214-0x154], // ----- padding: 192 bytes } +const _: () = assert!(mem::size_of::() == 0x214); + +impl BFUnit { + /// Test-only fixture, see `BFEntity::new_for_test`. + pub fn new_for_test(inner_class_ptr: u32, rotation: i32, map_footprint: i32) -> Self { + BFUnit { + base: BFEntity::new_for_test(inner_class_ptr, rotation, map_footprint), + padding: [0; 0x214 - 0x154], + } + } +} impl std::ops::Deref for BFUnit { type Target = BFEntity; @@ -321,7 +345,16 @@ pub(crate) struct ZTUnit { padding: [u8; 0x260-0x214], // ----- padding: 76 bytes } +const _: () = assert!(mem::size_of::() == 0x260); + impl ZTUnit { + /// Test-only fixture, see `BFEntity::new_for_test`. + pub fn new_for_test(inner_class_ptr: u32, rotation: i32, map_footprint: i32) -> Self { + ZTUnit { + base: BFUnit::new_for_test(inner_class_ptr, rotation, map_footprint), + padding: [0; 0x260 - 0x214], + } + } pub fn entity_type(&self) -> &'static ZTUnitType { unsafe { ref_from_memory(self.inner_class_ptr) } @@ -331,9 +364,10 @@ impl ZTUnit { if !use_map_footprint { self.base.get_footprint(use_map_footprint) } else { + let map_footprint = self.entity_type().map_footprint; IVec3 { - x: self.map_footprint as i32, - y: self.map_footprint as i32, + x: map_footprint, + y: map_footprint, z: 0, } } @@ -356,7 +390,7 @@ impl std::ops::DerefMut for ZTUnit { #[derive(Debug, Getters)] #[get = "pub"] #[repr(C)] -pub(crate) struct ZTAnimal { +pub(crate) struct ZTAnimal { // bytes: 0x3a8 = 936 bytes base: ZTUnit, // offset: 0x0000 _pad_0x0260: [u8; 300], food_tile: *const BFTile, // offset: 0x038c @@ -376,7 +410,18 @@ pub(crate) struct ZTAnimal { mbr_0x3b4: u8, // offset: 0x03b4 } +const _: () = assert!(mem::size_of::() == 0x3a8); + impl ZTAnimal { + /// Test-only fixture, see `BFEntity::new_for_test`. `mem::zeroed()` is safe here since + /// every field is an integer/bool/byte-array/raw-pointer, none of them references or niche types. + pub fn new_for_test(inner_class_ptr: u32, rotation: i32, map_footprint: i32, is_egg: bool, is_boxed: bool) -> Self { + let mut animal: ZTAnimal = unsafe { mem::zeroed() }; + animal.base = ZTUnit::new_for_test(inner_class_ptr, rotation, map_footprint); + animal.is_egg = is_egg; + animal.is_boxed = is_boxed; + animal + } pub fn entity_type(&self) -> &'static ZTAnimalType { unsafe { ref_from_memory(self.inner_class_ptr) } @@ -395,9 +440,9 @@ impl ZTAnimal { }; if self.rotation % 4 == 0 { - IVec3 { x: footprint.y, y: footprint.x, z: footprint.z } - } else { IVec3 { x: footprint.x, y: footprint.y, z: footprint.z } + } else { + IVec3 { x: footprint.y, y: footprint.x, z: footprint.z } } } } @@ -1298,3 +1343,201 @@ pub fn get_entity_type_by_id(id: u32) -> u32 { // struct BFMap { // padding: [u8; 0x5c], // } + +#[cfg(test)] +mod tests { + use super::*; + use crate::bfentitytype::BFEntityType; + + // Explicit list (not derived from the enum) so it visibly needs updating when a + // variant is added and the match arm in `FromStr` is forgotten. + const ZT_ENTITY_CLASS_CASES: &[(ZTEntityClass, &str)] = &[ + (ZTEntityClass::Food, "food"), + (ZTEntityClass::Path, "path"), + (ZTEntityClass::Fences, "fences"), + (ZTEntityClass::Building, "building"), + (ZTEntityClass::Animal, "animal"), + (ZTEntityClass::Guest, "guest"), + (ZTEntityClass::Scenery, "scenery"), + (ZTEntityClass::Keeper, "keeper"), + (ZTEntityClass::MaintenanceWorker, "maintenanceworker"), + (ZTEntityClass::TourGuide, "tourguide"), + (ZTEntityClass::Drt, "drt"), + (ZTEntityClass::Ambient, "ambient"), + (ZTEntityClass::Rubble, "rubble"), + (ZTEntityClass::TankWall, "tankwall"), + (ZTEntityClass::TankFilter, "tankfilter"), + ]; + + #[test] + fn test_zt_entity_class_from_str_round_trip() { + for (variant, s) in ZT_ENTITY_CLASS_CASES { + assert_eq!(s.parse::().unwrap(), *variant, "failed to parse '{}'", s); + } + } + + #[test] + fn test_zt_entity_class_from_str_case_insensitive() { + assert_eq!("Animal".parse::().unwrap(), ZTEntityClass::Animal); + assert_eq!("ANIMAL".parse::().unwrap(), ZTEntityClass::Animal); + assert_eq!("aNiMaL".parse::().unwrap(), ZTEntityClass::Animal); + } + + #[test] + fn test_zt_entity_class_from_str_unknown_is_err() { + assert!("not_a_real_entity_class".parse::().is_err()); + } + + fn entity_type_with_avoid_edges(avoid_edges: u32) -> BFEntityType { + let mut entity_type: BFEntityType = unsafe { mem::zeroed() }; + entity_type.avoid_edges = avoid_edges; + entity_type + } + + #[test] + fn test_check_avoid_edges_zero_always_false() { + let entity_type = entity_type_with_avoid_edges(0); + let entity = BFEntity::new_for_test(&entity_type as *const BFEntityType as u32, 0, 0); + + let mut tile = BFTile::new(IVec3::new(0, 0, 0), 0); + tile.north_fence = 1; + tile.east_fence = 1; + tile.south_fence = 1; + tile.west_fence = 1; + + assert!(!entity.check_avoid_edges(&tile), "avoid_edges == 0 should always return false, regardless of fence state"); + } + + #[test] + fn test_check_avoid_edges_radius_zero_no_fences() { + let entity_type = entity_type_with_avoid_edges(1); + let entity = BFEntity::new_for_test(&entity_type as *const BFEntityType as u32, 0, 0); + + let tile = BFTile::new(IVec3::new(0, 0, 0), 0); + + assert!(!entity.check_avoid_edges(&tile)); + } + + #[test] + fn test_check_avoid_edges_radius_zero_each_fence_direction_triggers() { + let entity_type = entity_type_with_avoid_edges(1); + let entity = BFEntity::new_for_test(&entity_type as *const BFEntityType as u32, 0, 0); + let pos = IVec3::new(0, 0, 0); + + let mut north = BFTile::new(pos, 0); + north.north_fence = 1; + assert!(entity.check_avoid_edges(&north), "north_fence alone should trigger avoid_edges"); + + let mut east = BFTile::new(pos, 0); + east.east_fence = 1; + assert!(entity.check_avoid_edges(&east), "east_fence alone should trigger avoid_edges"); + + let mut south = BFTile::new(pos, 0); + south.south_fence = 1; + assert!(entity.check_avoid_edges(&south), "south_fence alone should trigger avoid_edges"); + + let mut west = BFTile::new(pos, 0); + west.west_fence = 1; + assert!(entity.check_avoid_edges(&west), "west_fence alone should trigger avoid_edges"); + } + + // ZTUnit/ZTAnimal::get_footprint internal-consistency tests. + // + // These pin down our own reimplementation's branch behavior. Most of them can't be compared + // against `.original()` directly (unlike BFEntity's equivalent, see reimplementation_tests/mod.rs) + // because ZTAnimal's is_egg/is_boxed branches unconditionally virtual-dispatch through + // entity_type's vtable; see ztunit-ztanimal-footprint-crash-investigation.md for the confirmed + // root cause and the entity_type fixtures' real vtable pointer. + + fn entity_type_with_footprint(x: i32, y: i32, z: i32) -> BFEntityType { + let mut entity_type: BFEntityType = unsafe { mem::zeroed() }; + entity_type.footprintx = x; + entity_type.footprinty = y; + entity_type.footprintz = z; + entity_type + } + + #[test] + fn test_ztunit_get_footprint_map_footprint_ignores_rotation() { + let entity_type = ZTUnitType::new_for_test(IVec3::default(), 42); + for rotation in [-8, -3, -1, 0, 1, 3, 4, 8] { + let entity = ZTUnit::new_for_test(&entity_type as *const ZTUnitType as u32, rotation, 0); + let footprint = entity.get_footprint(true); + assert_eq!( + (footprint.x, footprint.y, footprint.z), + (42, 42, 0), + "use_map_footprint=true should return {{map_footprint, map_footprint, 0}} regardless of rotation ({})", + rotation + ); + } + } + + #[test] + fn test_ztunit_get_footprint_delegates_to_base_when_not_using_map_footprint() { + let entity_type = entity_type_with_footprint(5, 7, 9); + + let unrotated = ZTUnit::new_for_test(&entity_type as *const BFEntityType as u32, 0, 42); + let footprint = unrotated.get_footprint(false); + assert_eq!((footprint.x, footprint.y, footprint.z), (5, 7, 9)); + + let rotated = ZTUnit::new_for_test(&entity_type as *const BFEntityType as u32, 1, 42); + let footprint = rotated.get_footprint(false); + assert_eq!((footprint.x, footprint.y, footprint.z), (7, 5, 9), "odd rotation should swap x/y, matching BFEntity::get_footprint"); + } + + fn animal_type_with_footprints(egg: IVec3, boxed: IVec3) -> ZTAnimalType { + let mut entity_type: ZTAnimalType = unsafe { mem::zeroed() }; + entity_type.egg_footprint = egg; + entity_type.box_footprint = boxed; + entity_type + } + + #[test] + fn test_ztanimal_get_footprint_delegates_to_base_when_not_egg_or_boxed() { + let entity_type = entity_type_with_footprint(5, 7, 9); + let entity = ZTAnimal::new_for_test(&entity_type as *const BFEntityType as u32, 1, 0, false, false); + + let footprint = entity.get_footprint(false); + assert_eq!( + (footprint.x, footprint.y, footprint.z), + (7, 5, 9), + "is_egg=false, is_boxed=false should delegate through ZTUnit/BFEntity::get_footprint" + ); + } + + #[test] + fn test_ztanimal_get_footprint_egg_uses_egg_footprint_with_rotation_swap() { + let entity_type = animal_type_with_footprints(IVec3::new(11, 22, 33), IVec3::new(99, 98, 97)); + + // Same swap direction as BFEntity::get_footprint's: rotation % 4 == 0 leaves x/y unswapped, + // any other rotation swaps them. Confirmed live against the real ZTAnimal::getFootprint - + // see ztunit-ztanimal-footprint-crash-investigation.md. + let unrotated = ZTAnimal::new_for_test(&entity_type as *const ZTAnimalType as u32, 0, 0, true, false); + let footprint = unrotated.get_footprint(false); + assert_eq!((footprint.x, footprint.y, footprint.z), (11, 22, 33)); + + let rotated = ZTAnimal::new_for_test(&entity_type as *const ZTAnimalType as u32, 1, 0, true, false); + let footprint = rotated.get_footprint(false); + assert_eq!((footprint.x, footprint.y, footprint.z), (22, 11, 33)); + } + + #[test] + fn test_ztanimal_get_footprint_boxed_uses_box_footprint() { + let entity_type = animal_type_with_footprints(IVec3::new(11, 22, 33), IVec3::new(99, 98, 97)); + + let entity = ZTAnimal::new_for_test(&entity_type as *const ZTAnimalType as u32, 0, 0, false, true); + let footprint = entity.get_footprint(false); + assert_eq!((footprint.x, footprint.y, footprint.z), (99, 98, 97)); + } + + #[test] + fn test_ztanimal_get_footprint_egg_and_boxed_prefers_egg() { + // Deliberate tie-break: the code checks `is_egg` before `is_boxed`, so when both are set + // egg_footprint wins. Distinct egg/box values here make a regression to box_footprint visible. + let entity_type = animal_type_with_footprints(IVec3::new(11, 22, 33), IVec3::new(99, 98, 97)); + + let entity = ZTAnimal::new_for_test(&entity_type as *const ZTAnimalType as u32, 0, 0, true, true); + let footprint = entity.get_footprint(false); + assert_eq!((footprint.x, footprint.y, footprint.z), (11, 22, 33), "is_egg=true, is_boxed=true should prefer egg_footprint"); + } +} From 299452c1fbf6ce781a41ebed74563d8ed265be82 Mon Sep 17 00:00:00 2001 From: Finn Hartshorn Date: Wed, 19 Aug 2026 09:29:42 +1000 Subject: [PATCH 7/7] Re-enable experimental::init()'s detour registration Another artifact of the stale original tip: init() called zoo_experimental::init_detours() on main, but the wholesale copy carried a commented-out version that silently disabled every experimental detour, including the pre-existing DISPLAY_MESSAGE_0 hook main already had active - not something detour-testing ever intended to ship disabled. --- openzt/src/experimental.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/openzt/src/experimental.rs b/openzt/src/experimental.rs index a007caf..908a413 100644 --- a/openzt/src/experimental.rs +++ b/openzt/src/experimental.rs @@ -80,7 +80,7 @@ pub mod zoo_experimental { } pub fn init() { - // if let Err(e) = unsafe { zoo_experimental::init_detours() } { - // info!("Error initialising experimental detours: {}", e); - // }; + if let Err(e) = unsafe { zoo_experimental::init_detours() } { + info!("Error initialising experimental detours: {}", e); + }; }