isadorasophia/murder

Features

• 2D Game Frameworks - Provides a component-based 2D game framework featuring an integrated entity component system and state management.
• Game Development Engines - Implements a full 2D game engine featuring scene management and an entity-component-system architecture.
• Game Loop Updates - Implements the core game loop executing start, fixed-interval, and per-frame update cycles across all systems.
• Game Editors - Provides a visual development environment for designing 2D game worlds and configuring properties in real-time.
• Complex Data Serialization - Persists complex game object states to disk using immutable structures and custom restoration logic.
• Entity Component Assignment - Provides a system for assigning and retrieving data components like transforms and state machines for entities.
• Entity CRUD Management - Handles the creation and world-mapping of entities to be processed by reactive systems.
• Game State Persistence - Implements the saving and restoring of complex game world and entity states using immutable data structures.
• String Localization - Provides a capability to store and retrieve translated strings and metadata to support multiple languages.
• Asset Lifecycle Management - Handles the loading and disposal of game assets during active gameplay to manage the resource lifecycle.
• Dialogue Text Storage - Implements a system for storing and mapping localized text resources to specific dialogue identifiers for in-game conversations.
• Entity Component Systems - Uses an entity component system to decouple game logic from state and optimize performance.
• Component Filtering - Retrieves collections of entities based on specific component types or context filters.
• Entity Definitions - Defines the base properties and state of game abstractions using read-only structures as components.
• Entity Movement Tracking - Implements a capability to track positional data and movement states for object translation across the game world.
• Entity Rendering Systems - Executes drawing logic by leveraging render implementations to visualize game entities.
• Collision Detection - Provides a system for assigning collision areas to entities to detect physical overlaps and intersections.
• Prefab Instantiation - Allows creating new entities from predefined templates, including all associated children and component sets.
• World File Loading - Retrieves saved world assets via unique identifiers to instantiate the game environment.
• Spatial Referencing Systems - Maintains object locations and orientations within a coordinate system for spatial referencing.
• Texture Assignments - Links specific texture assets to objects via attributes to automate the rendering process.
• Asset Pipelines - Implements a comprehensive pipeline for serializing, loading, and editing game textures, fonts, and configuration files.
• Asset Management Systems - Provides a comprehensive pipeline for serializing, loading, and linking game resources like sprites and fonts.
• World Asset Instantiation - Creates entity instances in a specified game world using unique asset identifiers.
• Static Sprite Renderers - Assigns visual sprites to entities to enable their rendering on screen.
• Tile Map Renderers - Ships a specialized renderer for drawing individual tiles and auto-tiling patterns for game maps.
• 2D Rendering Engines - Implements a hardware-accelerated 2D rendering engine supporting pixel art, sprite slicing, and parallax effects.
• Pixel Art Rendering Pipelines - Ships a specialized 2D rendering pipeline supporting pixel art, sprite slicing, and parallax effects.
• Sprite Asset Management - Manages image frames, animations, and nine-slice data for 2D graphical rendering.
• System Execution Control - Provides mechanisms to activate, deactivate, pause, and resume logic systems within the engine's main loop.
• Hierarchical A* Implementations - A system that computes navigation paths between points using a Hierarchical A* algorithm.
• Entity Behavior Modules - Implements modular behavioral state management to coordinate entity logic and transitions.
• ECS Component Identifiers - Provides a centralized set of identifiers for fetching specific components within the ECS architecture.
• Fixed-Rate System Scheduling - Runs critical game logic on a fixed-interval time step to ensure deterministic behavior regardless of frame rate.
• ECS Component State Management - Enables the modification of data within ECS components to dynamically change entity behavior during gameplay.
• Entity State Machines - Provides a state machine system to track and transition the behavioral state of entities.
• State Persistence - Provides a system for marking specific components to be serialized, ensuring game state is correctly restored.
• Frame-Based Updates - Executes specific logic every frame to update the game state based on the current context.
• Friction and Restitution Systems - Calculates movement resistance based on the physical properties of the environment's surfaces.
• Entity Hierarchy Management - Establishes parent-child relationships between game objects to create structural nesting.
• Speaker Asset Definitions - Defines reusable assets used to represent characters or speakers within the asset system.
• Serialization Exclusions - Allows marking specific components or attributes to be ignored during the game save process.
• Entity Disabling - Temporarily removes entities from the game world so they no longer interact with other objects.
• Animation-Triggered Deletion - Deletes entities from the game world automatically once their current animation sequence has finished.
• Instance Linking - Provides a mechanism to identify fields as references to other entity instances to establish relationships.
• Persistence Exclusion Markers - Prevents specific entities from being saved to storage based on a marker attribute.
• Save File Exclusion Markers - Marks specific game objects to be ignored during the persistence process.
• Type Filtering - Tags entities with specific type attributes to enable targeted queries of entity groups.
• Entity Tracking - Records the removal of entities from the game world to synchronize the persisted state.
• Entity Grouping - Maintains lists of entity identifiers within components to associate groups of game objects.
• Custom Parallel Task Execution - Distributes processing tasks across multiple threads to improve engine execution speed.
• Cross-Platform Deployment Targets - Provides the capability to target game builds for Windows, MacOS, and Linux platforms.
• Auto-Advance Dialogue Triggers - Triggers the progression to the next piece of dialogue automatically without requiring user input.
• Character Definitions - Stores character metadata, portraits, and associated components for use in the game world.
• Character Visual State Variations - Assigns specific portraits and components to characters based on unique situational identifiers.
• Dialogue Choice Systems - Stores a set of available choices for an entity to present to the user during dialogue.
• Persistence Filters - Allows limiting the data saved for an entity to a single component to reduce persistence overhead.
• Entity Folders - Groups and filters entities into named folders to manage specific subsets of the game world.
• Interaction Definitions - Triggers specific logic when one entity interacts with another by passing world state.
• Behavioral Exchanges - A system that triggers immediate logic when one entity interacts with another to define a behavioral exchange.
• Entity Prototype Replacement - Enables swapping an active entity with a prefab instance while preserving its spatial properties and identifiers.
• Entity Scale Management - Defines the size dimensions of game objects to control scaling during the rendering process.
• Entity Tracking and Following - Stores references to other entities to identify the target of specific game interactions.
• Game Entity Identifier Mappings - Translates global unique identifiers for entity instances into internal IDs for stable referencing.
• Narrative Orchestration Systems - Provides tools for orchestrating scripted narrative sequences with timed animations and localized text.
• Relationship Lookups - Implements efficient retrieval of related data components using a lookup table and identifiers.
• Component Dependencies - Ensures required components are present when adding new components to entities or worlds.
• Standalone Executable Builds - Provides the capability to decouple the game from the editor to create a standalone executable.
• 2D Spatial Audio - Tracks the physical location of sound events to enable 2D spatial audio processing.
• Sprite Visual Effects - Provides sprite color tinting to visually indicate entity states through color overlays.
• Animation and Audio Completion Events - Tracks animation completion to trigger follow-up game logic and state changes.
• Custom Renderable Interfaces - Provides interfaces to specify custom drawing logic for controlling how entities are rendered on screen.
• Visual Effect Shaders - Provides control over global screen visual effects by adjusting shader properties such as dither amounts.
• Nine-Slice Scaling - Implements three-slice scaling to preserve the integrity of corners and edges when resizing assets.
• Entity-Based Message Handlers - Implements a system that reacts to messages added to entities by triggering predefined response functions.
• Pathfinding Area Markers - Tags specific map locations as carve components to guide pathfinding calculations.
• Centralized Configuration Systems - Implements a system for managing global game settings and resource paths in a centralized asset.
• Component Preservation - Enables marking specific components to be preserved when an entity is replaced by a prefab instance.
• Scene Entity Lifecycle Managers - Implements a manager to handle the activation, deactivation, and destruction of entities within the game scene.
• Event Messaging Systems - Provides a framework for decoupling components through event distribution to notify systems of entity state changes.
• Conditional State Halting - Allows state machines to halt progress until a specific condition, such as a message or timer, is satisfied.
• Animation Event Messaging - Associates text messages with specific animation frames to trigger timed events during playback.
• Animation Playback Controls - Provides a capability to accelerate or decelerate the playback rate of animation sequences.
• Camera Target Tracking - Specifies a coordinate for the camera to follow so the viewport dynamically centers on moving objects.
• Transparency Controls - Sets the alpha transparency value of entities to control their visual opacity during rendering.
• Game Event Listeners - Allows entities to register for and react to specific in-game event signals dispatched by the engine.
• Parallax Engines - Adjusts entity movement speeds relative to the camera to simulate spatial depth.
• UI Layer Rendering - Provides a system for rendering user interface elements on screen with configurable layering.
• Relative Transforms - Notifies components when a parent entity's transform changes to maintain relative alignment.
• Event Listener Managers - Includes utilities for managing collections of event listeners within components to trigger game logic.
• Pacing Delays - Introduces timed delays between state machine transitions to precisely control the pacing of entity logic.
• Game Engine Development - Pixel-art focused ECS game engine.

Star 历史