void

Pauses the current script. The duration unit is not documented here.

Stops the current script.

Description pending.

Consumes four bytes and delegates the integer to format %ld in the shared formatting buffer.

Description pending.

Consumes an eight-byte floating-point value and formats it with %f in the shared formatting buffer.

Description pending.

Consumes 256 bytes, copies the packed string, terminates payload at its unsigned length byte, and delegates format %s.

Consumes the eight-byte managed string cell, delegates its pointer plus four to format %s, then decrements and conditionally releases the reference.

Description pending.

Description pending.

Appends the second string to the first, modifying the first string.

Rescales the point's integer coordinates toward the requested vector length, modifying the point in place. Integer arithmetic and truncation can make the resulting length differ from the requested value.

Rotates a referenced integer point through an integer angle using sine and cosine.

Limits the point's coordinates to the rectangle's boundaries.

Description pending.

rect::Set pops four integer coordinates and a rect reference pair, writing them into memory in standard left, top, right, bottom offset order.

Description pending.

Description pending.

Description pending.

Description pending.

Description pending.

Description pending.

Description pending.

Scans the active VM frame bytes and formats them as hexadecimal.

Walks a local instruction pointer while formatting diagnostics into a shared buffer.

Routes a managed filename to a map worker and conditionally reports a nonzero return.

Description pending.

Description pending.

Obj::Clear resolves its referenced Obj slot and overwrites it with the null handle representation FFFF:00000000.

Resolves an Obj and forwards an integer to virtual slot [field].

SetMaxHealth and SetMaxStamina directly write their integer arguments at object [field] and [field].

Resolves an Obj handle and delegates an integer stamina value through virtual slot [field].

SetMaxHealth and SetMaxStamina directly write their integer arguments at object [field] and [field].

Description pending.

Clears commands on an eligible resolved object outside the guarded global mode.

Cancels or updates a valid object's command state when the local gates allow it.

creates and enqueues a named command on a target object.

Adds a named command with a point as its target.

Adds a named command with an object as its target.

Creates a named command under local guards, submits two candidates and updates command state.

Creates and submits a named command for the object, without an additional target.

Creates and submits a named command for the object with a point as its target.

Creates and submits a named command for the object with another object as its target.

Builds a one-receiver packet for default-command dispatch with point, target identifier and normalized flags.

Validates an object and named command, then dispatches it with script arguments.

Resolves the supplied command name through registry virtual [field] and dispatches nonnegative results through object virtual [field].

Resolves the supplied command name through registry virtual [field] and dispatches nonnegative results through object virtual [field].

Requests a visibility update for the object using the supplied boolean. Conditions that can affect visibility still need a practical explanation.

Resolves an Obj and selects one of two virtual status operations from a boolean argument.

Forwards Obj::Erase to a receiver virtual method.

Changes the object's owner. Player numbers start at one.

Increases health up to the object's maximum health.

HealStamina forwards a wrap32 stamina sum bounded by a signed maximum comparison to receiver virtual [field].

Description pending.

Clamps the supplied point and invokes virtual placement with two true flags.

Selects one of two virtual operations on a mask according to the supplied boolean.

Initializes an object command context, sets its facing point and conditionally invokes its command-update virtual method.

Implements a VM wait phase around an object's queued command progress.

Requests a script wait associated with an object's command progress, using the supplied duration. This overload uses the integer argument in the script wait counter and records the progress start and end times.

Adds the object to a named group, creating the group if necessary.

Looks up the supplied string key and calls [field] with the found object and resolved Obj when lookup status is zero.

Resolves one Obj reference, visits a temporary query snapshot and invokes a member-removal helper for each snapshot node.

Passes the string payload pointer and the resolved Obj to an implementation operation.

Adds an eligible Obj to active-player selection when the supplied player matches the current player.

Calls the selection helper with mode one only when the supplied player slot matches game [field].

Removes the object from the selection.

Clears the selection when the supplied player is the current player.

Requests a script-object animation and returns the VM suspension code.

Prepares and requests an animation with an optional target point.

Normalizes an equal-current point and forwards a decremented animation identifier with a final integer.

Forwards a decremented state identifier and preserves an anomalous invalid-receiver VM zero push.

RemoveItem int dispatches removal after signed one-based bounds.

RemoveItem str dispatches removal after nonnegative name lookup.

RemoveAllItems repeats virtual removal until count is zero.

Formats the supplied HX string under a receiver-field gate and releases it on every normal path.

Formats the supplied integer through chat dispatch when the receiver field matches the global gate.

Formats the unresolved payload handle pair when the receiver field matches the global gate.

SetDebug normalizes its byte Boolean to a dword 0/1 and forwards it through object virtual [field].

Increments a shared 32-bit value. The implementation reports status zero.

Routes class creation and placement across a signed grid, aborting on factory or template failure.

Prepares a named group and routes compatible grid objects to its insertion virtual.

Allocates and populates a command-shaped object before game submission.

SetCmdEnable writes normalized bool to object [field] only after virtual [field] returns zero.

Passes the resolved Obj to the next operation without checking for a null reference.

Passes the resolved Obj to the next operation without checking for a null reference.

Adapts script string and object arguments to the spatial sound playback method [field] and releases the string reference.

Submits string payload with a virtual point whose second coordinate is decreased by 120.

Resolves a named group and dispatches one of three level deltas according to the game difficulty value.

Invokes a virtual operation on query members that lack a particular object flag. The meaning of that flag is not documented.

Passes the script player value minus one to each live Query member's virtual slot [field].

Adds a signed amount to eligible query members' health and clamps each result to maximum health.

Adds an integer amount to eligible Query members' stamina and caps it at each member's maximum.

Resolves Query and optional Obj, passes point, target ID or 65535 and two normalized flags to the default-command dispatch chain.

Description pending.

For each live member of a resolved Query, calls virtual [field] with zero while the global gate is zero.

For each live Query member, calls [field] with zero while the global gate is zero.

Dispatches factory mode zero for each live Query member and installs nonnull results with the normalized bool.

Dispatches factory mode one with the unchanged point pair for each live Query member and installs nonnull results.

Dispatches factory mode two with the raw Obj pair after validating its low-word registry slot, installing nonnull results on live Query members.

Transforms each live member position by requested point minus live-member average, then dispatches mode one without local clamping.

Calls virtual [field](0) before mode-zero factory dispatch and calls [field](0) after each live member attempt.

Creates and installs the requested point command on each valid object selected by a Query.

Constructs and installs an object-targeted command for each live member of a resolved Query.

Translates member positions relative to the live-member average and clamps them before factory mode-one dispatch, after virtual [field](0).

Divides an unsigned experience amount across query members and adds the remainder to the first registry-live recipient.

Routes Query and area name to the shared dispatcher with the advance literal.

Routes Query and area name to the shared dispatcher with the move literal.

Dispatches live query members to the named group collection.

Removes each live object in the query from the named group.

Description pending.

Applies a face-point command to each live member of a query.

Assigns a nonnegative food value to every unit-compatible live member of a query.

Attempts forced holder entry for unit-compatible members of the query.

Dispatches unit-compatible query members to a Boolean-selected game virtual operation.

Dispatches a mask to eligible script objects through a virtual operation selected by the boolean argument.

Sets or clears a unit flag for eligible query members.

Conditionally repairs a broken Building to a health percentage above the broken threshold and refreshes its damage visuals.

Resolves the Building, checks its class descriptor and converts an embedded interface to a town hall interface before passing it to a UI allocation operation.

Starts a global-spell operation for a town hall when the first integer is in the range zero through five.

Starts a global-spell operation for a town hall with three script integers when the first is in the range zero through five.

Stops a town hall's global-spell entry by delegating to the global spell manager.

Passes a town hall and an integer to a global-spell vector updater.

Stonehenge-gated Building primitive with two-path candidate collection and capped signed level-to-XP dispatch, retaining concrete storage and override prerequisites.

Invokes a rectangle scan that reduces a linked object counter and qualifying wagon food.

Scans matching buildings and adds 300 divided by the script argument to linked settlement gold.

Collects eligible Druid objects for a Stonehenge town hall and invokes their divine-sacrifice operation.

Building::ClearDamageTaken writes zero to the resolved Building's dword at [field].

Building::SetUITarget writes the target object's 16-bit registry slot to Building [field], or 65535 when the target does not resolve.

Resolves a named command descriptor and invokes research with temporary command-cost context.

Description pending.

Description pending.

Description pending.

Description pending.

Stores a target handle on a catapult and propagates it to associated CatapultTower objects.

Clears a catapult's own target and propagates tower-target clearing to associated catapult towers.

Clears the stored target on CatapultTower objects associated with a catapult.

Stores a speed factor dword on a resolved Unit.

Stores a user dword on a resolved Unit.

Stores the supplied food value on a resolved Unit and dispatches a value-dependent virtual state update.

Updates the resolved Unit's feeding flag from a bool argument.

Constructs a path object on the first blocking invocation or reuses its saved pointer, calls its virtual [field] with a calculated step time, and returns native status 1 while a step remains or 0 after destroying the object.

CKS-exposed Unit::ExitHolder passes a position to a reserve and movement path that can detach the Unit from its Holder.

CKS-exposed Unit::EnterHolder, resolving a Building argument's Settlement Holder and force-entering it.

Invokes the flag-setting operation on the resolved Unit for a particular flag.

Invokes the flag-clearing operation on the resolved Unit for a particular flag.

Unit::SetLastAttackTime copies one 32-bit value from [shared state] offset [field] to the resolved Unit at offset [field].

After valid/dead checks, calls Unit helper [field] only when Hero [field] matches Unit [field].

With nonzero continuation, waits on the special virtual [field] coordinate pair; otherwise dispatches action 4 through [field], clears target tracking and returns native status 3. Zero continuation returns 0.

With nonzero continuation, waits on the special virtual [field] coordinate pair; otherwise dispatches action 5 through [field], clears target tracking and returns native status 3. Zero continuation returns 0.

Scripting VM bridge writing a raw experience value directly through the shared virtual experience setter.

Scripting VM bridge clamping input level, looking up experience threshold, and calling virtual experience setter.

Adds an integer to the resolved Unit's kill counter field.

After formation-state checks and possible holder waits, clears target tracking, creates a path controller when absent, passes formation field [field] to controller virtual [field], sets Unit [field] to 3, and returns status 0; ineligible state returns 2.

For nonzero continuation, clears target tracking, sets movement state 3 and a unit flag, stores wait ticks and reports status 1. For zero continuation, may clear a satisfied controller, clears the flag and reports status 0.

Dispatches a resolved Unit to one of two game virtual operations according to a boolean argument.

Stores the supplied 32-bit value in a field of the selected player record.

Sets or clears bit 19 of a resolved Unit's state flags.

Sets or clears bit 20 of a resolved Unit's state flags.

Unit[field] is the current zero-based animation index; the no-argument SetWalkAnim selects index zero and the int overload stores argument minus one.

Unit[field] is the current zero-based animation index; the no-argument SetWalkAnim selects index zero and the int overload stores argument minus one.

Selects animation index 16 for eight recognized villager ambient template names.

Maps recognized villager ambient template names to one of two carry-goods animation state values.

Clears Unit command state and dispatches a series of path, visual, context, and virtual calls.

Clears Unit [field] bit [field] and sets it when the bool argument is nonzero.

Sets or clears the Unit minimap flag from a bool argument.

Clears a unit flag, then sets it if the boolean argument is nonzero.

Unit::ForceIdle pops an 8-byte Unit handle, validates it through the global unit registry, and writes 32-bit integer 1 into unit offset [field].

Passes a resolved Unit to helper [field] and returns native status zero; invalid Unit skips the call.

Unit::SetBuilding writes the Building argument's 16-bit registry slot to Unit [field], or 65535 when the Building does not resolve.

For index below 36, a nonzero bool ORs its shifted bit into Unit [field], while false calls [field] to clear it; invalid Unit or out-of-range index is skipped.

Changes parry mode when the Unit capability bit allows it.

Delegates a resolved Unit to a status-effect helper with mode zero.

Delegates a resolved Unit to a status-effect helper with mode one.

Sets a Unit disease flag and creates an effect when its slot is empty.

Description pending.

Resolves a named class template and dispatches Unit mutation or a deferred mutation state.

For nonzero continuation, refreshes formation movement, sets hero state 3 and a flag, stores the integer as VM wait ticks and reports status 1. Zero continuation clears the flag and reports status 0.

After holder-related waits, the point overload clears the Hero path controller, passes the point, two integers, and bool to formation destination change; on success it installs a new controller, enables formation move mode, and sets Hero [field] to 3.

After holder-related waits, clears the hero path controller and selects an object destination change or a point destination derived from the object, depending on an object flag. On success, installs a new controller and sets hero state 3.

SetFormation resolves the supplied string in the formation map and, when found and Hero [field] exists, passes the string text to the formation object shape-setting helper; unknown names and invalid Heroes call the error helper.

Delegates Hero::DetachArmy to the army cleanup routine.

Delegates Hero::CancelArmyBoard to a holder and army validation routine.

Stores the transformed orientation request point for this function.

Resolves the hero reference and delegates the skill-level update.

Clears or sets a flag in the resolved Hero according to the boolean argument.

Description pending.

Description pending.

Description pending.

Allocates an editor object and dispatches construction with the data/subai literal.

Consumes a managed directory string and dispatches the editor constructor.

Shared no-argument handler for two CKS registrations that allocates and constructs a dialog using the literal EditorIni/ string.

Consumes a CKS string and passes its character data to the dialog constructor.

Shared no-argument handler for two CKS registrations that allocates and constructs a dialog using the literal EditorIni/ string.

Branches on the minimap holder and either constructs its supporting message/UI objects or invokes close/destruction slots.

Consumes a script rectangle, narrows its coordinates to words, shifts/clamps it against native bounds, and updates an existing minimap.

Consumes a managed script string and forwards a temporary native string to the minimap builder.

Invokes a virtual operation on the shared zoom-map interface.

Invokes a virtual operation on the shared zoom-map interface.

Invokes a virtual operation on the shared zoom-map interface.

Selects the carried resource type and forwards the supplied amount to the wagon amount-update helper.

Selects the carried resource type and forwards the supplied amount to the wagon amount-update helper.

Adapts Wagon resource loading through a selected pointer, signed capacity arithmetic and resource-store removal.

Adapts Wagon resource loading through a selected pointer, signed capacity arithmetic and resource-store removal.

CKS-exposed setter that validates a 0..100 loyalty value and writes it, scaled by ten, to the wagon's loyalty field.

Description pending.

Description pending.

Description pending.

Description pending.

CKS-exposed Settlement::ForceAddUnit, adding a unit to the settlement's Holder bypassing capacity.

Writes raw loyalty directly from a 0-100 input, bypassing the change accumulator.

Subtracts a scaled non-negative amount from the loyalty change accumulator.

Sets current gold on the resource store to an absolute value, clamped to the store's maximum gold.

Sets current food on the resource store to an absolute value, clamped to the store's maximum food.

Writes current population, clamped to at most the settlement's maximum population.

Applies an unconditional signed delta to current population, with no guard or clamp.

CKS AddToMaxPopulation adapter that adds a dword delta after guarded receiver resolution.

Description pending.

CKS SetLoan adapter that overwrites settlement offset [field] with wrapped signed scaling and calls a helper.

Writes the settlement's food production rate unconditionally.

Writes the settlement's gold production rate unconditionally.

AllowCapture stores the zero-extended argument byte at Settlement [field].

ClearDamageTaken writes zero to dword [field] of every iterated settlement member.

Adds an amount to a player-level gold-converted accounting counter without mutating the resource store.

CKS GoldSpent adapter that adds an amount to a selected structure's dword at offset [field].

PutSentry calls [field] with wrapped [field] plus one and then increments dword [field].

Decrements one of two settlement sentry counters with a zero floor on the fallback field.

AddSentries adds its integer argument modulo 2^32 to [field], then calls [field] with wrapped [field] plus the same argument.

Settlement::AddMaxSentries adds its signed integer argument directly to the resolved Settlement's dword at [field].

Dispatches virtual removal for the first indexed entry whose derived string equals the supplied name.

Repeatedly invokes virtual removal at index zero until the count becomes zero.

SendMule and SendBoat call the same helper with mode zero or one when their linked target passes a relation-bit gate, otherwise clearing that target id.

SendMule and SendBoat call the same helper with mode zero or one when their linked target passes a relation-bit gate, otherwise clearing that target id.

Description pending.

Description pending.

UnloadWagon adds the wagon quantity to the linked settlement resource dword and clamps the wrapping sum by a signed comparison to its capacity.

Description pending.

Appends an Obj's slot to the list if no matching slot is already present.

Removes the first matching Obj slot from a list.

Removes list members lacking a registry object or reporting nonzero at virtual slot [field].

Iterates a source object list and appends objects not already present in the destination list.

Removes receiver members matching handles encountered in a second list.

Empties an ObjList's chunked member container.

The handler looks up the named group, creates a group object on the nonzero lookup branch, then traverses the receiver list.

The handler looks up the supplied group name.

Traverses groups and input list members, conditionally erasing matching members from each group.

For each resolved member whose virtual [field] predicate returns zero, invokes [field] with zero to update command state.

Iterates an ObjList and clears commands on members accepted by a virtual eligibility predicate.

Creates and enqueues a named command for every eligible object-list member.

For each resolved eligible member, creates a named point command with selector 1 and submits it through virtual [field] using the supplied Boolean.

After validating the supplied Obj handle, creates a named object-target command with selector 2 for each eligible member and submits it through virtual [field] using the Boolean.

Creates point-targeted commands for object-list members while preserving their offsets from the list center.

Resolves the optional Obj handle to its object identifier at +8 and delegates the list, point, identifier, two Booleans and -1 to [field].

Looks up the supplied command string through the command-order registry virtual [field]; on success passes the resolved command and remaining arguments to [field], while the failure path reports an invalid command.

For each resolved eligible member, calls virtual [field] with zero, creates the named command with selector 0, submits it through virtual [field] with false, and updates command state.

For each resolved eligible member, calls virtual [field] with zero, creates a named point command with selector 1, submits it through virtual [field] with false, and updates command state.

After validating the receiver and target Obj, calls virtual [field] with zero on each eligible member, creates an object-target command with selector 2, submits it through virtual [field] with false, and updates command state.

Computes the list center, offsets each eligible member position from that center, clamps the translated target to map bounds, then creates and submits a selector-1 point command after virtual [field].

After popping the point and receiver list, the handler traverses member slots.

The handler rejects a negative input.

The handler accepts input player numbers 1 through 16.

Moves compatible units from the list into the named settlement.

Applies a visibility boolean to an object list and to eligible nested visibility controllers of its members.

Selects ObjList member slots by a numbered special-bit test and constructs an ObjList value.

CKS Conversation Init adapter that replaces a referenced window and delegates named initialization.

Description pending.

Description pending.

Description pending.

Description pending.

Pops value and key managed strings and delegates their payloads to the environment writer.

Description pending.

Encodes a resolved object identifier as decimal marker text and delegates it with the key.

CKS native primitive that writes a string value under a key into a settlement's Env key-value store.

Formats a settlement-scoped environment path and writes a decimal integer value.

Description pending.

Formats a building-scoped environment path and delegates the value string to the environment writer.

Formats a building-scoped environment path and delegates an integer value as decimal text to the environment writer.

Formats a building-scoped key and encodes an object identifier for the environment writer.

Writes a string under a key in the specified player's environment. Arguments are, in order, the player number, the key, and the string to write.

Formats a player-scoped environment path and writes a decimal integer value.

Formats a player-scoped key and encodes an object identifier for the environment writer.

Description pending.

Description pending.

Description pending.

Consumes a filename and dispatches the serializer-produced buffer to a VFS stream.

Description pending.

Parses command-definition triples and dispatches settlement property writes.

Gates on research command type and dispatches player property writes from command triples.

Validates a named sequence and starts the matching sequence when validation succeeds.

Prints a status line for every registered script sequence.

Pops a world point and lock boolean from the CKS VM stack and forwards them to the native camera-centering helper.

PlayMusic dispatches a guarded named sound request.

plays a global 2D non-spatial sound effect via the sound manager.

PlaySound player overload gates its request on the local player index.

SetSpeed prepares and submits a command when game field230 is zero.

TogglePause alternates submitted values between one and saved speed.

Adapts the verified global Run overload with 0 integer arguments to named script compilation and dispatch.

Adapts the verified global Run overload with 1 integer arguments to named script compilation and dispatch.

Adapts the verified global Run overload with 2 integer arguments to named script compilation and dispatch.

Adapts the verified global Run overload with 3 integer arguments to named script compilation and dispatch.

Adapts the verified global Run overload with 4 integer arguments to named script compilation and dispatch.

Adapts the verified global Run overload with 5 integer arguments to named script compilation and dispatch.

Compiles the requested script with a Settlement argument declaration and dispatches it after successful compilation.

ToggleFPS writes the zero test of global [field].

Dispatches input-block flags and refreshes then destroys the control-group HUD holder.

Dispatches input-unblock flags and ensures the control-group HUD exists.

Validates a player index and delegates a center and radius to a map exploration helper.

Gates a named-area reveal call by a signed player index.

Converts a one-based player input to a zero-based index and delegates its address with the lose flag to the game virtual method.

LockView sets global [field], the flag read by IsViewLocked and shared with camera-follow activation.

UnlockView clears global [field].

StartViewFollow resolves the target unit and activates camera tracking by setting [shared state] at [field] to 1 and storing the unit ID at [field].

Writes zero to a shared 32-bit value and the all-bits-set sentinel to a shared 16-bit value.

Resolves a managed NamedObj packet to a live unit and conditionally installs view-follow state.

SetDifficulty admits exactly zero one and two.

ChangeMap looks up its first string in the game map table before forwarding mapped text and its second string.

SetNextSeason stores codes3,2,1 only for complete winter,autumn,spring matches.

Passes an inverted script boolean to a UI control helper and stores the original byte at Game[field].

SaveAdventure builds profile[field] slash payload dot-adv and forwards it on the initial phase.

Description pending.

Description pending.

Description pending.

Description pending.

Crash attempts an absolute zero-address dword write before its normal status-zero tail.

Clears a resolved area state field before a conditional thread request.

Dispatches a successfully resolved area to an enable helper.

Spawns an AdvArea and forwards rectangle, name and string setup.

Spawns and configures a circular adventure area from script arguments.

Consumes the Druid and Sacrifice references. For a nonnull Sacrifice, passes the receiver and resolved Druid to an implementation operation.

Processes a temporary collection, accepting nonnull entries only when they carry a particular flag and their registered reference is null or matches the resolved receiver.

Consumes one reference and queries an interface derived from the receiver. If that query is nonnull, invokes the corresponding operation on the returned interface.

Converts the script name to a native string and dispatches to the note-manager helper with a zero second argument.

Converts the script name to a native string and dispatches to the note-manager removal helper.

Dispatches a zero argument to the notes-dialog helper and returns normally.

Dispatches note-tree erasure and resets its header links and logical count to the empty state.

Resolves a Unit and a feedback class name, looks up its class template, and spawns the feedback visual/audio effect.

Resolves a unit and named class and dispatches feedback construction with the supplied duration integer.

Constructs named feedback at a supplied point and initializes its scheduling field from the current game field.

Constructs named feedback at a supplied point and initializes its scheduling field with the integer offset.

Description pending.

Description pending.

Description pending.

Description pending.

Description pending.

Description pending.

Resets gate proximity cache and runs a bounded native circle scan.

CKS-exposed Gate::OpenNow, setting the target state to open and resetting the timer, guarded by broken status and current state.

CKS-exposed Gate::CloseNow, setting the target state to closed and resetting the timer, guarded by broken status and current state.

Teleport::Traverse ORs the dword at an indexed player record [field] into the resolved Teleport dword [field].

ShowBuildAnimation uses a 30-byte retained packet and leaves the VM cursor unchanged on nonzero wait returns, consuming the packet only on its terminal zero return.

Resolves Ship and Unit references and conditionally invokes the native boarding notification admission helper.

Description pending.

Description pending.

Selects candidate positions and dispatches a reserve and movement routine for matching ObjList members.

Resolves the Ship, builds a filtered position vector and repeatedly dispatches its first matching member while candidates and the saved-container count remain.

Initializes ship idle state when necessary and returns the VM blocking status.

Description pending.

Description pending.

Calls a resolved Unit's virtual bonus recalculation slot.

Builds a bonus descriptor, adds it to a Unit-linked collection, and recalculates bonuses.

Subtracts a bonus descriptor from a Unit-linked collection and recalculates bonuses.

Deducts a script-supplied amount from a registry object's dword and invokes its virtual slot zero when nonpositive.

Resolves the registered Item base and forwards it to the immediate use helper.

Forwards a target object handle to the targeted use helper after resolving the Item base.

Clamps a point to signed map bounds and forwards it to the positional use helper.

Description pending.

Validates and starts a Flying animation, then suspends the VM.

Conditionally transforms a referenced point outside an inset rectangle using object vector fields and quadrant rotations.

updates a squad's internal state code and records the transition timestamp.

Updates state, masked flags and a game-clock snapshot for a resolved Squad.

Updates a squad command state and notifies member units.

Updates squad state and flags and submits named zero-argument commands to member units.

Resolves the squad reference and delegates a command operation with target point coordinates.

Updates squad command state and submits an object-target command to eligible member units.

The handler pops two integers and two object handles.

Stores the final state argument before validating the target and delegates member siege planning.

Validates a packed Squad handle and delegates a destination command for an active squad.

Delegates a packed squad index to the player AI order-release helper.

Description pending.

Description pending.

Description pending.

The two-argument GetSquads replaces its referenced list with a fresh list of every packed squad ID in record [field].

The three-argument GetSquads replaces the referenced list and appends squad IDs whose nonzero [field] and computed category intersect its mask.

The four-argument GetSquads requires relation mask 1 before applying the category mask and rebuilding the output list.

Builds a SquadList from GAIKA squads filtered by relation and destination masks.

Accumulates three relation buckets and a conditional fourth squad subset into four referenced integers.

Traverses neighboring GAIKA records, filters them, and accumulates three referenced evaluation outputs.

The seven-argument Count fills four referenced accumulators selected by category mask and relation codes, leaving its fourth output unchanged on missing GAIKA.

SetPriority resolves low16 GAIKA through a player AI word mapping and calls the mapped-priority helper with the supplied priority.

Sets or clears bit 1 in a validated per-player GAIKA record.

Updates the no-attack mask in a byte of the resolved GAIKA record.

Updates the no-recruit mask in a byte of the mapped player record.

Scans town halls and reports minimum weighted distances for three diplomatic relation categories.

Resolves a per-player AI strategy context and delegates a GAIKA strategy assignment.

Description pending.

Description pending.

Description pending.

Description pending.

Applies priority 100 or -1 to player AI records whose points lie inside a named area.

Description pending.

Validates three distinct GAIKA identifiers and delegates a relation update to the global AI context.

DumpMAIKA filters and visits six-byte route records.

Sets bit 3 on every squad record referenced by a resolved SquadList.

Clears bit 3 on every squad record referenced by a resolved SquadList.

Creates a list entry when necessary and passes the supplied Squad low word to its append helper.

Reconciles the current player selection and adds resolved members of the supplied squad list.

OpenAllGates traverses gate members and submits opengate commands for gates whose target-state field is not 1.

IdleAllGates invokes gate virtual slot [field] with argument 1 when its current string does not equal idle.

Checks the current script player's AI context and delegates the input script ID to an AI break helper.

Routes an interruption request for the identified script to the specified player's AI system. Arguments are the player number followed by the script ID.

Description pending.

IsAIShow physically pushes one equality byte.

Uses a persistent blocking frame to interpolate a projected viewport center and schedule retries.

Resolves the Unit operand and dispatches the resulting pointer to a native AI hook.

Description pending.

Description pending.

CKS scripting primitive wrapper exposing Squadize(ObjList ol, SquadList *sl, int nState) to scenario and AI scripts.

Resolves a Settlement and named upgrade, then conditionally submits a research command.

Description pending.

Accumulates an amount in a per-game, per-settlement and per-player persistent army-spending counter.

Adds a signed amount with 32-bit wrap to the keyed technology expenditure value.

ClrShipNeeds writes zero to the global-AI ship-needs cell selected by lsa and player indices.

IncShipNeeds increments the global-AI ship-needs cell selected by lsa and player indices.

Description pending.

Description pending.

Description pending.

Validates a player, AI profile, and difficulty before replacing that player's AI controller.

Description pending.

Description pending.

CKS handler that forwards a tactic ID and resolved settlement to the player-AI tactic-task starter.

CancelSupply resolves stoptribute by name and forwards a seven-dword packet beginning with a partially initialized linked-object id to the native dispatch helper.

Scans settlement members for a repair descriptor and conditionally submits one staged command per admitted member.

CheckLP calls the graph helper with fixed node indices 3 and 1, mode 1, an empty string and two minus-one values, then discards its result.

SendSquadToLsaX retains a selected-unit pointer as a sixth order operand.

Prints widened signed mouse coordinates after calling a terrain conversion whose output is unused.

Description pending.

Resolves three referenced output integers, delegates a spatial query, and writes its three results.

Tries indexed AI candidates and dispatches a settlement fallback into the resolved integer-array destination.

Initializes two output references, evaluates 25 Hero skill slots through mutable target and weight references, and scans a virtual draw against admitted weights.

The handler traverses the supplied ObjList.

Converts two IntArray references to temporary handles and invokes the player-specific TSH_HeroSkills.vs universal command.

SelSquad without arguments submits the primary objects squad members.

SelSquad player-index overload submits resolved squad members.

SelSquadLeader submits the resolved first squad member.

Dumps spatial coordinates, settlement type, squad counts, and AI player status for a specified GAIKA identifier to in-game chat and logs.

Delegates a nonzero packed squad value to a diagnostic formatter.

Prints diagnostics for list elements from the active cursor and advances that cursor to its end.

The implementation performs no additional work and reports zero internally. This void signature exposes no return value to the script.

PrGAIKAStrat formats the named strategy query result.

vg requests camera centering and diagnostics for a narrowed GAIKA.

AIV integer overload passes a decremented player and empty prefix.

AIV string overload unlinks and releases its prefix operand.

DbgAI formats an AI profile under an upper-only player gate.

DbgArmy queries fifty class names and prints nonzero results.

Emits priority notifications for a bounded prefix of the local player's AI records.

SetAIVar updates the selected player AI variable when its player, index, record and table checks pass, discarding the write otherwise.

SetAIVar sets or clears bit (bit argument modulo 32) in an indexed dword reached through the selected player record.

Native adapter for this function resolving a player script and dispatching 0 integer arguments.

Native adapter for this function resolving a player script and dispatching 1 integer arguments.

Native adapter for this function resolving a player script and dispatching 2 integer arguments.

Native adapter for this function resolving a player script and dispatching 3 integer arguments.

Native adapter for this function resolving a player script and dispatching 4 integer arguments.

Native adapter for this function resolving a player script and dispatching 5 integer arguments.

Resolves a script path for a settlement's player and submits a command for that path.

Resolves a player script name and dispatches it as a registered command when found.

Forwards a packed squad value to a resolved registered script command.

Retries opening a filename and dispatches content through stream virtual methods.

Displays the supplied text in the in-game message log and chat window.

Displays an integer as a decimal number in the game's chat.

Displays true or false in the game's chat.

Invokes a clearing operation on a field of the game state.

Dispatches game vtable slot [field] and returns normal interpreter status if the call returns.

Requests the editor test transition through a helper that writes one to its flag.

Sets one global dword and dispatches two UI virtual operations.

Routes class creation, template validation and player-zero placement from console arguments.

Invalidation toggle primitives normalize their dword globals by a zero test.

Invalidation toggle primitives normalize their dword globals by a zero test.

Description pending.

ProfileStart forwards the profiling start request.

ProfileStop forwards the profiling stop request.

The implementation performs no additional work and reports zero internally. This void signature exposes no return value to the script.

ShrinkEntities invokes one worker and returns status zero.

ReloadConstIni delegates two operations with the constant filename.

Calls [field] and returns native status zero without accessing the VM cursor.

Calls [field] and returns native status zero without accessing the VM cursor.

PrintMemStats formats current and saved counters.

DumpObj preserves a five-byte modal packet while returning one.

Rewrites packed terrain cells across the map through a fixed sixteen-entry conversion table.

CheckClasses dispatches the class registry and diagnostic callback.

Clears one packed map bit per sixteen-unit interior coordinate and returns native status zero.

Description pending.

Constructs a twelve-byte fog command and sends it through the game command entry.

Normalizes one VM boolean into a sixteen-byte command payload.

Forwards the map subobject at [field] to one engine call.

Description pending.

Invokes virtual slot [field] on the global view receiver.

Description pending.

ActivateScreenShots preserves a nine-byte retry packet until stop.

ToggleScreenShots requests stop or compiles an activation call.

DebugSelected formats selection and script diagnostics.

The no-argument Save and Load adapters construct test.svg and route it to distinct helpers.

Selects a filename and routes a temporary map context to the object export worker.

Selects a filename and routes a temporary map context to the terrain save wrapper.

The no-argument Save and Load adapters construct test.svg and route it to distinct helpers.

Named Save and Load prefix Scenarios/ under a nonzero global or append.svg when no dot is present.

Named Save and Load prefix Scenarios/ under a nonzero global or append.svg when no dot is present.

ChMap consumes its script string and forwards its unchanged payload to [field].

Prints the signed word pair from the input-interface position query.

Allocates a conversation object and passes the fixed test name to its setup worker.

Selects one of two receiver calls and normalizes the selector to its zero test.

Attempts independent argument-sized square grids for players zero and one, then centers a terrain-adjusted point.

Routes a calculated packed-grid extent to zero fill and then processes the viewport refresh path.

Selects complementary mask2 argument triples for the control style helper.

Constructs a menu object and routes a managed name plus fixed layout arguments to virtual calls.

DumpStats resolves an Obj and formats its unit statistics.

Desync passes a diagnostic file object through two virtual calls.

Consumes one boolean byte and selects two helper sequences around active-pathfinder virtual slot [field].

Inserts a callback into a global list and refreshes the current render-target rectangle.

Description pending.

Invokes the map passability-mask rebuild routine for the current map bounds.

executes a modal introductory splash video/image sequence from INI configuration.

Description pending.

Zeroes the global packed height surface, rebuilds the derived slope surface, and processes the pending viewport rectangle.

Pause calls game virtual slot54 with one.

TestLoad calls [field] and returns status zero without a VM packet operation.

Sequentially executes explorer dialog state serialization followed by dialog list cleanup and heap deallocation.

sd delegates without a semantic incoming-register argument.

Dispatches the two UI virtual operations also used after the _Black global store.

Writes an unmasked shifted decor value into the selected packed-grid word and dispatches a callback.

Clears the selected 16-bit halfword of a packed-grid dword and dispatches a callback.

Dispatches a full-extent light worker with fixed constants before printing its completion label.

Forwards three VM integers and the full terrain rectangle to one worker.

Gates on signed X and forwards all four VM integers to a six-argument worker.

Dispatches the fixed XML filename and announces completion without checking the result.

Prints the running-script name for every currently selected unit, or a no-selection message.

Toggles one rendering callback in a global callback list and requests viewport redraw processing.

Routes a managed shape name to a selected registry object form pointer.

UndoMemory prints a sampled field or an unavailable diagnostic.

Description pending.

Description pending.

Resolves a translation key and prints the input and translated value to chat.

TTestf passes fixed variadic test operands to the formatter.

Dispatches a fixed scenario path through the game object virtual slot [field].

Prints a TLS-derived pointer with the literal ScopeStack format.

Initiates an integrity audit of the current adventure map set, reporting errors and warnings to the in-game message console.

audits adventure integrity and outputs results via the debug stream logger.

SettlementCount prints vector length and each stored building field.

Description pending.

GAIKAFD toggles a callback and forwards a bitmap filename.

ESG filters packed squad entries and prints a local accumulator.

GS prints a viewport cell identifier and a registered symbol.

Pops an integer and forwards it with /cvar1 to the property setter helper.

Pops an integer and forwards it with /cvar2 to the property setter helper.

Toggles a native mask bit and sends the viewport rectangle to the dirty-rect marker.

Clears the native draw mask and sends the viewport rectangle to the dirty-rect marker.

Sets every native draw-mask bit and sends the viewport rectangle to the dirty-rect marker.

Clears every packed 16-bit decor-grid sample across the global map dimensions.

The implementation performs no additional work and reports zero internally. This void signature exposes no return value to the script.

Description pending.

Description pending.

Description pending.

Description pending.

Description pending.

Description pending.

Description pending.

_SetNextSeason stores the parser result even when it is zero.

The implementation performs no additional work and reports zero internally. This void signature exposes no return value to the script.

Description pending.

Description pending.

Resolves a Hero and zeroes its 25 skill-level bytes directly.

Description pending.

_handles prints two initialized counter outputs behind pointer gates.

Description pending.

Description pending.

Native CKS binding writing eligible units from an ObjList into a numbered control group, validating the full 0..9 range.

Consumes the requested tab integer but uses it only as a guard for a selection refresh helper.

Narrows its integer to signed sixteen bits before terrain processing and refresh dispatch.

Runs a terrain worker followed by slope-grid rebuild and viewport processing.

Modifies a selected related unit descriptor, prints native values and conditionally creates feedback for a point command.

Description pending.

WaitPlayerChat copies and removes a matching-stamp chat entry into output references.

Projects the stored notification target and submits a scene viewport center request.

Triggers a notification from two script strings and a point when the requested player matches the active player.

Consumes 2 script strings and forwards their character data to the global AI helper invocation routine.

Consumes 3 script strings and forwards their character data to the global AI helper invocation routine.

Consumes 4 script strings and forwards their character data to the global AI helper invocation routine.

Consumes 5 script strings and forwards their character data to the global AI helper invocation routine.

Consumes 6 script strings and forwards their character data to the global AI helper invocation routine.

Consumes 7 script strings and forwards their character data to the global AI helper invocation routine.

Consumes 8 script strings and forwards their character data to the global AI helper invocation routine.

Consumes 9 script strings and forwards their character data to the global AI helper invocation routine.

Consumes a helper-name string and forwards a named task cancellation request.

Alternates destruction and allocation of the object pointer at [field].

Calls [field] only when the diagnostic object pointer is nonzero.

Restores the active pathfinder from task offset zero, releases the task and clears its global pointer.

Passes the current SPF task to an implementation operation. The implementation reports zero.

Delegates direction-map initialization from the current SPF build task.

Delegates point-to-area connection data initialization from the current SPF build task.

Initializes five counters in the current SPF build task from a nested size value.

Routes three arguments from the SPF task to [field] and then zeros task [field].

Description pending.

Description pending.

Description pending.

Description pending.

Description pending.

Shared address-taken handler that decrements the VM cursor by eight bytes and returns zero.

Description pending.

Builds a local statistics context, invokes collection and reporting workers, then cleans its stored output handle.

Routes a pointer to a local byte to the class-registry worker.

Allocates and constructs a unit-import adapter object under a nonzero global gate.

Allocates and constructs a decor-import adapter object under a nonzero global gate.

Allocates and constructs a building-import adapter object under a nonzero global gate.

The implementation performs no additional work and reports zero internally. This void signature exposes no return value to the script.

Description pending.

Description pending.

Consumes two VM string arguments and calls the announcement table helper using receiver [field].

Consumes a key string, looks it up in the table at [field], and sets a matched node field[field] to1.

Consumes two strings and an integer selector. Calls the announcement operation for selectors from 1 to 16 using the corresponding receiver.

Consumes a key and selector, and invokes the matched-node flag helper for a nonnull key and selectors1..16.

Forwards a player, key, string and importance flag to a global status store.

Forwards a player, key, and importance bool to the global player-status store when present.

Consumes an integer and conditionally forwards it to the notification helper.

Hints and tutorials setters conditionally write pointer field [field].

Hints and tutorials setters conditionally write pointer field [field].

Processes a temporary collection, accepting nonnull entries only when they carry a particular flag and their registered reference is null or matches the resolved receiver.

For a nonnull resolved Obj, MagicActionEnd forwards the word at receiver[field] to helper [field]; null resolution skips dispatch.

Consumes one reference and queries an interface derived from the receiver. If that query is nonnull, invokes the corresponding operation on the returned interface.

Consumes a managed string and player selector, conditionally printing its characters without releasing the payload.

Routes an empty native string to the report worker.

Description pending.

GAIKA::SetControlFlag sets or clears byte +2 mask 32 in the mapped player record.

Applies a bool argument to the Unit freedom state bit.

The three-argument EndGame stores its message only when the decremented player matches the computed local index.

Description pending.

Description pending.

Stores the supplied 32-bit value in a base item field.

WaitForMapChange waits while a cached adventure field equals the current field.