Bit Quirky Core

Assembly: BitQuirky.Core

Low-level runtime

These public contracts support advanced execution and data access. Most projects should integrate through the GameObject or entity entry points instead.

• ActionEventListener: This listener implementation is kept for backward compatibility. For new code, use direct event subscription with the EventRaised delegate: Example: // Old…
• ActionEventListener<T>: This listener implementation is kept for backward compatibility. For new code, use direct event subscription with the EventRaised delegate: Example: // Old…
• Activator: Activate or deactivate a component - subclasses will define the trigger.
• AnimatorEvent: Event channel asset carrying a reference to a scene Animator to its listeners. Created from Bit Quirky/Event/Game/Animator.
• AnimatorSetter: Publishes the Animator on this game object into an AnimatorVariable during Awake, ahead of default execution order.
• AnimatorVariable: Shared reference to a scene Animator, published by AnimatorSetter. Created from Bit Quirky/Variable/Game/Animator.
• AsyncExtensions: Helpers to mirror common UniTask patterns using Unity’s native Awaitable/Task APIs.
• AudioSourceEvent: Event channel asset carrying a reference to a scene AudioSource to its listeners. Created from Bit Quirky/Event/Game/AudioSource.
• AudioSourceSetter: Publishes the AudioSource on this game object into an AudioSourceVariable during Awake.
• AudioSourceVariable: Shared reference to a scene AudioSource, published by AudioSourceSetter. Created from Bit Quirky/Variable/Game/AudioSource.
• BaseConfig: Optional per-game configuration hook. A project needs a config asset only when it overrides a convention; at most one instance may exist in a project….
• BindableValue<T>: Serialized field wrapper that a designer can either fill in with a literal value or bind, in the inspector, to a shared Variable asset or to another bindable…
• BindingMode: Kind of source a bound value follows.
• BoolActivator: Activate or deactivate a component based on the setting in a bool variable.
• BoolEvent: Event channel asset carrying a Boolean to its listeners. Created from Bit Quirky/Event/Bool.
• BoolEventListener: Component that listens to a bool event channel and, for each raise, invokes the response with the value and then either the true or the false branch, so a…
• BoolUnityEvent: Serializable Unity event carrying a Boolean, so the response can be wired in the inspector.
• BoolVariable: Shared Boolean flag asset, created from Bit Quirky/Variable/Bool.
• BoxGroupAttribute: Draws the decorated members inside a titled box in the inspector. Members sharing a title are grouped together. Drawn by the bundled Bit Quirky editor, so…
• BuildType: Kind of build a scene list is being requested for.
• ButtonAttribute: Draws the decorated method as a clickable button in the inspector, so designers can invoke it on the selected asset or component. Drawn by the bundled Bit…
• CameraEvent: Event channel asset carrying a reference to a scene Camera to its listeners. Created from Bit Quirky/Event/Game/Camera.
• CameraEventListener: Component that listens to a camera event channel: each raise invokes the response with the camera and then either the present or the absent branch, so a scene…
• CameraSetter: Just sets the given camera to this object in OnEnable.
• CameraUnityEvent: Serializable Unity event carrying a Camera, so the response can be wired in the inspector.
• CameraVariable: Shared reference to a scene Camera, normally published by an AudioSource-style setter on the camera object. Created from Bit Quirky/Variable/Game/Camera.
• CollectionEventActionHandler<TEvent, TElement, TAction>: Extends event handler to refresh collections of objects that are picked at random when an event occurs.
• ComponentSetter<TVariable, TComponent>: Publishes a component from this game object into a shared variable asset during Awake, so that other scenes and logic can reach it without a scene reference….
• ConfigLoader: Bootstrap asset that tells the game which data object index and which optional per-game config to use. A game assigns it once at startup, through Initialize or,…
• ContentHash: Deterministic content hashing for text sources of truth (Mermaid, JSON, etc.). Responsibilities: - Produce a stable hex digest of UTF-8 text for stale-cache…
• DataObject: Base class for the scriptable-object assets that carry game data: variables, event channels, game logic, configuration, and indexes. A data object survives…
• DataObjectCollection<TIndex>: Base class for data objects that gather other assets into a single browsable collection asset, with an inspector button that repopulates the collection from the…
• DataObjectDictionary: Serializable map from TypeName.AssetName keys to the indexed assets.
• DataObjectIndex: Project-wide directory of every DataObject asset, keyed by type and name, so game code and saved data can resolve an asset by name instead of holding a direct…
• DefaultedDataObject<T>: Defines a data object that can be used basically as a singleton via its default instance method. It expects there to be a single instance of the subclass, with…
• DefaultedGameLogic<T>: Defines a game logic object that can be used basically as a singleton via its default instance method. It expects there to be a single instance of the subclass,…
• DelayedEventRaiser: Invokes its inspector-wired response a configurable number of seconds after the scene starts, for giving other objects time to initialize.
• DoubleEvent: Event channel asset carrying a double-precision value to its listeners. Created from Bit Quirky/Event/Double.
• DoubleEventListener: Component that listens to a a double-precision value event channel and invokes its inspector-wired response with the value of each raise.
• DoubleUnityEvent: Serializable Unity event carrying a double-precision value, so the response can be wired in the inspector.
• DoubleVariable: Shared double-precision value asset, created from Bit Quirky/Variable/Double.
• DynamicEvent: Event channel asset carrying an ExpandoObject, for payloads whose shape is decided at runtime to its listeners. Created from Bit Quirky/Event/Dynamic.
• DynamicEventListener: Component that listens to a an ExpandoObject event channel and invokes its inspector-wired response with the value of each raise.
• DynamicRangeAttribute: Marks a numeric field as a range slider whose maximum is read from another field on the same object, named by maxValueFieldName, so the ceiling can change at…
• DynamicUnityEvent: Serializable Unity event carrying an ExpandoObject, so the response can be wired in the inspector.
• DynamicVariable: Shared value asset carrying an ExpandoObject, for loosely structured data whose fields are decided at runtime. Created from Bit Quirky/Variable/Dynamic.
• Ease: Defines the provider-neutral Core easing catalog.
• EventActionHandler<TEvent, TElement, TAction>: Base game logic asset that attaches one action to each event channel in a set: on GameStart it creates and subscribes an action per event, and on GameDestroy it…
• FloatEvent: Event channel asset carrying a single-precision value to its listeners. Created from Bit Quirky/Event/Float.
• FloatEventListener: Component that listens to a a single-precision value event channel and invokes its inspector-wired response with the value of each raise.
• FloatUnityEvent: Serializable Unity event carrying a single-precision value, so the response can be wired in the inspector.
• FloatVariable: Shared single-precision value asset, created from Bit Quirky/Variable/Float.
• FoldoutGroupAttribute: Draws the decorated fields inside a collapsible section in the inspector. Fields sharing a title share one foldout. Drawn by the bundled Bit Quirky editor.
• GameEvent: Base event with no parameters.
• GameEventBase: Base class for all game events
• GameEventListener: Listener for simple GameEvents that don’t carry a value
• GameEventRaiser: Raises one event channel when the scene starts, so scene setup can be announced without a script.
• GameEvents: Name-indexed catalog of every parameterless and typed game-event asset. Responsibilities: - Rebuilds a shared lookup over the complete GameEventBase family….
• GameLogic: Subclassing this class lets us put general game logic outside the scene
• GameLogicAttribute: Prioritizes certain game logic objects above/below others. Default priority is zero.
• GameLogicList: Maintains a list of all the game logic objects. You probably only want one list of these - it’s used by the game logic runner to iterate over all the current…
• GameLogicRunner: A single instance of this class is responsible for running all the lifecycle methods on all game logic objects.
• GameMaster<TState>: Abstract ScriptableObject authority for a game’s top-level state and clock control. Responsibilities: - Owns one strongly typed game state, pause state, and…
• GameObjectEvent: See https://github.com/roboryantron/Unite2017
• GameObjectEventListener: Listens to a GameObjectEvent and forwards the raised GameObject to an inspector-wired response.
• GameObjectSetter: Just sets the given gameobject to this object in OnEnable
• GameObjectUnityEvent: Inspector-wirable response carrying the raised GameObject.
• GameObjectVariable: Shared reference to a scene GameObject, letting assets and other scenes reach an object without a direct scene reference. Created from Bit…
• GameSaves: Persistent save asset for a player’s game, holding the data that must survive scene changes. It currently stores the chosen character prefab.
• GenericEvent<T>: Generic event that carries a value of type T.
• GenericEventListener<T>: Base listener class for events that carry a value of type T
• IBindableSource<T>: Contract for an object that can serve as the source of a BindableValue, so both Variable<T> and BindableValue<T> can be bound to.
• IGameEventListener: Base interface for all event listeners
• IGenericGameEventListener<T>: Interface for event listeners that handle events with a value
• ILogging: Common logging surface of Bit Quirky components and data assets: messages are attributed to the object, and ordinary and trace messages are gated by the…
• INamedObject: Implemented by objects that expose a stable display name for logs, indexes, and inspector listings.
• INonGenericGameEventListener: Interface for event listeners that handle events without a value
• ITween: Legacy tween abstraction retained for source compatibility. Responsibilities: - Preserve the existing fluent ease, completion, cancellation, and awaitable…
• ITweenOperation: Represents one owner-scoped tween operation. Responsibilities: - Expose immutable ownership and current terminal state. - Publish one stored completion or…
• ITweenProvider: Creates explicitly owned provider-neutral tween operations. Responsibilities: - Create float operations from complete immutable requests. - Cancel only…
• InstanceMethod: One data object paired with one lifecycle method discovered on it by reflection. The runner caches these pairs during Awake so that each frame it can invoke the…
• IntEvent: Event channel asset carrying an Int32 to its listeners. Created from Bit Quirky/Event/Int.
• IntEventListener: Component that listens to a an Int32 event channel and invokes its inspector-wired response for each raise whose value matches the configured one, when the…
• IntSetter: Applies explicit integer changes to a bindable value and invokes the matching event. Responsibilities: - Publish values supplied through code, UnityEvents, or…
• IntUnityEvent: Serializable Unity event carrying an Int32, so the response can be wired in the inspector.
• IntVariable: Shared Int32 value asset, created from Bit Quirky/Variable/Int.
• LifecycleEventRaiser: Useful for raising various events at points in the Unity lifecycle. Create an instance of this class in the title scene to reset all data objects.
• LoggerConfig: Per-class logging settings: which of thread id, game time, class name, and object name are prepended to each message written through UnityObjectLoggerExt.
• LoggingBehavior: Base class for Bit Quirky components. It adds inspector-toggled logging that tags every message with the game object name, caches that name for use off the…
• LongEvent: Event channel asset carrying a 64-bit signed integer to its listeners. Created from Bit Quirky/Event/Long.
• LongEventListener: Component that listens to a a 64-bit signed integer event channel and invokes its inspector-wired response with the value of each raise.
• LongUnityEvent: Serializable Unity event carrying a 64-bit signed integer, so the response can be wired in the inspector.
• LongVariable: Shared 64-bit signed integer value asset, created from Bit Quirky/Variable/Long.
• MinMaxFloat: Serializable inclusive range of two floats that designers edit in the inspector, typically to pick a random value per use. Nothing enforces Min being below Max.
• NativeTweenProvider: Executes provider-neutral tween requests with Unity frame timing. Responsibilities: - Own only the operations created by this provider instance. - Create native…
• NonGenericGameEventListenerBase: Base class for non-generic event listeners
• ObjectIndex<TIndex, TTarget>: Create collections of Unity Objects that can be referenced by name.
• OnValueChangedAttribute: Calls a method on the same object right after the decorated member is edited in the inspector and the change has been applied, so the object can react while…
• PlayerPrefsUtils: Serialize and de-serialize PlayerPrefs data and save it.
• PropertyOrderAttribute: Sets where the decorated member appears in the inspector; members are drawn in ascending order and undecorated members behave as order zero. Drawn by the…
• ReadOnlyAttribute: Draws the decorated member in the inspector but disables editing, for values the game owns at runtime. Drawn by the bundled Bit Quirky editor.
• ReflectionUtils: Static methods to assist with reflection.
• RequiredAttribute: Marks a serialized field the asset or component cannot work without, so the inspector can flag it while it is unassigned. Drawn by the bundled Bit Quirky…
• ScriptableObjectDictionary: Serializable name-to-asset map shown in the inspector, keyed by asset name.
• ShowIfAttribute: Hides the decorated member in the inspector unless a boolean member of the same object is true, keeping irrelevant options out of the way. Drawn by the bundled…
• ShowInInspectorAttribute: Draws a property in the inspector even though Unity does not serialize it, for computed or runtime-only values. Drawn by the bundled Bit Quirky editor.
• StringEvent: Event channel asset carrying a string to its listeners. Created from Bit Quirky/Event/String.
• StringEventListener: Component that listens to a a string event channel and invokes its inspector-wired response for each raise whose value matches the configured one, when the…
• StringListEvent: Used when a StringList variable changes.
• StringListVariable: Provides access to the StringList independent of scenes.
• StringUnityEvent: Serializable Unity event carrying a string, so the response can be wired in the inspector.
• StringVariable: Shared text value asset, created from Bit Quirky/Variable/String.
• TabGroupAttribute: Places the decorated members on a named tab of a tab strip in the inspector, so a crowded asset stays readable. Drawn by the bundled Bit Quirky editor.
• TextSourceBake: Text-driven bake with stale-cache invalidation. Same principle as Behavior Trees and State Machines authoring: the text file (Mermaid, JSON, …) is…
• TextSourceBakeResult<T>: Outcome of EnsureFresh. Responsibilities: - Carry the baked value, the source content hash, and whether a rebuild ran. Does NOT: - Own disposal of T (caller…
• TweenDriver: Entry point for creating tweens with DOTween when available or a native fallback otherwise. Responsibilities: - Preserve the legacy static creation and…
• TweenOperationState: Identifies the current or terminal state of one tween operation. Responsibilities: - Distinguish active, naturally completed, and cancelled operations. Does…
• TweenProviderBehaviour: Provides a provider-neutral serialized composition base for Unity scenes. Responsibilities: - Make an explicit tween provider assignable through a Unity object…
• TweenRequest: Contains the complete immutable configuration for one float tween. Responsibilities: - Validate finite endpoints and non-negative timing before playback starts….
• TweenTermination: Describes the immutable terminal result of one tween operation. Responsibilities: - Preserve whether an operation completed or was cancelled. - Carry an…
• TweenTimeMode: Selects the Unity clock used by a tween request. Responsibilities: - Distinguish game-time playback from time-scale-independent playback. Does NOT: - Select a…
• UIntVariable: Shared 32-bit unsigned integer value asset, created from Bit Quirky/Variable/UInt.
• ULongEvent: Event channel asset carrying a 64-bit unsigned integer to its listeners. Created from Bit Quirky/Event/ULong.
• UniqueAsset: Editor-side convention: a project declares an asset-backed singleton simply by holding exactly one asset of its type, with no registration or hard-coded path….
• UnityObjectLoggerExt: Utility class for UnityEngine.Object subclasses (MonoBehaviour, Component, Editor, etc.) that want to use the extended logging capabilities below: Option to log…
• UnitySerializedDictionary<TKey, TValue>: See https://odininspector.com/tutorials/serialize-anything/serializing-dictionaries
• Variable<T>: Scriptable-object asset holding a single value of T that any number of scenes, components, and game logic objects can share by referencing the same asset….
• VariableInitialValues: Used by menu class VariableInitializer to reset all vars to their defaults.
• Vector2Event: Used when a Vector2 variable changes.
• Vector2IntEvent: Used when a Vector2Int variable changes.
• Vector2IntVariable: Provides access to the Vector2Int independent of scenes.
• Vector2Variable: Provides access to the Vector2 independent of scenes.
• Vector3Event: Event channel asset carrying a Vector3 to its listeners. Created from Bit Quirky/Event/Vector3.
• Vector3EventListener: Component that listens to a a Vector3 event channel and invokes its inspector-wired response with the value of each raise.
• Vector3UnityEvent: Serializable Unity event carrying a Vector3, so the response can be wired in the inspector.
• Vector3Variable: Shared Vector3 value asset, created from Bit Quirky/Variable/Vector3.

Namespaces

• BitQuirky.Core.Activator: 2 public types
• BitQuirky.Core.Async: 1 public type
• BitQuirky.Core.Attributes: 10 public types
• BitQuirky.Core.Binding: 4 public types
• BitQuirky.Core.Config: 3 public types
• BitQuirky.Core.Data: 9 public types
• BitQuirky.Core.Event: 44 public types
• BitQuirky.Core.Event.Game: 8 public types
• BitQuirky.Core.GameLogic: 7 public types
• BitQuirky.Core.Lifecycle: 1 public type
• BitQuirky.Core.Logging: 4 public types
• BitQuirky.Core.PlayerPrefs: 1 public type
• BitQuirky.Core.Reflection: 1 public type
• BitQuirky.Core.TextSource: 3 public types
• BitQuirky.Core.Tween: 11 public types
• BitQuirky.Core.Variable: 17 public types
• BitQuirky.Core.Variable.Dictionaries: 1 public type
• BitQuirky.Core.Variable.Game: 9 public types

Source fingerprint: sha256:ad0983d00d773d882bc61865e18d8c5559e009d181e5891575cd7f262515b23e