One folder, one concept, named after it. src/votv-coop/src/ holds the implementation and
src/votv-coop/include/ the headers, in the same layout. Paths below are relative to
src/votv-coop/src/; a name without an extension is a .cpp/.h pair.
| Layer | Folder | Owns | Never contains |
|---|---|---|---|
| gameplay and network | coop/ |
elements, sync lanes, sessions, players, the wire protocol | reflection or engine-memory access (it goes through ue_wrap/) |
| what the player sees | ui/ |
the menus, the server browser, the HUD, the F1 overlay | network state |
| the player's language | l10n/ |
the catalogues of the mod's own text, the lookups, the formatter | anything of coop/ or ui/ (they call it) |
| boot glue and tests | harness/ |
the scenario runner and the scripted test scenarios | gameplay logic |
| engine wrapper | ue_wrap/ |
reflection, signatures, hooks, the game-thread pump, one wrapper per engine or game class | network, gameplay or co-op state |
| the loader contract | loader/, bootstrap/ |
start_mod() as UE4SS calls it, DllMain, the refuse dialog |
everything else |
| Folder | Concept | Key files |
|---|---|---|
coop/net/ |
transport, sessions, admission, the wire protocol | protocol.h (every message kind and the build number), session (GameNetworkingSockets host and client, four peers, the lanes) with session_streams (the unreliable per-tick streams), stream_slot + remote_streams (what a peer keeps of each stream it receives: the newest value behind a sequence latch, grouped by the owner whose edge resets it) and outbound_streams (what it sends, reset whole at a session's start), eid_pose_lane (the host-originated pose lanes keyed by element id, the send queue and the receive merge) and session_* send helpers, session_start (LAN or P2P entry), session_serial (a serial per session start), signaling_client + ice_config (NAT traversal through the master server) with signaling_proof (the Ed25519 answer to the relay's registration challenge, its own file because the bytes are a contract with the relay and the release gate), lobby_client + lobby_announcer (the server browser's list) with master_slots (which masters there are and which one is chosen), peer_identity + identity_key_file + identity_crypto + peer_admission + lobby_password (the Ed25519 identity, its key file and the primitives under both, the mutual challenge, the password), connect_history (the per-source history primitive, one instance for the connection cap and one for the password-guess bound), intent_bucket (a client's budget of intents on the host, one per sender slot), latest_wins (a client's changes of one display state on the host, applied at a pace with the newest kept), end_reason (the stable code a close carries), send_backlog (a reliable send is delivered or the connection dies), blob_chunks (large transfers), http_client |
coop/dispatch/ |
routing of reliable messages | event_feed drains and dispatches; event_dispatch_entity, _state, _signal, _intent, _economy, _prop_drive, _world, _container_act are the eight family routers, each owning its message kinds |
coop/session/ |
the per-tick orchestrator and the join | net_pump (connect and disconnect edges, announcements) with net_pump_world_ready (the client's world-ready announce), session_manager, player_handshake with _version (the game+build gate), _nick, _prefs, _roster (the Join and PlayerJoined messages), join_seed, join_progress, world_load_episode with save_replay_watch (the by-name watch on the world's save replay), host_mode, pause_guard (no pause while connected), shutdown, teleport_client, subsystems, world_ready_answer (the host's answer to a client's ClientWorldReady: first completes the join, a repeat flood is rate-capped then ended), local_grants (this machine's local dev grants) and grants_sync (their projection from the host, kind 168) |
coop/element/ |
entity identity and lifecycle: the one owner of eid to actor | registry, element, mirror_manager + mirror_managers, identity_create (create-or-adopt a mirror), identity_destroy (retire one), element_deleter (deferred destroy), death_seam (an element's end of play, or a subscribed class's, announced once to the lanes that subscribed), portable_identity (a name both peers compute for an actor the save does not key), intent_authority, object_scan_hub (the one pass over the object index that every index consumer rides), quiescence_drain, mirror_defer, bind_wait (the one hold for a message whose prop has no actor yet: a drive row, a slot line, a rack canonical, a lid line, a floppy box canonical, a container slice, a Kerfus state), lerp_window, and the element kinds prop, npc, player, world_actor |
coop/player/ |
remote players and per-player state | remote_player + remote_player_ragdoll, puppet_drive, puppet_carry_drive, puppet_body_yaw, puppet_footsteps (driving the engine pawn), players_registry, player_profile_store (the host's copy of every player's profile: held in memory, cut to disk with the world save), roster + roster_ledger (who is in each slot), nickname_arbiter, nick_color, nameplate, hand_item (the item in a player's hand, shown on every peer; a client's launcher shot waits for its own announce of it) + hand_history (what each slot held in its hand and when: the ring the host judges a shot or a hand blast against), local_body, local_streams, client_model + skin_registry + skin_preview + skin_effects (skins), movement_ledger, player_damage + player_hit (a puppet's hit verbs refused; a parked creature's hit delivered to its peer), hit_judge (the host's judge of a swing a peer says it made), hit_intent (a client's hit on an entity the host owns, sent as an intent and judged by the host), death_revive + run_end_travel (a trip to the menu the player did not ask for is refused and answered with a revive), revive_protection (the game's own spawn invulnerability, held for its 5 s after a revive and ended by the player's melee swing), ragdoll_gate, sleep_sync + sleep_rest (who rests; a client's rest at the game's native rate), item_activate, flashlight_click_sound, stat_orders (an admin's order to, and query of, one player's stats and effects) + stat_orders_wire (their bytes, their checks, and the table of the ones awaiting an answer) |
coop/props/ |
physics props, piles and trash | prop_lifecycle (the destroy seam), prop_damage_gate (a client never decides the damage of a prop it does not author), hit_target_prop (a prop the host owns as the target of a client's hit), bracket_position_wait (inside the snapshot bracket a position bind waits, and the bracket's end matches nearest first), prop_snapshot + snapshot_census (the connect snapshot), remote_prop with _spawn, _convert, _physics, _destroy (the receivers), host_spawn_watcher, prop_key_index (every live keyed prop by key, for a key on the wire; its key reads are ue_wrap/actors/prop_keys) + prop_tracked_keys (the props this peer tracks by key), prop_synth_key, save_identity_bind + save_identity_map (bind save-loaded actors to host eids in the join window), pile_spawn_bind, trash_mirror (the client's mirror of either trash form, the game's own actor parked), trash_morph_gate (the verbs a client refuses so it never authors a transition), trash_native_hold (the one recipe that parks a trash body the host authors, and the catch that holds a joiner's save-loaded clumps at their spawn), trash_sweep (the clumps a broom stroke sets rolling: their ids at birth, a carry nobody holds, the roll), trash_channel, trash_grab_intent, trash_collect_sync, trash_pile_sync, trash_use_intercept, trash_clump_pose_stream, prop_drop_intent, prop_spawn_authoring (did a PLAYER's spawn verb author this birth, or the world's own churn -- the fact the drop-intent seam admits a catalog spawn on), prop_save_data (each prop's own save record, by Key), prop_stick_sync, container_contents_sync (a world container slice: the host publishes it, and takes a client's only as a thrown container's birth) + container_contents_publish (its host-to-peers half: the dirty drain, the broadcast, the relay) + container_arming (whether a container's overlap box is armed: the host's physical read, the hook that catches a change, the mirror's box) + container_writer_watch (the edge: a write to a container's inventory becomes a dirty mark) + container_truth (the host's truth sent back to a client slot whose slice it refused, and the bound on it) + container_contents_io (the raw read and write of one inventory's records) + container_reach (the container, or an actor that opens it, within the reach) + container_park (the readiness pen for a slice whose container is here but not ready; a slice for a container with no actor waits in bind_wait) + container_apply_hold (dev only: a container's completed slices kept in arrival order, then replayed) + container_birth (a container that changes hands through the world: the thrower's slice, the host's awaited copy, the host's bound on a client's arrivals) + container_view_close (a player's view into a container ends where the player's reach does), grab_observer, registry_reaper, join_membership_sweep, unresolved_pose_ledger, prop_echo_suppress, prop_wire_parity, prop_census, prop_destroy_seam, prop_fresh_spawn, prop_element_tracker, prop_sound, active_drive |
coop/creatures/ |
NPCs and creatures | npc_sync + npc_sync_install (the spawn seam), npc_mirror, creature_hit (what a creature is, for a hit on a player), hit_target_creature (a parked creature as the target of a client's hit), npc_mirror_brain (a parked family's mirror runs none of its Blueprint graph but the entries a table allows, the Octa's table all but its twelve decisions: the mark, the graph watches, and the tables), npc_adoption, npc_pose_host, npc_pose_drive, npc_world_enum, kerfur_convert with _host and _client, kerfur_entity, kerfur_reconcile, kerfur_prop_adoption, kerfur_command, kerfur_menu_input, kerfur_form_assembler (the prop-to-NPC conversion cycle), owner_entity_sync (creatures whose AI reads the local player: owned per peer, visible to all), piramid_sync, geom_octa_sync (the Geom Octa's host decisions, sent as GeomOctaEvent, and the [OCTA] lines each peer prints) + geom_octa_relay (a client's half: the Aggro replayed, the refused fire-finish answered with the newest verdict, the answer written into one overlap read), roach_sync, wisp_attack_sync, wisp_grab_hold, wisp_tear_mirror |
coop/interactables/ |
keyed device state | doors, lights, light groups, containers, garage, appliances, lockers: interactable_sync + interactable_channel; cord_sync + cord_sync_watch + cord_sync_sockets (a cord's link to its socket: the host decides, a client claims the plug its player made; the level sockets by key, read once per world); keypad_sync + keypad_verbs, verb_lanes (the lanes on a device's own verbs at the script gate, wired in one place), toggle_verbs (a symmetric device's state at the verb that writes it), window_sync, grime_sync, turbine_sync, drone_sync, device_occupancy, notebook_sync (the notebook editor's close and its text on the prop record lane), garbage_sync. The signal workstation: signal_sync, signal_catch_sync, signal_wire, dish_sync, dish_calib_sync, download_arm_sync (the download's arm and reset, the host's), desk_input_sync, desk_sim_sync, desk_ping_sync (the ping's verdict, rolled on the host), desk_verb_intent and desk_verb_effects (the desk's save-family presses, run by the host, their gloss, stat and sounds sent to the presser), desk_cursor_sync, desk_snd_fx, deck_play_sync, comp_sync (the refiner's decode, the host's), console_state_sync, drive_sync, drive_payload_sync (a drive's row, the host's), eraser_press_intent (the eraser's delete, run by the host), drive_rack_sync, tape_caddy_sync, physmods_sync, serverbox_sync, server_upgrade_sync (a server box's physical upgrades), sat_console_sync and sat_console_table (the SAT console's shared commands, run on a terminal the host keeps for each typist, and which command runs where), laptop_sync, laptop_tab (the tab the PC's user is on, shown on every peer), portable_pc_lid (the portable PC's lid, on its own verb), swinger_join_pose (an open lid's rest place, sent to a joiner), laptop_buffer_sync, floppybox_sync, floppy_slot_sync and floppy_slot_entry (a device's disc slot: the state, and which overlap into it counts as an insert), meadow_db_sync, meadow_db_writers, meadow_db_join, meadow_db_park and meadow_db_hash (the laptop's signal database, the bodies that write it, a joiner's seed of it, its inbound lines that cannot apply yet, and the database as content hashes). The ATV: atv_sync, atv_stream_gates (the stream's per-block gates: the trap bit stamped and taken, the explosion re-arm, the idle syncer's change gate), atv_authority (the host's table of who sits in and who syncs each ATV, and its judgements), atv_body (this machine's own seat and carry against that table, the requests it sends and the yields), atv_index (which actor is which wire key, and a runtime ATV's game key), atv_runtime_mirror (a client's mirror of a runtime ATV, its spawn and destroy), atv_spawn_park (a runtime ATV's spawn held until its world is ready), atv_corrector, atv_hit_guard, atv_damage_gate (the script-gate watches that stop a non-owner copy's ATV damage and death), atv_condition_sync |
coop/world/ |
global and ambient state | time_sync, sky_sync, weather_sync with weather_rain, weather_fog, weather_lightning, weather_redsky, weather_badsun, weather_event_births, firefly_sync, spawn_authority (shared-world spawners run on the host only), event_fire_sync + event_fire_policy (which received fire a client replays), event_active_sync, creature_event_relay (the host's creature events in a client's event count), event_cue_sync, alarm_sync, balance_sync, email_sync, daily_task_sync, power_grid (the generators run on the host) + power_decay (their wear dice) + power_puzzle (their repair puzzles) + power_upgrade (the upgrades an install spent) + power_panel (the panel's one author), world_actor_sync + world_actor_mirror, explosion_sync (the host's explosions on every client: a client dissolves its own game's explosion births, asks the host for the one its own player caused, and spawns the host's copy) + explosion_parking (what a client copy may still move: its own player's damage and knock-back, the scorch, and the blast verbs of an ATV it owns) + explosion_request with _client (the launchers' fire bodies watched, the shots and requests sent), _host (each judged, the blast spawned natively), _atv (a client's ATV explosion, judged against the ATV's syncer and spawned at its tp) and _internal (the queues, budgets and counters they share) + explosion_recipe (the wire's values and what each explosion source blasts with), salt_rocket_flight (a lit salt rocket's flight, claimed on the drive channel from its fuse to its blast), salt_rocket_ignite with _host (a client's light on a salt rocket, refused at home and performed on the host) |
coop/items/ |
inventory, the economy, and the deployed items | player_inventory_sync + inventory_wire, inventory_pickup_sync, order_sync (shop orders: the client names the row, the host performs and prices it) + order_queue_sync (the host's delivery queue mirrored on the clients) + order_rows (an order's items on the wire), coingun_sync + coingun_arbiter + coingun_collect (the sell gun and its coins), save_record_wire, hook_sync + hook_anchor + hook_prop_claim + hook_constraint (the grappling hook and the rope: the owner's stream and the mirrors, the anchor handoff, the props its ties claim, and the tie itself, which lives on the host), broom_stroke + broom_push (the broom: every stroke is the host's, a client's queued with what it read of its holder, and what a stroke pushes or knocks out of a dispenser streams) |
coop/comms/ |
text chat | chat_sync, chat_rate (how fast a client may speak, judged on the host: Source's interval and two-tier bucket), chat_feed, chat_bubbles, chat_log, chat_nick_color, peer_action_feed |
coop/commands/ |
commands typed in chat, run on the host | command_line (splits a line), command_targets (who a word names), command_registry (the commands and their nodes), command_dispatcher (one line to one verb), command_args (an argument word's parsers: a whole number, true or false, a duration), action_source (who an admin action is recorded as), command_sync (the transport: the chat route, the two wire kinds, the player record), moderation_commands (/kick, /ban, /banid, /unban, /tphere: the handlers call the moderation verbs through ports), settings_commands (/set, /reset: a server setting named by its key, through ports onto the config setters), mv_commands (/mv: the permission store edited in game, LuckPerms' /lp shape), mv_info (the lines of info and listgroups) |
coop/voice/ |
voice chat | voice_capture, voice_chat, voice_playback (Opus, 3D positional) |
coop/moderation/ |
kick, and bans by player id and address | moderation, ban_list, seen_players |
coop/permissions/ |
who may ask the host for what (LuckPerms' model) | context_set, node + node_map (a holder's nodes), model + inheritance (users, groups, parents), resolution (a player's resolved answers), permission_files (the store's files: read, loaded, written one holder at a time), permission_edit (an edit of one holder, planned through the loader), action_log (the action log's record and its writer), permission_host (the hosted server's live model), grants_core (the projected table and its rules) |
coop/save/ |
the host owns the save | save_transfer (streams the host's world to a joiner), slot_file_read (a slot file read once it holds still), save_guard, save_block, save_button_disable, save_indicator_suppress |
coop/server_profile/ |
the server a host runs, as a folder in the mod's data folder | server_profile (a server's id, the hosted server's folder, its creation at a host start) |
coop/game_build/ |
which game build this process runs, and what it means for this Multivoid | game_build (the target, a known newer or older build, or one no row names; the [dev] game_build_force drill arm; the popup's remembered answer; the key the Join and the lobby carry), last_builds.inc (the last Multivoid build for each game version left behind) |
coop/text/ |
text encoding and names | utf8_codec (the one owner of encoding and decoding), repertoire + repertoire_ranges (what this build can draw), case_fold, mark_ranges, ignorable_ranges, exclude_ranges, novelty_ledger |
coop/config/ |
the ini | config, config_registry + config_registry_rows (every key is a registered row with a description), config_ini_read (the ini file reader), config_ini_write, config_review, config_selftest |
coop/atomic_file/ |
a file written whole: beside itself, flushed, moved in one step | atomic_file (the writer and its selftest) |
coop/mod_data/ |
the mod's own data folder, seen from the exe folder it left | legacy_note (one notice per file an older build kept beside the exe, and the warning for a session with no data folder) |
coop/input/ |
who owns the keyboard | input_owner (the game, a text field, or the overlay), game_window_proc (the one subclass of the game window and the order its messages travel) |
coop/dev/ |
developer features and probes, ini-gated, off by default | freecam, pos_hud, set_clock, spawn_npc, force_weather, event_force, event_trigger, the *_probe, *_watch and *_selftest instruments and the *_drill drivers, perf_probe, atv_seat (the player seated in an ATV through the game's own seat verb, for a drill that needs a driver), explosion_drill with _host, _client, _request, _request_host, _source, _source_verbs, _source_measure and _witch (the explosion lanes' arms; the witch car's seated shot), hostile_drill_explosion with _client and _host (a client's forged shots and blasts, and the host's refusal of each), hostile_drill_ignite with _client and _host (a client's forged lights on a salt rocket), hostile_drill_cord with _client and _host (a client's forged cord link claims, and the host's count of each outcome), hostile_drill_coffee with _client and _host (a client's forged coffee presses and maker record, and the host's count of each outcome), hostile_drill_atv with _client and _host (a client's raw ATV state, seat, takeover and blast-request messages, phase by phase, and the host's refusal of each by its counters), atv_spawn_near (the host spawns an ATV at a NavMesh point and reads its key; shared by the ATV health drill's spawned and _peers arms and the hostile atv_ family), hostile_drill_arms (the hostile drill's arm table and family routes), fire_ignite_drill (a salt rocket lit by a client and by the host, watched in flight), cord_drill with _cast, _hand, _host and _client (cords plugged, dragged and held through the players' own verbs on both peers, each arm judged by the host's word), cord_pos_drill with _host and _client (three corded coffee makers plugged on ledges as a joiner becomes world-ready; the joiner's hidden copies judged against the host's rest) [?], atv_health_drill with _arms, _host, _seated, _damage, _spawned and _peers (a client sits in, grabs or goes silent on the ATV the host spawns (the world's own for the story-event trap), or the host itself sits in or grabs it and the client's raw request is refused; the host judges its table, the at-rest hand-back and the silence rule; _seated is the client walk-and-sit both client halves share; the damage arms: the host's blast cancelled on its copy and run on the seated client's, the client's kill accepted once and marked blown, the host's trap fired on the client's copy; _spawned: the host spawns its own ATV beside the players and the client times its table showing it, then walks to it and sits, and holds the host spawn step the other arms reuse; _peers: four arms on a host-spawned ATV, a carried ATV standing still is not handed back, a second client's grab of a carried ATV is refused, a peer joining under a seated client takes the seat from its snapshot, a syncer's burst of blocks is paced, with slot 2 as an observer), drill_chat (the drills' lobby-chat lines), drill_hold (a bool switch of the game held true for an arm's span and put back; the explosion drill's guard and the Octa drill's), octa_drill with _host and _births + octa_probe (the Geom Octa: the gamemode's spawn enrolled and mirrored, its liveness measured, the relayed attack judged on the client, and a joiner's snapshot of an attack in flight); dev/director/ drives a player through a test scenario (its input_stub presses a key at the input seam, for the walk and for a drill that holds a key itself; its ladder_climb climbs a ladder through the game's own use verb and its forward key) |
| Concept | Files |
|---|---|
| the Multiplayer menu | multiplayer_menu, host_window_native, host_save_picker, host_session_settings, host_session_choices, browser_input_screens, end_reason_dialog, boot_warning_dialog, game_build_dialog (the popup naming a game this Multivoid was not made for), menu_sfx |
| the server browser | server_browser_native with server_browser_rows, server_browser_actions, server_browser_panels, server_browser_surface (which browser is open) and server_browser_selftest; server_browser is the ImGui fallback |
| the native UI kit | native_screen, native_text_field, style, scale, link_format |
| in-game surfaces | hud (nameplates, chat, the event feed), chat_input, chat_view, scoreboard, loading_screen, join_curtain, voice_icons |
| the F1 overlay | imgui_overlay, overlay_seams, overlay_backend with overlay_backend_dx11, overlay_backend_dx12, overlay_backend_dx12_capture, overlay_backend_vk, overlay_backend_vk_frame, overlay_cursor, overlay_diag, overlay_test_arm, fonts, atlas_watch, input_focus |
| overlay panels | dev_menu (its developer panes in dev_panes), admin_panel, skins_panel, voice_panel, world_rules_panel, server_settings_pane, bug_report_pane, config_review_panel, net_stats_panel, console |
l10n (the lookups T, Tc, Tn, Label, Fmt, and Init, which builds the one catalogue; the markers in mark),
po_reader (a gettext .po file read, the only parser of a translator's text), plural_expr (a catalogue's
plural rule, compiled once), printf_check (the conversions a message may carry), fmt (the positional
formatter), catalog, locale_choice and quiet -- these and the three before them private to src/l10n/ --
l10n_selftest. The packs the mod ships
are src/votv-coop/locale/<ll_CC>.po, embedded by name, beside the template multivoid.pot that
.github/ci/l10n_pot.py extracts and gates (the files that may hold player text are its allowlist);
.github/ci/l10n_vectors.py writes the selftest's plural vectors.
harness (the scenario runner), session_runtime, autotest + autotest_dispatch and harness/autotest/
(one file per scenario: join churn, grab, ragdoll, weather, events, death, damage, pause guard, save UI,
scan parity and more), sdk_check, fingerprint_census + fingerprint_capture (every watched or hooked game function checked
against the build the mod was made for, bytecode-fingerprint.md; the dev capture), compat_report
(the report file every check writes, and its one verdict), compat_boot (its sections the boot writes: the game build
that runs, and the engine's checks with every search of the game's code), screenshot, mod_environment, harness_diag,
browser_click_arm (the test variables that open the browser, host and join as a player's click does). The launcher drives
these from outside the game.
| Folder | Concept | Key files |
|---|---|---|
ue_wrap/core/ |
the substrate | sig_scan (AOB resolution of GUObjectArray, GNames, ProcessEvent), reflection + reflection_props + reflected_offset (classes, properties, functions), uobject_listeners + object_index (the engine's object-created and object-deleted notifications, and the per-class index of live objects they keep), call (calling a reflected function), hook + pe_detour + ufunction_hook (the MinHook ProcessEvent detour and per-function interceptors), script_gate + script_gate_names (a detour on the VM's script loop: a Blueprint function body observed and cancelled per call, with its arguments and its caller, on every route; the name watches in a file of their own), script_bytecode + script_fingerprint + script_calls (a function's compiled bytecode read as canonical text and fingerprinted, and its call expressions listed in that order), caller_locals (a Blueprint caller's actor array and hit result edited in place from a seam inside its call), game_thread (the posted-task pump; engine calls happen only there), cached_obj_ref + obj_keyed_cache + gc_pin (object lifetime across worlds; one value held per class or function), sdk_profile + sdk_profile_names (the per-game-version offsets and names), game_build (which game build runs: the executable's link stamp and the pak's index hash, matched against ue_wrap/facts/game_builds.inc), scan_ledger (every search of the game's code, found, missed or not tried), fname_utils, fstring_utils, ftext_utils, field_io, engine_heap, asset_load, hot_path_guard, walk_timer, walk_census (how often the finders walk the whole object array, and from which call sites), log, trace, paths, types, hook_drill, pe_diag |
ue_wrap/facts/ |
the game facts the mod depends on | function_row (every watched or hooked game function, declared as a row in the file that registers it; the registration APIs take only rows), fingerprints_<target>.inc (the generated reference table of the target build) |
ue_wrap/engine/ |
engine objects | engine (world, actors, spawning), engine_pawn, engine_component, engine_timeline (a timeline component's run, direction and place), engine_widget + umg_build (UMG), engine_bones, engine_attach, engine_audio, engine_nav, data_table (a data table's rows, walked in memory and read by column through the engine), engine_save + save_capture + save_to_slot_hook (the one detour on the engine's save function: a gate before a world save, a notice after) + save_browser + gvas_meta (save files), engine_mainplayer + engine_hurt_flash (the puppet's hurt flash), engine_player_verbs (the verbs that hurt a player pawn, its melee swing, and its fire), screen_state (what covers this machine's view), engine_playerragdoll, spawn_gate, actor_end_play (the detour on the engine's AActor::EndPlay: every actor that began play, ending it, with the reason), vulkan_rhi (what the Vulkan renderer holds, read from its viewport at the present seam, and the loader slots it calls through), spawn_menu, scs_rig, world_identity (which world is current) |
ue_wrap/actors/ |
the game's actor classes | puppet + puppet_spawn, prop, prop_fire (a prop's flame and its two light verbs), kerfur, wisp, geom_octa (the Octa's target and its laser's owner, read), zombie + fossilhound (what a creature's BeginPlay sets up for the eye, which its mirror still needs, and the zombie's hit feedback), int_objects (a hit as the game's interface carries it), inventory, vitals (the player's stats, one table, and the profile snapshot), effects (the player's status effects: the game's list, add, remove, and reset out of a joiner's save), sleep, swinger, save_record (the Fstruct_save codec, and the actor's own getData/loadData), floppy_disc, notebook (the notebook props and the editor widget that writes them), begin_equipment, broom, container_openers (the actors a far-standing container is opened through: the drone, its sack, the ATV), container_view (the local player's inventory screen: the container it shows, the game's own close, a slot's read and press, and the screen's redraw) |
ue_wrap/devices/ |
keyed devices | door, door_box, lightswitch, cord, passwordlock, power_control, garage, appliance, base_window, grime, windturbine, drone + drone_console (its garage console, keyed by no lane: the host finds it by the presser's reach), atv + atv_condition, laptop, portable_pc, floppybox, serverbox, coord_tower (the three triangulation towers), radio_tower (the radio tower) |
ue_wrap/desk/ |
the signal workstation | dish, dish_writers (the toolgun's calibration tool and the uncalibrator), console_desk, desk_ping (the ping machine and its verdict), sat_console (the SAT console's terminal), coords_panel, comp_pane, device_screen, drive_chain, tape_caddy, phys_mods, saved_signals, meadow_store, signal_dynamic, space_renderer, desk_audio, daily_task |
ue_wrap/world/ |
world singletons | world_singleton (one live instance of a class the game keeps one of, from the object index, of the running world), world_instances (every such instance of a class a level places several of, judged by the same rule), daynightcycle, active_events (the gamemode's running-event refcount and its senders), skysphere, jellyfish_path (the space jellyfish's path and its fish), red_sky (the gamemode's red sky toggle and its event), bad_sun (a Bad Sun copy's state and the live copies), directionalwind, game_rules, game_mode (the mode enum and the running world's mode byte), explosion (explosion_C: its classes, its blast parameters, its begin-play), explosion_source (the classes whose own Blueprint spawns an explosion, by kind), economy, order_economy, store_catalog, weapon_catalog (what one swing of a held item can deal, and how far it reaches), email, votv_lib |
loader/cppmod_entry exports start_mod() and uninstall_mod(), the two functions the UE4SS mod scan
calls, and refuses to start beside a leftover pre-mod-folder install; cppmod_stubs.asm carries the
stubs. bootstrap/dllmain, boot and refuse_dialog are the process entry and the one dialog the mod
can show before the game's UI exists.
- Decide who owns the state (see architecture.md): the host owns it and clients mirror; a client names an intent and the host performs it; or each peer owns its own copy and the rest see it.
- Add the message kind to
coop/net/protocol.hand bump the build number: the wire changed. - Route it in the family router that owns its kind in
coop/dispatch/. - Own it in one file, in the folder of its concept. The late-join answer (what a peer who joins mid-way receives) lives in the same file.
- Add its row to the subsystem's doc, and a driver under
coop/dev/behind a registered config flag when the lane can be exercised without hands (*_selftestis the shape).