Unit

Reads the linked speed dword for a Unit handle.

Unit[field] defaults to 100, is exposed by the speed-factor getter/setter, and divides base step duration as a percentage.

Reads the stamina dword for a Unit handle.

Reads the user dword for a Unit handle.

Reads the food dword for a Unit handle.

Reads the linked maximum food dword for a Unit handle.

Reads the linked maximum stamina dword for a Unit handle.

Scripting VM bridge reading the cumulative raw experience counter directly from unit [field].

Scripting VM bridge calling virtual method vtable[[field]]() to obtain effective unit or hero level.

Scripting VM bridge computing unit inherent level on-the-fly from raw experience via LevelFromExp.

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.

Returns the resolved Unit's feeding flag as a byte.

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

Clamps the point to map bounds and coordinates a Unit path controller, movement command, wait ticks and terminal bool through native status 0, 1 or 2; its path destination call passes final flag 1.

Follows the point-route wait and completion branches while passing final flag 0 to the path destination call at [field]; the sibling Goto point handler passes 1.

Resolves an optional Obj and required Unit, clears Unit tracking at [field] when set, then delegates the movement state machine to [field]; invalid Unit pushes false.

Prepares target tracking and delegates cooperative attack routing.

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.

For a nonzero continuation state, clears target tracking and requests an active-path stop with wait status 1, or clears the controller and returns true. For zero state, checks a virtual path operation, returns its boolean outcome and clears a unit flag.

Returns false for an invalid Unit or when a unit state field differs from -1. Otherwise checks an implementation operation for hero units with a particular flag, or a unit field for nonhero units. The field meanings are not documented.

Returns two signed 16-bit components from path-controller virtual [field] when Unit [field] exists, otherwise from Unit virtual [field]; an invalid Unit returns (-1,-1).

Unit::TimeWithoutWalking returns zero for sentinel -1 at Unit [field], otherwise subtracting it from the dword reached through Unit [field].

Checks whether the resolved Unit records a holder reference different from the invalid-reference sentinel.

Unit::GetHolderSett derives a returned slot word through Unit [field], registry entry [field], and final entry [field].

Follows the Unit holder handle and a linked registry handle, then returns whether the latter resolves.

Follows the Unit holder object's linked registry handle and returns that object's handle or an invalid Ship handle.

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.

Returns the objects in the unit's holder as a new ObjList.

A Unit training-attack primitive that can start native attack mode 2 and return VM handler status 3.

Searches nearby candidates around a resolved Unit and returns the selected object's handle or an invalid handle.

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::IsTraining extracts bit 28 from the resolved Unit object's dword at offset [field] and returns it as a boolean.

Implements a cooperative single-target attack sequence using continuation state, eligibility checks, attack dispatch, and wait status.

Implements a cooperative attack sequence with range and eligibility checks before dispatch.

Unit::TimeWithoutAttack returns the 32-bit subtraction [[shared state][field]] - [Unit[field]], with zero as the invalid-unit fallback.

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

Resolves a Unit, verifies it is alive, and queries the squad sight targeting search engine function, returning the best target object handle.

Calls the squad-sight target search with zero option arguments after validating the Unit.

Calls squad-sight target search with the no-independent option set.

Finds the best tactical target within squad sight matching the supplied class filter string.

Calls squad-sight target search with string data and the exclusive option set.

Calls squad-sight target search with the prefer-undiseased option set.

searches for the best combat target for a unit using its current position and sight radius.

Forwards explicit point coordinates and integer radius to the common target-search helper.

For a valid live unit, returns whether the enemy record associated with its squad contains entries.

Builds a diplomacy-filtered spatial query around the Unit and returns whether a matching candidate was found.

Checks a resolved target against a resolved Unit using the common attack-range helper.

Returns an eight-byte Hero handle containing the resolved Unit's linked Hero slot.

Resolves Unit and Hero, rejects invalid or virtual [field] positive operands, then returns whether Unit helper [field] accepts the Hero.

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.

Prepares a point-centered path query for a Unit and returns the native pathfinder result code or a sentinel.

Prepares an object-centered path query for a Unit and returns the native pathfinder result code or a sentinel.

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

Returns the registered Unit GetParty boolean for this function.

Invokes a Unit virtual handle provider and returns its first word as a Sacrifice handle.

Tests a packed global-map bit at the resolved Unit's virtual position.

Returns a random unexplored point near the unit, or the point (-1, -1) when it finds none.

Combines a Unit flag test with a class helper to return a boolean.

Returns the registered Unit GetFlags boolean for this function.

Returns a value from the Unit's [field] controller virtual method, or sentinel 900000000 when unavailable.

Description pending.

Returns the nonnegative part of a resolved Unit's signed stamina decrement time field.

Compares the holder-handle words of two resolved Units.

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

Reads bit 19 of a resolved Unit's state flags as a boolean.

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

Reads bit 20 of a resolved Unit's state flags as a boolean.

Selects the unit's walking animation from the supplied index. This call does not issue a movement order.

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 the carry-water animation for recognized ambient-villager templates. The call selects an animation; it does not collect or transfer resources.

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

Tests whether a resolved Unit's carry animation selector is zero.

Clears the unit's command state. In verified calls, it also moved the unit to (-1, -1), away from its map position.

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.

When Unit [field] exists and its virtual [field] returns nonzero, returns the point from path virtual [field]; otherwise returns (-1,-1).

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.

Reads one Unit flag bit as a CKS bool.

Reads one Unit flag bit as a CKS bool.

Configures target filters and delegates curse-target selection to spatial or squad-aware search helpers.

Returns a Building handle containing the resolved Unit's linked Building slot.

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

Tests an indexed bit in the Unit special mask.

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.

Builds a script string from a Unit special-name table entry or fallback.

Unit[field] bit 0 gates parry support, while Unit[field] stores the Boolean mode changed by SetParryMode and returned by GetParryMode.

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.

Runs a bounded spatial candidate query and emits an Obj handle.

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

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.

Description pending.

Returns two 32-bit components from the resolved Unit as a point.

Returns the zero-extended squad word linked from a resolved Unit.

Returns a target object handle selected by the GAIKA target search helper for a resolved Unit.

Queries whether a unit is controlled by AI by verifying player AI state and checking the squad record's active AI flag.

Ranks filtered hostile squad leaders by a circle relation count with optional friendly penalties and a distance bonus.

Scores hostile squad leader neighborhoods by relation-count balance and a product, preferring a normal leader result over a same-player sacrifice override.

Maps the resolved Unit's [field] state integer according to a global animation mode predicate.

Applies a bool argument to the Unit freedom state bit.

Returns a Unit reference when the object has a compatible unit category.

Configures target filters and delegates curse-target selection to spatial or squad-aware search helpers.

Description pending.

CKS-exposed AI helper that scans for an ally to apply an experience-gain effect to, sharing the same vision-range/eligibility pattern as the druid's other target-search helpers.

CKS-exposed AI helper that scans for an ally to apply an invisibility-style effect to, sharing the same vision-range/eligibility pattern as the druid's other target-search helpers.

CKS target selector that chooses the greatest positive [field] score among eligible candidates from a squad-member traversal or a radius-bounded map traversal.

CKS-exposed AI helper that scans for a drained ally to recharge, sharing the same vision-range/eligibility pattern as the druid's other target-search helpers.

CKS Druid adapter that searches within receiver [field] and validates one spatially selected candidate against a strict experience-derived level threshold.

Description pending.

CKS Jupiter Anger target adapter that allocates an output registry slot for an eligible target without clearing the stored target field.

Description pending.

CKS scripting bridge resolving a squad's leading unit handle from the head of its member collection.

Returns the currently selected unit handle, or the null handle when the selected object is not a unit.

calculates the entrance point coordinates of a building relative to an approaching unit.

Compares the holder-handle words of two resolved Units.

Description pending.

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

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

Description pending.

Description pending.

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

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.

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

Description pending.

Description pending.

Scores a candidate unit using squad size, affiliation equality and its virtual level result.

Returns a stored destination or derives an approach point for selected building configurations.

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