API reference

Every function, documented

624 compiled functions across seven components, each on its own page. Public entries are intended for missions and third-party scripts; internal entries are documented so you can read the systems, not so you can depend on them. Start from a category below, or search the flat table at the bottom.

CORE1 public

FF: Core

Shared editor categories, module bases and UI contracts. No gameplay, no ACE or ZEN dependency.

1 functions

UTILS62 public

FF: Utils

Wardrobe, circuits, faulty optics, documents, generic items, AI balancing, reconnect recovery, blackout, flashlights, PASS, ammo provisioning, UAV automation, ready room, weapon faults, terminals, power and solar.

236 functions

CINEMATIC29 public

FF: Cinematic

Camera paths, overlay renderer, gravity pulses and the shared music playback and director services. Presentation only, no gameplay side effects.

53 functions

CBRN7 public

FF: CBRN

Hazard simulation, filters, SCBA, detector and decontamination with ACE medical integration.

14 functions

ZEUS14 public

FF: Zeus

Curator footer, FPS monitoring, Alt look orders, volunteer/RP service and the dialogs for drones, music, ready room and weapon faults.

59 functions

SPECTATOR6 public

FF: Spectator

Opt-in spectator service: presets, command broker, UI rendering and optional TFAR/ACRE2 radio integration.

114 functions

HORROR20 public

FF: Horror

Soul respawn, flying skulls, hordes, atmosphere director, scares, themed items and media.

147 functions

Hierarchy

Browse by component, then by subsystem

Each category is a subsystem; every function inside it has its own page with signature, arguments, return value, example, source file and the internals page that explains the system.

Soul respawn 23 Flying skulls 10 Spawning and hordes 15 Atmosphere 5 Scare entity 7 Persistence aliases 5 Atmosphere aliases 2 CBRN aliases 12 Wardrobe aliases 18 Circuit aliases 6 Faulty optics aliases 4 Gravity traps 4 Cinematic aliases 4 Zeus tools 17 Eden modules 9 Runtime and startup 3 AI and document aliases 3

Function	Component	Exposure	Purpose
`FFATM_fnc_report`	Horror	internal	Server-side entry for client threat reports. Validates the reporting unit and age, stores the sample and feeds the pressure calculation.
`FFATM_fnc_zeusRequest`	Horror	internal	Server-side atmosphere control request used by the ZEN dialog: automatic mode, track, forced mood, priority track, horde cue and stop commands.
`FFATM_fnc_zombieProfile`	Horror	internal	Returns [kind, weight, closeUrgency] for an enemy unit, recognizing WBK class names and falling back to the display name.
`FFPP_fnc_acknowledge`	Horror	alias	Persistence entry point that calls the Utils implementation.
`FFPP_fnc_applyRestore`	Horror	alias	Persistence entry point that calls the Utils implementation.
`FFPP_fnc_requestRestore`	Horror	alias	Persistence entry point that calls the Utils implementation.
`FFPP_fnc_snapshot`	Horror	alias	Persistence entry point that calls the Utils implementation.
`FFPP_fnc_zeusRequest`	Horror	alias	Persistence entry point that calls the Utils implementation.
`FFSC_fnc_audio`	Horror	internal	Plays one of the four local apparition sounds positionally and replaces the previous voice so events never stack.
`FFSC_fnc_canView`	Horror	internal	Gaze and visibility test: inside the configured cone, on screen, and with an unobstructed camera-to-image path.
`FFSC_fnc_clear`	Horror	internal	Removes local apparition visuals, lights, audio and stress contribution, and restores the flashlight rendering gate.
`FFSC_fnc_stopAudio`	Horror	internal	Stops the apparition's active audio voice and clears its handle.
`FFSC_fnc_teleport`	Horror	internal	Chooses a random dry, out-of-view position outside the rush zone with overhead clearance, then relocates the local apparition.
`FFSC_fnc_tick`	Horror	internal	Single local frame handler for every apparition: billboard placement, gaze tests at 10 Hz, overlay, teleports, warning/rush timing and flashlight interference.
`FFSC_fnc_zeusRequest`	Horror	internal	Validates a curator request, creates the retained controller logic, resolves viewers and publishes the audience to all clients.
`FF_cbrn_fnc_cbrnAddActions`	CBRN	internal	Adds one set of ACE self actions to a locally controlled unit.
`FF_cbrn_fnc_cbrnDecontaminate`	CBRN	public	Clears accumulated local CBRN exposure after a mission decontamination action.
`FF_cbrn_fnc_cbrnGetConfig`	CBRN	public	Builds effective CBRN settings from CBA defaults and mission overrides.
`FF_cbrn_fnc_cbrnGetDanger`	CBRN	public	Returns local chemical danger from a custom provider, altitude layer, and zones.
`FF_cbrn_fnc_cbrnGetProtection`	CBRN	public	Resolves facewear, backpack, and remaining filter or air protection.
`FF_cbrn_fnc_cbrnGiveItem`	CBRN	internal	Return an inventory magazine, dropping it nearby only when allowed and necessary.
`FF_cbrn_fnc_cbrnRefresh`	CBRN	internal	Apply the current effective enable state after a live CBA setting change.
`FF_cbrn_fnc_cbrnStart`	CBRN	public	Starts local CBRN simulation, ACE actions, and detector effects for the player.
`FF_cbrn_fnc_cbrnStop`	CBRN	public	Stops local CBRN simulation and releases detector/HUD effects.
`FF_cbrn_fnc_cbrnTick`	CBRN	internal	Advances local CBRN exposure, filtration, ACE effects, supply bar, and detector.
`FF_cbrn_fnc_cbrnUseItem`	CBRN	public	Connects a respirator or consumes a matching FF_Horror replacement filter.
`FF_cbrn_fnc_cbrnVisuals`	CBRN	internal	Apply the Contact APR model and hose selections from the owning client.
`FF_cbrn_fnc_moduleCBRNSettings`	CBRN	internal	Applies optional Eden CBRN settings and starts or stops local simulation.
`FF_cbrn_fnc_moduleCBRNZone`	CBRN	internal	Registers an optional Eden-placed chemical zone on each client.
`FF_cinematic_fnc_animateCamera`	Cinematic	public	Animates a supplied camera with weighted Bezier frames.
`FF_cinematic_fnc_briefingHandleRequest`	Cinematic	internal	Revalidates an authenticated briefing request and updates server-owned state.
`FF_cinematic_fnc_briefingPublishSites`	Cinematic	internal	Publishes public briefing screen metadata for current and joining clients.
`FF_cinematic_fnc_briefingRegister`	Cinematic	public	Registers an opt-in synchronized physical briefing screen and slide deck.
`FF_cinematic_fnc_briefingRequest`	Cinematic	internal	Authenticates a player request for a registered briefing screen.
`FF_cinematic_fnc_briefingServerTick`	Cinematic	internal	Publishes synchronized slides and the eligible players' readiness roster.
`FF_cinematic_fnc_briefingUnregister`	Cinematic	public	Removes a briefing screen and its shared state.
`FF_cinematic_fnc_cameraPath`	Cinematic	public	Owns a local camera and delegates movement to the shared animator.
`FF_cinematic_fnc_driveScene`	Cinematic	public	Sends a vehicle's local AI crew to a supplied scene destination.
`FF_cinematic_fnc_facecamBroadcast`	Cinematic	public	Starts server staging and sends the synchronized facecam plan to current viewers.
`FF_cinematic_fnc_facecamClientStop`	Cinematic	internal	Stops a viewer when the authoritative server cancels its facecam schedule.
`FF_cinematic_fnc_facecamPlan`	Cinematic	public	Plans weighted face-camera appearances across configurable scene blocks.
`FF_cinematic_fnc_facecamReceive`	Cinematic	internal	Accepts a server facecam session and starts its local viewer on the next frame.
`FF_cinematic_fnc_facecamRestore`	Cinematic	public	Restores a participant staged by Cinematic, including their original vehicle seat.
`FF_cinematic_fnc_facecamStage`	Cinematic	public	Temporarily stages a local participant and schedules restoration.
`FF_cinematic_fnc_facecamStart`	Cinematic	public	Starts one server-owned facecam staging schedule from a supplied plan.
`FF_cinematic_fnc_facecamStop`	Cinematic	public	Cancels the server staging schedule and restores its participants.
`FF_cinematic_fnc_facecamView`	Cinematic	public	Plays a facecam plan locally against the supplied synchronized start time.
`FF_cinematic_fnc_facecamViewStop`	Cinematic	public	Stops the local facecam viewer, clears its caption and releases its camera.
`FF_cinematic_fnc_gravityPulse`	Cinematic	public	Broadcast one or more visual pulses. No physics, freeze, or damage.
`FF_cinematic_fnc_gravityPulseLocal`	Cinematic	internal	Local-only particles, light and post-processing for a single travelling wave.
`FF_cinematic_fnc_musicCatalog`	Cinematic	internal	Normalizes track catalogues and pools without requiring any themed soundtrack.
`FF_cinematic_fnc_musicDirectorAdminReply`	Cinematic	internal	Displays whitelisted server feedback for curator music commands.
`FF_cinematic_fnc_musicDirectorAdminRequest`	Cinematic	alias	Authenticates bounded curator commands and rejects stale director incarnations.
`FF_cinematic_fnc_musicDirectorCommand`	Cinematic	internal	Normalizes the bounded primitive command shared by native and curator director controls.
`FF_cinematic_fnc_musicDirectorControl`	Cinematic	public	Applies explicit server-local selection, priority, timed-force and source controls.
`FF_cinematic_fnc_musicDirectorPublishCatalogs`	Cinematic	internal	Publishes only safe catalogue metadata for optional local curator interfaces.
`FF_cinematic_fnc_musicDirectorStart`	Cinematic	public	Registers an opt-in server music director without activating client audio.
`FF_cinematic_fnc_musicDirectorState`	Cinematic	public	Returns a public director descriptor suitable for the local music follower.
`FF_cinematic_fnc_musicDirectorStop`	Cinematic	public	Removes one server director and its shared timeline; followers receive silence.
`FF_cinematic_fnc_musicDirectorTick`	Cinematic	internal	Advances registered server directors and publishes only changed primitive timelines.
`FF_cinematic_fnc_musicHold`	Cinematic	public	Adds/removes a local external music-channel hold before another system takes ownership.
`FF_cinematic_fnc_musicOffset`	Cinematic	internal	Computes synchronized seek offsets and rejects expired one-shot playback.
`FF_cinematic_fnc_musicOverrides`	Cinematic	internal	Advances priority completion and queued timed overrides using an authoritative clock.
`FF_cinematic_fnc_musicPlan`	Cinematic	internal	Plans normal, descending-rank and completed-one-shot transitions.
`FF_cinematic_fnc_musicRelease`	Cinematic	internal	Relinquishes only the follower's owned channel, optionally yielding without touching foreign audio.
`FF_cinematic_fnc_musicRequest`	Cinematic	internal	Validates a synchronized local music descriptor without invoking game audio.
`FF_cinematic_fnc_musicSelect`	Cinematic	internal	Selects and schedules a generic track with no-repeat pool rotation and ranked transitions.
`FF_cinematic_fnc_musicSelection`	Cinematic	internal	Normalizes a generic base/forced mood selection.
`FF_cinematic_fnc_musicStart`	Cinematic	public	Acquires the local music follower with an explicit source and channel gate.
`FF_cinematic_fnc_musicStop`	Cinematic	public	Stops the named follower, with optional ownership-token protection.
`FF_cinematic_fnc_musicTick`	Cinematic	internal	Follows a shared timeline with late-join seeks, fades, one-shots and explicit external-channel gates.
`FF_cinematic_fnc_overlayConfig`	Cinematic	internal	Validates local animated-picture configuration and bounds animation costs.
`FF_cinematic_fnc_overlayFade`	Cinematic	public	Changes a named overlay's numeric fade or local fade callback with optional token protection.
`FF_cinematic_fnc_overlayStart`	Cinematic	public	Starts/replaces a named local animated overlay and returns its ownership token.
`FF_cinematic_fnc_overlayStatus`	Cinematic	public	Returns the local control, owner and token for a named overlay.
`FF_cinematic_fnc_overlayStop`	Cinematic	public	Removes a named overlay only when its optional ownership token matches.
`FF_cinematic_fnc_overlayStopAll`	Cinematic	public	Removes only Cinematic-owned overlays and their worker.
`FF_cinematic_fnc_overlayTick`	Cinematic	internal	Renders bounded animated overlays without scheduled scripts or global texture state.
`FF_cinematic_fnc_prepareCameraPath`	Cinematic	public	Validates and expands weighted camera frames without changing game state.
`FF_cinematic_fnc_splashStart`	Cinematic	public	Plays an opt-in sequence of full-screen image cards with owned cleanup.
`FF_cinematic_fnc_splashStop`	Cinematic	public	Stops the local splash sequence, releasing its UI and optional music hold.
`FF_cinematic_fnc_splashTick`	Cinematic	internal	Advances image cards using local monotonic time and bounded CBA frame handling.
`FF_core_fnc_isCuratorRequest`	Core	public	Validates the player and network owner of a server curator request.
`FF_horror_fnc_aiBalanceReveal`	Horror	alias	Calls the Utils AI ownership service.
`FF_horror_fnc_aiBalanceTick`	Horror	alias	Calls the Utils AI ownership service.
`FF_horror_fnc_armSoulRespawn`	Horror	internal	Hold the next respawn before death; the killed template alone can run too late.
`FF_horror_fnc_arsenalInit`	Horror	internal	Register optional ACE Arsenal item tabs. Medical and Tools use ACE's own tabs.
`FF_horror_fnc_atmosphereMoodRank`	Horror	internal	Maps Horror atmosphere modes to the generic director's transition ranks.
`FF_horror_fnc_atmosphereMusicRequest`	Horror	internal	Publishes the atmosphere track state on the shared music timeline.
`FF_horror_fnc_atmospherePlaybackStart`	Horror	alias	Starts the native music follower plus the Horror cue and visual layer.
`FF_horror_fnc_atmospherePlaybackTick`	Horror	internal	Keeps themed overlay intensity and cancellable whisper cues outside the generic music owner.
`FF_horror_fnc_atmosphereWhisper`	Horror	internal	Plays only the still-current and eligible themed one-shot cue.
`FF_horror_fnc_cameraPath`	Horror	public	Calls the Cinematic implementation with the same arguments.
`FF_horror_fnc_cbrnAddActions`	Horror	alias	Calls the owning implementation; state keys stay stable.
`FF_horror_fnc_cbrnDecontaminate`	Horror	alias	Calls the owning implementation; state keys stay stable.
`FF_horror_fnc_cbrnGetConfig`	Horror	alias	Calls the owning implementation; state keys stay stable.
`FF_horror_fnc_cbrnGetDanger`	Horror	alias	Calls the owning implementation; state keys stay stable.
`FF_horror_fnc_cbrnGetProtection`	Horror	alias	Calls the owning implementation; state keys stay stable.
`FF_horror_fnc_cbrnGiveItem`	Horror	alias	Calls the owning implementation; state keys stay stable.
`FF_horror_fnc_cbrnRefresh`	Horror	alias	Calls the owning implementation; state keys stay stable.
`FF_horror_fnc_cbrnStart`	Horror	alias	Calls the owning implementation; state keys stay stable.
`FF_horror_fnc_cbrnStop`	Horror	alias	Calls the owning implementation; state keys stay stable.
`FF_horror_fnc_cbrnTick`	Horror	alias	Calls the owning implementation; state keys stay stable.
`FF_horror_fnc_cbrnUseItem`	Horror	alias	Calls the owning implementation; state keys stay stable.
`FF_horror_fnc_cbrnVisuals`	Horror	alias	Calls the owning implementation; state keys stay stable.
`FF_horror_fnc_cleanupWake`	Horror	internal	Idempotent cleanup, including when a death sequence was terminated.
`FF_horror_fnc_faultyVision`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_faultyVisionMap`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_faultyVisionReplace`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_faultyVisionTick`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_finishSoulRespawn`	Horror	internal	Release the held respawn after either the altar scene or a Zeus recovery.
`FF_horror_fnc_flyingSpawn`	Horror	public	[unit OR class, destinationASL, options, optional horde controller]. Server returns job ID (empty on failure). Remote calls enqueue and return empty. Existing infantry keep their identity. New infantry are created on arrival.
`FF_horror_fnc_getConfig`	Horror	public	Builds effective horror settings from CBA settings and mission overrides.
`FF_horror_fnc_gravityPulse`	Horror	public	Calls the Cinematic implementation with the same arguments.
`FF_horror_fnc_gravityPulseLocal`	Horror	public	Calls the Cinematic implementation with the same arguments.
`FF_horror_fnc_gravityTrapRegister`	Horror	public	Arms an explicit object for a single expanding gravity trap.
`FF_horror_fnc_gravityTrapRequest`	Horror	internal	Authenticates a player's inventory-open request for a trap.
`FF_horror_fnc_gravityTrapTrigger`	Horror	public	Fires a registered trap once and applies its callback as the wave reaches players.
`FF_horror_fnc_gravityTrapUnregister`	Horror	public	Disarms a registered gravity trap without triggering it.
`FF_horror_fnc_hordeControl`	Horror	internal	Public server API: ["create", centerASL, options] returns controller on server. ["edit"/"pause"/"resume"/"stop", controller, options]. Stop preserves living units.
`FF_horror_fnc_hordeDialog`	Horror	internal	Drop at the horde centre, or open with an existing controller to edit future arrivals.
`FF_horror_fnc_hordeManageDialog`	Horror	internal	ZEN dialog for selecting a horde controller and editing, pausing, resuming or stopping it.
`FF_horror_fnc_hordePosition`	Horror	internal	Bounded terrain search; never silently spawn in water or outside the chosen radius.
`FF_horror_fnc_initDocument`	Horror	alias	Document entry point that supplies the Horror lore library as the default directory.
`FF_horror_fnc_interactionAvailable`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_interactionClientInit`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_interactionExecute`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_interactionInputs`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_interactionItemCount`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_interactionSignal`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_isSoulActive`	Horror	internal	Shared local lifecycle query. Does not depend on atmosphere being started.
`FF_horror_fnc_moduleCBRNSettings`	Horror	alias	Calls the owning implementation; state keys stay stable.
`FF_horror_fnc_moduleCBRNZone`	Horror	alias	Calls the owning implementation; state keys stay stable.
`FF_horror_fnc_moduleFaultyVision`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_moduleFlyingSkull`	Horror	internal	Registers all props synchronized to an Eden Flying Skull module.
`FF_horror_fnc_moduleGravityPulse`	Horror	internal	Eden module entry point for the gravityPulse function.
`FF_horror_fnc_moduleInteraction`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_moduleSoulSettings`	Horror	internal	Applies optional Eden soul respawn settings without replacing scripted overrides.
`FF_horror_fnc_moduleWardrobe`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_moduleWardrobeSettings`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_onPlayerKilled`	Horror	public	Starts the configurable wake and soul search sequence after death.
`FF_horror_fnc_onPlayerRespawn`	Horror	public	Restores loadout and moves the respawned player to the selected destination.
`FF_horror_fnc_onProjectileHit`	Horror	internal	Converts local projectile impacts on a skull proxy into server-authoritative skull hits.
`FF_horror_fnc_overlay`	Horror	public	Supplies Horror overlay presets to the shared Cinematic renderer.
`FF_horror_fnc_registerHorrorStatus`	Horror	internal	Register Horror counters with the shared Zeus monitor.
`FF_horror_fnc_registerSkull`	Horror	public	Enables an opt-in flying skull actor on a placed skull object for all players, including JIP.
`FF_horror_fnc_registerZeusFooterStatus`	Horror	alias	Calls the shared Zeus tools.
`FF_horror_fnc_seekRespawn`	Horror	public	Lets a dead player fly as a soul to a configurable respawn object.
`FF_horror_fnc_setOtherworld`	Horror	public	Enables or removes local otherworld post processing, smoke, and light.
`FF_horror_fnc_skullAttackEvent`	Horror	internal	Client observations change only the server-owned attack state, never position.
`FF_horror_fnc_skullCommand`	Horror	public	[skull, "fly"/"traversal"/"patrol", optional anchor position ASL]. Moving the original prop relocates its permanent patrol centre, not the proxy.
`FF_horror_fnc_skullHit`	Horror	public	Applies a configurable hit to a registered skull and disables it when the hit limit is reached.
`FF_horror_fnc_skullLocal`	Horror	internal	Renders and moves one local skull proxy with light and particles.
`FF_horror_fnc_skullMotionPosition`	Horror	internal	Pure shared motion evaluation. [fromASL, toASL, start, duration, arc, pausedAt].
`FF_horror_fnc_skullStartMotion`	Horror	internal	Server-only trajectory publication. Clients and the server evaluate the same path.
`FF_horror_fnc_skullTick`	Horror	internal	Server-only arrival and patrol state machine; no dependency on a rendering client.
`FF_horror_fnc_soulShieldActions`	Horror	internal	Install the corpse interaction on each client's ACE menu.
`FF_horror_fnc_soulShieldConsume`	Horror	internal	Remove the capsule where its inventory is local, then acknowledge the server.
`FF_horror_fnc_soulShieldRequest`	Horror	internal	Server-side arbitration for using one soul shield on a player corpse.
`FF_horror_fnc_soulShieldResult`	Horror	internal	Finish a pending application; retry the helper's inventory if the corpse was looted.
`FF_horror_fnc_soulSpawnPosition`	Horror	internal	Resolve finite ATL coordinates to clear ground. Empty means use engine respawn.
`FF_horror_fnc_spawnCommand`	Horror	internal	Zeus UI requests go to the server. Core APIs also work in scripts without Zeus/ZEN.
`FF_horror_fnc_spawnConfig`	Horror	internal	Normalize public flying-spawn/horde options. Positions are ASL; radii are metres.
`FF_horror_fnc_spawnFX`	Horror	internal	Client-only visuals. Server timestamps let late joiners catch up, never replay arrivals.
`FF_horror_fnc_spawnFinish`	Horror	internal	Server-only completion/cancellation; never called by the effect renderer.
`FF_horror_fnc_spawnLogic`	Horror	internal	Internal, server-only: create a Logic in a local sideLogic group. Optional result map receives an error string; callers only register non-null results.
`FF_horror_fnc_spawnPlaced`	Horror	internal	Server-side Zeus filter; shared settings override per-curator settings when present.
`FF_horror_fnc_spawnPool`	Horror	public	parse "Class=weight,Class=weight" without compiling user input. Returns [flat selectRandomWeighted pool, invalid entries]. Empty means original preset.
`FF_horror_fnc_spawnSettingsDialog`	Horror	internal	ZEN dialog for automatic flying arrivals: per-Zeus or all-Zeus scope, class filter, flight options and enable/disable.
`FF_horror_fnc_spawnTick`	Horror	internal	One server scheduler for all jobs/controllers. At most one launch per horde per tick.
`FF_horror_fnc_startMissionSystems`	Horror	internal	Opt in from initServer/initPlayerLocal. Each role/component starts once. [["atmosphere","reconnect","scare"], "server"] call FF_horror_fnc_startMissionSystems; Use role "client" on interface clients, including JIP. No system starts just because the addon is loaded. FFATM/FFPP/FFSC public names are retained.
`FF_horror_fnc_statusSettingsDialog`	Horror	alias	Zeus can adjust reporting rates without restarting or hiding operational status.
`FF_horror_fnc_unregisterSkull`	Horror	public	Disables a skull actor and releases its local render resources.
`FF_horror_fnc_unregisterZeusFooterStatus`	Horror	alias	Calls the shared Zeus tools.
`FF_horror_fnc_wakeLight`	Horror	public	Creates a short local light trail in response to a soul wake key press.
`FF_horror_fnc_wakeSoul`	Horror	public	Space-bar struggle at the corpse. A shield is required to finish.
`FF_horror_fnc_wardrobeApplyStartingGear`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobeBuildArsenal`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobeClose`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobeGetConfig`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobeInit`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobeIsElectronics`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobeIsExcluded`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobeIsVanilla`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobeMissionItems`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobeOpen`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobeOpenClient`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobePreset`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobeRegisterHandlers`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobeReset`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobeSanitize`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobeSelfActions`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_wardrobeSetConfig`	Horror	alias	Calls the Utils implementation with the same arguments and state keys.
`FF_horror_fnc_zeusFaultyVisionDialog`	Horror	internal	ZEN dialog wrapper for the faulty-vision module. Builds the action/target/category controls and calls the Utils module function.
`FF_horror_fnc_zeusFooterClientTick`	Horror	alias	Calls the shared Zeus tools.
`FF_horror_fnc_zeusFooterInit`	Horror	alias	Calls the shared Zeus tools.
`FF_horror_fnc_zeusFooterLoad`	Horror	alias	Calls the shared Zeus tools.
`FF_horror_fnc_zeusFooterServerTick`	Horror	alias	Calls the shared Zeus tools.
`FF_horror_fnc_zeusFooterUnload`	Horror	alias	Calls the shared Zeus tools.
`FF_horror_fnc_zeusFooterUpdate`	Horror	alias	Calls the shared Zeus tools.
`FF_horror_fnc_zeusFooterWatch`	Horror	alias	Calls the shared Zeus tools.
`FF_horror_fnc_zeusGravityPulseDialog`	Horror	internal	ZEN custom module entry point. ZEN supplies an ASL position and optional attached object.
`FF_horror_fnc_zeusLookLoad`	Horror	alias	Calls the shared Zeus tools.
`FF_horror_fnc_zeusLookTick`	Horror	alias	Calls the shared Zeus tools.
`FF_horror_fnc_zeusLookUnload`	Horror	alias	Calls the shared Zeus tools.
`FF_horror_fnc_zeusSkullInit`	Horror	internal	Optionally registers skulls placed or deleted by the local Zeus curator.
`FF_horror_fnc_zeusSoulApply`	Horror	internal	Execute a curator recovery command on the affected player's own client.
`FF_horror_fnc_zeusSoulCommand`	Horror	internal	Send a command for the player selected in the curator soul panel.
`FF_horror_fnc_zeusSoulEmergency`	Horror	internal	Hard recovery when a soul script is stalled inside a callback or cutscene.
`FF_horror_fnc_zeusSoulLoad`	Horror	internal	Add a soul roster and recovery controls to vanilla curator and ZEN displays.
`FF_horror_fnc_zeusSoulPublish`	Horror	internal	Publish phase changes and orb positions, retaining the latest phase for JIP Zeus.
`FF_horror_fnc_zeusSoulTick`	Horror	internal	Draw orb nicknames in Zeus 3D view and refresh the recovery list.
`FF_horror_fnc_zeusSoulToggle`	Horror	internal	Show or hide the curator recovery panel.
`FF_horror_fnc_zeusSoulUnload`	Horror	internal	Detach soul overlays and controls when curator closes.
`FF_horror_fnc_zeusSpawnInit`	Horror	internal	Called on curator assignment/open. Hooks are installed once per local curator.
`FF_spectator_fnc_acceptRegistration`	Spectator	internal	Starts a viewer only after the server accepts the current local session.
`FF_spectator_fnc_adminButton`	Spectator	internal	Creates a localized command button with data-bound arguments.
`FF_spectator_fnc_adminDialog`	Spectator	internal	Builds localized controls for all spectator modes, maintenance, radio and optional admin code.
`FF_spectator_fnc_adminExecute`	Spectator	internal	Routes every admin script scope through the same optional server authorization.
`FF_spectator_fnc_adminTick`	Spectator	internal	Shows read-only replicated viewer status as plain text.
`FF_spectator_fnc_applyBodySnapshot`	Spectator	internal	Restores local viewer body flags and position unless a newer session owns it.
`FF_spectator_fnc_applyCommand`	Spectator	internal	Applies a validated command in local context after server dispatch.
`FF_spectator_fnc_beginView`	Spectator	internal	Starts one accepted viewer with owned workers, body state and mission handlers.
`FF_spectator_fnc_bindControls`	Spectator	internal	Binds one controller key handler to the current HUD display.
`FF_spectator_fnc_calculateCameraPosition`	Spectator	internal	Computes an ASL camera position behind and above a center.
`FF_spectator_fnc_calculateSquadCenter`	Spectator	internal	Computes a weighted squad center, filtering distant outliers.
`FF_spectator_fnc_cam`	Spectator	public	Animates the spectator-owned camera using Cinematic's shared driver.
`FF_spectator_fnc_cameraTransition`	Spectator	alias	Starts a cancellable fade or Bezier transition without suspending.
`FF_spectator_fnc_canRegisterToken`	Spectator	internal	Rejects replayed registrations for a closed or newer same-body session.
`FF_spectator_fnc_cancelTransition`	Spectator	internal	Invalidates queued camera steps and stops the current animation.
`FF_spectator_fnc_checkACRE2`	Spectator	internal	Detects optional ACRE and updates the radio integration mode.
`FF_spectator_fnc_checkAutoCut`	Spectator	internal	Temporarily cuts to distant combat and restores the actual prior mode.
`FF_spectator_fnc_checkTFAR`	Spectator	internal	Detects the optional TFAR event API.
`FF_spectator_fnc_cleanupCamera`	Spectator	internal	Releases only this spectator's camera and pending transitions.
`FF_spectator_fnc_cleanupCombatHandlers`	Spectator	internal	Removes combat handlers from the current and any tracked squad units.
`FF_spectator_fnc_cleanupRadioHandlers`	Spectator	internal	Removes the radio event registrations owned by this addon.
`FF_spectator_fnc_cleanupUIState`	Spectator	internal	Prunes expired voice and unit-icon caches.
`FF_spectator_fnc_client`	Spectator	public	Compatibility entry for opt-in automatic role detection and controller bindings.
`FF_spectator_fnc_commandReply`	Spectator	internal	Reports server acceptance without claiming that remote execution has completed.
`FF_spectator_fnc_commandRequest`	Spectator	internal	Authenticates a network caller before scheduling a typed server command.
`FF_spectator_fnc_controlKey`	Spectator	internal	Handles spectator mode keys with cancellable one-second cycling.
`FF_spectator_fnc_endView`	Spectator	internal	Releases every viewer worker and restores locally owned body, aperture and radio state.
`FF_spectator_fnc_ensureCamera`	Spectator	internal	Acquires only an active viewer camera, initially above the current body.
`FF_spectator_fnc_executeApply`	Spectator	internal	Runs optional administrator code only after a server-authorized dispatch.
`FF_spectator_fnc_fade`	Spectator	internal	Uses a dedicated spectator fade layer without clearing mission titles.
`FF_spectator_fnc_findThePlayer`	Spectator	internal	Resolves the configured target or a living nonspectator player.
`FF_spectator_fnc_getSquad`	Spectator	internal	Returns the selected unit group members.
`FF_spectator_fnc_getTargetCameraConversation`	Spectator	internal	Computes the current conversation camera position, orientation and field of view.
`FF_spectator_fnc_getTargetCameraDrone`	Spectator	internal	Computes the current drone camera position, orientation and field of view.
`FF_spectator_fnc_getTargetCameraGear`	Spectator	internal	Computes the current gear camera position, orientation and field of view.
`FF_spectator_fnc_getTargetCameraGroup`	Spectator	internal	Computes the current group camera position, orientation and field of view.
`FF_spectator_fnc_getTargetCameraMappos`	Spectator	internal	Computes the current mappos camera position, orientation and field of view.
`FF_spectator_fnc_getTargetCameraOverhead`	Spectator	internal	Computes the current overhead camera position, orientation and field of view.
`FF_spectator_fnc_getTargetCameraPostmortem`	Spectator	internal	Computes the current postmortem camera position, orientation and field of view.
`FF_spectator_fnc_getTargetCameraShoulder`	Spectator	internal	Computes the current shoulder camera position, orientation and field of view.
`FF_spectator_fnc_getTargetCameraTheater`	Spectator	internal	Computes the current theater camera position, orientation and field of view.
`FF_spectator_fnc_getTargetCameraVehicle`	Spectator	internal	Computes the current vehicle camera position, orientation and field of view.
`FF_spectator_fnc_getTeamColor`	Spectator	internal	Returns an icon color for the unit assigned team.
`FF_spectator_fnc_getUnitIconState`	Spectator	internal	Chooses the highest-priority medical or voice icon for a unit.
`FF_spectator_fnc_healSpectator`	Spectator	internal	Clears vanilla damage, fatigue and unconsciousness on the active viewer body.
`FF_spectator_fnc_killcam`	Spectator	internal	Shows a cancellable victim/killer shot, then enters postmortem view.
`FF_spectator_fnc_manageExecute`	Spectator	internal	Compatibility entry requesting the explicitly enabled administrator code service.
`FF_spectator_fnc_manageSpectatorHide`	Spectator	internal	Requests server-authorized viewer visibility changes.
`FF_spectator_fnc_monitorACE`	Spectator	internal	Updates casualty and nearby medic tracking.
`FF_spectator_fnc_monitorACRE2`	Spectator	internal	Refreshes ACRE voice indicators and followed radio channels.
`FF_spectator_fnc_monitorLighting`	Spectator	internal	Updates automatic aperture enhancement with lighting hysteresis.
`FF_spectator_fnc_monitorTFAR`	Spectator	internal	Refreshes TFAR voice indicators and followed radio tuning.
`FF_spectator_fnc_normalizeCommand`	Spectator	public	Validates the bounded spectator command protocol without executing user data.
`FF_spectator_fnc_normalizeDirectionDiff`	Spectator	internal	Normalizes a heading difference across the 360-degree boundary.
`FF_spectator_fnc_presetAmbient`	Spectator	internal	Builds the ambient camera path using the selected target and current scene.
`FF_spectator_fnc_presetConversation`	Spectator	internal	Builds the conversation camera path using the selected target and current scene.
`FF_spectator_fnc_presetDrone`	Spectator	internal	Builds the drone camera path using the selected target and current scene.
`FF_spectator_fnc_presetFront`	Spectator	internal	Builds the front camera path using the selected target and current scene.
`FF_spectator_fnc_presetGear`	Spectator	internal	Builds the gear camera path using the selected target and current scene.
`FF_spectator_fnc_presetGroup`	Spectator	internal	Builds the group camera path using the selected target and current scene.
`FF_spectator_fnc_presetMappos`	Spectator	internal	Builds the mappos camera path using the selected target and current scene.
`FF_spectator_fnc_presetOverhead`	Spectator	internal	Builds the overhead camera path using the selected target and current scene.
`FF_spectator_fnc_presetPostmortem`	Spectator	internal	Builds the postmortem camera path using the selected target and current scene.
`FF_spectator_fnc_presetShoulder`	Spectator	internal	Builds the shoulder camera path using the selected target and current scene.
`FF_spectator_fnc_presetTheater`	Spectator	internal	Builds the theater camera path using the selected target and current scene.
`FF_spectator_fnc_presetTopdown`	Spectator	internal	Builds the topdown camera path using the selected target and current scene.
`FF_spectator_fnc_presetVehicle`	Spectator	internal	Builds the vehicle camera path using the selected target and current scene.
`FF_spectator_fnc_radioPairACRE`	Spectator	internal	Finds target and viewer radios of the same ACRE base type using public APIs.
`FF_spectator_fnc_receiveCommand`	Spectator	internal	Accepts server camera dispatches only for the current registered viewer.
`FF_spectator_fnc_registerRequest`	Spectator	internal	Authenticates a registration request before scheduling server-local work.
`FF_spectator_fnc_registrationReply`	Spectator	internal	Accepts only server registration replies for the current local body and token.
`FF_spectator_fnc_reinitializeSpectator`	Spectator	internal	Recreates the viewer camera without duplicating workers or changing server body registration.
`FF_spectator_fnc_renderDeadUnits`	Spectator	internal	Draws dead units for the current viewer.
`FF_spectator_fnc_renderEnemyContacts`	Spectator	internal	Draws enemy contacts for the current viewer.
`FF_spectator_fnc_renderFriendlyUnits`	Spectator	internal	Draws friendly units for the current viewer.
`FF_spectator_fnc_renderMapMarkers`	Spectator	internal	Draws map markers for the current viewer.
`FF_spectator_fnc_renderMedicIndicators`	Spectator	internal	Draws medic indicators for the current viewer.
`FF_spectator_fnc_renderModeIndicator`	Spectator	internal	Draws mode indicator for the current viewer.
`FF_spectator_fnc_renderSquadIcons`	Spectator	internal	Draws squad icons for the current viewer.
`FF_spectator_fnc_renderTracerLines`	Spectator	internal	Draws tracer lines for the current viewer.
`FF_spectator_fnc_renderUI`	Spectator	internal	Draws u i for the current viewer.
`FF_spectator_fnc_requestMapPos`	Spectator	internal	Waits briefly for the map and binds one cancellable map-position click.
`FF_spectator_fnc_resetState`	Spectator	internal	Initializes native viewer state without activating gameplay.
`FF_spectator_fnc_resetVariables`	Spectator	internal	Resets viewing preferences without changing session counters or mission settings.
`FF_spectator_fnc_resolveRole`	Spectator	internal	Resolves spectator roles from server-owned configuration and curator assignment.
`FF_spectator_fnc_respawnSpectator`	Spectator	internal	Ends viewer effects before requesting an actual local spectator respawn.
`FF_spectator_fnc_restoreBody`	Spectator	internal	Accepts only server-authorized restoration on the current body owner.
`FF_spectator_fnc_restoreRadios`	Spectator	internal	Restores personal radio tuning captured before spectator synchronization.
`FF_spectator_fnc_resyncRadios`	Spectator	internal	Rebinds optional radio events and synchronizes existing spectator radios.
`FF_spectator_fnc_sanitizeDirection`	Spectator	internal	Returns a numeric direction or zero for invalid data.
`FF_spectator_fnc_sendCommand`	Spectator	public	Requests a typed server-authorized camera or maintenance operation.
`FF_spectator_fnc_serverCommand`	Spectator	internal	Authorizes registered controllers and dispatches only validated viewer operations.
`FF_spectator_fnc_serverRegister`	Spectator	internal	Creates or acknowledges a validated current-body registration on the server.
`FF_spectator_fnc_serverRelease`	Spectator	internal	Restores visibility and releases one server registration without replaying stale sessions.
`FF_spectator_fnc_serverTick`	Spectator	internal	Cleans registrations when player bodies disconnect or change owner.
`FF_spectator_fnc_serviceStart`	Spectator	public	Starts opt-in local/server spectator services without automatically assigning arbitrary viewers.
`FF_spectator_fnc_serviceStop`	Spectator	public	Stops local services and releases server-owned viewer registrations.
`FF_spectator_fnc_serviceTick`	Spectator	internal	Binds one HUD controller and registers the current player body with the server.
`FF_spectator_fnc_setMode`	Spectator	internal	Selects a camera preset and starts its cancellable transition.
`FF_spectator_fnc_setNVGMode`	Spectator	internal	Applies automatic, aperture, green or disabled camera vision.
`FF_spectator_fnc_setNVGStrength`	Spectator	internal	Updates aperture enhancement strength.
`FF_spectator_fnc_setupACRE2Handlers`	Spectator	internal	Registers CBA event handlers for ACRE2 speaking and transmitting events. These handlers directly maintain the spectator-local speaking and transmitting unit arrays (GVAR(acre2_speakingUnits) / GVAR(acre2_transmittingUnits)). Like the local TFAR setup, ACRE2's remote events fire locally on ALL clients Ă˘â‚¬â€ť including the spectator Ă˘â‚¬â€ť so no broadcasting is needed. The arrays are maintained directly here. Events used (from ACRE2 public API, available since v2.7.0 / v2.7.2): acre_startedSpeaking [Unit, On Radio (BOOL), Radio ID (STRING), Speaking Type (NUMBER)] Fires on the LOCAL machine when the local player starts speaking. acre_stoppedSpeaking [Unit, On Radio (BOOL)] Fires on the LOCAL machine when the local player stops speaking. acre_remoteStartedSpeaking [Unit, Speaking Type (NUMBER), Radio ID (STRING)] Fires on ALL clients when a REMOTE unit starts speaking. Speaking Type: 0 = local voice, 1 = radio transmission. acre_remoteStoppedSpeaking [Unit] Fires on ALL clients when a REMOTE unit stops speaking. Parameters: None Returns: Nothing Examples: (begin example) call FF_SPECT_fnc_setupACRE2Handlers; (end) Author: ffredyk ----------------------------------------------------------------------------
`FF_spectator_fnc_setupTFAREventHandlers`	Spectator	internal	Binds local TFAR voice events without broadcasting executable code.
`FF_spectator_fnc_slotMatches`	Spectator	internal	Matches a unit against server-configured objects or Eden variable names.
`FF_spectator_fnc_syncRadio`	Spectator	internal	Copies TFAR tuning to existing personal spectator radios, retaining original settings.
`FF_spectator_fnc_syncRadioACRE2`	Spectator	internal	Synchronizes matching personal ACRE radios while retaining the original channel.
`FF_spectator_fnc_trackCombat`	Spectator	internal	Binds local combat and vehicle handlers and prunes expired combat events.
`FF_spectator_fnc_trackDeathsAndRespawns`	Spectator	internal	Tracks squad casualty and respawn marker transitions.
`FF_spectator_fnc_transitionCurrent`	Spectator	internal	Checks that delayed camera work still owns the active transition.
`FF_spectator_fnc_unbindControls`	Spectator	internal	Removes HUD/map bindings and invalidates pending key/map actions.
`FF_spectator_fnc_unregisterRequest`	Spectator	internal	Authenticates release of the calling player session.
`FF_spectator_fnc_updateCamera`	Spectator	internal	Updates the continuous camera target using mode-specific smoothing.
`FF_spectator_fnc_updateThePlayer`	Spectator	internal	Resolves a new target and synchronizes camera/radio selection.
`FF_spectator_fnc_validBodySnapshot`	Spectator	internal	Checks the shape of a viewer body restoration record.
`FF_utils_fnc_aiBalanceReveal`	Utils	internal	Reapply horde target knowledge after an AI group changes locality.
`FF_utils_fnc_aiBalanceStart`	Utils	public	Starts or stops the opt-in server AI ownership service.
`FF_utils_fnc_aiBalanceTick`	Utils	internal	Server-side ownership balancer for AI created by any mission script or mod.
`FF_utils_fnc_blackout`	Utils	public	Disables terrain lamps while preserving configured safe circles.
`FF_utils_fnc_cargoDeficits`	Utils	internal	Calculates positive integer cargo top-ups without removing stock.
`FF_utils_fnc_droneAssign`	Utils	public	Changes a registered UAV assignment using a trusted local server call.
`FF_utils_fnc_droneClearPatrol`	Utils	internal	Removes only waypoint handles created by the native drone controller.
`FF_utils_fnc_droneConfig`	Utils	internal	Normalizes server-owned drone settings and callbacks.
`FF_utils_fnc_droneContacts`	Utils	internal	Finds nearby living hostile units, including vehicle crew.
`FF_utils_fnc_droneFeedClear`	Utils	public	Disables all native feeds and replaces the JIP service state.
`FF_utils_fnc_droneFeedEligible`	Utils	public	Resolves a live-feed audience without touching game state.
`FF_utils_fnc_droneFeedLocal`	Utils	internal	Starts or stops the native client live-feed worker without touching another inactive owner.
`FF_utils_fnc_droneFeedPrune`	Utils	internal	Removes dead/deleted feed sources and releases idle server/client workers.
`FF_utils_fnc_droneFeedRequest`	Utils	alias	Authenticates curator changes to named feed audiences.
`FF_utils_fnc_droneFeedSet`	Utils	public	Publishes a named server-owned live feed with configurable source, target and audience.
`FF_utils_fnc_droneFeedStart`	Utils	internal	Accepts server feed-service activation and schedules local worker ownership.
`FF_utils_fnc_droneFeedTick`	Utils	internal	Selects the newest eligible feed and handles JIP, role/body changes and unavailable sources.
`FF_utils_fnc_droneFollowCenter`	Utils	internal	Resolves a live assignment center without choosing fixed sides or named objects.
`FF_utils_fnc_droneFollowGoal`	Utils	public	Calculates a ground navigation goal on the requested follow ring.
`FF_utils_fnc_droneHandleRequest`	Utils	internal	Revalidates the owner and configured access immediately before changing server state.
`FF_utils_fnc_droneIssuePilot`	Utils	internal	Dispatches server orders to vehicle, current pilot and previous pilot localities.
`FF_utils_fnc_droneNavigate`	Utils	internal	Updates follow, patrol and hold navigation while retaining patrol progress through alerts.
`FF_utils_fnc_dronePilotApply`	Utils	internal	Applies server-authorized UAV orders only at current AI/vehicle localities.
`FF_utils_fnc_dronePilotCommand`	Utils	internal	Accepts only bounded server orders and schedules local AI work.
`FF_utils_fnc_droneRegister`	Utils	public	Registers one explicitly supplied UAV for server-owned follow/patrol/watch automation.
`FF_utils_fnc_droneReleaseWatch`	Utils	internal	Releases a temporary watch PATH override owned by this registration.
`FF_utils_fnc_droneReply`	Utils	internal	Displays server-authorized drone request feedback.
`FF_utils_fnc_droneRequest`	Utils	internal	Authenticates a curator or configured operator before scheduling a server assignment.
`FF_utils_fnc_droneRestorePilot`	Utils	internal	Restores AI features and group state saved before this registration took control.
`FF_utils_fnc_droneServerTick`	Utils	internal	Scans registered UAVs without scheduled permanent loops.
`FF_utils_fnc_droneSortMarkers`	Utils	public	Sorts an explicit marker catalogue by positive numeric suffix.
`FF_utils_fnc_droneSound`	Utils	internal	Plays one transient drone cue from the server without JIP replay.
`FF_utils_fnc_droneStopAll`	Utils	public	Releases every registered native UAV controller.
`FF_utils_fnc_droneTickOne`	Utils	internal	Runs one UAV controller scan and publishes late-join-safe status.
`FF_utils_fnc_droneUnregister`	Utils	public	Releases one registered UAV and restores only its managed indicators and AI controls.
`FF_utils_fnc_droneWatchTick`	Utils	internal	Runs a bounded watch lease and stops turning during manual control or locality loss.
`FF_utils_fnc_faultyVision`	Utils	public	[action, audience, units, nvg, scopes, binoculars, interval] action: 0 once, 1 continuous, 2 stop, 3 stop and restore. audience: 0 players, 1 all living units, 2 explicit units. One mission-wide continuous policy; latest command replaces it.
`FF_utils_fnc_faultyVisionMap`	Utils	internal	Exact config-driven mapping; never replace unknown/modded equipment by ancestry.
`FF_utils_fnc_faultyVisionReplace`	Utils	internal	Runs only where a unit is local. Rewrites class strings, preserving loadout data.
`FF_utils_fnc_faultyVisionTick`	Utils	internal	Per-unit periodic scan used by continuous mode. Converts supported worn, mounted and stored equipment, then reschedules itself while the policy is active.
`FF_utils_fnc_flashlightsStart`	Utils	public	Starts or stops opt-in shared player flashlight rendering locally.
`FF_utils_fnc_flashlightsStop`	Utils	public	Removes flashlight rendering, sources and the published local switch.
`FF_utils_fnc_flashlightsTick`	Utils	internal	Publishes the native switch and renders local player flashlight cones.
`FF_utils_fnc_initDocument`	Utils	public	Installs a local inspectable document using a mission or addon image.
`FF_utils_fnc_interactionAvailable`	Utils	internal	Shared client/server circuit check. Returns [available, empty] after validating the target, completion state and every upstream input.
`FF_utils_fnc_interactionClientInit`	Utils	internal	Installs the ACE action on a consumer's target objects for every client and re-adds it after respawn, so late joiners see the same interaction.
`FF_utils_fnc_interactionExecute`	Utils	internal	Server-side completion of a consumer action. Re-validates owner, distance, liveness and the whole circuit before broadcasting the state variable and animation.
`FF_utils_fnc_interactionInputs`	Utils	internal	Resolves the consumer/gate input node IDs against directly synchronized neighbours. Returns [valid, inputs]; rejects missing, duplicate or ambiguous IDs.
`FF_utils_fnc_interactionItemCount`	Utils	internal	Counts matching items in a unit's inventory (or a container's direct cargo) for item-based producers.
`FF_utils_fnc_interactionSignal`	Utils	internal	Evaluates one producer or gate and returns [passes, detail]. Producers read items, object variables or mission variables; gates combine their own inputs.
`FF_utils_fnc_loadoutRecoveryApply`	Utils	internal	Executes a server-authorized loadout operation on its owning machine.
`FF_utils_fnc_loadoutRecoveryRequest`	Utils	public	Dispatches curator-authorized loadout saves/restores to player owners.
`FF_utils_fnc_loadoutRecoveryStart`	Utils	public	Configures opt-in saved-loadout retention across player respawns.
`FF_utils_fnc_moduleFaultyVision`	Utils	internal	Eden module callback. Normalizes action/targets/categories and starts or stops the faulty-vision policy, optionally deferred to a synchronized trigger.
`FF_utils_fnc_moduleInteraction`	Utils	internal	Eden module callback for circuit consumers. Registers target objects and pushes the ACE action setup to all clients.
`FF_utils_fnc_moduleWardrobe`	Utils	internal	Opens or closes the wardrobe for synchronized or all players from Eden/Zeus.
`FF_utils_fnc_moduleWardrobeSettings`	Utils	internal	Applies an Eden/Zeus wardrobe policy for the mission.
`FF_utils_fnc_passAlarmRequest`	Utils	public	Starts a timed manual PASS alarm or permits a nearby operator to stop it.
`FF_utils_fnc_passBindActions`	Utils	internal	Installs local ACE identification controls and manual-alarm disabling.
`FF_utils_fnc_passClientTick`	Utils	internal	Renders synchronized identification/alert lights and one PASS audio source per body.
`FF_utils_fnc_passServerTick`	Utils	internal	Publishes one manual/casualty alarm epoch per physical player body.
`FF_utils_fnc_passSignal`	Utils	internal	Computes synchronized PASS phase and bounded flash intensity.
`FF_utils_fnc_passStart`	Utils	public	Starts/stops independent identification and casualty PASS beacons.
`FF_utils_fnc_passStop`	Utils	public	Retires native alarms and removes local PASS sources/actions/handlers.
`FF_utils_fnc_persistenceAcknowledge`	Utils	internal	persistenceAcknowledge handler for session reconnect recovery.
`FF_utils_fnc_persistenceApplyRestore`	Utils	internal	Accepts a server restore plan for the local player.
`FF_utils_fnc_persistenceClientEnable`	Utils	internal	Accepts the server's opted-in recovery startup, including JIP.
`FF_utils_fnc_persistenceClientTick`	Utils	internal	Advances bounded restore stages and periodic client snapshots.
`FF_utils_fnc_persistenceFinishRestore`	Utils	internal	Acknowledges a consumed plan and releases client recovery state.
`FF_utils_fnc_persistenceForget`	Utils	internal	Removes recovery data belonging to a dead or respawned body.
`FF_utils_fnc_persistenceRequestRestore`	Utils	internal	persistenceRequestRestore handler for session reconnect recovery.
`FF_utils_fnc_persistenceRestoreSeat`	Utils	internal	Restores an available vehicle seat, preferring the saved seat.
`FF_utils_fnc_persistenceSetEnabled`	Utils	public	Changes recovery collection and invalidates all earlier snapshots.
`FF_utils_fnc_persistenceSnapshot`	Utils	internal	persistenceSnapshot handler for session reconnect recovery.
`FF_utils_fnc_persistenceStart`	Utils	public	Starts opt-in session recovery on the specified machine role.
`FF_utils_fnc_persistenceZeusInit`	Utils	alias	Optional UI integration; Utils has no dependency on the Zeus addon.
`FF_utils_fnc_persistenceZeusRequest`	Utils	internal	persistenceZeusRequest handler for session reconnect recovery.
`FF_utils_fnc_powerBatteryAck`	Utils	internal	Authenticates an inventory acknowledgement and queues transaction completion.
`FF_utils_fnc_powerBatteryConsume`	Utils	internal	Removes one battery on the player's owner and acknowledges the reservation.
`FF_utils_fnc_powerBatteryFinish`	Utils	internal	Commits a confirmed battery reservation or returns a removed item if the site changed.
`FF_utils_fnc_powerBatteryRefund`	Utils	internal	Returns a locally removed battery once when a server reservation cannot commit.
`FF_utils_fnc_powerBatteryRequest`	Utils	internal	Reserves a power source for one authenticated battery transaction.
`FF_utils_fnc_powerClientClear`	Utils	internal	Removes local power controls and their worker on stop or mission end.
`FF_utils_fnc_powerClientEnable`	Utils	internal	Accepts monotonic server activation for local physical transfer controls.
`FF_utils_fnc_powerClientTick`	Utils	internal	Binds generation-specific physical switch actions for native power sites.
`FF_utils_fnc_powerHandleRequest`	Utils	internal	Rechecks authority and locality-independent physical conditions before atomic lever mutation.
`FF_utils_fnc_powerHasSupply`	Utils	public	Checks current server records and physical objects before authorizing a powered service.
`FF_utils_fnc_powerInput`	Utils	internal	Evaluates authoritative physical and mission-defined upstream supply.
`FF_utils_fnc_powerLimits`	Utils	internal	Normalizes capacitor timing and safe connection thresholds.
`FF_utils_fnc_powerPublishSites`	Utils	internal	Publishes safe power-site metadata and activates client actions only while sites exist.
`FF_utils_fnc_powerRegister`	Utils	public	Registers explicit source and transfer objects for a native server-owned power site.
`FF_utils_fnc_powerReply`	Utils	internal	Displays localized server-owned transfer state to the requesting player.
`FF_utils_fnc_powerRequest`	Utils	internal	Authenticates bounded player switch requests and rejects stale site registrations.
`FF_utils_fnc_powerServerTick`	Utils	internal	Advances registered power sites atomically and publishes bounded meter traffic.
`FF_utils_fnc_powerSetInput`	Utils	public	Enables or disables an explicitly registered upstream source.
`FF_utils_fnc_powerTransferStep`	Utils	internal	Advances the shared transfer lever/capacitor/trip state without game objects.
`FF_utils_fnc_powerUnbind`	Utils	internal	Removes only this service's local actions from a transfer prop.
`FF_utils_fnc_powerUnregister`	Utils	public	Removes one site, restores its explicitly controlled props and signals downstream power loss.
`FF_utils_fnc_powerVisual`	Utils	internal	Updates only explicitly mapped transfer animations and warning texture.
`FF_utils_fnc_prepareAmmo`	Utils	public	Tops up consumable cargo to a multiple of supplied operators' inventories.
`FF_utils_fnc_readyRoomAck`	Utils	internal	Delivers a matched server result without letting stale pages clear newer drafts.
`FF_utils_fnc_readyRoomAdminReply`	Utils	internal	Reports curator-request acceptance from the authoritative server.
`FF_utils_fnc_readyRoomAdminRequest`	Utils	alias	Authenticates explicit curator start/reset/release/cancel controls.
`FF_utils_fnc_readyRoomAudioFinish`	Utils	internal	Releases owned audio handlers and restores only the channels this room changed.
`FF_utils_fnc_readyRoomAudioStart`	Utils	internal	Optionally owns a configured music bed and game-channel mute across dialog reloads.
`FF_utils_fnc_readyRoomAudioTick`	Utils	internal	Fades the optional music bed with the authoritative countdown and restores channels before handoff.
`FF_utils_fnc_readyRoomClientSet`	Utils	internal	Starts one client room worker and resets state only for a newer room epoch.
`FF_utils_fnc_readyRoomClientStart`	Utils	internal	Accepts only server room activation and defers UI lifecycle work to local context.
`FF_utils_fnc_readyRoomClientTick`	Utils	internal	Owns ready-room UI reopening, membership refresh and release handoff without loops.
`FF_utils_fnc_readyRoomConfig`	Utils	internal	Normalizes ready-room policy and separates public content from server callbacks.
`FF_utils_fnc_readyRoomEligible`	Utils	internal	Checks current server-owned audience membership for a human player.
`FF_utils_fnc_readyRoomFinish`	Utils	internal	Freezes the release decision once and emits a server-local extension hook.
`FF_utils_fnc_readyRoomHandleRequest`	Utils	internal	Applies owned readiness/vote/chat changes and replies privately to their author.
`FF_utils_fnc_readyRoomHandoff`	Utils	internal	Runs one local release or late-join hook after UI/audio and native pause have cleared.
`FF_utils_fnc_readyRoomKey`	Utils	internal	Routes Escape from the ready-room browser to the correct native pause menu.
`FF_utils_fnc_readyRoomLoad`	Utils	internal	Loads the packaged browser and binds only bounded local UI commands.
`FF_utils_fnc_readyRoomPause`	Utils	internal	Opens the native pause menu on mission display 46 while retaining drafts and entry state.
`FF_utils_fnc_readyRoomProgress`	Utils	internal	Calculates roster-sensitive countdown and rational skip-vote threshold.
`FF_utils_fnc_readyRoomPublish`	Utils	internal	Publishes one ready-room snapshot only when its public values change.
`FF_utils_fnc_readyRoomReduce`	Utils	internal	Applies one normalized readiness/vote/answer/chat operation without mutating its input record.
`FF_utils_fnc_readyRoomRefresh`	Utils	internal	Pushes the current public room state to the loaded local browser.
`FF_utils_fnc_readyRoomRelease`	Utils	public	Releases the current assembly manually without any built-in mission movement or intro.
`FF_utils_fnc_readyRoomRequest`	Utils	internal	Authenticates bounded ready-room requests before scheduling server-local mutation.
`FF_utils_fnc_readyRoomRows`	Utils	internal	Builds public roster flags without broadcasting private questionnaire answers.
`FF_utils_fnc_readyRoomSend`	Utils	internal	Sends one local UI operation with a monotonic per-connection request sequence.
`FF_utils_fnc_readyRoomServerTick`	Utils	internal	Updates readiness, roster changes and the release countdown using one CBA worker.
`FF_utils_fnc_readyRoomStart`	Utils	public	Starts an opt-in configurable server ready room and activates participating clients.
`FF_utils_fnc_readyRoomStop`	Utils	public	Cancels the server ready room and restores client UI/audio without running release callbacks.
`FF_utils_fnc_readyRoomWelcome`	Utils	internal	Applies server audience membership and restores only the caller private answer draft.
`FF_utils_fnc_solarCanUse`	Utils	internal	Checks physical operator eligibility and site-defined upstream access.
`FF_utils_fnc_solarClientAck`	Utils	internal	Routes authorized acknowledgements to the matching opening request or browser page.
`FF_utils_fnc_solarClientClear`	Utils	internal	Removes owned commissioning actions, browser and worker.
`FF_utils_fnc_solarClientEnable`	Utils	internal	Accepts server-only monotonic activation for native commissioning actions and UI.
`FF_utils_fnc_solarClientTick`	Utils	internal	Maintains registered actions, context validity, bounded requests and live calibration contact.
`FF_utils_fnc_solarClose`	Utils	public	Closes only the native solar display and ends its heartbeat/queued edits.
`FF_utils_fnc_solarCreate`	Utils	internal	Builds a provably solvable commissioning challenge from validated seed data.
`FF_utils_fnc_solarDwell`	Utils	internal	Advances only continuously valid calibration dwell and completes commissioning once.
`FF_utils_fnc_solarHandleRequest`	Utils	internal	Owns replay handling and cooperative engineer contact without stale dial heartbeats.
`FF_utils_fnc_solarIsSolved`	Utils	public	Queries authoritative commissioning completion for downstream power/services.
`FF_utils_fnc_solarLabels`	Utils	internal	Supplies localized commissioning interface labels to the packaged browser.
`FF_utils_fnc_solarLoad`	Utils	internal	Binds the packaged commissioning page to bounded generation-specific local requests.
`FF_utils_fnc_solarNumbers`	Utils	internal	Validates bounded integer vectors used by commissioning puzzles.
`FF_utils_fnc_solarOpen`	Utils	public	Requests server authorization before displaying one native commissioning console.
`FF_utils_fnc_solarParity`	Utils	internal	Checks unique return pairing against every four-bit row syndrome.
`FF_utils_fnc_solarPublishSites`	Utils	internal	Publishes safe native console metadata without server callbacks.
`FF_utils_fnc_solarReduce`	Utils	internal	Applies parity, control-word and dial edits with strict stage ordering and immutable input.
`FF_utils_fnc_solarRefresh`	Utils	internal	Pushes only matching-generation commissioning snapshots to the current native browser.
`FF_utils_fnc_solarRegister`	Utils	public	Registers a solvable commissioning console with explicit power and role prerequisites.
`FF_utils_fnc_solarReply`	Utils	internal	Delivers server acknowledgements to the terminal client bound to the current player body.
`FF_utils_fnc_solarRequest`	Utils	internal	Authenticates bounded commissioning packets before local atomic processing.
`FF_utils_fnc_solarSend`	Utils	public	Sends monotonically sequenced primitive commissioning operations from the local player.
`FF_utils_fnc_solarServerTick`	Utils	internal	Enforces continuous operator contact and voltage tolerance before commissioning.
`FF_utils_fnc_solarShuffle`	Utils	internal	Returns a bounded Fisher-Yates shuffle without mutating caller-owned arrays.
`FF_utils_fnc_solarUnload`	Utils	internal	Clears the owned browser context after display unload without closing another display.
`FF_utils_fnc_solarUnregister`	Utils	public	Removes a console and ends its solved signal without changing mission story state.
`FF_utils_fnc_solarVoltage`	Utils	internal	Checks the coupled dial matrix against the displayed voltage tolerance.
`FF_utils_fnc_solarXor`	Utils	internal	Computes XOR of two validated four-bit input words.
`FF_utils_fnc_terminalActor`	Utils	internal	Gets private body/identity-bound authorization and export state.
`FF_utils_fnc_terminalApplyCommand`	Utils	internal	Applies authorized phase, credential, service, export and communications operations.
`FF_utils_fnc_terminalAuth`	Utils	internal	Reads media presence, credential scope and per-console authentication from private state.
`FF_utils_fnc_terminalAuthorize`	Utils	internal	Resolves credential/media rules independently of physical station access.
`FF_utils_fnc_terminalCanUse`	Utils	internal	Rechecks physical actor access and optional live online supply.
`FF_utils_fnc_terminalChat`	Utils	internal	Logs bounded station or curator transmissions with server-owned callsigns and cooldown.
`FF_utils_fnc_terminalClearChannel`	Utils	public	Clears retained traffic or drops an unused named channel.
`FF_utils_fnc_terminalClientAck`	Utils	internal	Applies private views and acknowledgements only to the current owner/context/page.
`FF_utils_fnc_terminalClientClear`	Utils	internal	Removes only native terminal actions, UI context and local worker.
`FF_utils_fnc_terminalClientEnable`	Utils	internal	Accepts server-only monotonic terminal discovery/action activation.
`FF_utils_fnc_terminalClientTick`	Utils	internal	Maintains terminal actions, private views and bounded page-specific requests.
`FF_utils_fnc_terminalClose`	Utils	public	Closes only the owned terminal browser.
`FF_utils_fnc_terminalCommand`	Utils	internal	Normalizes bounded primitive operations without client-supplied code or targets.
`FF_utils_fnc_terminalGrant`	Utils	public	Grants or revokes a server-owned credential scope without modifying mission inventory.
`FF_utils_fnc_terminalHandleRequest`	Utils	internal	Revalidates queued terminal authority, applies one operation and replies only to its owner.
`FF_utils_fnc_terminalHasExport`	Utils	public	Checks a completed body-bound archive flag after server commit.
`FF_utils_fnc_terminalLabels`	Utils	internal	Supplies localized terminal labels without mission-specific content.
`FF_utils_fnc_terminalLeaseMatches`	Utils	internal	Binds UI closure cancellation to the exact old export lease, never a newer window.
`FF_utils_fnc_terminalLoad`	Utils	internal	Binds a self-contained terminal page to bounded server operations and page-specific acknowledgements.
`FF_utils_fnc_terminalOpen`	Utils	public	Requests authorized normal or curator-only terminal access before creating a browser.
`FF_utils_fnc_terminalPhase`	Utils	internal	Advances case opening, boot and supply-loss states on an authoritative clock.
`FF_utils_fnc_terminalPowered`	Utils	internal	Evaluates the live physical and server-configured power source.
`FF_utils_fnc_terminalPublishSites`	Utils	internal	Publishes discovery metadata without private credentials, archives or callback code.
`FF_utils_fnc_terminalRefresh`	Utils	internal	Pushes the latest private snapshot and trusted server clock to the current browser.
`FF_utils_fnc_terminalRegister`	Utils	public	Registers explicit terminal services, media/scope prerequisites, exports and a shared communications port.
`FF_utils_fnc_terminalReply`	Utils	internal	Delivers a server-only private reply to the same current body and player identity.
`FF_utils_fnc_terminalRequest`	Utils	internal	Authenticates primitive terminal requests, actor identity, registration generation and bounded admission.
`FF_utils_fnc_terminalSeedChannel`	Utils	public	Seeds configurable archive traffic without any built-in mission lore.
`FF_utils_fnc_terminalSend`	Utils	public	Sends one sequenced local-player terminal request.
`FF_utils_fnc_terminalServerTick`	Utils	internal	Advances server terminal phases and cancels invalid transfers before a commit can occur.
`FF_utils_fnc_terminalService`	Utils	internal	Applies a registered service ID through native targets or a trusted server callback.
`FF_utils_fnc_terminalShutdownServices`	Utils	internal	Turns off explicitly mapped light/power/watch outputs on supply loss or release.
`FF_utils_fnc_terminalSiteTick`	Utils	internal	Advances one terminal while respecting callback-driven release/replacement.
`FF_utils_fnc_terminalSnapshot`	Utils	internal	Builds a private authorized terminal view without exposing server callbacks or session internals globally.
`FF_utils_fnc_terminalText`	Utils	internal	Bounds chat text, removes control characters and trims surrounding whitespace.
`FF_utils_fnc_terminalTransferStatus`	Utils	internal	Rejects stale, early or expired export commits against their reserved server session.
`FF_utils_fnc_terminalTranslateView`	Utils	internal	Localizes trusted metadata and callsigns while retaining player message text literally.
`FF_utils_fnc_terminalUnload`	Utils	internal	Ends the owned browser lease without cancelling a newer export window.
`FF_utils_fnc_terminalUnregister`	Utils	public	Ends one terminal and its transfers, restores owned light visibility and releases server workers.
`FF_utils_fnc_wardrobeApplyStartingGear`	Utils	public	Applies the configured starting gear on the local client, once per session.
`FF_utils_fnc_wardrobeBuildArsenal`	Utils	public	Builds the wardrobe item list from the effective policy.
`FF_utils_fnc_wardrobeClose`	Utils	public	Closes the wardrobe state for the local player.
`FF_utils_fnc_wardrobeGetConfig`	Utils	public	Returns the effective wardrobe policy for the local machine.
`FF_utils_fnc_wardrobeInit`	Utils	internal	Initializes client-local wardrobe state and handlers once per session.
`FF_utils_fnc_wardrobeIsElectronics`	Utils	public	Detects equipment that counts as restricted electronics for the wardrobe.
`FF_utils_fnc_wardrobeIsExcluded`	Utils	public	Applies the wardrobe restrictions to one item class name.
`FF_utils_fnc_wardrobeIsVanilla`	Utils	internal	Returns true when a config class comes from a vanilla Arma addon.
`FF_utils_fnc_wardrobeMissionItems`	Utils	internal	Reads playable mission slots from the saved mission.sqm for the wardrobe.
`FF_utils_fnc_wardrobeOpen`	Utils	public	Opens the wardrobe for the local player. Call with spawn.
`FF_utils_fnc_wardrobeOpenClient`	Utils	internal	Remote entry point for the wardrobe. Runs the scheduled open locally.
`FF_utils_fnc_wardrobePreset`	Utils	public	Returns a ready-made wardrobe policy that can be extended by the mission.
`FF_utils_fnc_wardrobeRegisterHandlers`	Utils	internal	Registers the ACE Arsenal close handler used to re-apply wardrobe restrictions.
`FF_utils_fnc_wardrobeReset`	Utils	public	Clears cached wardrobe item lists after a policy change.
`FF_utils_fnc_wardrobeSanitize`	Utils	public	Removes restricted electronics from a local unit.
`FF_utils_fnc_wardrobeSelfActions`	Utils	internal	Adds the optional ACE self-interaction entry point.
`FF_utils_fnc_wardrobeSetConfig`	Utils	public	Merges wardrobe overrides into the local mission configuration.
`FF_utils_fnc_weaponFaultAdminRequest`	Utils	alias	Authenticates targeted/global curator fault and repair operations.
`FF_utils_fnc_weaponFaultApply`	Utils	public	Explicitly faults a player firearm; both firearms can be selected.
`FF_utils_fnc_weaponFaultBeginRepair`	Utils	internal	Runs local progress while the server independently validates duration and conditions.
`FF_utils_fnc_weaponFaultBind`	Utils	internal	Adds optional ACE interactions or a vanilla repair action to one body.
`FF_utils_fnc_weaponFaultCanRepair`	Utils	internal	Checks physical conditions and configured specialist classes/traits. Server callers supply private fault records.
`FF_utils_fnc_weaponFaultClear`	Utils	public	Clears only this service's faults and invalidates outstanding repairs.
`FF_utils_fnc_weaponFaultClientEnable`	Utils	internal	Accepts monotonic server service activation for JIP clients.
`FF_utils_fnc_weaponFaultClientReset`	Utils	internal	Removes owned local workers, actions and firing interceptors.
`FF_utils_fnc_weaponFaultClientTick`	Utils	internal	Maintains local actions, owner firing lock and vanilla progress through body changes.
`FF_utils_fnc_weaponFaultConfig`	Utils	internal	Normalizes independent weapon-fault repair policy.
`FF_utils_fnc_weaponFaultFeedback`	Utils	internal	Displays whitelisted server repair feedback.
`FF_utils_fnc_weaponFaultFront`	Utils	internal	Computes a finite expanding fault front; negative means not started.
`FF_utils_fnc_weaponFaultHandleRequest`	Utils	internal	Owns exclusive repairs and prevents cross-target, early or replayed completion.
`FF_utils_fnc_weaponFaultPulse`	Utils	public	Starts a finite server-owned expanding malfunction front in ASL coordinates.
`FF_utils_fnc_weaponFaultRepairStatus`	Utils	internal	Validates a repair token, revision, owner and authoritative time window.
`FF_utils_fnc_weaponFaultRepairWeapon`	Utils	public	Selects a carried faulty firearm, preferring the held weapon.
`FF_utils_fnc_weaponFaultRequest`	Utils	internal	Authenticates repair requests and queues server-local handling.
`FF_utils_fnc_weaponFaultServerTick`	Utils	internal	Continuously validates repair sessions and advances finite expanding pulses.
`FF_utils_fnc_weaponFaultStart`	Utils	public	Starts or stops the opt-in server-authoritative fault service.
`FF_utils_fnc_weaponFaultState`	Utils	internal	Pure immutable firearm selection and revision transition for faults.
`FF_utils_fnc_weaponFaultStop`	Utils	public	Stops server workers, removes faults and cancels repairs and pulses.
`FF_utils_fnc_weaponFaultSync`	Utils	internal	Accepts monotonic owner snapshots without touching ACE jam state.
`FF_utils_fnc_weaponFaultUnbind`	Utils	internal	Removes only this service's local repair actions.
`FF_zeus_fnc_adminMarkersStop`	Zeus	internal	Removes the local curator unit-marker drawing handler.
`FF_zeus_fnc_adminToolbar`	Zeus	public	Shows or hides the opt-in local curator F-key diagnostics toolbar.
`FF_zeus_fnc_adminToolsApply`	Zeus	internal	Applies a server-authorized curator diagnostic to the local player only.
`FF_zeus_fnc_adminToolsDialog`	Zeus	internal	Offers opt-in local admin diagnostics to the active curator.
`FF_zeus_fnc_adminToolsRequest`	Zeus	internal	Authenticates a curator's self-directed admin tools request.
`FF_zeus_fnc_adminToolsStop`	Zeus	public	Removes local diagnostics and restores the player's captured damage setting.
`FF_zeus_fnc_adminToolsTick`	Zeus	internal	Refreshes nearby marker subjects and releases tools after curator or player changes.
`FF_zeus_fnc_droneDialog`	Zeus	internal	Opens optional curator controls for explicitly selected UAVs and live feeds.
`FF_zeus_fnc_droneDialogApply`	Zeus	alias	Translates curator choices into authenticated Utils requests.
`FF_zeus_fnc_fpsSettingsDialog`	Zeus	public	Opens optional ZEN controls for the shared FPS reporting interval.
`FF_zeus_fnc_loadoutRecoveryDialog`	Zeus	public	Opens curator controls to save or restore a player's loadout snapshot.
`FF_zeus_fnc_lookApply`	Zeus	internal	Applies a validated server look order on the unit's owner.
`FF_zeus_fnc_lookRequest`	Zeus	internal	Validates a curator's look orders and forwards them to unit owners.
`FF_zeus_fnc_musicDirectorApply`	Zeus	alias	Converts local ZEN fields into a bounded generation-aware curator request.
`FF_zeus_fnc_musicDirectorChoose`	Zeus	alias	Builds localized controls from current public director metadata without transmitting code.
`FF_zeus_fnc_musicDirectorDialog`	Zeus	internal	Lists optional Cinematic directors with current track and source diagnostics.
`FF_zeus_fnc_persistenceZeusInit`	Zeus	alias	Registers an optional ZEN control for reconnect recovery.
`FF_zeus_fnc_readyRoomDialog`	Zeus	public	Opens optional curator controls for ready-room lifecycle operations.
`FF_zeus_fnc_registerZeusFooterStatus`	Zeus	public	register a Zeus footer field on the machine that owns its value. [id, label, updateCode, intervalSeconds, scope] call FF_horror_fnc_registerZeusFooterStatus updateCode is called without arguments and returns a number, boolean, or text. Server fields are broadcast to every Zeus; local fields are shown only here. Scope defaults to "server" on the server and "local" on a client.
`FF_zeus_fnc_screenPreviewDialog`	Zeus	internal	Selects a locally registered read-only screen and view mode from Zeus.
`FF_zeus_fnc_screenPreviewLoad`	Zeus	internal	Initializes an independent read-only browser for a registered local screen.
`FF_zeus_fnc_screenPreviewOpen`	Zeus	public	Opens a registered screen as an independent full view or bottom Zeus preview.
`FF_zeus_fnc_screenPreviewRegister`	Zeus	public	Registers a local read-only Zeus screen renderer.
`FF_zeus_fnc_screenPreviewStop`	Zeus	public	Closes the small Zeus preview without closing a full view.
`FF_zeus_fnc_screenPreviewSyncPower`	Zeus	internal	Registers read-only previews for replicated FF Utils transfer sites.
`FF_zeus_fnc_screenPreviewTick`	Zeus	internal	Updates open read-only screens and closes them when curator access ends.
`FF_zeus_fnc_screenPreviewUnload`	Zeus	internal	Releases a preview browser without disturbing another active view.
`FF_zeus_fnc_screenPreviewUnregister`	Zeus	public	Removes a local screen renderer and closes its active views.
`FF_zeus_fnc_statusRatesRequest`	Zeus	internal	Sets reporting intervals after server curator/ownership validation.
`FF_zeus_fnc_terminalHQ`	Zeus	alias	Selects a registered terminal for curator communications.
`FF_zeus_fnc_unregisterZeusFooterStatus`	Zeus	public	remove a footer field registered on this machine.
`FF_zeus_fnc_volunteerClientTick`	Zeus	internal	Maintains volunteer controls through display and player changes.
`FF_zeus_fnc_volunteerCuratorLoad`	Zeus	internal	Adds volunteer controls to vanilla Zeus while the service is enabled.
`FF_zeus_fnc_volunteerCut`	Zeus	internal	volunteerCut operation for the opt-in roleplay service.
`FF_zeus_fnc_volunteerDrawPlayers`	Zeus	internal	volunteerDrawPlayers operation for the opt-in roleplay service.
`FF_zeus_fnc_volunteerKeyDown`	Zeus	internal	Handles keys only while an offer or volunteer session is active.
`FF_zeus_fnc_volunteerLoad`	Zeus	internal	volunteerLoad operation for the opt-in roleplay service.
`FF_zeus_fnc_volunteerOfferHUD`	Zeus	internal	volunteerOfferHUD operation for the opt-in roleplay service.
`FF_zeus_fnc_volunteerOpen`	Zeus	public	Opens the RP panel, resolving an attached or selected AI target.
`FF_zeus_fnc_volunteerReceive`	Zeus	internal	volunteerReceive operation for the opt-in roleplay service.
`FF_zeus_fnc_volunteerRefresh`	Zeus	internal	volunteerRefresh operation for the opt-in roleplay service.
`FF_zeus_fnc_volunteerRelease`	Zeus	internal	volunteerRelease operation for the opt-in roleplay service.
`FF_zeus_fnc_volunteerRequest`	Zeus	internal	volunteerRequest operation for the opt-in roleplay service.
`FF_zeus_fnc_volunteerServerTick`	Zeus	internal	Expires offers, releases invalid sessions and publishes the roster.
`FF_zeus_fnc_volunteerStart`	Zeus	public	Starts or stops the opted-in volunteer/RP service on each role.
`FF_zeus_fnc_volunteerSwitch`	Zeus	internal	volunteerSwitch operation for the opt-in roleplay service.
`FF_zeus_fnc_weaponFaultDialog`	Zeus	public	Configures an explicit targeted or global firearm fault/recovery request.
`FF_zeus_fnc_zenInit`	Zeus	internal	Registers optional shared Zeus modules when ZEN is available.
`FF_zeus_fnc_zeusFooterClientTick`	Zeus	internal	Merge replicated and local fields, then size the footer to fit its contents.
`FF_zeus_fnc_zeusFooterInit`	Zeus	internal	Register FF_Horror's server-owned fields and start one shared updater.
`FF_zeus_fnc_zeusFooterLoad`	Zeus	internal	Attach a passive footer to the vanilla curator display (also used by ZEN).
`FF_zeus_fnc_zeusFooterServerTick`	Zeus	internal	Run server callbacks and broadcast changed footer values.
`FF_zeus_fnc_zeusFooterUnload`	Zeus	internal	Stop local updates when the curator display closes.
`FF_zeus_fnc_zeusFooterUpdate`	Zeus	internal	Refresh due callbacks in registration order and return their display rows.
`FF_zeus_fnc_zeusFooterWatch`	Zeus	internal	Fallback for display load/unload events, including repeated Zeus opens.
`FF_zeus_fnc_zeusFpsTick`	Zeus	internal	Publish current-body FPS at the configured reporting interval.
`FF_zeus_fnc_zeusLookLoad`	Zeus	internal	Let a curator point selected AI infantry with Alt while the display is open.
`FF_zeus_fnc_zeusLookTick`	Zeus	internal	Preview the cursor target and periodically send doWatch to each unit owner.
`FF_zeus_fnc_zeusLookUnload`	Zeus	internal	Remove input, map, and frame handlers when the curator display closes.

Scroll horizontally to see all columns.