Namespace FishMMO.Shared

Namespaces

FishMMO.Shared.Core

Classes

AIAbilityClassifier: Works out what an ability does by reading the ECA action graph the designer already built, so archetypes never have to name specific abilities.

Abstract base class for AI ability conditions. Each condition evaluates a boolean predicate that determines whether an ability rotation entry should be selected. Conditions are ScriptableObject assets that can be shared across multiple rotations.

Subclasses override Evaluate(AIController, ICharacter, ICharacter) to implement specific checks such as health thresholds, buff presence, distance comparisons, etc.

AIAbilityIntentExtensions: Helpers for reasoning about an ability's intent.

AIAbilityRotation

ScriptableObject that defines an ordered list of ability entries with conditions. Attach to an AIController to give NPCs intelligent, designer-driven ability selection instead of (or in addition to) the default scoring-based picker.

In Priority mode, entries are evaluated top-to-bottom and the first match wins — ideal for conditional behaviour such as "use Heal when health ≤ 40%, else use Fireball".

In Sequence mode, the NPC advances through the list in order, trying the next entry each evaluation — ideal for structured rotations such as "Fireball → Frost Bolt → Pyroblast → repeat".

AIAbilityRotationEntry: A single entry in an AI ability rotation. Pairs an ability template with a set of conditions that must all be satisfied for the ability to be selected.

AIAdoptGroupTargetNode

Behavior tree leaf that adopts the group's shared target. If the NPC belongs to an NPCGroup with a GroupTarget, this node sets the NPC's Target to match and returns Success.

Use case: "Focus the tank's target" → place this before a StateTransition to AttackState.

AIArchetypeTemplate: A complete, reusable AI brain in one asset: which states an NPC uses, how it picks abilities, and how it behaves in combat.

AIBehaviorNode

Abstract base class for all behavior tree nodes. Nodes are ScriptableObject assets so designers can build trees entirely in the Unity inspector without code.

Behavior trees sit above the state machine layer and decide which BaseAIState the NPC should transition to. The state machine then handles the actual movement, combat, and animation logic.

Node types:

AISelector — Tries children left-to-right, returns first success.
AISequence — Runs children left-to-right, fails on first failure.
AIInverter — Inverts the child's result.
AIRepeater — Repeats the child a configurable number of times.
AIConditionNode — Leaf that checks an AIAbilityCondition.
AIStateTransitionNode — Leaf that transitions to a BaseAIState.

AIBehaviorTree

Root container for a behavior tree. Assign to BehaviorTree to give an NPC high-level decision-making above the state machine.

The tree is evaluated once per AI tick (governed by AI LOD). If the root node returns Success, the tree produced a state transition and the current state's UpdateState is skipped for that tick. If it returns Failure, the current state continues normally.

Example tree:

AIBehaviorTree (root = Selector)
  ├─ Sequence: [Condition: IsDead] → [StateTransition: DeadState]
  ├─ Sequence: [Condition: HP ≤ 30%] → [StateTransition: RetreatState]
  ├─ Sequence: [Condition: EnemyNearby] → [StateTransition: AttackState]
  └─ StateTransition: WanderState

AIBuffCondition

Condition that checks whether a character has (or doesn't have) a specific buff or debuff.

Examples:
- "Self has buff 42" → target already has a HoT, skip re-applying.
- "Target missing debuff 7" → apply the DoT.

AICombatDecision: The single combat decision shared by every attacking state.

AICombatPersonality

Data-driven combat personality asset that makes two NPCs with the same ability set behave differently in combat. Assign to Personality.

The personality provides per-AbilityCategory score multipliers that PickBestAbility(float) applies on top of the default scoring. Two warriors sharing the same ability list but with different personalities will favour different abilities and positioning.

Range thresholds control how abilities are classified. Abilities whose Range falls below MeleeRangeThreshold are considered melee; those above are ranged. Abilities with HitCount greater than 1 or grounded spawn targets are classified as AOE. Self-targeted abilities are classified as Support.

AICombatSlots: Hands each attacker its own standing spot in a ring around a shared target, so a pack surrounds its victim instead of piling onto one point.

AICompositeNode: Composite node that wraps a list of children. Base class for AISelector and AISequence.

AIConditionNode

Leaf node that evaluates an AIAbilityCondition and returns Success or Failure.

Use case: "Is the NPC's health below 30%?"

The existing AIAbilityCondition system is reused so designers don't need to create duplicate condition assets. Any condition that works in an ability rotation also works as a behavior tree guard.

AIController: Controls AI navigation, state transitions, and behavior for NPCs using NavMeshAgent. Handles movement, enemy detection, leash logic, waypoints, state management, and provides a virtual camera for aiming abilities at targets during combat.

AIDistanceCondition

Condition that evaluates based on the distance between the NPC and its current target.

Examples:
- "Distance ≤ 3" → in melee range, use a cleave ability.
- "Distance ≥ 15" → far away, use a snipe ability.

AIGroupInCombatNode

Behavior tree leaf that checks if the NPC belongs to an NPCGroup and whether the group is currently in combat. Returns Success when the group is fighting.

Use case: "If my pack is in combat → join the fight (even if I haven't been attacked)."

AIHasTargetNode

Behavior tree leaf that checks if the NPC currently has a combat target. Returns Success if Target is not null, Failure otherwise.

Use case: "If has target → stay in combat" in a behavior tree selector.

AIHealthCondition

Condition that evaluates based on a character's health percentage. Can check either the NPC's own health or the current target's health.

Examples:
- "Self health ≤ 40%" → use a defensive or healing ability.
- "Target health ≤ 20%" → use an execute ability.
- "Self health ≥ 80%" → use an offensive stance ability.

AIInverter

Decorator that inverts the child's result. Success becomes Failure and vice versa. Running passes through unchanged.

Use case: "If NOT low health → continue attacking."

AIIsDeadNode

Behavior tree leaf that checks if the NPC is alive. Returns Success when alive, Failure when dead or missing damage controller.

Use case: First check in a selector — "If dead → DeadState". Combine with AIInverter to get "IsAlive".

AILodSettings: Distance thresholds and per-tier update intervals for AI level-of-detail. Assign to LodSettings.

AIRandomCondition: Condition that passes with a configurable random probability each evaluation. Useful for introducing variety — e.g., "30% chance to use a special attack".

AIRepeater

Decorator that repeats its child a configurable number of times per evaluation. Returns Success after all repetitions succeed. Returns Failure if any repetition fails.

When RepeatCount is 0, repeats indefinitely (always returns Running).

AISelector

Selector (OR) node. Tries each child left-to-right and returns Success as soon as one child succeeds. Returns Failure only if every child fails. Returns Running if any child is running.

Use case: "Try heal → if that fails, try attack → if that fails, wander."

AISequence

Sequence (AND) node. Runs each child left-to-right and returns Success only if every child succeeds. Returns Failure on the first child that fails. Returns Running if any child is running.

Use case: "Check health condition AND then transition to retreat state."

AIStateTransitionNode

Leaf node that transitions the NPC's state machine to a specific BaseAIState. Always returns Success after triggering the transition.

This is the bridge between the behavior tree (decision layer) and the state machine (execution layer). The tree decides "attack", and this node calls ChangeState(BaseAIState, List<ICharacter>) to make it happen.

AITargetSelection: Target-picking strategies shared by the attacking states and the behaviour tree.

AIUtility: Shared utility methods for the AI subsystem. Provides common operations used across ability rotations, boss scripts, and attacking states to eliminate duplication (DRY).

AbandonQuestAction: ECA action that abandons a quest, removing it from the character's quest log. Server-only execution.

Ability: Represents an in-game ability instance, constructed from an AbilityTemplate and containing all runtime state and events. Resource costs and requirements are determined by ECA conditions on the template's ActivationConditions and each event's Conditions via the IResourceCost interface. Implements ITooltip for consistent UI tooltip display.

AbilityApplyAreaAction: Action that applies an ability effect to all targets within a specified area.

AbilityApplyHitscanAction: Action that resolves an instantaneous ray from the ability object and runs the ability's OnHit events for everything it passes through — the hitscan half of the ability system.

AbilityApplyTargetAction: Action that applies an ability effect to a single targeted character.

AbilityCollisionEventData: Event data for an ability hit, carrying the ability object and where the impact landed. The hit character is stored on the base TargetCharacter so all consumers can access it the same way.

AbilityController: Partial class for AbilityController handling network payload serialization and client-side broadcast registration for abilities and knowledge.

AbilityCrafter: Represents an ability crafter NPC that allows players to craft or modify abilities.

AbilityEvent: Abstract base class for ability events. Extends Trigger to provide ECA-driven conditions and actions. Ability requirements (resources, faction, archetype, attributes) are defined as ECA conditions on the inherited Conditions list or on the parent ActivationConditions list.

AbilityEventData: ECA event data carrying the ability ID for ability activation events.

AbilityForkHitAction: Action that turns an ability object onto a new heading inside a cone when it hits something — a projectile that scatters or ricochets off its target rather than carrying straight on.

AbilityHitCountAction: Adds to (or subtracts from) an ability object's remaining hit count.

AbilityMoveTransformAction: Action that moves an ability object along a straight line from its spawn pose, at the ability's speed, evaluated in closed form from the object's integer tick count.

AbilityObject: Represents a spawned ability object in the world, handling its lifetime, collision, and event triggers.

AbilityObjectSnapshot: Immutable snapshot of ability data, captured lazily at the moment an object is detached from its ability (DetachAllAbilityObjects()), not at spawn. If events were removed from the ability between spawn and detach the snapshot reflects the ability as it was at detach. Allows an AbilityObject to persist and function independently after the owning character disconnects, dies, or is otherwise cleaned up. When the live Ability reference becomes null (e.g., after detach), the AbilityObject falls back to this snapshot for lifetime checks, event dispatch, and collision handling.

AbilityObjectSweep: The swept shape query an AbilityObject resolves its hits with, in place of Unity's collision callbacks.

AbilityObserverBroadcastSerializers: Hand written wire format for AbilityActivatedBroadcast.

AbilityOnDestroyEvent: ScriptableObject event triggered when the ability object is destroyed.

AbilityOnHitEvent: ScriptableObject event triggered when an ability object collides or hits a character.

AbilityOnPreSpawnEvent: ScriptableObject event triggered before the primary ability object is spawned.

AbilityOnSpawnEvent: ScriptableObject event triggered when the primary ability object is spawned.

AbilityOnTickEvent: ScriptableObject event triggered when an ability object ticks (e.g., moves or applies continuous effects).

AbilityPrefabColliderCache: Static cache of prefab colliders keyed by ability template ID. Extracted from AbilityObject to keep that class focused on lifecycle and collision. Avoids repeated GetComponent calls on the prefab every spawn.

AbilitySpawnEventData: Event data for spawning abilities, containing all relevant information for ability instantiation and tracking.

AbilitySpawnMultiplyAction: Action that multiplies the spawn of an ability, creating multiple instances of the ability object. This is typically used to spawn several copies of a projectile or effect at once.

AbilityTemplate: ScriptableObject template for defining an ability, including prefabs, triggers, event lists, and requirements.

AbilityTickEventData: Event data for an ability tick. The tick subject's transform is reachable via AbilityObject.Transform so no separate transform field is carried here.

AbilityTypeOverrideEventType: ScriptableObject for overriding the ability type in an event.

AcceptQuestAction: ECA action that grants a quest to the initiating character. On the server, adds the quest to the character's quest controller and raises OnQuestAccepted. On the client, this action is a no-op.

Achievement: Represents a player's progress toward a specific achievement, including current tier, value, and template reference.

AchievementCompletedCondition: Condition that checks if a character has completed a specified achievement, optionally at a required tier and value.

AchievementController: Controls and tracks a character's achievements, including progress, tier, and event handling.

AchievementIncrementAction: ECA action that increments achievement progress for a character. Server-only execution.

AchievementTemplate: ScriptableObject template representing an achievement, including icon, category, description, and tiers.

AchievementTemplateDatabase: ScriptableObject database for storing and retrieving achievement templates by name.

AchievementTemplateDatabase.AchievementDictionary: Serializable dictionary mapping achievement names to their templates.

AchievementTier: Represents a single tier or milestone within an achievement, including rewards and completion data.

AddFactionAction: ECA action that adds a faction reputation amount for a character. Server-only execution.

AddressableAssetKey: Serializable class representing a key or set of keys for Unity Addressable assets, with merge mode support.

AddressableLoadBatch: A single caller's unit of work inside AddressableLoadProcessor. Returned by BeginProcessQueue(), it tracks exactly the items that caller enqueued and raises Completed once those items — and only those items — have finished.

AddressableLoadProcessor: Central queue for Addressable asset and scene loading.

AddressableLoadProcessor.AddressableLoadHelper: MonoBehaviour used purely to own the load coroutine.

AddressableSceneLoadData: Represents the data required to load a Unity scene using the Addressables system. Includes scene name, activation behavior, load mode, and post-load callback.

AddressableSceneProcessor: Scene processor for loading and unloading Unity scenes using the Addressables system. Manages async operations and loaded scene tracking.

AdvanceQuestObjectiveAction: ECA action that advances a specific quest objective for the initiating character. Typically used in dialogue OnSelect actions or interactable triggers. Server-only execution.

AggressionController

Manages an aggression (threat) table for a single NPC. Tracks threat from damage, healing, resource expenditure, and arbitrary point adjustments. Threat decays over time. Target selection uses both raw threat points and a vulnerability multiplier based on the target's current health and mana percentages.

Plain C# class — one instance per NPC, owned by AggressionState.

AggressionDispatcher: Routes combat events to the one NPC that cares about them, instead of broadcasting every event to every NPC in the scene.

AggressionEntry: Tracks accumulated aggression (threat) from a single character toward an NPC. Points are gained when the character damages the NPC, heals an enemy, spends resources, or takes other aggressive actions. Points decay over time so stale threats fade.

AggressionState

Manages the aggression (threat) system for a single NPC. Owns the AggressionController instance, subscribes to global damage/heal/kill events, and tracks the per-NPC target re-evaluation timer.

Extracted from AIController to keep the controller focused on navigation and state management. One instance per NPC — plain C# class.

Event-driven combat entry: When the threat table transitions from empty to non-empty (first damage received), the OnCombatInitiated callback is invoked for immediate combat entry without waiting for the next physics sweep.

Replay safety: Event handlers are guarded to ignore damage/heal/kill events fired during prediction replay. Global combat events are not replay-suppressed by the damage controller, so we suppress them here.

AimDirectionCompression: Packs an aim direction into 32 bits as a quantised yaw/pitch pair, and — more importantly — exposes the quantisation itself so a producer can commit to the value it is about to send.

AllCharactersTargetSelector: Selects every scene UnityEngine.GameObject with a component that implements ICharacter.

ApplyBuffAction: Action that applies a specified buff to a target character, potentially stacking it multiple times.

ApplyDamageAction

Action that applies damage to a target character using a configurable value provider and a given damage attribute type.

Runs on the server, and on the client that OWNS the initiator — see MayPredict(ICharacter, EventData). The caster draws its own number immediately through PredictedCombatEvents rather than waiting half a round trip for the server's report; the server's report then confirms it, or the prediction is greyed out when none arrives. Observers still wait to be told.

ApplyDispelAction: Action that dispels (removes) a specified number of buffs and/or debuffs from a target character.

ApplyHealAction: Action that restores health to a target character using a configurable value provider.

ApplyRegionAttributeAction: ECA action that changes a character's attribute while it is inside a region. Server-only (gameplay state); suppressed during prediction reconciliation.

ApplyRegionBuffAction: ECA action that applies a buff to a character in a region. Server-only (gameplay state); suppressed during prediction reconciliation.

ApplyReviveAction

Action that offers a resurrect to a dead target character. Unlike ApplyHealAction, this applies to dead characters (CurrentValue == 0). Used by resurrect/resurrection ability templates.

For a player with a live connection this sends a ResurrectOfferBroadcast and stops there — the death dialog surfaces its "Accept Resurrect" button and the player chooses between that and respawning at their bind point. The revive itself happens in CharacterSystem's accept handler, which is the only place that both clears IsDead and restores health.

A target that cannot be asked — an NPC, or a player with no active connection — is revived outright, so scripted and system resurrects still work.

ApplyTauntAction: Action that forces an NPC's threat onto the initiator — the taunt primitive.

ApplyThreatAction: Action that generates threat on nearby hostile NPCs without dealing damage.

ArchetypeController: Controls the archetype state for a character. Handles archetype assignment, network payload serialization, and event invocation when the archetype changes. The archetype determines which abilities, items, buffs, titles, and attributes a character has access to.

ArchetypeEventData: ECA event data for archetype change events, carrying the new and previous archetype templates.

ArchetypeTemplate: ScriptableObject template representing a character archetype, including rewards, requirements, and metadata.

AreaTargetSelector: Selects all UnityEngine.GameObjects within a certain radius of the context object. Useful for area-of-effect abilities or detection.

ArmorTemplate: ScriptableObject template for armor items, defining armor bonus attributes. Inherits from EquippableItemTemplate for equipment logic.

AsyncOperationExtensions: Extension methods that make Unity AsyncOperation awaitable so it can be used directly with C# async/await (e.g. await request.SendWebRequest()).

AttributeBuffTemplate: Buff template that grants bonus attributes to a character while active. Applies additive modifiers on apply/stack and removes them symmetrically on remove/unstack.

AttributeTickBuffTemplate: Buff template that applies cumulative attribute modifiers on each tick. Each tick adds a modifier; on remove, the total accumulated modifier is reversed. Tracks total applied ticks internally on the buff to ensure perfect symmetry. Useful for "ramping" buffs that grow stronger over time.

AuthSizeLimits: Size limits for authentication broadcast fields. Used by server-side validation to reject oversized payloads before any crypto work.

BankController: Controls the player's bank inventory, handling currency and item slots. Manages client-server synchronization and broadcast handling for bank operations.

Banker: Represents a banker NPC that allows players to access their bank storage.

BaseAIState: Abstract base class for all AI states. Defines common parameters and logic for state transitions, leash checks, enemy detection, and line of sight.

BaseAbilityTemplate: Abstract base ScriptableObject for ability templates, providing common fields, activation conditions, and tooltip logic. Ability requirements (resources, faction, archetype, attributes) are defined as ECA conditions on the ActivationConditions list rather than as hardcoded fields.

BaseAttackingState: The one attacking state. Handles target selection, spacing, ability activation and mid-combat re-targeting for every NPC archetype.

BaseBuffTemplate: Abstract base class for all buff templates, defining shared properties, tooltip logic, and effect hooks. Stack and tick hooks are virtual with sensible defaults: stacking delegates to apply/remove, and ticking is a no-op. Derived classes only override what they need (OCP).

BaseCharacter: Abstract base class for all networked character entities in the game. Provides core properties, behaviour registration, flag management, and prefab/model instantiation.

BaseItemTemplate: Abstract base class for item templates, providing common properties and tooltip logic for all items. Implements ITooltip for UI display and ICachedObject for template caching.

BaseRespawnCondition: Abstract base class for respawn conditions. Used to determine if an object spawner is allowed to respawn entities based on custom logic.

Bindstone: Bindstone interactable, used for setting player respawn points. Inherits from Interactable. Typically displays no title in the UI.

BindstoneAction: ECA action that binds the player's respawn location to their current position and scene. Requires the interactable to implement IBindstone. Server-only.

BlendShapeProfile: A collection of blend shape entries representing a character's body shape or an equipment item's blend shape overrides. Used to sync body blend shapes to equipment meshes that have matching shape keys.

BodyVisibilityManager: Manages visibility of pre-split body region SkinnedMeshRenderers. Tracks per-slot hidden regions so unequipping one item doesn't reveal a region still hidden by another equipped item.

BootstrapSystem: Base class for bootstrap systems in FishMMO. Handles asset and scene loading, progress tracking, and initialization flow.

BossPhase: Defines a single phase of a boss encounter. A boss transitions to the next phase when its health drops below HealthThreshold. Each phase can override the boss's behavior tree, attacking state, and spawn adds.

BossScript

ScriptableObject that defines a boss encounter's phases and timed mechanics. Assign to BossScript to make an NPC a scripted boss.

The AIController evaluates the boss script every tick:

Checks health against phase thresholds.
On phase change, applies overrides (behavior tree, attacking state, ability rotation) and spawns adds.
Ticks all active timed mechanics and force-activates abilities or spawns when timers fire.

Example setup:

Phases:
  [0] HP ≥ 70%  — default behavior
  [1] HP < 70%  — spawn 2 adds, switch to Phase2 behavior tree
  [2] HP < 40%  — enrage: switch to melee attacking state
Timed Mechanics:
Meteor — every 30s, force-cast AbilityTemplate #5
Summon — every 60s, spawn skeleton prefab (only in phase 1)

BossScriptState

Per-NPC runtime state for a BossScript. Tracks the current phase index, timed mechanic timers, and handles phase transitions and mechanic activations.

This is a plain C# class (not a ScriptableObject) because it holds mutable state that differs per NPC instance — the same BossScript asset may be shared across multiple boss spawns.

BossTimedMechanic: Defines a timed mechanic that fires at regular intervals during a boss encounter. E.g., "Every 30 seconds, cast Meteor."

Buff: Represents a single instance of a buff applied to a character, tracking time, stacks, and template. All state is deterministic — timing is tick-based (ExpiryTick, NextTickTick) rather than float-second accumulators, eliminating floating-point drift across prediction ticks.

BuffAttributeTemplate: Represents a single attribute modification applied by a buff, including the value and target attribute template.

BuffController: Controls the application, ticking, and removal of buffs for a character, including network synchronization.

BuffEventData: ECA event data carrying the buff involved in an apply or remove event.

BuffTemplateDatabase: ScriptableObject database for storing and retrieving buff templates by name.

BuffTemplateDatabase.BuffDictionary: Serializable dictionary mapping buff names to their templates.

BuffTickEvent: ECA trigger fired on each tick of a buff, driving damage-over-time, heal-over-time, and any other periodic effect.

CachedScriptableObject<T>: Abstract base class for ScriptableObjects that need to be cached and retrieved quickly by ID. Objects are cached not only by their concrete type but also by their base types up to CachedScriptableObject<T>. This allows for flexible retrieval by specific derived types or broader base types.

CanAcceptQuestCondition: Condition that checks whether the character can accept a specific quest. Evaluates attribute requirements, prerequisite quests, and whether it is already acquired.

CanEquipItemCondition: Condition that checks if an item can be equipped by the character (initiator or event target). Requires an ItemEventData in the EventData.

CanUseItemCondition: Condition that checks if a character can use a specific item (i.e., possesses it in their inventory).

CapturePoint: Capture point interactable for PvP or general objective capture. Tracks ownership, capture progress, and objective state. Fires OnCaptured when a player successfully captures the point. Configured via a CapturePointTemplate ScriptableObject asset.

CapturePointAction: ECA action that applies one capture interaction to an ICapturePoint. Server-only.

CapturePointTemplate: Template defining a capture point's parameters for PvP or general objective capture.

CasterAttackingState: Caster archetype preset (mages, warlocks, crowd controllers). Sits at the far edge of its spell range, refuses to be meleed, and interrupts its own cast to escape when something gets inside the panic radius.

ChainTargetSelector: Selects a chain of UnityEngine.GameObjects starting from the context object, such as for chain lightning or similar effects. Each link in the chain is the closest unselected UnityEngine.GameObject within ChainRadius of the previous target.

ChangeFogAction: ECA action that changes fog settings when a character enters/exits a region. Client-only: suppressed on server and during prediction reconciliation.

ChangeSkyboxAction: ECA action that changes the skybox material when a character enters/exits a region. Client-only: suppressed on server and during prediction reconciliation.

CharacterAimOrigin: Derives the point a character aims from, out of state the server already owns.

CharacterAnimationController

Centralized animation controller for characters. Sets parameters on the character's Animator. When combined with FishNet's NetworkAnimator component (on BaseCharacter), all parameter changes are automatically synchronized to remote clients.

Animator parameter names are constants to ensure consistency.

Implements IModelReadyHandler to re-acquire the Animator reference after the character model finishes loading asynchronously.

CharacterAppearanceManager

Manages character visual appearance: bone scaling for body proportions, blend shape synchronization, and appearance data serialization.

Bone scaling is separated into a global Height pass and individual body-part adjustments. Height scales all height-affecting bones uniformly. Individual sliders (TorsoLength, LegLength, ArmLength) apply additional proportional tweaks on top. This means a Dwarf with Height=0.75 and LegLength=0.70 has legs at 0.75 * 0.70 = 0.525x scale — intentionally shorter than the already reduced height.

All operations are client-only.

CharacterAttribute: Represents a character attribute, including its value, modifier, dependencies, and hierarchical relationships. Supports parent/child/dependency relationships and value propagation for complex attribute systems.

CharacterAttributeController: Controls all character attributes and resource attributes for an entity. Handles initialization from template databases, network payload serialization, parent/child/dependency relationship wiring, tick-based resource regeneration, and reconcile-driven synchronization of both base and resource attributes via the unified CharacterReconcileData. There is no longer a separate broadcast path for non-resource attributes.

CharacterAttributeFormulaTemplate: Abstract base class for defining formulas that calculate bonuses for character attributes. Inherit from this FormulaTemplate to implement custom logic for how one attribute affects another.

CharacterAttributeResourceStateSerializer

Custom serializers for CharacterAttributeResourceState.

Regular serializer (Write/Read extension methods): Used by FishNet's codegen for RPCs, SyncVars, broadcasts, and any non-prediction serialization context. Writes all 7 fields using FishNet's built-in packed encoding (varint for ints, full precision for floats).

Delta serializer (registered via FishNet.Serializing.GenericDeltaWriter<T>/FishNet.Serializing.GenericDeltaReader<T>): Used during prediction replicate/reconcile ticks. Writes a 1-byte bitmask (7 bits for 7 fields) followed by delta-encoded values for only the changed fields. On a typical tick where only health regens, this sends ~3-4 bytes instead of 28.

The delta serializer must use SetWrite(Func<Writer, T, T, DeltaSerializerOption, bool>) because FishNet's [DefaultDeltaWriter] attribute only supports single-value signatures, not the (prev, next, option) signature needed for per-field delta compression.

CharacterAttributeTemplate

CharacterAttributeTemplate.CharacterAttributeFormulaDictionary: Serializable dictionary mapping attribute templates to their formula templates. Used to define how child attributes affect this attribute.

CharacterAttributeTemplate.CharacterAttributeSet: Serializable set of attribute templates. Used for parent, child, and dependant relationships.

CharacterAttributeTemplateDatabase

CharacterAttributesBroadcastSerializer: Wire format for CharacterAttributesBroadcast.

CharacterBehaviour: Abstract base class for character-related behaviours attached to networked characters. Handles initialization, registration, and lifecycle events for character behaviours.

CharacterBuffsBroadcastSerializer: Wire format for CharacterBuffsBroadcast.

CharacterCurrency: Reads and moves a character's currency.

CharacterDamageController: Controls damage, healing, kill, and resurrection logic. Handles resistance calculation, ECA trigger dispatch, immortal state, combat state transitions, and combat-escape prevention via the IsInCombat flag.

CharacterDetails: Serializable class containing details about a character for selection and display.

CharacterHitReaction: A short, purely cosmetic displacement of a character's model, played the moment a hit is predicted rather than when the server's correction arrives.

CharacterIncapacitation: Single definition of "this character is incapacitated and may not act or move".

CharacterInitialSpawnPosition: MonoBehaviour for marking a character's initial spawn position in the scene. Allows restricting spawn to specific races and draws a gizmo for visualization.

CharacterInitialSpawnPositionDetails: Serializable class containing details for a character's initial spawn position, including location, rotation, and allowed races.

CharacterInitialSpawnPositionDictionary: Serializable dictionary mapping string keys to character initial spawn position details. Used to store and retrieve initial spawn locations and settings for characters.

CharacterPositionHistory: Server-side ring buffer of where a character's collider was on each recent tick.

CharacterPredictionController: Unified prediction controller that replaces per-subsystem [Replicate]/[Reconcile]. Discovers all IPredictableController components on the same GameObject, sorts them by Order, and drives them through a single FishNet Prediction V2 pipeline. This avoids the issues caused by having multiple predicted NetworkBehaviours on the same NetworkObject.

CharacterReconcileDataDeltaSerializer

Custom delta serializers for CharacterReconcileData.

Delta serializer: Writes a 2-byte bitmask (12 bits for 12 fields) followed by delta-encoded values for only the changed fields. The nested KinematicCharacterController.KinematicCharacterMotorState and CharacterAttributeResourceState use their own delta serializers, so savings compound. Cooldowns, buffs, and non-resource attributes use index-delta compression via CooldownReconcileEntry, BuffReconcileEntry, and AttributeReconcileEntry.

CharacterReplicateDataDeltaSerializer

Custom delta serializers for CharacterReplicateData.

Delta serializer: Writes a 1-byte bitmask followed by delta-encoded values for only the changed fields. Seven bits are in use — bit 3 is a retired gap, see the constants — for the seven fields of CharacterReplicateData.

An idle tick costs the bitmask alone. For real figures rather than an estimate, run PredictionBandwidthBenchmarkTests, which measures this type against the production serializers; byte counts written into a comment go stale the first time a field is added.

CharacterResourceAttribute: Represents a character resource attribute (e.g., health, mana, stamina) that can be consumed or regenerated. Extends CharacterAttribute to add current value tracking and resource-specific logic.

CharacterRespawnPosition: MonoBehaviour for marking a character's respawn position in the scene. Draws a gizmo for visualization in the editor.

CharacterRespawnPositionDetails: Serializable class containing position and rotation details for a character's respawn location.

CharacterRespawnPositionDictionary: Serializable dictionary mapping string keys to character respawn position details. Used to store and retrieve respawn locations and orientations for characters.

CharacterTickExtensions: Helper extensions for character-related utilities.

CharacterTransientGroundingReportDeltaSerializer

Custom delta serializers for KinematicCharacterController.CharacterTransientGroundingReport.

Delta serializer: Writes a 1-byte bitmask (6 bits for 6 fields) followed by delta-encoded values for only the changed fields. When the grounding status is stable and unchanged this writer declines entirely and sends NOTHING — the parent's flags word records its absence. It only emits a bitmask when something changed, or when a caller forces it, and nothing forces it today: the root reconcile routes FullSerialize through its own absolute path and passes Unset down here.

ChatHelper: Static helper class for chat-related functionality, including command parsing, channel mapping, and message sanitization.

ChatSanitizer: Text-hygiene routines applied to every piece of untrusted text that enters the chat pipeline — player input, and anything bridged in from Discord.

ChildrenTargetSelector: Selects all direct children of the context UnityEngine.GameObject. Useful for applying effects to all immediate child objects.

ClearTargetAction: ECA action that clears the initiator's current target. Suppressed during client-side prediction replay to prevent redundant target-clearing on every replay frame.

ColliderExtensions: Extension methods for Unity Colliders, including gizmo drawing and dimension extraction.

CollisionEventData: Event data for a hit, carrying where in the world the impact happened.

CombatEventBroadcastSerializer: Custom serializer for CombatEventBroadcast.

CombatEventCoalescer: Merges the combat events one character receives within a tick into a bounded set.

CompleteQuestAction: ECA action that attempts to complete a quest (transition from Active to Complete). Server-only execution.

CompositeBuffTemplate: Composite buff template that combines attribute modifiers, state flags, and resource ticks into a single buff. Follows the Composite pattern to avoid requiring multiple separate buffs for complex effects (e.g., a frost spell that slows movement speed AND freezes AND deals DoT).

ConeTargetSelector: Selects all UnityEngine.GameObjects within a cone in front of the context object. Useful for cone-shaped area-of-effect abilities.

ConstantFloatValue: Float value provider that always returns a fixed constant value.

ConstantValue: Value provider that always returns a fixed constant value.

Constants

Constants.Character

Constants.Configuration

Constants.Layers

Constants.Layers.Index: Layer indices (0-31), for APIs that take a single layer such as UnityEngine.GameObject.layer. The members of the enclosing class are UnityEngine.LayerMask bit masks instead, for APIs that take a mask such as Physics.Raycast: assigning a mask where an index is expected sets a wildly out-of-range layer (mask 256 for layer 8), and shifting a mask again (1 << mask) silently selects the wrong layer because C# masks the shift count to 5 bits.

ConsumableTemplate: Abstract base class for consumable item templates, defining type, charge cost, and cooldown behavior. Provides logic for consuming items and applying cooldowns.

ConsumeResourceAction: Action that consumes a specified amount of a resource attribute from a character. Useful for per-event resource costs (e.g., channeled abilities consuming mana per tick).

Container: Container interactable (chests, wardrobes, crates, etc.) that stores items and implements IItemContainer. Players can interact with it to view and take items. Configured via a ContainerTemplate ScriptableObject asset.

ContainerTemplate: ScriptableObject template defining configuration for container interactables (chests, wardrobes, etc.).

CooldownController: Controls and manages ability cooldowns using immutable CooldownInstance based on StartTick + DurationTicks. No per-tick mutation — cooldowns expire automatically via integer comparison: (currentTick - StartTick) >= DurationTicks.

CoroutineRunner: Minimal MonoBehaviour for running coroutines from non-MonoBehaviour classes.

DamageAmountValue: Value provider that reads the damage amount from DamageEventData. Returns a configurable fallback when no damage event data is present.

DamageAttributeTemplate

DamageEventData: ECA event data for damage-related triggers. Carries the damage amount and damage attribute type. The damaged character is exposed on TargetCharacter.

DayNightEventData: ECA event data for world-level day/night cycle transitions. Initiator is null for world events.

DeadNPCRespawnCondition: Respawn condition that allows respawning only when all specified NPCs are dead.

DefenderAttackingState: Defender / tank archetype. Fights in melee, keeps its taunts on cooldown to hold threat, and physically interposes itself between the enemy and whoever it is protecting.

DestroyObjectAction: Action that destroys a specified game object in the scene.

DeterministicRNG

A fast, deterministic, thread-safe pseudo-random number generator. Drop-in replacement for Random in all game code.

Algorithm: xoshiro128** (Blackman & Vigna, 2018). Period: 2^128 − 1. Passes BigCrush. Thread safety: no shared mutable state — each instance is independent.

API surface matches the subset of Random used in this codebase: Next(), Next(int), Next(int,int), NextDouble(), NextFloat(), Range(int,int), Range(float,float).

A static Shared instance is provided for fire-and-forget usage that does not require determinism (replaces UnityEngine.Random).

DialogueChoice: Represents a player choice within a dialogue node. Serialized inline on DialogueNode. Contains display text, conditions for availability, actions on selection, and a link to the next node.

DialogueEventData: Event data for dialogue interactions, carrying the NPC speaker reference and dialogue node context. Used by ECA conditions and actions that operate within a dialogue tree.

DialogueInteractable: Represents an NPC that players can interact with to start a server-authoritative dialogue. Uses a DialogueTemplate to define the conversation tree.

DialogueNode: Represents a node in a dialogue tree. Serialized inline on a DialogueTemplate asset. Contains speaker text, ECA conditions/actions, and branching choices.

DialogueTemplate: A CachedScriptableObject that defines a complete dialogue tree. Contains all dialogue nodes, branching choices, and ECA conditions/actions. Assigned to NPCs via DialogueInteractable.

DisplayDialogueAction: ECA action that triggers a server-authoritative dialogue session. On the server, raises OnServerDialogueRequested which the InteractableSystem subscribes to. On the client, this action is a no-op.

DisplayRegionNameAction: ECA action that displays the region name as a 2D label when a character enters a region. Client-only: suppressed on server and during prediction reconciliation.

DungeonAttributeScalar: One NPC attribute a difficulty scales, and by how much.

DungeonDifficultyDefinition: One difficulty a dungeon can be run at: what it takes to get in, what it does to the dungeon, and what it pays for the trouble.

DungeonDifficultyRegistry: Which difficulty ruleset applies inside each loaded dungeon scene, on this process.

DungeonEntrance: Interactable representing a dungeon entrance. Displays a title and optional image in the UI.

DungeonTemplate: Everything about a dungeon that is the same for every instance of it: how it is described to a player standing at the entrance, and the difficulties it can be run at.

DynamicAddressableLoadPathSystem

Dynamically overrides the Addressables remote load path at runtime. Registers a persistent InternalIdTransformFunc on the Addressables ResourceManager that rewrites remote asset URLs to use RuntimeBaseUrl. Only one instance should exist in the scene — the last one to Awake wins.

Client builds with an empty or loopback RuntimeBaseUrl do not register a rewrite: Addressables.RuntimePath already resolves correctly (including WebGL, where StreamingAssets is an absolute http(s) URL derived from the page origin, e.g. https://fishmmo.com/test/StreamingAssets/aa). Rewriting those IDs to a hardcoded host (or prefixing file://) breaks loads when the game is served from a different domain or subpath.

EquipItemAction: Action that attempts to equip an item on the initiating character. Requires an ItemEventData in the EventData. Server-only execution — equipment mutations rearrange persistent item ownership between containers and must never run during client prediction replay.

EquipItemEventData: ECA event data carrying the item and slot involved in an equip or unequip event.

EquipmentController

Controls the character's equipment slots, handling equip/unequip logic and network synchronization. Manages client-server broadcasts for equipment changes and slot management.

Implements IPredictableController at Order 93 so equipment state participates in the prediction pipeline. Equipment-driven attribute changes are reconciled alongside other predicted state, eliminating the broadcast/reconcile race on ExternalModifier.

Three network paths feed this container and they must agree with one another:

The spawn payload (WritePayload(NetworkConnection, Writer)/ReadPayload(NetworkConnection, Reader)) — owner shaped for the owner, template+seed only for everyone else.
The owner's acknowledgement broadcasts and reconcile snapshot, which can arrive in either order and are reconciled against each other by instance id (see RestoreFromReconcile(EquipmentReconcileEntry[]) and the pending-request records).
EquipmentObservedSlotBroadcast, sent by the server to the character's observers after every successful equip/unequip, applied by ApplyObservedSlot(int, int, int).

EquipmentVisualController

Manages visual equipment rendering on a character. Pre-allocates renderers per slot, loads equipment prefabs via Addressables, extracts meshes and materials, binds skinned meshes to the character skeleton, and coordinates body region hiding with IBodyVisibilityManager.

All rendering operations are client-only, guarded with #if !UNITY_SERVER. Public API and interface implementations exist unconditionally for server compilation.

EquippableItemTemplate: Abstract base class for equippable item templates, defining slot, attributes, and model data. Used for equipment items such as armor and weapons.

EventTargetSelector

Selects the Target already carried on the event — without running any spatial query. This is the intended default for triggers fired in response to an event that already resolved its own target, such as:

Ability OnHit triggers (collision target).
Region enter / exit triggers.
Dialogue, item-use, or interaction triggers.

Falls back to the initiator's GameObject when the event has no Target — so an OnHit trigger fired as a self-cast (initiator == hit) still resolves correctly.

Faction: Represents a character's standing or reputation with a specific faction. Holds the current value and reference to the faction template.

FactionAmountValue: Value provider that reads the faction value from FactionEventData. Returns a configurable fallback when no faction event data is present.

FactionController: Controls faction reputation, alliance grouping, and relationship queries for a character. Handles network synchronization of faction standings via FishNet broadcasts and payload serialization.

FactionEventData: ECA event data for faction change events.

FactionMatrix: Represents a matrix of faction relationships, where each cell defines the alliance level between two factions. Used to determine how factions interact (e.g., ally, enemy, neutral).

FactionMatrixTemplate: ScriptableObject template containing a matrix of alliance levels between all factions. Provides editor tools for rebuilding the matrix and propagating relationships to individual faction templates.

FactionTemplate: ScriptableObject template defining a faction's properties, reputation bounds, and default relationships.

FactionTemplate.FactionHashSet: Serializable hash set of faction templates. Used for storing allied, neutral, and hostile relationships.

FailQuestAction: ECA action that fails an active quest. Server-only execution.

FlatBonusFormulaTemplate

FogSettings: Serializable class for configuring fog settings in a region, including mode, color, density, and transition properties.

FormulaTemplate<T, K>: Abstract base class for defining formulas that calculate bonuses for types. Inherit from this ScriptableObject to implement custom logic for how one type affects another.

FriendController: Character friend controller. Manages the player's friend list and handles friend-related network events.

FurthestTargetSelector: Selects the furthest UnityEngine.GameObject from the context within a given radius and layer mask. Useful for targeting the most distant enemy, ally, or object.

GatheringDrop: Defines a single drop entry for a GatheringNodeTemplate. Each entry specifies an item template, amount range, and weight for weighted random selection.

GatheringNode: Gathering node interactable that grants items from a loot table when gathered. Tracks remaining uses and despawns when depleted. Configured via a GatheringNodeTemplate ScriptableObject asset.

GatheringNodeAction: ECA action for gathering node interactions. Broadcasts the gathering progress bar to the client, rolls the drop table, invokes OnGrantItem for DB persistence, manages node state, and increments the achievement counter. Server-only.

GatheringNodeTemplate: Template defining a gathering node's loot table and interaction parameters. Each gathering interaction rolls the drop table and grants items to the player.

GenderedNameCacheSet: Name caches for a specific generated character gender.

GenderedRaceModelSet: Race model references available for a specific generated character gender.

GeneratedHostConfig: IL-embedded host configuration. The real values are substituted at build time by CI or the FishMMO-Installer. The committed sentinel values are intentionally invalid.

GetBehindState: Combat sub-state that circles the NPC around to the back of its current target.

GiveItemAction: ECA action that gives an item to a character's inventory. Server-only execution.

GuildController: Character guild controller. Manages guild membership, events, and synchronization for a character.

GuildEventData: ECA event data for guild join and leave events.

GuildRankDefaults: The rank ladder a guild is seeded with, and the mapping from the legacy GuildRank enum to the permission flags that reproduce its behaviour exactly.

GuildTextLimits: Maximum length the server accepts for a guild message of the day or notice.

HasAttributeControllerCondition: Condition that checks if a character has an attribute controller component.

HasBankControllerCondition: Condition that checks if a character has a bank controller component.

HasBankItemCondition: Condition that checks if a character's bank contains a specific item template.

HasBankSpaceCondition: Condition that checks if a character's bank has at least a specified number of free slots.

HasBuffCondition: Condition that checks if a character currently has a specific buff applied.

HasCooldownCondition: Condition that checks if an ability is currently on cooldown. Resolves the current tick from the character's NetworkObject.

HasEquippedItemCondition: Condition that checks if the character (initiator or event target) has a specific item equipped in a given slot. Requires an ItemEventData in the EventData, or checks by EquippableItemTemplate and slot.

HasFactionCondition: Condition that checks if a character belongs to a specific faction. Evaluates true if the character has the specified FactionTemplate in their faction controller.

HasGuildCondition: Condition that checks if a character is in a guild, with optional inversion.

HasInventoryItemCondition: Condition that checks if a character has a required amount of each specified item in their inventory.

HasInventorySpaceCondition: Condition that checks if a character has at least a specified number of free inventory slots.

HasLineOfSightCondition: Passes when nothing blocks the line from the initiator to the evaluated character.

HasPartyCondition: Condition that checks if a character is in a party, with optional inversion.

HasPetCondition: Condition that checks if the character currently has an active pet.

HasQuestCondition: Condition that checks whether the character currently has a specific quest in their quest log.

HasRequiredAttribute: Condition that checks if a character has a required value for a specified attribute, with optional inversion.

HasResourceCondition: Condition that checks if a character has at least a required amount of a specified resource attribute (e.g., Mana, Health). Also implements IResourceCost for ability resource cost aggregation and overrides GetTooltipContribution() for tooltip display.

HasTargetCondition: Condition that checks if the character currently has a target.

HealAmountValue: Value provider that reads the heal amount from HealEventData. Returns a configurable fallback when no heal event data is present.

HealEventData: ECA event data for heal-related triggers. Carries the heal amount. The healed character is exposed on TargetCharacter.

HealerAttackingState: Healer archetype. Keeps caster spacing from the enemy, but interrupts its damage rotation to top up the most wounded nearby ally.

Hex: A static utility class for converting between hexadecimal color strings and UnityEngine.Color objects, and for normalizing color component values.

HitCountCondition: Condition that evaluates whether an ability object's hit count satisfies a specified comparison.

IdleState: AI state for idle behavior. Handles update rate, entering, exiting, and transition logic for NPCs.

InitiatorTargetSelector: Selects Initiator's GameObject as the only target. Useful for self-targeted effects regardless of any current event target.

Interactable: Abstract base class for interactable objects in the game world. Handles interaction logic, network payloads, and UI display. Implements IInteractable and ISpawnable for scene registration and spawning.

InteractableResolver: Decides which of a GameObject's interactables a player means.

InterruptAction: Action that interrupts the target character's current ability or action.

InventoryController: Controls the character's inventory slots, handling item activation, slot manipulation, and network synchronization. Manages client-server broadcasts for inventory changes and slot management.

IsArchetypeCondition: Condition that checks if a character is of a specified archetype.

IsCharacterAliveCondition: Condition that checks if a character is alive (health > 0), with optional inversion to check for death.

IsCharacterNPCCondition: Condition that checks if a character is an NPC, with optional inversion.

IsImmortalCondition: Condition that checks if a character is immortal (cannot be killed), with optional inversion to check for mortality.

IsRaceCondition: Condition that checks if a character is of a specific race.

IsWithinFacingAngleCondition: Passes when the evaluated character lies within an arc of the initiator's facing — a "must be in front of you" gate, or with Invert, a backstab gate.

Item: Represents an item instance in the game, including stackable, equippable, and generated properties. Handles initialization, attribute management, and tooltip generation. Implements ITooltip for consistent UI tooltip display.

ItemAttribute: Represents an attribute instance for an item, such as strength, durability, or custom stat. Holds a reference to the attribute template and its current value.

ItemAttributeTemplate: ScriptableObject template for item attributes, defining min/max values and associated character attribute. Used to configure item attribute ranges and their effect on character stats.

ItemAttributeTemplateDatabase: ScriptableObject database for item attribute templates, providing lookup and storage by name. Used to manage and retrieve item attribute templates for items in the game.

ItemAttributeTemplateDatabase.ItemAttributeDictionary: Serializable dictionary mapping attribute names to their templates.

ItemContainer: Abstract base class for item containers, providing slot and item management for inventories, equipment, banks, etc. Implements IItemContainer and extends CharacterBehaviour for character association.

ItemEquippable: Represents the equippable component of an item, handling equip/unequip logic and owner tracking. Manages events for when the item is equipped or unequipped by a character.

ItemEventData: Event data for an item-related action or condition. Used to pass item, inventory, and container information to actions and conditions that operate on items.

ItemGenerator: Handles random attribute generation and management for items, including applying/removing attributes to characters. Supports equippable and template-based attribute logic, and exposes events for attribute changes.

ItemSpawnableSettings: Per-spawner configuration for world items: which item, how many, and how often the rare one shows up instead of the common one.

ItemSpawnableSettings.ItemRoll: One possible item roll: a template, a stack range, and a weight.

ItemStackable: Represents the stackable component of an item, managing stack size, addition, removal, and unstacking logic.

ItemTemplateDatabase: ScriptableObject database for item templates, providing lookup and storage by name. Used to manage and retrieve item templates for items in the game.

ItemTemplateDatabase.ItemDictionary: Serializable dictionary mapping item names to their templates.

KCCCamera: Third-person camera controller for character following, orbiting, zoom, and obstruction handling. Supports smooth movement, rotation, and framing adjustments.

KCCController: Kinematic Character Controller wrapper that implements KinematicCharacterController.ICharacterController. Handles movement, jumping, crouching, sprinting, and state transitions.

KCCMoveFlagsHelper: Helper for clearing one-shot flags on observer prediction. If new one-shot flags are added to KCCMoveFlags, include them here so observer future-state prediction clears them.

KCCPlatform: Predicted moving platform that uses FishNet Prediction V2 for deterministic movement. Players standing on this platform receive platform velocity through KCCPlayer.

KCCPlatformReconcileDataDeltaSerializer: Delta serializers for KCCPlatform.ReconcileData.

KCCPlatformReplicateDataDeltaSerializer: Delta serializers for KCCPlatform.ReplicateData.

KCCPlayer: Movement subsystem for KCC-based prediction. Implements IPredictableController so that CharacterPredictionController drives replication and reconciliation through a single unified pipeline.

KinematicCharacterMotorStateDeltaSerializer

Custom delta serializers for KinematicCharacterController.KinematicCharacterMotorState.

Delta serializer: Writes a 2-byte bitmask over 14 bit positions carrying 13 fields (bit 4 is a retired gap — see the constants below) followed by delta-encoded values for only the changed fields. On a typical grounded walking tick, only Position, Rotation, BaseVelocity, and GroundingStatus change. On an idle tick where the character stands still this writer declines and sends nothing at all. Measured figures live in PredictionBandwidthBenchmarkTests rather than here, where they cannot go stale silently.

The nested KinematicCharacterController.CharacterTransientGroundingReport uses its own delta serializer, so savings compound for unchanged grounding normals.

KnockbackHitAction

Action that applies a knockback force to a target character, pushing them away from the source. Uses the KCC motor's velocity system for collision-aware knockback instead of direct Transform.position manipulation, which would bypass prediction, reconciliation and collision detection.

The displacement is SERVER ONLY — see the note in Execute(ICharacter, EventData) for why this is the one feedback action that did not move to EcaAuthority.MayPredict. The victim's own client receives it through the reconcile, and the attacker's client plays a cosmetic flinch (PlayPredictedReaction(EventData)) in the meantime.

LagCompensatedQuery: Spatial queries resolved against where characters were when the caster's client saw them.

LagCompensationRegistry: Server-side registry of CharacterPositionHistory, and the scoped rewind that resolves a hit against where characters were rather than where they are.

LagCompensationTick: Works out which past tick a caster's client was actually looking at, so a hit can be resolved against that instead of against the server's present.

LineTargetSelector: Selects all UnityEngine.GameObjects along a line (ray) from the context in a given direction and distance. Useful for beam, projectile, or piercing effects.

LootTableEntry: One item line in a LootTableTemplate: what may drop, how likely it is, and how much of it.

LootTableTemplate: Defines what a corpse holds: a set of independently-rolled item entries and a currency range.

LoreObject: Lore object interactable that displays a UILore window on interaction. Optionally provides immediate unlocks of known base abilities, ability events, and/or items. Configured via a LoreObjectTemplate ScriptableObject asset.

LoreObjectAction: ECA action for lore object interactions. Sends a LoreObjectBroadcast to display the UILore window, grants abilities and ability events inline (idempotent), invokes OnGrantItem once per item grant so that InteractableSystem can persist each item to the database, and increments the achievement counter. Server-only.

LoreObjectTemplate: Template defining a lore object's display text and optional immediate unlocks. When interacted with, the lore text is displayed in a UILore window. Abilities, ability events, and items listed here are granted immediately on interaction. Abilities and events are idempotent (already-known entries are skipped).

Mailbox: Mailbox interactable that allows players to send, receive, and manage mail. Opens the mail UI on interaction; mail operations are handled server-side via broadcasts.

MainBootstrapSystem: Main bootstrap system for FishMMO. Handles initialization, logging, version management, and graceful shutdown.

MapBoundsResolver: Works out the world-space rectangle a scene's map covers.

MapMarker: Makes an object appear on the minimap and the world map. Attach to any prefab — a character, an NPC, a gathering node, a door — that players should be able to find.

MapMarkerRegistry: The set of MapMarker components currently in the world, for the map panels to draw from.

MapPointOfInterest: Marks a landmark in the scene — a town, a dungeon entrance, a flight point, a vista. Harvested into the scene's WorldMapDefinition when the world scene details cache is rebuilt.

MapPointOfInterestDetails: A fixed landmark baked into a scene's map definition: a town, a dungeon entrance, a flight point, a vista. Drawn on both maps as a marker with a label.

MapRegionLabel: Marks a named area of the scene. Harvested into the scene's WorldMapDefinition when the world scene details cache is rebuilt.

MapRegionLabelDetails: A named area drawn as text across the world map, and used to answer "where am I" on the minimap's location readout.

MeleeAttackingState: Melee archetype preset. Closes to weapon reach, never backs away, and occasionally steps into a flanking or orbiting sub-state for variety.

Merchant: Represents a merchant NPC that players can interact with to buy or sell items. Inherits from Interactable and uses a MerchantTemplate for configuration.

MerchantTemplate

MoveAxisCompression: Packs a movement input axis into a single signed byte, and exposes the quantisation so a producer can commit to the value it is about to send.

NPC: Represents a non-player character (NPC) in the game. Handles attribute generation, network payloads, and spawning logic.

NPCAttribute: Represents an attribute for an NPC, with options for scaling, randomization, and value range. Used to define how an NPC's attribute is calculated and applied from a template.

NPCAttributeDatabase: ScriptableObject database for storing and retrieving NPC attributes by name.

NPCGroup

Coordinates a pack of NPCs that fight together. Provides shared state so individual NPC brains can make group-aware decisions via the behavior tree or state machine.

Shared state includes:

Group target — the enemy the group is focusing.
Lowest-health member — so healers know who needs help.
Alive member count — for pack-wipe / rally logic.
Combat flag — whether any member is in combat.

Place this component on an empty GameObject near the pack spawn point. Assign members in the inspector or call AddMember(AIController, NPCGroupRole) at runtime. Each member's Group is set automatically.

NPCGroupMember: Associates an AIController with a role in an NPCGroup. Serialized so designers can configure group composition in the inspector.

NPCGuildTemplate: ScriptableObject template for defining NPC guilds, their icon, description, archetypes, and requirements.

NPCLookAtInteractorAction: ECA action that makes an NPC face the interacting player and transition to idle state. Add this to any NPC's OnInteractTriggers alongside the primary interaction action (e.g., SendMerchantBroadcastAction) to achieve the classic "NPC turns to greet the player" behaviour.

NPCSpawnableSettings: Per-spawner overrides for an NPC prefab: which attributes it rolls, which brain it runs, what it knows how to cast, and how big it is.

NameCache: ScriptableObject cache for storing a list of character names.

NamedSceneObjectTargetSelector

Resolves a scene UnityEngine.GameObject by name at runtime. Designed for asset-based Triggers that need to point at a specific scene object — selectors serialized on ScriptableObject assets cannot hold direct scene references, but they can hold a name string and look the object up when the trigger fires.

The lookup is scoped to the context's scene (whatever scene the event's Target or Initiator lives in). If no scene context is available, the active scene is used. Names are compared exactly (case sensitive). For non-unique names, use TaggedSceneObjectTargetSelector instead, or compose this selector with per-target conditions to disambiguate.

Performance: the lookup walks the scene's root objects and their descendants on every fire. For frequent triggers, cache the resolved GameObject in your scene wiring rather than depending on a name lookup.

NearestTargetSelector: Selects the nearest UnityEngine.GameObject to the context within a given radius and layer mask. Useful for targeting the closest enemy, ally, or object.

NetHelper: A static utility class providing network-related helper methods, such as fetching the external IP address and validating loopback addresses. IP address and hostname validation is delegated to the IsAddressValid(string) method.

NetworkTransformDistanceLod: Rate limits a FishNet.Component.Transforming.NetworkTransform's unreliable updates per observer by how far that observer is from the object, so a spectator across the zone stops paying full rate for something it can barely see while a spectator standing next to it still gets every tick.

ObjectSpawner: Manages spawning and respawning of networked objects in the game world. Supports various spawn types, respawn conditions, and object pooling.

ObjectSpawnerPool: Pre-allocates the network objects a scene will need, so a map's memory footprint is fixed at load rather than discovered under load.

ObjectSpawnerScheduler: Runs the respawn checks for every ObjectSpawner that currently has something to respawn, from one Update instead of one per spawner.

ObjectSpawnerSchedulerDriver: The single Update that drives ObjectSpawnerScheduler.

ObserverBroadcastScope: Sends a broadcast to everyone observing a character except its owner.

ObserverBudgetCondition: Caps how many CHARACTERS one client observes at a time, keeping the most relevant.

ObserverStreamingEntry: One registered character in ObserverStreamingRegistry: the per-observer send intervals the scheduler assigned it, the range it is currently visible from, and the cached relevance inputs (combat, party, guild) used to rank it for each viewer.

ObserverStreamingPolicy: Tunables and pure decision functions for per-observer streaming: how far a character is visible from (scaled by local density), which observed characters a client receives at full rate, and what reduced rate the rest get.

ObserverStreamingRegistry: Server-side scheduler that applies ObserverStreamingPolicy to every registered character: scales each one's observer range by local density, and for every viewing client ranks what it can see and rate limits everything beyond the cap.

ObserverSyncMode: Decides which of the two observer synchronisation systems owns a character's state.

OrbitState: Combat sub-state that strafes the NPC in a circle around its current target.

ParticleAdjuster: Utility MonoBehaviour for adjusting and visualizing particle system shapes in the editor.

PartyController: Controller for managing party membership, invites, and rank for a character. Handles network broadcasts and event invocation.

PartyEventData: ECA event data for party join and leave events.

PartyVitalsQuantiser: Converts party vitals between the values the game holds and the quantised wire form.

PartyVitalsSerializer: Custom serializers for the party vitals payload.

PatrolState: Waypoint patrol. Walks the spawner-supplied waypoint ring in order.

PayloadVisibility: Answers "is this spawn payload being written for the character's owner?" for the controllers that filter what non-owners receive.

PercentageBonusFormulaTemplate

Pet: Represents a pet NPC, including owner, abilities, orders, and network payload logic.

PetAbilityTemplate: ScriptableObject template for defining a pet ability, including prefab and spawn parameters.

PetAttackingState: Pet combat preset. A plain melee-tuned attacking state with pet-appropriate defaults.

PetController: Controller for managing pet entities attached to a character. Handles pet state, network broadcasts, and event invocation.

PetEventData: ECA event data for pet summon and dismiss events.

PetIdleState: A pet's out-of-combat state: heel near its owner, hold position on a Stay order, and enter combat when the pet's PetStance says it should.

PickupWorldItemAction: ECA action that handles picking up a world item. Validates the item, applies a per-object concurrency guard to prevent duplicate pickups, creates the item, invokes OnGrantItem to grant it to the player's inventory and persist it to the database, and manages world-item state. Server-only.

PlayFXAction: Action that plays a visual effect (FX) at a determined position, typically at the point of collision or interaction.

PlayRegionAudioAction: ECA action that triggers audio playback when a character enters a region. Client-only: suppressed on server and during prediction reconciliation.

PlayerCharacter

Represents a player-controlled character in the game world, with inventory, abilities, and networked state. Implements IPlayerCharacter and extends BaseCharacter with player-specific logic, hotkeys, and event-driven behaviour.

Coupling note: This class uses 19 UnityEngine.RequireComponent attributes, creating strong coupling between PlayerCharacter and its component dependencies. All required components are tightly bound to this class and cannot be removed/replaced without modifying this declaration block. If a more modular composition approach is desired in the future (e.g., optional components registered at runtime), this set of RequireComponent attributes would need to be refactored into a dynamic registration system.

PlayerInteractionEventData: Event data for player interactions, such as talking to NPCs or interacting with objects. Carries the interactable that was triggered so ECA actions can cast it to the specific type.

PredictedAbilityStateHistory: Per-tick record of what the owning client predicted for its ability controller, so a reconcile can be compared against the client's state at the reconcile tick rather than against whatever the client holds now.

PredictedCombatEvents: Tracks combat numbers a client has drawn from its OWN predicted hits, and reconciles them against the server's combat report.

QuestAttributeRequirement: Represents a requirement for a quest based on a character attribute and minimum value. Used to check if a character meets the attribute requirement for quest progression.

QuestCharacterAttributeObjective: Objective for reaching a character attribute value.

QuestController: Manages quest instances for a character including acceptance, objective tracking, completion, turn-in, failure, and abandonment. Syncs state via broadcasts.

QuestCraftObjective: Objective for crafting a specific item.

QuestEnchantObjective: Objective for enchanting.

QuestEventData: Event data for quest-related ECA actions and conditions. Carries the quest template and optional objective index for context.

QuestExploreObjective: Objective for exploring a location.

QuestGatherObjective: Objective for gathering a specific item from gathering nodes.

QuestHarvestObjective: Objective for harvesting a specific item.

QuestInstance: Runtime instance of an accepted quest for a character. Holds the template reference, per-objective progress, and lifecycle status.

QuestInteractObjective: Objective for interacting with something.

QuestInteractable: Represents an NPC that players can interact with to accept or turn in quests. Configured via a list of QuestTemplate assets.

QuestKillObjective: Objective for killing a specific type of NPC identified by name.

QuestObjective: Abstract base class for quest objectives. Defines required value and rewards for completing the objective.

QuestObjectiveAmountValue: Value provider that reads the objective amount from QuestEventData. Returns a configurable fallback when no quest event data is present.

QuestObjectiveCompleteCondition: Condition that checks whether a specific quest objective has been completed.

QuestObjectiveInstance: Tracks runtime progress for a single quest objective.

QuestPurchaseObjective: Objective for purchasing a specific item.

QuestSocializeObjective: Objective for socializing.

QuestStatusCondition: Condition that checks whether the character has a quest at a specific status. Commonly used to check if a quest is completed/turned-in before unlocking dialogue choices.

QuestTemplate: ScriptableObject template defining a quest, its requirements, objectives, and reward structure. Does not contain lifecycle logic; that lives in QuestController.

RaceTemplate: ScriptableObject template for defining a playable race, including models, attributes, starting abilities, inventory, and equipment.

RandomRangeFloatValue: Float value provider that returns a random float between Min and Max (inclusive). Uses the deterministic DeterministicRNG from RNG when available, otherwise falls back to Shared.

RandomRangeValue: Value provider that returns a random integer between Min and Max (inclusive). Uses the deterministic DeterministicRNG from RNG when available, otherwise falls back to Shared.

RandomTargetSelector: Selects a random UnityEngine.GameObject from all within a given radius and layer mask. Useful for random targeting effects or abilities.

RangedAttackingState: Ranged archetype preset (archers, hunters, gunners). Holds a working distance, kites when the target closes, and breaks away hard once the target is inside the panic radius.

Region

Represents a networked region in the game world. Handles region hierarchy, collider setup, and triggers region actions on player entry, stay, and exit.

Membership is tracked locally in a RegionMembership<T> rather than trusting the NetworkCollider callbacks one-for-one: FishNet re-polls colliders during prediction reconcile replay (and we deliberately fire nothing while a character teleports), so callbacks that arrive while suppressed are recorded only and the resulting Enter/Exit is raised exactly once on the next non-reconciling post-tick via a raw-vs-effective diff. Stay never fires during replay.

Hierarchy: a child region takes ownership of a character standing inside it. Every ancestor receives a paired Exit only if it had raised an Enter, and a parent re-Enters when the last child releases the character while it is still physically inside the parent. Parent Stay is suppressed while any descendant owns the character.

RegionActionGate: Authority gate for region actions that mutate gameplay state (buffs, attributes). The server is authoritative for gameplay; clients only observe the result through the normal replication/reconcile path, so these actions must never run on a client peer.

RegionEventData: ECA event data for region-related triggers. Carries the Region reference and whether the FishNet prediction system is currently reconciling.

RegionGeometry: Point-containment helpers for region colliders. Axis-aligned Collider.bounds is wrong for rotated boxes, so boxes are tested in their own local space; other convex colliders use UnityEngine.Collider.ClosestPoint(UnityEngine.Vector3); anything else falls back to bounds.

RegionMembership<T>

Pure, engine-free bookkeeping for which characters a Region considers "inside". Separates the two truths a region has to reconcile:

Raw presence: what the underlying NetworkCollider has told us via Enter/Exit callbacks. This is updated on every callback, including during prediction reconcile replay and while a character is teleporting.
Effective membership: characters for which the region has actually raised an Enter (and no Exit yet). Gameplay/visual triggers key off this set.

Callbacks that arrive while suppressed (reconciling or teleporting) update raw presence only; Flush(Func<T, bool>, Func<T, bool>, Func<T, bool>, List<T>, List<T>) later diffs raw against effective and yields the Enter/Exit decisions that were deferred, each exactly once. Because Flush(Func<T, bool>, Func<T, bool>, Func<T, bool>, List<T>, List<T>) is a pure diff it also repairs any drift between the two sets (e.g. a child region releasing a character back to its parent).

RemoveItemAction: ECA action that removes items from a character's inventory by template. Server-only execution.

ResistanceAttributeTemplate

ResourceTickBuffTemplate: Buff template that applies periodic resource modifications (heal-over-time / damage-over-time). Each tick adds or subtracts from the current value of target resource attributes. The tick amount scales linearly with the number of stacks (base + stacks). This buff is deterministic — identical inputs produce identical state changes.

RetreatState: Moves the NPC away from its target until a safe distance is reached, then disengages.

ReturnHomeState: AI State for returning the NPC to its home position. Handles healing and movement speed adjustments.

RichText: Utility class for formatting rich text strings with color, size, and optional prefixes/suffixes for UI display. Provides both string-returning Format methods and zero-allocation AppendTo methods for StringBuilder use.

RogueAttackingState: Rogue archetype. Melee, but refuses to trade blows face-to-face: it circles into the target's rear arc before opening, and drifts back around whenever the target turns on it.

SceneBoundary: MonoBehaviour for defining a scene boundary. Draws gizmos for visualization and provides boundary size and offset.

SceneBoundaryDetails: Serializable class containing details for a scene boundary, including origin, size, and point containment logic.

SceneBoundaryDictionary: Serializable dictionary mapping string keys to scene boundary details. Provides logic to check if a point is contained in any boundary.

SceneObject: Manages registration and tracking of scene objects with unique IDs in FishMMO.

SceneObjectNamer: Assigns a generated name to a scene object using gender-specific name caches. Handles network payloads for name synchronization.

SceneTeleporter: MonoBehaviour for scene teleporters. Handles teleportation logic on the server and draws gizmos for visualization in the editor.

SceneTeleporterCacheDictionary: Serializable dictionary mapping composite keys (SceneName/TeleporterName) to scene teleporter cache entries. Used by TeleporterCache to store all known scene teleporters.

SceneTeleporterCacheEntry: Serializable entry representing a single scene teleporter in the TeleporterCache. Stores the teleporter name, scene, destination connection, and position.

SceneTeleporterDetails: Serializable class containing details for a scene teleporter destination, including target scene, position, and rotation.

SceneTeleporterDictionary: Serializable dictionary mapping string keys to scene teleporter details. Used to store and retrieve teleporter destinations and settings for scenes.

ScrollConsumableTemplate: Abstract base class for scroll consumable templates, which grant abilities when consumed. Inherits from ConsumableTemplate and adds ability learning logic.

SendAbilityCrafterBroadcastAction: ECA action that opens the ability crafter UI for the interacting player. Broadcasts AbilityCrafterBroadcast to the owner connection. Server-only.

SendBankerBroadcastAction: ECA action that opens the bank UI for the interacting player. Sets the character's last-interactable ID so follow-up bank transactions are associated with this banker, then broadcasts BankerBroadcast to the owner connection. Server-only.

SendContainerOpenBroadcastAction: ECA action that sends a ContainerOpenBroadcast to the player containing the container's current item contents. Requires the interactable to implement both IContainer and IItemContainer. Server-only.

SendDungeonFinderBroadcastAction: ECA action that broadcasts a DungeonFinderBroadcast to the player, opening the dungeon finder interface on the client. Server-only.

SendMailboxBroadcastAction: ECA action that opens the mailbox UI for the interacting player. Broadcasts MailboxBroadcast to the owner connection. Server-only.

SendMerchantBroadcastAction: ECA action that opens the merchant UI for the interacting player. Requires the interactable to implement IMerchant. Broadcasts MerchantBroadcast. Server-only.

SendQuestOfferAction: ECA action that filters available quests and sends QuestOfferBroadcast to the player. Requires the interactable to implement IQuestInteractable. Only quests acceptable by or completable (turn-in ready) for the player are included. Server-only.

SerializableDictionary: SerializableDictionary class definition.

SerializableDictionary.Storage<T>: Base class for Storage implementation.

SerializableDictionaryBase: Base class for SerializableDictionaryBase implementation.

SerializableDictionaryBase.Dictionary<TKey, TValue>: Dictionary class definition.

SerializableDictionaryBase.Storage: Base class for Storage implementation.

SerializableDictionaryBase<TKey, TValue, TValueStorage>

SerializableDictionary<TKey, TValue>: SerializableDictionary class definition.

SerializableDictionary<TKey, TValue, TValueStorage>: SerializableDictionary class definition.

SerializableHashSetBase: Base class for SerializableHashSetBase implementation.

SerializableHashSetBase.HashSet<TValue>: HashSet class definition.

SerializableHashSetBase.Storage: Base class for Storage implementation.

SerializableHashSet<T>

ServerAddress

Internal server bind address. For client-facing communication, the address is always Constants.Configuration.GameHost — use Port directly or ServerAddresses.Ports.

Converted from a mutable struct to a class to avoid the pass-by-value silent data loss anti-pattern. The previous struct warning about this has been removed since the class semantics eliminate the issue: instances are passed by reference and mutations are not silently lost.

ServerAddresses: Serializable class containing a list of server ports and a one-time connection token for real-IP recovery on the game server.

ShowReadonlyAttribute: Attribute to mark fields as readonly in the Unity inspector. Used with a custom property drawer to display fields as non-editable.

Shrine: Shrine interactable that applies buffs or heals health, mana, or both when a player interacts with it. Configured via a ShrineTemplate ScriptableObject asset.

ShrineAction: ECA action that applies healing and/or a buff from a IShrine, then sends ShrineBroadcast for client-side VFX/SFX feedback. Server-only.

ShrineTemplate: Template defining a shrine's healing and buff effects. Shrines can heal health, mana, or both, and optionally apply a buff on interaction.

SkeletonBinder: Utility for binding equipment SkinnedMeshRenderers to the character skeleton at runtime. Provides safe bone binding that does not destroy shared parent hierarchies.

SkeletonBones: Authoritative bone names for the master humanoid skeleton. Every character model and equipment mesh must use these exact bone names. Artists must never rename, add, or remove required bones.

SkinnedMeshRendererExtensions: Extension methods for SkinnedMeshRenderer, including skeleton assignment and bone cache management.

SnapshotAttributeController

Lightweight read-only ICharacterAttributeController backed by frozen CharacterAttribute instances. Used by SnapshotCharacter to satisfy StatScaledValue and StatScaledFloatValue lookups for detached ability objects whose caster has disconnected.

Only TryGetAttribute(int, out CharacterAttribute) is functional. All mutating methods are no-ops.

SnapshotCharacter

Lightweight phantom ICharacter implementation that preserves a frozen snapshot of character identity and attribute data. Created when a caster disconnects so that detached AbilityObjects can continue to resolve stat-scaled calculations via StatScaledValue and StatScaledFloatValue without a live networked character.

Only TryGet<T>(out T) for ICharacterAttributeController is supported. All other behaviour lookups return false, causing downstream systems (achievements, factions, etc.) to gracefully degrade.

SpawnableSettings: Base serializable settings for configuring a spawnable object. Supports polymorphic subclassing via UnityEngine.SerializeReference for type-specific data injection (e.g., items, NPCs). Use the SubclassSelector attribute on the containing field/list for Inspector support.

StatScaledFloatValue: Float value provider that scales a character attribute's final value by a configurable factor. Reads the initiator's (or event target's) attribute and returns Attribute.FinalValue * ScaleFactor.

StatScaledValue: Value provider that scales a character attribute's final value by a configurable factor. Reads the initiator's (or event target's) attribute and returns (int)(Attribute.FinalValue * ScaleFactor).

StateBuffTemplate: Buff template that enables CharacterFlags on apply and disables them on remove. Used for crowd-control effects such as Frozen, Stunned, and Mesmerized. Flags are additive per stack: each stack enables the same flag (idempotent via bitwise OR), but removal only clears the flag when the last stack (and base) are removed.

SubclassSelectorAttribute: Attribute for UnityEngine.SerializeReference fields that enables a type-selection dropdown in the Unity Inspector. Supports polymorphic serialization of plain C# class hierarchies. Apply to fields or list elements decorated with UnityEngine.SerializeReference.

Switch: Switch interactable that executes a function on another script when activated. Used for opening doors, unlocking chests, stopping or engaging traps, and similar mechanisms. The target object must implement ISwitchTarget.

SwitchAction: ECA action that activates or deactivates an ISwitchTarget linked by the interacted ISwitch, then broadcasts the new state to the player. Toggle switches flip state each interaction; non-toggle switches only activate once (the CanInteract(IPlayerCharacter) guard prevents re-interaction on non-toggle switches that are already activated). Server-only.

SwitchTargetMover: A ISwitchTarget that slides and/or rotates a transform between a closed pose and an open pose — a door, a portcullis, a drawbridge, a moving platform.

SwitchTargetObject: A ISwitchTarget that enables and disables a set of GameObjects.

TaggedSceneObjectTargetSelector

Resolves scene UnityEngine.GameObjects by Unity tag at runtime. Designed for asset-based Triggers that need to target one or more pre-tagged scene objects — selectors serialized on ScriptableObject assets cannot hold direct scene references, but they can hold a tag string and resolve it at fire time.

The lookup is scoped to the context's scene (whatever scene the event's Target or Initiator lives in). Results are filtered through this selector's Conditions.

Tag pre-requisite: the tag must exist in Unity's Tag Manager (ProjectSettings > Tags and Layers). Using an unknown tag logs a warning and yields no targets.

TargetAllianceCondition: Condition that checks the alliance relationship between the initiator and the target (defender). Allows configuration for which alliance types (self, enemy, neutral, ally) the condition applies to.

TargetController: Controls targeting logic for a character, including raycasting, target selection, and target events.

TargetOrdering: Deterministic ordering, ranking and shape tests shared by every target selector.

TargetSelector

Abstract base class for selecting targets in an ability or event context. Implementations consume the current EventData (its Target or Initiator serve as the spatial / contextual reference) and yield one or more UnityEngine.GameObjects for triggers, conditions or actions to operate on.

Asset safety: selectors are serialized inline on Trigger ScriptableObjects via [SerializeReference]. Unity cannot serialize references to scene GameObjects from asset files, so selectors intentionally hold no direct scene references. To "pick a specific scene object" from an asset-based Trigger, use NamedSceneObjectTargetSelector or TaggedSceneObjectTargetSelector — they resolve scene objects at runtime by name or tag. For inline (MonoBehaviour-hosted) triggers in a scene, prefer setting Target at the invocation site so the trigger receives the picked GameObject through standard event flow.

TargetedEntitySelector: Selects the caster's resolved target entity, validated by range — the EverQuest / WoW model.

TeleportAction: ECA action that teleports the interacting player via a ITeleporter. If the teleporter has a Target transform set, the player is moved to that world position and rotation. Otherwise the player is teleported by scene name via Teleport(string). Server-only.

Teleporter: Represents a teleporter interactable that can transport players to a target location. Inherits from Interactable and provides a target Transform for teleportation.

TeleporterCache: ScriptableObject cache for storing all known teleporter destinations. Pre-baked by scanning world scenes for TeleporterDestination components, keyed by stable DestinationID. Must be rebuilt before WorldSceneDetailsCache to ensure teleporter connections are validated.

TeleporterCacheDictionary: Serializable dictionary mapping destination IDs to teleporter cache entries. Used by TeleporterCache to store all known teleporter destinations.

TeleporterCacheEditor: Custom editor for the teleporter cache asset. Displays cache health, highlights invalid teleporter links, and provides one-click scene navigation to broken teleporter objects for quick fixes.

TeleporterCacheEntry: Serializable entry representing a single teleporter destination in the TeleporterCache. Stores the stable GUID, scene, display name, position, and rotation for a destination.

TeleporterDestination: Represents a destination point for teleporters in the scene. Each destination has a stable DestinationID (GUID) that survives renames and moves. Used to visually indicate and mark teleporter endpoints in the Unity Editor.

TemplateReferenceAttribute: Marks an int or List<int> field as a template ID reference. In the Inspector, the field displays an object picker for the specified CachedScriptableObject type but serializes only the deterministic ID.

TerrainBoundary: MonoBehaviour for defining terrain boundaries. Draws gizmos for visualization and provides boundary size and offset based on terrain data.

TickEventData: Lightweight EventData subtype carrying a network tick for tick-aware triggers.

TinyColor: A lightweight color struct using byte values for R, G, B, and A components (0-255). Provides conversions, predefined colors, and utility functions for color manipulation.

TinyColorExtensions: Provides extension methods for the TinyColor struct.

TooltipBuilder: Builder pattern class for constructing formatted tooltip strings. Supports priority-based line ordering, rich text colors, bold, and font sizes. Uses ZString for zero-allocation string building.

TooltipColors: Centralized color strings for tooltip rich text. Colors are runtime-configurable via Initialize(string, string, string, string) and default to sensible fallback values. All hex color values include # prefix and alpha, compatible with Unity's rich text system.

TransformExtensions: Extension methods for Unity Transforms, including bone hierarchy and child GameObject search utilities.

TurnInQuestAction: ECA action that turns in a completed quest, granting rewards. Server-only execution.

UnequipItemAction: Action that attempts to unequip an item from the initiating character. Optionally uses ItemEventData from the EventData to override the target slot and container. Server-only execution — equipment mutations rearrange persistent item ownership between containers and must never run during client prediction replay.

UnityConsoleFormatter: Implements ILogger to output log entries to the Unity Editor console. Also implements IConsoleFormatter to support direct colored output via Log.WritePartsToConsole. Supports Unity rich text coloring.

UnityConsoleLogger: Implements ILogger to output log entries to the Unity Editor console. Supports Unity rich text coloring.

UnityConsoleLoggerConfig: Configuration for the Unity Console Logger. Messages routed through FishMMO.Logging.Log will also appear in the Unity console if this logger is enabled and the log level is allowed.

UnityLoggerBridge: Bridges Unity's logging system with the FishMMO.Logging system by implementing ILogHandler. Intercepts all Unity Debug.Log messages and forwards them to the central Log manager, while also preventing Unity's default console output. Designed to be separate from core ILogger implementations.

Vector3Extensions: Extension methods for Vector3, providing randomization and geometric utilities for spheres and toroids.

VersionBuilder: Handles versioning for FishMMO builds. Provides build post-processing to write version info, and menu items for incrementing and resetting version numbers.

VersionConfig: ScriptableObject holding semantic versioning information for FishMMO builds. Supports parsing, comparison, and equality operations.

WanderState: Wandering behaviour. The NPC drifts to random points around its home, pausing at idle now and then.

WeaponTemplate: ScriptableObject template for weapon items, defining attack power and attack speed attributes. Inherits from EquippableItemTemplate for equipment logic. Weapons are not skinned — they attach as MeshRenderer children of the specified bone transform.

WithinRangeCondition: Passes when the evaluated character is within a distance of the initiator.

WorldDayNightCycle: MonoBehaviour for managing the day/night cycle in a scene. Handles skybox transitions, object rotations, object activations/deactivations, and material alpha fading based on the current game time of day. Supports ECA triggers for scene-load, day-start, and night-start events.

WorldItem: Represents an item that exists in the world and can be interacted with or picked up by players.

WorldMapDefinition: Everything a scene needs in order to present itself: its player-facing name, the image shown while it loads, the baked overhead map the world map draws, the world-space rectangle that map covers, and the labels and landmarks placed on it.

WorldSceneDetails: Serializable data structure containing configuration details for a game scene. Includes client limits, transition visuals, spawn/respawn positions, teleporters, and boundaries.

WorldSceneDetailsCache: ScriptableObject cache for storing and managing all world scene details in the game. Provides centralized access and rebuild functionality for scene configuration data.

WorldSceneDetailsCacheEditor: Custom editor for WorldSceneDetailsCache ScriptableObject. Adds a "Rebuild" button to the inspector for manual cache rebuilding.

WorldSceneDetailsCacheReader: ScriptableObject responsible for reading and rebuilding world scene details from Unity scenes. Scans all configured world scenes, extracts spawn positions, boundaries, teleporters, and validates destinations against the TeleporterCache.

WorldSceneDetailsDictionary: Serializable dictionary mapping scene names to their configuration details. Used to store and access all world scene details for the game.

WorldSceneSettings: MonoBehaviour holding per-scene server-facing configuration and the link to the scene's WorldMapDefinition. Day/night cycle authoring has moved to WorldDayNightCycle on its own component so a scene can mix and match (a dungeon may want only the settings, a surface zone may want both).

WorldSceneTrigger

Inline ECA trigger data for world-scene events (scene load, day start, night start, …).

Unlike the asset-based Trigger, this type is [Serializable] and lives directly on a host MonoBehaviour so designers can author scene-specific responses inline. Execution semantics — selector fan-out, condition branching, action dispatch — are delegated to RunInline(TargetSelector, List<BaseCondition>, List<BaseAction>, List<BaseAction>, EventData) so this type stays in lock-step with any future Trigger behaviour changes.

WorldServerDetails: Serializable class containing details about a world server, including name, port, status, and player count.

Structs

AICharacterInputs: Input data supplied by an AI controller for character movement and facing.

AICombatContext: Everything the shared combat decision needs, as plain numbers.

AICombatPlan: The decision produced from an AICombatContext.

AbilityActivatedBroadcast: Tells observers that a character activated an ability, with everything needed to reproduce it.

AbilityActivationReplicateData: Replicate data for ability activation, used internally by AbilityController. The unified CharacterReplicateData is what FishNet serializes for prediction.

AbilityAddBroadcast: Broadcast for adding an ability to a character, including its events. Contains the ability's instance ID, template ID, and associated event IDs.

AbilityAddMultipleBroadcast: Broadcast for adding multiple abilities to a character at once. Used for bulk updates or synchronization.

AbilityCraftBroadcast: Broadcast for crafting an ability using an interactable object. Contains the interactable object's ID, template ID, and a list of event IDs.

AbilityCrafterBroadcast: Broadcast for interacting with an ability crafter object. Contains the interactable object's ID.

AbilityLearnedObserverBroadcast: Tells observers that a character learned an ability, so they can draw its casts.

AbilityObjectDestroyedBroadcast: Tells observers that an ability object ended on the server through a collision.

AbilityObjectHitBroadcast: Tells observers which body an ability object hit, so they can draw the impact the server resolved instead of guessing at one.

AbilitySpawnPose: World pose an ability object is spawned with.

AbilitySweepHit: One collider the swept query found, with the impact information a hit needs.

AccountVerifyBroadcast: Broadcast sent by the client to verify an account using a verification code received after account creation.

AchievementUpdateBroadcast: Broadcast for updating a single achievement for a character. Contains the achievement template ID, value, and tier.

AchievementUpdateMultipleBroadcast: Broadcast for updating multiple achievements for a character at once. Used for bulk updates or synchronization.

ArchetypeUpdateBroadcast: Broadcast for updating the owner's archetype.

AttributeReconcileEntry

A single non-resource character attribute entry for reconcile serialization. Mirrors BuffReconcileEntry / CooldownReconcileEntry index-delta compression so unchanged attributes contribute zero network bytes.

Resource attributes (HP/MP/Stamina) are NOT carried by this entry — they ride CharacterAttributeResourceState on the reconcile payload because they also need CurrentValue + RegenTickAccum state that base attributes do not have.

Only Value (authoritative base) and ExternalModifier (sum of buff / equipment / region contributions) are reconciled. FormulaModifier is intentionally recomputed locally via the dependency graph (CharacterAttribute.ApplyChildren): replicating it would (a) cost bandwidth for a derived value and (b) potentially overwrite a more up-to-date local computation.

BankRemoveItemBroadcast: Broadcast for removing an item from a specific bank slot.

BankSetItemBroadcast: Broadcast for setting a single item in the bank inventory. Contains all data needed to place or update an item in a bank slot.

BankSetMultipleItemsBroadcast: Broadcast for setting multiple items in the bank inventory at once. Used for bulk updates or synchronization.

BankSwapItemSlotsBroadcast: Broadcast for swapping two item slots in the bank or between inventories.

BankerBroadcast: Broadcast for interacting with a banker object. No additional data required.

BlendShapeEntry: A single named blend shape entry with a 0-100 weight value.

BuffReconcileEntry: A single buff entry for reconcile serialization. Uses tick-based timing fields (ExpiryTick, NextTickTick) mirroring CooldownReconcileEntry's immutable tick design. Tick values are absolute network ticks, so they are stable between structural changes (add/remove/stack), allowing the delta serializer's ReferenceEquals fast-path to suppress transmission on unchanged ticks with zero network overhead. Implements IEquatable<T> for efficient delta comparison in CharacterReconcileDataDeltaSerializer.

CapturePointUpdateBroadcast: Server → Client broadcast when a capture point's state changes.

ChannelAddress: Serializable struct representing a scene channel, including server connection info, scene identity, and population. Used for channel selection and network communication.

CharacterAppearanceData

Serializable snapshot of a character's full visual appearance. Used for save/load, network replication, and character creation.

All values are deterministic — applying the same data produces the same visual result.

CharacterAttributeResourceState: Represents the current state of a character's resource attributes (health, mana, stamina) and regeneration timer. Used for synchronizing resource values and regeneration progress between client and server.

CharacterAttributesBroadcast: Carries changed character attributes to everyone observing a character.

CharacterBuffsBroadcast: Carries a character's publicly visible buffs to everyone observing it.

CharacterCombatStateBroadcast: Tells observers a character entered or left combat.

CharacterCreateBroadcast: Broadcast for creating a new character. Contains character name, race, model, and spawn location details.

CharacterCreateResultBroadcast: Broadcast for reporting the result of a character creation attempt. Contains the result status.

CharacterDeathStateBroadcast: Tells observers a character died or was revived.

CharacterDeleteBroadcast: Broadcast for deleting a character from the account. Contains the name of the character to delete.

CharacterDetails.EquippedItemEntry: Serializable key-value pair for equipped items. Register as a FishNet custom serializer and migrate EquippedItems to EquippedItemEntry[] when ready. See FishNet.Serialize.DictionarySerializer for the registration pattern.

CharacterListBroadcast: Broadcast for sending the list of available characters to the client. Contains a list of character details.

CharacterListResultBroadcast: Broadcast sent when a CharacterRequestListBroadcast cannot be answered with a CharacterListBroadcast.

CharacterObserverArchetypeUpdateBroadcast: Observer-targeted broadcast for updating archetype of a specific character.

CharacterObserverFactionUpdateBroadcast: Observer-targeted broadcast for updating faction values of a specific character.

CharacterPositionHistory.Snapshot: One recorded tick.

CharacterReconcileData

CharacterReplicateData: Unified per-tick input data for all predicted character subsystems. Contains movement input (KCC) and ability activation input. Prediction works best when replicate data contains only input, not state.

CharacterRequestListBroadcast: Broadcast for requesting the list of available characters for the account. No additional data required.

CharacterResourcesBroadcast: Carries a character's resources to everyone observing it.

CharacterSceneChangeRequestBroadcast: Broadcast for requesting a character scene change via a teleporter. Contains the source teleporter and target teleporter names.

CharacterSelectBroadcast: Broadcast for selecting a character to play. Contains the name of the character to select.

CharacterSelectResultBroadcast: Broadcast sent for every character selection — accepted or refused — so the client always has a terminal answer instead of appearing to hang on an unanswered request.

ChatBroadcast: Broadcast for transmitting a chat message. Contains the chat channel, sender ID, and message text.

ChatCommandDetails: Struct containing details for a chat command, including the channel and the command function.

ChatCommandRegistration: A registered slash command and the minimum access level allowed to run it.

ClientAuthResultBroadcast: Broadcast sent by the server to communicate the result of client authentication.

ClientHandshake: Broadcast sent by the client to initiate a handshake, containing the ephemeral X25519 public key for ECDH key agreement and supported protocol version range.

ClientScenesUnloadedBroadcast: Broadcast indicating that the client has unloaded one or more scenes. Contains a list of unloaded scenes.

ClientValidatedSceneBroadcast: Broadcast indicating that the client has validated the current scene. No additional data required.

CombatEventBroadcast: Tells everyone who can see a character that it just took damage or was healed.

CombatEventCoalescer.Entry: One merged entry.

ConnectionTokenBroadcast: Server → client: a freshly minted connection token, or an empty token when the server could not mint one. Answers RequestConnectionTokenBroadcast.

ContainerOpenBroadcast: Server → Client broadcast to open the container UI with its current contents.

ContainerSlotData: Data structure for a single item slot within a ContainerOpenBroadcast.

ContainerTakeItemBroadcast: Client → Server broadcast requesting to take an item from a container slot.

ContainerTakeResultBroadcast: Server → Client reply to a container take request.

CooldownInstance: Immutable cooldown instance using StartTick + DurationTicks. Remaining time is computed as DurationTicks - (currentTick - StartTick), which is perfectly deterministic across client and server with zero float drift. No per-tick mutation is needed — cooldowns auto-expire via integer comparison.

CooldownReconcileEntry: A single cooldown entry for reconcile serialization. Implements IEquatable<T> for efficient delta comparison in CharacterReconcileDataDeltaSerializer.

CorpseLootBroadcast: Server → Client broadcast opening (or refreshing) a corpse's loot window.

CorpseLootCloseBroadcast: Client → Server broadcast saying the player closed a corpse's loot window.

CorpseLootCloseWindowBroadcast: Server → Client broadcast forcing a corpse's loot window shut.

CorpseLootResultBroadcast: Server → Client reply to any corpse take request.

CorpseLootSlotData: One item slot on a corpse, as sent to a looter.

CorpseLootTakeAllBroadcast: Client → Server broadcast requesting everything the corpse holds.

CorpseLootTakeCurrencyBroadcast: Client → Server broadcast requesting the currency on a corpse.

CorpseLootTakeItemBroadcast: Client → Server broadcast requesting one item from a corpse.

CreateAccountBroadcast: Broadcast sent by the client to create a new account, containing SRP username, salt, and verifier.

DeathBroadcast: Sent server to client when a player dies. Triggers the death dialog UI.

DialogueChoiceBroadcast: Client → Server broadcast when the player selects a dialogue choice. The server validates the choice and responds with a result or end broadcast.

DialogueChoiceResultBroadcast: Server → Client broadcast when the server accepts a dialogue choice. Tells the client which node to display next and the updated choice bitmask.

DialogueEndBroadcast: Server → Client broadcast to forcibly end a dialogue session (e.g., out of range).

DialogueStartBroadcast: Server → Client broadcast to start a dialogue session. The client resolves the DialogueTemplate from the cache and displays the start node.

DisconnectNoticeBroadcast: Sent immediately before a server closes a connection on purpose, so the player is told why instead of simply finding themselves back on the login screen.

DungeonFinderBroadcast: Server → Client broadcast opening the dungeon finder for one entrance.

DungeonFinderCreateBroadcast: Client → Server broadcast asking to open a new instance of a dungeon.

DungeonFinderJoinBroadcast: Client → Server broadcast asking to join somebody else's instance.

DungeonFinderListBroadcast: Client → Server broadcast asking for the instances joinable at one difficulty.

DungeonFinderListResultBroadcast: Server → Client reply listing the instances joinable at one difficulty.

DungeonInstanceEntry: One joinable instance, as offered in the dungeon finder's list.

EquipmentEquipItemBroadcast: Broadcast for equipping an item from an inventory slot to an equipment slot. Sent client→server to request an equip, echoed server→client as acknowledgement.

EquipmentObservedSlotBroadcast: Tells everyone observing a character that one of its equipment slots changed.

EquipmentReconcileEntry: Lightweight reconcile entry for a single equipped item slot. Only filled slots are serialized — empty slots are omitted.

EquipmentUnequipItemBroadcast: Broadcast for unequipping an item from an equipment slot to an inventory slot. Sent client→server to request an unequip, echoed server→client as acknowledgement.

FactionUpdateBroadcast: Broadcast for updating a single faction value for a character. Contains the faction template ID and the new value.

FactionUpdateMultipleBroadcast: Broadcast for updating multiple faction values for a character at once. Used for bulk faction updates or synchronization.

FriendAddBroadcast: Broadcast for adding a friend to the friend list, including online status.

FriendAddMultipleBroadcast: Broadcast for adding multiple friends to the friend list at once. Used for bulk friend addition or synchronization.

FriendAddNewBroadcast: Broadcast for adding a new friend to a character's friend list. Contains the character ID of the new friend.

FriendRemoveBroadcast: Broadcast for removing a friend from the friend list. Contains the character ID of the friend to remove.

GatheringNodeBroadcast: Server → Client broadcast when gathering starts. Used for progress bar display.

GuildAcceptInviteBroadcast: Broadcast for accepting a guild invitation.

GuildAddBroadcast: Broadcast for adding a member to a guild. Contains guild ID, character ID, rank, and location.

GuildAddMultipleBroadcast: Broadcast for adding multiple members to a guild at once. Used for bulk member addition or synchronization.

GuildApplicationEntry: One pending application on the wire.

GuildApplicationListBroadcast: Broadcast carrying the guild's pending application queue, oldest first.

GuildApplicationListRequestBroadcast: Broadcast requesting the guild's pending application queue.

GuildApplyBroadcast: Broadcast requesting to join a guild through its directory listing.

GuildChangeRankBroadcast: Broadcast for changing a member's rank within a guild. Contains the character ID and the new rank.

GuildCreateBroadcast: Broadcast for creating a new guild. Contains the name of the guild to be created.

GuildCreateRankBroadcast: Broadcast requesting a new rank at a given position.

GuildDeclineInviteBroadcast: Broadcast for declining a guild invitation.

GuildDeleteRankBroadcast: Broadcast requesting removal of a rank.

GuildDirectoryBroadcast: Broadcast carrying a page of the recruitment directory.

GuildDirectoryEntry: One guild as it appears in the recruitment directory.

GuildDirectoryRequestBroadcast: Broadcast requesting a page of the recruitment directory.

GuildDisbandBroadcast: Broadcast requesting that the guild be disbanded.

GuildEditRankBroadcast: Broadcast requesting a change to one rank's name and permissions.

GuildInfoBroadcast: Broadcast carrying a guild's descriptive text to its members.

GuildInviteBroadcast: Broadcast for inviting a character to a guild. Contains the inviter and target character IDs.

GuildLeaveBroadcast: Broadcast for a member leaving a guild. No additional data required.

GuildLogBroadcast: Broadcast carrying a guild's recent activity log, newest first.

GuildLogEntry: One guild activity log row on the wire.

GuildLogRequestBroadcast: Broadcast requesting the guild's recent activity log.

GuildRankEntry: One rank on a guild's ladder, on the wire.

GuildRankListBroadcast: Broadcast carrying a guild's rank ladder and the recipient's own standing in it.

GuildRankListRequestBroadcast: Broadcast requesting the guild's rank ladder.

GuildRecruitmentInfoBroadcast: Broadcast carrying a guild's recruitment advertisement to its own members.

GuildRemoveBroadcast: Broadcast for removing a member from a guild. Contains the character ID to be removed.

GuildResolveApplicationBroadcast: Broadcast accepting or declining one pending application.

GuildResultBroadcast: Broadcast for sending the result of a guild operation. Contains the result type indicating success or failure reason.

GuildSetMemberNoteBroadcast: Broadcast requesting a change to one of a member's two guild notes.

GuildSetMessageOfTheDayBroadcast: Broadcast requesting a change to the guild's message of the day.

GuildSetNoticeBroadcast: Broadcast requesting a change to the guild's notice text.

GuildSetRecruitmentBroadcast: Broadcast requesting a change to the guild's recruitment advertisement.

GuildTransferLeadershipBroadcast: Broadcast requesting that guild leadership be transferred to another member.

HotkeyData: Data structure representing a hotkey assignment for a character.

HotkeySetBroadcast: Broadcast for setting a single hotkey assignment for a character. Contains the hotkey data to be set.

HotkeySetMultipleBroadcast: Broadcast for setting multiple hotkey assignments at once. Used for bulk hotkey updates or synchronization.

InstanceDetailsBroadcast: Broadcast carrying the state of an instance to one of its members.

InstanceKickBroadcast: Broadcast asking the server to remove another character from the instance.

InstanceMemberData: One member of an instance, as presented to another member.

InstancePrivacyBroadcast: Client → Server broadcast showing or hiding the instance in the dungeon finder's list.

InteractableBroadcast: Broadcast for requesting to use an interactable object. Contains the ID of the interactable object.

InventoryRemoveItemBroadcast: Broadcast for removing an item from a specific inventory slot.

InventorySetItemBroadcast: Broadcast for setting a single item in the character's inventory. Contains all data needed to place or update an item in an inventory slot.

InventorySetMultipleItemsBroadcast: Broadcast for setting multiple items in the character's inventory at once. Used for bulk updates or synchronization.

InventorySwapItemSlotsBroadcast: Broadcast for swapping two item slots in the inventory or between inventories.

ItemOperationFailedBroadcast: Sent to a client when an item operation it requested did not happen.

KCCInputReplicateData: Represents a single frame of input data for KCC character replication and prediction. Used internally by SetInputs(ref KCCInputReplicateData) and PlayerInputController.

KCCPlatform.ReconcileData: Reconcile data for the platform. Contains all state read during PerformReplicate(ReplicateData, ReplicateState, Channel) to ensure deterministic replay after reconciliation.

KCCPlatform.ReplicateData: Replicate data for the platform. Autonomous movement requires no client input.

KnownAbilityAddBroadcast: Broadcast for adding a known ability to a character. Contains the template ID of the ability to add.

KnownAbilityAddMultipleBroadcast: Broadcast for adding multiple known abilities to a character at once. Used for bulk updates or synchronization.

KnownAbilityEventAddBroadcast: Broadcast for adding a known ability event to a character. Contains the template ID of the ability event to add.

KnownAbilityEventAddMultipleBroadcast: Broadcast for adding multiple known ability events to a character at once. Used for bulk updates or synchronization.

LagCompensatedQuery.CompensatedHit: One body a compensated query selected, with the impact information a hit needs.

LagCompensationRegistry.RewindScope: Holds characters displaced for the duration of a using block.

LoginQueuePositionBroadcast

Broadcast sent by the LoginServer to a queued client with their current position in the login queue. Sent periodically at a server-configured rate.

Position semantics:

> 0 — Waiting in queue. Display the position to the user.
0 — Admitted. The client should re-initiate the handshake now.
-1 — Cancelled. The queue entry was purged (timeout or shutdown).

Server-authoritative update rate: The server controls how often this broadcast is sent via the LoginQueueUpdateRateSeconds config key. Clients are passive receivers only — there is no request path for faster updates.

Validation: The server MUST enforce the documented QueuePosition semantics (>0 waiting, 0 admitted, -1 cancelled). The client treats these values as authoritative — no local defensive validation is performed.

LoreObjectBroadcast: Server → Client broadcast to display the UILore window. The client resolves the LoreObjectTemplate from the cache.

MailClaimAttachmentBroadcast: Client → Server broadcast claiming one mail's attachment.

MailClaimResultBroadcast: Server → Client reply to an attachment claim.

MailDeleteBroadcast: Client → Server broadcast to delete a mail entry.

MailEntryData: Data structure for a single mail entry within a MailListBroadcast.

MailFetchBroadcast: Client → Server broadcast requesting the character's mail list.

MailListBroadcast: Server → Client broadcast containing the character's mail list.

MailSendBroadcast: Client → Server broadcast to send mail to another player.

MailSendResultBroadcast: Server → Client reply to a mail send.

MailboxBroadcast: Server → Client broadcast to open the mailbox UI.

MerchantBroadcast: Broadcast for interacting with a merchant object. Contains the interactable object's ID and the merchant's template ID.

MerchantPurchaseBroadcast: Broadcast for purchasing an item from a merchant. Contains the interactable object's ID, item ID, index, and tab type.

MerchantSellBroadcast: Client → Server broadcast to sell an inventory item to a merchant.

MerchantSellResultBroadcast: Server → Client broadcast acknowledging or refusing a merchant sale.

ModifierSource: Identifies one contributor to a CharacterAttribute's external modifier.

NamingBroadcast: Broadcast for updating or assigning a name in the naming system. Contains the type, ID, and name to assign.

NetworkTransformDistanceLod.Band: One distance band: everything nearer than MaximumDistance and not covered by a nearer band synchronises every Interval ticks.

ObservedBuffEntry: One buff on another character, as the SERVER has chosen to show it to observers. Display-only: nothing on the client applies an effect from this.

ObservedResourcePushScheduler: Decides, tick by tick, whether a character's resources go out to its observers.

ObserverStreamingPolicy.LodBand: A distance band and the send interval (in ticks) applied inside it.

PartyAcceptInviteBroadcast: Broadcast for accepting a party invitation.

PartyAddBroadcast: Broadcast for adding a member to a party. Contains party ID, character ID, rank, and health percentage.

PartyAddMultipleBroadcast: Broadcast for adding multiple members to a party at once. Used for bulk member addition or synchronization.

PartyChangeRankBroadcast: Broadcast for changing a member's rank within a party. Contains the character ID and the new rank.

PartyCreateBroadcast: Broadcast for creating a new party. Contains the party ID and location.

PartyDeclineInviteBroadcast: Broadcast for declining a party invitation.

PartyInviteBroadcast: Broadcast for inviting a character to a party. Contains the inviter and target character IDs.

PartyLeaveBroadcast: Broadcast for a member leaving a party. No additional data required.

PartyMemberVitalsEntry: One party member's live state, as observed on a scene server.

PartyMemberVitalsUpdateBroadcast: Broadcast carrying live state for the party members sharing a scene with the recipient.

PartyRemoveBroadcast: Broadcast for removing a member from a party. Contains the character ID to be removed.

PetAddBroadcast: Broadcast for adding a pet to a character. Contains the pet's unique ID and its current orders.

PetAttackBroadcast: Client-to-server: send the pet at the owner's current target.

PetFollowBroadcast: Broadcast for commanding a pet to follow its owner. No additional data required.

PetMovementOrderBroadcast: Server-to-client: the pet's movement order changed.

PetPersistedAttribute: One attribute value restored from the database and staged onto a Pet for application at spawn.

PetPersistedBuff: One buff restored from the database and staged onto a Pet for application at spawn.

PetReleaseBroadcast: Broadcast for releasing a pet (removing it from ownership). No additional data required.

PetRemoveBroadcast: Broadcast for removing a pet from a character. No additional data required.

PetStanceBroadcast: Client-to-server: change the pet's combat stance. Also sent server-to-client to confirm the authoritative stance.

PetStayBroadcast: Broadcast for commanding a pet to stay in its current location. No additional data required.

PetSummonBroadcast: Broadcast for summoning a pet to the owner's location. No additional data required.

PredictionTick: A tick value that can only be legitimately produced from a replicate input via GetPredictionTick(). Because the constructor is internal, callers outside this assembly cannot construct one from a raw uint (e.g. TimeManager.LocalTick) without an explicit, intentional conversion — the compiler enforces correct tick sourcing on every Apply() call in the prediction path.

QuestAbandonBroadcast: Client to Server broadcast requesting to abandon a quest.

QuestAcceptBroadcast: Client to Server broadcast requesting to accept a quest from a quest interactable.

QuestOfferBroadcast: Server to Client broadcast presenting available quests from a QuestInteractable.

QuestRemoveBroadcast: Server to Client broadcast for removing a quest from the client's quest log.

QuestTurnInBroadcast: Client to Server broadcast requesting to turn in a completed quest.

QuestUpdateBroadcast: Server to Client broadcast for updating a single quest's state and objective progress.

QuestUpdateMultipleBroadcast: Server to Client broadcast for updating multiple quests at once (login sync).

RaceProportions: Default body proportions for a race. These values are applied as bone scaling on character spawn. 1.0 = default human proportion. Values are multipliers on individual bone localScale.

RenewTokenResponseBroadcast: Broadcast sent by a World or Scene server immediately after a successful TokenAuthBroadcast authentication, carrying a freshly-minted auth token with a refreshed expiration window. The client decrypts the new token over the existing AES-GCM session channel and replaces its stored token so that future reconnects continue working past the original LoginServer-issued token's expiration.

RequestConnectionTokenBroadcast: Client → server: request a connection token for the server this client is about to connect to next (Login → World, World → Scene).

RequestInitialSceneBroadcast: Broadcast requesting the initial scene to be loaded for the client. No additional data required.

RequestInstanceDetailsBroadcast: Broadcast asking the server for the state of the instance the character is standing in.

RequestLeaveInstanceBroadcast: Broadcast asking the server to remove the character from its current instance and return it to the open world.

RequestSceneChannelListBroadcast: Broadcast requesting the list of available scene channels from the server. Sent by the client to request an updated channel list for the current scene.

RequestServerListBroadcast: Broadcast for requesting the list of available servers. No additional data required.

RespawnAtBindPointBroadcast: Sent client to server when the dead player chooses to respawn at their bind point.

ResurrectAcceptBroadcast: Sent client to server when the dead player accepts a resurrect.

ResurrectOfferBroadcast: Sent server to client when another player offers a resurrect. The client adds an "Accept Resurrect" button to the death dialog.

ReverseNamingBroadcast: Broadcast for looking up an entity by name in the naming system. Contains the type, lowercase name, ID, and original name.

RevokeTokenBroadcast

Broadcast sent by the client during an explicit logout to ask the LoginServer to revoke its currently-held auth token before its TTL expires. The token is sent as the raw HMAC-signed bytes the LoginServer originally issued (and which the client decrypted into memory on SrpSuccess). The server hashes the bytes via TokenService.HashToken and matches the row in IAuthTokenService.

Security note: this broadcast is sent over the FishNet transport without additional encryption; the server's AES-GCM auth channel has typically been torn down by the time the user logs out. Because the only purpose is to revoke the token the eavesdropper would have captured anyway, this is safe.

RewindTarget: A point in the past to rewind the world to: a whole tick, plus how far before that tick the target actually sits.

SceneChannelListBroadcast: Broadcast for sending a list of available scene channels to the client. Contains a list of channel addresses.

SceneChannelSelectBroadcast: Broadcast for selecting a specific scene channel. Contains the selected channel address.

SceneLoadBroadcast: Broadcast for loading a specific scene. Contains the name of the scene to load.

SceneTransferRefusedBroadcast: Broadcast sent when the server declines a voluntary scene-instance transfer, so the client can restore its UI and tell the player why rather than appearing to hang.

SceneUnloadBroadcast: Broadcast for unloading a specific scene. Contains the name of the scene to unload.

ServerBusyBroadcast: Broadcast sent by the server when it cannot process a gameplay request because the async work queue is full. The client should display a transient "Server Busy" notification.

ServerHandshake: Broadcast sent by the server to complete the handshake, containing the server's X25519 public key for ECDH key agreement and the negotiated protocol version.

ServerListBroadcast: Broadcast for sending the list of available servers to the client. Contains a list of world server details.

ShrineBroadcast: Server → Client broadcast answering a shrine interaction.

SrpProofBroadcast: Broadcast sent by the client to prove SRP authentication, containing the proof value.

SrpSuccessBroadcast: Broadcast sent by the server to indicate successful SRP authentication, containing proof and result.

SrpVerifyRequestBroadcast: Broadcast sent by the client to initiate SRP authentication (client→server only). Carries the encrypted username/email and the client's SRP public ephemeral A.

SrpVerifyResponseBroadcast: Broadcast sent by the server in response to SRP verification (server→client only). Carries the encrypted SRP salt s and the server's SRP public ephemeral B.

SwitchStateBroadcast: Server → Client broadcast when a switch is toggled. Communicates the new state.

TargetInfo: Struct containing information about a target and the hit position.

TargetRank: One candidate's sort keys, detached from the GameObject it came from.

TokenAuthBroadcast: Broadcast sent by the client to authenticate with a World or Scene server using a signed token issued by the LoginServer after SRP success.

TooltipLine: Represents a single line of tooltip content with formatting and priority-based ordering.

TwoFactorSetupBroadcast

Broadcast sent by the server after account creation containing encrypted TOTP setup data (otpauth URI and recovery codes) for two-factor authentication.

WARNING: The nonce-derivation scheme on both client and server depends on C# struct field declaration order matching FishNet serialization order. The server sends OtpauthUri first, then RecoveryCodes, and the client consumes them in that exact sequence via receiveNonceCtx.NextNonce(). If these fields are reordered, the nonce streams desynchronize and TOTP silently breaks. DO NOT reorder OtpauthUri and RecoveryCodes.

TwoFactorVerifyBroadcast: Broadcast sent by the client to submit a TOTP code during login when two-factor authentication is required.

WorldSceneConnectBroadcast: Broadcast for connecting to a world scene server. Contains only the port; address is always Constants.Configuration.GameHost.

WorldSceneQueuePositionBroadcast

Broadcast sent by the WorldServer to a client waiting to be routed to a SceneServer, with its current position in the scene-routing queue. Sent periodically at a server-configured rate.

Position semantics (identical to LoginQueuePositionBroadcast):

> 0 — Waiting in queue. Display the position to the user.
0 — Routed. A WorldSceneConnectBroadcast follows; dismiss the wait UI.
-1 — Cancelled. The wait was abandoned and the connection is being closed.

Why this exists. The World → Scene hop is the one leg of the connection pipeline that could stall indefinitely with nothing on screen but a loading overlay. A client with no scene instance to go to is held in the WorldServer's queue and re-evaluated every cycle, so the wait is legitimate — but it was completely silent, which is indistinguishable from a hang. This is the login queue's feedback channel applied to the same problem one hop later.

Server-authoritative update rate: The WorldServer controls how often this broadcast is sent. Clients are passive receivers only — there is no request path.

Interfaces

IBodyVisibilityManager: Manages visibility of body region SkinnedMeshRenderers. Hides body parts covered by equipped armor and restores them on unequip. Also provides access to the character's skeleton root for equipment mesh binding.

ICachedObject: Interface for objects that support caching with a unique identifier and cache management methods.

ICharacterAnimationController: Centralized animation control interface for characters. Abstracts Animator parameter setting and integrates with FishNet NetworkAnimator for sync.

ICharacterAppearanceManager: Manages character visual appearance: bone scaling for body proportions, blend shape synchronization across body and equipment, and appearance data serialization.

IEquipmentVisualController: Manages visual representation of equipped items on a character. Handles mesh loading, skeleton binding, renderer pooling, and body region hiding.

IInteractable: Interface for interactable objects in the scene, providing interaction logic and UI display properties. Used for NPCs, objects, and other entities that players can interact with.

IModelReadyHandler: Implemented by character behaviours that need to re-initialize when the character's visual model finishes loading asynchronously. Called from InstantiateRaceModelFromIndex(RaceTemplate, int) after the model is instantiated and the Animator is wired.

IPredictableController: Interface for controllers that participate in the unified character prediction pipeline. Implemented by subsystems (e.g., movement, abilities) that contribute to replicate/reconcile through CharacterPredictionController.

ISceneObject: Interface for scene objects with a unique ID and associated GameObject in FishMMO.

ISwitchTarget: Interface for objects that can be activated or deactivated by a Switch interactable. Implement on doors, chests, traps, or any scene object that responds to switch interactions.

Enums

AIAbilityIntent: What an ability actually does, derived from the ECA actions attached to its events.

AICombatIntent: What an NPC has decided to do about its current target this combat tick. Produced by Plan(in AICombatContext) and executed by BaseAttackingState.

AILodTier: AI Level-of-Detail tiers. Determines how frequently an NPC's brain ticks based on its proximity to the nearest player observer.

AIMovementProgress: How an NPC is faring against its current destination.

AIMovementResult: Outcome of asking an NPC to move somewhere.

AINodeResult: Result of a behavior tree node evaluation.

AIRotationMode: Determines how the rotation evaluates its entries.

AITargetingMode: How an NPC picks which enemy to hit when several are available. Supplied by TargetingMode and consumed by PickTarget(AIController, List<ICharacter>).

AbilityActivationFlags

Flags representing the activation state of an ability. Stored as bit positions in an int and manipulated via IntBitExtensions.

Bit position 0 (IsActualData) is used as a sentinel to distinguish real input from FishNet's default-filled replicate data. Data without this bit set does NOT stop the replicate: AbilityController.ReplicateInternal clears the queued ability, carries the held flag over from the replicated state, and goes on simulating — a tick with no new input still has to advance an active cast, its cooldowns and its resource drain, or the owner and the server diverge whenever a packet is late. This lets bit 0 double as a "data present" marker without consuming an extra field in the replicate struct.

Constraint: All enum values are bit positions and must remain in the range 0–15 (bits 0–15 after shifting). Pack(int, int) stores flags in the lower 16 bits. Values at or above 16 will be silently truncated during reconcile.

AbilityCategory: Ability category inferred at runtime from an ability's template data. Used by AICombatPersonality to apply personality weights.

AbilitySpawnTarget: Specifies the target location or entity for spawning an ability. Used to determine where an ability effect or object should appear in the game world.

AbilityType: Represents the type of ability, such as physical or magical, and whether it is grounded or aerial. Also drives animation triggers via CharacterAnimationController.

AchievementCategory: Categories for achievements, used to group and organize different types of achievements in the game.

AgentAvoidancePriority: Defines avoidance priority levels for AI agents. Higher values cause agents to avoid others more aggressively. Used to control how strongly an agent tries to avoid collisions with other agents in the navigation system.

BodyRegion: Body regions that can be individually hidden when equipment is worn. Maps to the pre-split SkinnedMeshRenderers on the character body model.

BonusOrientationMethod: Additional orientation modes that adjust the character up vector.

CharacterCreateResult: Result types for character creation attempts, indicating success or specific failure reasons. All members have explicit byte values to prevent wire-protocol reordering when new values are inserted.

CharacterDamageController.CombatTimerStep: Outcome of one evaluation of the combat timer.

CharacterFlags: Flags representing various character states and conditions. Used for bitwise state management and quick checks of character status.

CharacterGender: Gender used for generated scene-object names and optional race model selection.

CharacterListResult: Why a character-list request could not be answered with a list.

CharacterSelectResult: Why a character selection could not be honoured.

ChatChannel: Enum representing the different chat channels available in the game.

CombatEventKind: What a CombatEventBroadcast describes.

ComparisonOperator: Comparison operators for numeric condition evaluation.

ConditionSubject: Determines which character a condition evaluates against.

ConsumableType: Specifies the types of consumable items available in the game, used for categorization and logic.

ContainerFailureReason: Why a container take was refused.

CorpseLootFailureReason: Why a corpse loot request was refused.

CurrencyMovementReason: What a currency movement was for.

CurrencyMovementState: How a currency movement ended.

DisconnectNoticeReason: Why a server is about to close a connection.

DungeonListFailureReason: Why a dungeon finder list request produced nothing.

FactionAllianceLevel: Defines the alliance level between two factions (e.g., Ally, Neutral, Enemy). Used in faction matrices to determine relationships and interactions.

GuildLogEvent: The kind of event a guild log row records.

GuildPermissions: The individual powers a guild rank may hold.

GuildRank: Represents the rank of a character within a guild.

GuildResultType: Result types for guild operations, indicating success or specific failure reasons.

HitCountComparisonType: Specifies the type of comparison to perform when evaluating an ability's hit count.

InventoryType: Specifies the types of inventories available to a character, used for item management and slot operations.

ItemOperationFailureReason: Why the server refused an item operation. Deliberately coarse.

ItemOperationType: Identifies which item operation a ItemOperationFailedBroadcast refers to.

ItemSlot: Represents the possible equipment slots for items on a character. Used to determine where an item can be equipped.

KCCCharacterState: Character movement states for the KCC controller state machine.

KCCMoveFlags

Flags representing movement actions for KCC input replication. Used as a bitmask for jump, crouch, sprint, and other actions.

One-shot vs. continuous flags: Jump is a one-shot impulse that should fire once and be cleared. Crouch and Sprint are continuous (held) flags that persist while the key is held.

This used to add "observer prediction clears one-shot flags to prevent indefinite re-prediction. When adding new one-shot flags, include them in OneShotMask." There is no OneShotMask and there never was one in this project, and the clearing it described belonged to the observer-prediction path — which does not run: state forwarding is off, so FishNet never invokes a replicate body on a non-owner. A one-shot flag is cleared by its producer, KCCPlayer.PopulateInput, on the tick after it is consumed.

MailFailureReason: Why a mail send or attachment claim was refused.

MapMarkerType: What a marker represents. Drives the default icon tier, the draw order between overlapping markers, and which filter rows the world map offers.

MapMarkerVisibility: The rule that decides whether a marker is drawn for the local player.

MerchantTabType: Specifies the types of tabs available in a merchant's UI, representing different categories of goods or services.

ModifierSourceKind: What kind of thing contributed a modifier to an attribute.

NPCCombatStyle: Combat style archetype that broadly describes how the NPC approaches combat. Designers pick a style per personality asset; the AICombatPersonality weights then fine-tune the behaviour.

NPCGroupRole: Roles that NPCs can play within an NPCGroup. The group brain uses these roles to coordinate tactics — e.g., the tank holds aggro, the healer prioritizes healing, and DPS focus the group's target.

NamingSystemType: Enum representing the types of naming systems used in the game.

ObjectSpawnType: Defines the method used to select which object to spawn from the spawner's list.

ObjectiveState: Represents the current state of a capturable objective.

ObservedResourcePushScheduler.Decision: Why Evaluate(uint, in CharacterAttributeResourceState, uint) asked for a send.

OrientationMethod: Determines how the character faces based on input or camera direction.

PackTactic: Describes how an NPCGroup coordinates spatial positioning during combat. The tactic determines how each member's OrbitAngle is assigned relative to the group target.

PartyRank: Defines the rank of a character within a party.

PetMovementOrder: What a pet is currently being told to do about movement, independent of its PetStance.

PetStance: How willing a pet is to start a fight on its own.

PredictedCombatEvents.Kind: What a predicted entry describes.

QuestStatus: Defines the lifecycle status of a quest instance for a character.

SceneStatus: Represents the status of a scene in the FishMMO server lifecycle.

SceneTransferRefusalReason: Why the server declined to move a character to another scene instance.

SceneType: Defines the types of scenes available in the FishMMO server.

WorldSceneQueueReason: Why a client is waiting in the WorldServer's scene-routing queue.

Delegates

ChatCommand: Delegate for chat commands.

TargetSelector.GatherTargets: Delegate for the body of a rewound gather.

Table of Contents