Godot Core System

The framework is divided into specialized systems and utilities. Use the following guide to identify which module fits your needs:

Core Systems

• State Machine System: Game state management and transitions.
• Audio System: Sound and music management.
• Input System: Input control and event handling.
• Logger System: Logging and debugging.
• Resource System: Resource loading and management.
• Scene System: Scene switching and management.
• Tag System: Object tagging and categorization.
• Trigger System: Event-driven triggers and conditions.
• Config System: Configuration management.
• Save System: Game save management.

Utilities

• Frame Splitter: Performance optimization tool for distributing tasks.
• Async IO Manager: Non-blocking file I/O.
• Threading System: Simplified multi-threading management.
• Random Picker: Weighted random selection tool.

The Godot Core System is a modular framework for Godot 4.4+ consisting of several specialized systems and utility tools:

Core Systems (via ManagerOfManagers)

• State Machine System: Game logic state management.
• Audio System: Audio management and transitions.
• Input System: Input handling and event management.
• Logger System: Multi-channel logging.
• Resource System: Resource loading and management.
• Scene System: Scene transitions and management.
• Tag System: Object tagging and classification.
• Trigger System: Event-driven triggers and conditions.
• Save System: Game save management.
• Config System: Configuration management.

Utility Tools

• Frame Splitter: Performance optimization by spreading heavy tasks across multiple frames.
• Async IO Manager: Non-blocking file read/write with strategic processing.
• Threading System: Simplified multi-threading management.
• Random Picker: Weighted random selection tool.

The input_demo folder is organized by sub-module, with each module containing a .tscn scene and a .gd script for implementation details:

input_demo/
├── basic/                # Basic functionality demo
│   ├── basic_demo.tscn  # Basic demo scene
│   └── basic_demo.gd    # Basic demo script
├── virtual_axis/         # Virtual axis system demo
│   ├── character.tscn   # Character scene
│   └── movement_demo.gd # Movement demo script
├── input_state/         # Input state system demo
│   ├── combo_demo.tscn  # Combo demo scene
│   └── combo_demo.gd    # Combo demo script
├── input_buffer/        # Input buffer system demo
│   ├── buffer_demo.tscn # Buffer demo scene
│   └── buffer_demo.gd    # Buffer demo script
├── input_recorder/      # Input recorder demo
│   ├── recorder_demo.tscn # Recorder demo scene
│   └── recorder_demo.gd   # Recorder demo script
└── event_processor/     # Event processor demo
    ├── processor_demo.tscn # Processor demo scene
    └── processor_demo.gd   # Processor demo script

The FrameSplitter is a performance optimization utility designed to prevent game stuttering (lag) caused by heavy computations. It works by spreading time-consuming tasks across multiple frames instead of executing them all at once in a single frame.

Key Features:

• Automatic Frame Splitting: Distributes large tasks over multiple frames.
• Dynamic Adjustment: Automatically adjusts the number of items processed per frame based on actual execution time.
• Progress Feedback: Emits signals to facilitate UI progress bars.
• Multiple Processing Modes: Supports arrays, ranges, iterators, and custom batch processing.

Common Use Cases:

• Resource Loading: Loading large batches of resources without freezing the game.
• Map Generation: Generating large maps tile-by-tile.
• Batch Data Processing: Handling large datasets.
• AI Updates: Updating AI behaviors for many entities in chunks.

The InputState class is the primary manager for tracking input action states. It maintains an ActionState data structure for every registered action, allowing you to track not just whether a button is pressed, but also the timing and intensity of the input.

Each action is represented by an ActionState containing:

• pressed: Boolean indicating if the action is currently active.
• just_pressed: Boolean indicating if the action was triggered in the current frame.
• just_released: Boolean indicating if the action was released in the current frame.
• strength: A float (0.0 to 1.0) representing input intensity (e.g., trigger pressure).
• press_time: The timestamp of the current press.
• last_press_time: The timestamp of the previous press.
• last_release_time: The timestamp of the last release.

class ActionState:
    var pressed: bool        # Current pressed state
    var just_pressed: bool   # Just pressed this frame
    var just_released: bool  # Just released this frame
    var strength: float      # Input strength (0.0 - 1.0)
    var press_time: float    # Current press timestamp
    var last_press_time: float    # Last press timestamp
    var last_release_time: float  # Last release timestamp

To handle different input types uniformly, you can transform raw InputEvent objects into a standardized Dictionary format. This process, known as normalization, allows the rest of your system to work with a consistent data structure.

Normalization Example:

func _normalize_event(event: InputEvent) -> Dictionary:
    return {
        "type": _get_event_type(event),
        "action": _get_event_action(event),
        "strength": event.get_action_strength(),
        "timestamp": Time.get_ticks_msec()
    }

Event Merging: You can also implement logic to merge duplicate or conflicting events (e.g., combining two simultaneous button presses into one state) using a _merge_events function.

func _merge_events(event1: Dictionary, event2: Dictionary) -> Dictionary:
    # Merge events based on rules
    return {
        "type": event1.type,
        "action": event1.action,
        "strength": max(event1.strength, event2.strength),
        "timestamp": event1.timestamp
    }