AlmasB/FXGL

FXGL is a Java-based 2D and 3D game engine that provides a comprehensive suite of systems for building interactive applications, including entity management, physics, AI, and input handling. It supports complex gameplay features such as dialogue trees, inventory systems, minigames, and multiplayer networking, alongside tools for asset loading, serialization, and localization. The engine also includes dedicated development utilities like a dialogue editor and a game editor, along with extensive sample projects demonstrating various mechanics and rendering capabilities.

64 changes.

This period focused on a major architectural overhaul of the FXGL engine, introducing the Java Platform Module System, a new GameApplication entry point, and a comprehensive Kotlin DSL for simplified game development. The team significantly expanded the core library with new utilities for math, serialization, concurrency, and state machines, while simultaneously enriching the ecosystem with extensive sample games, a dedicated dialogue editor, and robust test coverage.

64 changes.

This period focused on consolidating disparate modules like audio, input, and localization into fxgl-core while introducing comprehensive 3D rendering capabilities and first-class game controller support. The library also expanded its ecosystem with a new standalone editor tool, extensive sample applications, and robust unit test coverage for core services.

21 changes.

This period focused on expanding the FXGL engine with comprehensive AI capabilities, including GOAP planning, speech recognition, and computer vision services via local WebSocket integration. It also introduced robust physics joint samples, a particle system, and core gameplay frameworks such as inventory, cutscenes, and mini-games to support complex game development.

A new Uno card game sample has been added to the FXGL sandbox. This includes the core game logic and UI components, such as Card, Deck, Hand, and UnoFactory classes, along with a Vignette effect for visual styling. The sample demonstrates basic gameplay mechanics including card drawing, playing cards, and a simple AI opponent.

fxgl-samples/src/main/java/sandbox/uno · high confidence

A new interactive sample game has been added to the advanced platformer directory, featuring a robot character with state-based animations and physics. The sample includes a RobotComponent that manages movement states (stand, walk, run, jump, fall, crouch, roll, death) and a RobotFactory for spawning the robot and platform entities. Users can control the robot using keyboard inputs: W to jump, F to roll, X to die, A/D to walk, Q/E to run, and Z/C to crouch, with the current state displayed in the UI.

fxgl-samples/src/main/java/advanced/platformer · high confidence

A new 3D Snake game example has been added to the FXGL samples under the sandbox.test3d.snake package. This sample demonstrates 3D gameplay capabilities by implementing a classic Snake game where the player controls a snake moving in three-dimensional space, collecting food items to grow, with 3D rendering and physics integration.

fxgl-samples/src/main/java/sandbox/test3d/snake · high confidence

New sample applications have been added to the advanced scene3d package to demonstrate 3D capabilities. Basic3DSample shows how to create a simple 3D cube and use it for the player entity view. Camera3DSample demonstrates how to use a 3D camera with keyboard controls. Camera3DFollowSample shows how to make a 3D camera follow a given entity.

fxgl-samples/src/main/java/advanced/scene3d · high confidence

New behavior tree configuration files have been added to the AI assets directory, providing declarative AI logic for various sample scenarios. These include patrol and combat trees for the 's08ai' and 'towerfall' samples, a danger-response tree for the 'sandbox.robots' sample, and a test tree for general validation. Users can now reference these specific tree structures to understand or customize AI behaviors in these game samples.

fxgl-samples/src/main/resources/assets/ai · high confidence

A new sandbox sample demonstrating a beat 'em up game has been added to the FXGL library. This sample includes a player entity with WASD controls, attack animations, and health bars, alongside enemy zombies with attack animations and collision-based damage logic. The implementation showcases entity factories, physics collisions, and animated textures within the FXGL framework.

fxgl-samples/src/main/java/sandbox/beatemup · high confidence

A new EntityInspector UI component has been introduced in the development editor, providing a scrollable panel to inspect and modify game entities. It allows users to add views by selecting image files, attach built-in components (such as Health, Projectile, and Collidable) via a selection dialog, and attempt to load custom components from the classpath. The inspector dynamically displays properties of existing components and listens for changes to keep the view synchronized.

fxgl/src/main/kotlin/com/almasb/fxgl/dev/editor · high confidence

A new utility application, ImageMergerApp, has been added to the dev.tools package to help users generate sprite sheets from individual image files. This tool allows users to select multiple image files and configure the layout (frames per row), then merges them into a single output PNG file. Supporting code in ImageUtils handles the conversion and saving of the resulting image.

fxgl-samples/src/main/kotlin/dev/tools · high confidence

The fxgl-samples directory now includes a set of new level definition files (mario.json, mario.tmx, mario0.json, mario1.json, mario1.tmx, mario2.json, mario2.tmx, mario3.json, and mario3.tmx) that define tile maps, platforms, collectible coins, and portals for a basic platformer sample.

fxgl-samples/src/main/resources/assets/json · high confidence

A new sample application (MiniGameSample) has been added to the sandbox/minigames directory. It demonstrates how to integrate and use the MiniGameService by providing a UI with buttons to launch five different mini-game types: Trigger Sequence, Trigger Mash, Skill Check (Sweet Spot), Circuit Breaker, and a Custom Mini Game. This serves as a practical example for developers on how to incorporate these interactive elements into their FXGL games.

fxgl-samples/src/main/java/sandbox/minigames · high confidence

FXGL now includes two new visual effects for game entities. The SlowTimeEffect allows developers to temporarily reduce the time scale of an entity's updates by a specified ratio for a given duration, reverting to normal speed when the effect ends. The WobbleEffect applies a sinusoidal displacement to a texture, splitting it into chunks that oscillate independently; it supports configurable radius, number of chunks, and orientation (horizontal or vertical) to create a shaking or wobbling animation.

fxgl/src/main/kotlin/com/almasb/fxgl/dsl/effects · high confidence

A new SpeechRecognitionService has been introduced in the fxgl-intelligence module to manage speech recognition capabilities. This service connects to a local WebSocket server and exposes methods to register and unregister input handlers, allowing applications to receive transcribed text along with confidence scores asynchronously.

fxgl-intelligence/src/main/kotlin/com/almasb/fxgl/intelligence/speechrecog · high confidence

The FXGL Intelligence module now includes a WebAPI class that defines constants for local web-based AI services, including text-to-speech, speech recognition, gesture recognition, hand tracking, and face detection. These constants specify the relative resource paths and corresponding local server ports (55550–55570) used to access the extracted web assets, enabling the library to integrate with these intelligence features via local HTTP endpoints.

fxgl-intelligence/src/main/java/com/almasb/fxgl/intelligence · high confidence

The basics package now includes a suite of new sample applications demonstrating core FXGL capabilities, including basic game setup, custom components, input handling, physics and collision detection, sound playback, sprite sheet animations, texture rendering, UI integration, timer actions, and global game variables.

fxgl-samples/src/main/java/basics · high confidence

A new 500x500 orthogonal Tiled map file (csv\_1layer\_horizontalflip\_500x500.tmx) has been added to the benchmarking assets directory. This large, single-layer map serves as a test fixture for verifying Tiled map loading performance and correctness within the FXGL samples.

fxgl-samples/src/main/resources/assets/levels/tmx/benchmarking · high confidence

The samples now include a new chat demo, supported by a dedicated CSS stylesheet (chat.css) that styles the chat text area and input fields with a dark theme. Additionally, a suite of UI test assets has been added to the assets/ui directory, including a test FXML layout, an Open Font License file, and several CSS files (test.css, test\_fxgl\_light.css) that define styles for notification panes, buttons, list views, choice boxes, spinners, and dialogs.

fxgl-samples/src/main/resources/assets/ui · high confidence

The face detection module now includes a Face data class representing detected face coordinates and a FaceDetectionFromImageService that enables detecting faces in images via a local WebSocket server. Users can now register input handlers to receive face detection results and trigger detection by passing JavaFX Image objects to the service.

fxgl-intelligence/src/main/kotlin/com/almasb/fxgl/intelligence/facedetect · high confidence

Users can now connect and use game controllers on Windows 64-bit, Linux 64-bit, and macOS platforms. The new ControllerInputService automatically loads the required native libraries (SDL2 and FXGL-specific bindings) into a local cache, detects connected controllers at startup, and exposes them via an observable list for use in game logic. Note that hot-swapping controllers is not currently supported; controllers must be plugged in before the engine starts.

fxgl-controllerinput/src/main/kotlin · high confidence

A new configuration file (config.kv) has been added to the assets/kv directory, defining default settings for the sample game including enemy name, count, loot ratio, and inventory behavior on death.

fxgl-samples/src/main/resources/assets/kv · high confidence

A new level file (level1.tmx) has been added to the robot sample assets, defining a 18x10 orthogonal tilemap. This level includes a tile layer using the 'tiles\_spritesheet' and an object layer that places five platform objects at specific coordinates, establishing the basic terrain and interactive elements for the first stage of the sample.

fxgl-samples/src/main/resources/assets/levels/robot · high confidence

The FXGL game library now includes localized string resources for five languages (English, French, German, Hungarian, and Russian) in the languages directory. These files provide translations for core UI elements, including dialog prompts, menu options (such as save/load, video/audio settings, and controls), multiplayer connection text, profile management, and achievement notifications, enabling users to interact with the game interface in their preferred language.

fxgl/src/main/resources/fxglassets/languages · high confidence

A new LocalWebSocketServer class has been introduced in the net.ws package, providing a simple WebSocket server implementation that listens on localhost. This component allows applications to establish local WebSocket connections, handle incoming messages via registered handlers, and send data through a background thread, facilitating local network communication within the FXGL game library.

fxgl-intelligence/src/main/java/com/almasb/fxgl/net · high confidence

New Wavefront OBJ model files and their associated material definitions have been added to the assets directory to support experimental features. This includes a simple cube model, a detailed stack of gifts with diffuse and bump mapping textures, and a grenade model, providing sample geometry for testing rendering capabilities.

fxgl-samples/src/main/resources/assets/models · high confidence

The project now includes a dedicated directory for third-party licenses, containing the full text of the BSD 2-clause license for jbox2d and the Apache 2.0 license for libGDX. This allows users and contributors to easily inspect the origins and licensing terms of code derived from these external codebases.

_.LICENSE\_3RD\PARTY · high confidence

New HTML and JavaScript resources have been added to the fxgl-intelligence module to provide browser-based interfaces for face detection, hand tracking, gesture recognition, speech-to-text, and text-to-speech services. These frontends utilize the MediaPipe tasks-vision library (v0.10.0) for computer vision tasks and the Web Speech API for audio processing, communicating with backend services via WebSocket RPC.

fxgl-intelligence/src/main/resources · high confidence

A new BuildProperties class is now available in the generated package, exposing the project version and build timestamp as static constants. These values are populated from the Maven pom.xml during the build process by the templating-maven-plugin, allowing the application to access its own version and build time information at runtime.

fxgl/src/main/java-templates · high confidence

The dialogue editor now supports undoing actions (such as moving, adding, or removing nodes and edges) via Ctrl+Z, and allows duplicating nodes with Ctrl+D. A new preferences sub-scene lets users toggle snap-to-grid and audio line visibility, and customize node colors, with these settings persisted across sessions. The editor also highlights incomplete dialogue paths with an error icon and includes a node inspector pane for detailed node configuration.

fxgl-tools/src/main/kotlin/com/almasb/fxgl/tools/dialogues · high confidence

The intermediate samples directory now includes a broad set of new examples demonstrating FXGL capabilities. These cover entity management (ActivatorComponent, CollisionFilter, EntityDrawingOrder), UI and theming (CustomCSS, CustomGameMenu, CustomIntro, CustomLoading, CustomStartup, Dialogs, Font), asset handling (Cutscene, DifferentSizeTexture), and input/animation (InputFluent, InputSequence, Interpolator). The AchievementSample has been refactored to use the current API, and the FXMLSample demonstrates integrating FXML UI controllers.

fxgl-samples/src/main/java/intermediate · high confidence

The sandbox area now includes a broader set of demonstration applications, adding samples for bounding box physics and effects (BBoxSample), 3D scene interpolation (CirclesSample), and engine tick profiling (EngineTicksSample). It also introduces samples for complex dialogue systems with custom function handlers (ComplexDialogueSample), Tiled map loading (IsoTiledMapSample), and input modifiers like speed multipliers (InputModifierSample). Additionally, new samples cover game sub-scenes (EntitiesScenesSample), physics-based bouncing bullets (PhysicsBounceSample), and detailed collision handling with hitbox scaling and rotation (PhysicsCollisionSample).

fxgl-samples/src/main/java/sandbox · high confidence

This change introduces a new high-level API for game controller input, allowing users to access standard button states (A, B, X, Y, D-pad, shoulder buttons) as well as analog stick positions and trigger values. The implementation includes a native backend for connecting to and querying hardware controllers, with specific support for Windows 64-bit and Linux platforms, exposing properties for left/right stick coordinates and trigger pressure levels.

fxgl-controllerinput/src/main/java · high confidence

A new TextToSpeechService has been added to the fxgl-intelligence module, enabling applications to convert text into spoken audio. The service operates via a local WebSocket server and exposes a list of available synthesis voices, allowing users to select a specific voice before speaking text.

fxgl-intelligence/src/main/kotlin/com/almasb/fxgl/intelligence/tts · high confidence

Adds a new SlidesApp entry point within the fxgl-tools module, establishing the basic structure for a presentation tool. The application initializes with the title "Slides App" and registers keyboard listeners for the LEFT and RIGHT arrow keys to navigate between slides, though the navigation logic and slide rendering are currently unimplemented stubs.

fxgl-tools/src/main/kotlin/com/almasb/fxgl/tools/slides · high confidence

This change introduces the foundational systems for the FXGL game engine, including a Goal-Oriented Action Planning (GOAP) AI planner and a Sense AI system with hearing capabilities. It also adds the core entity management infrastructure, featuring a GameWorld for entity lifecycle management, an EntityGroup for type-based queries, and an EntityPool for object reuse. Additionally, the update includes essential entity components for handling transforms, bounding boxes, collision detection, and visual views, along with level loading support.

(repo-wide) · high confidence

This change introduces the main user interface for the FXGL game editor, providing a workspace where users can manage game entities. The UI includes a toolbar with controls to play, pause, and stop the game simulation, as well as buttons to add new entities and define entity types. An explorer panel lists existing entities, which users can rename directly in the list, while a side panel displays an inspector for the selected entity's properties.

fxgl-tools/src/main/kotlin/com/almasb/fxgl/tools/editor · high confidence

A new standalone editor tool has been added to the fxgl-tools module, allowing users to launch a dedicated UI environment for game development. The EditorApp initializes a JavaFX stage titled "FXGL Editor" and embeds the FXGL game engine via EditorGameApplication, enabling interaction between the custom UI components and the underlying game logic.

fxgl-tools/src/main/java/com/almasb/fxgl/tools/editor · high confidence

Added a new native C++ module (fxgl\_ShaderLib.cpp) that exposes functions to initialize an OpenGL context, compile and link vertex/fragment shaders, set uniform variables, and render frames to a pixel buffer. This enables the FXGL engine to execute custom 2D shaders, with the underlying GL context created at a fixed 1920x1080 resolution to define the maximum rendering area for GLImageView components.

fxgl-core/src/main/native · high confidence

The serialization subsystem now uses a new Bundle class to store key-value pairs of serializable data and a SerializableType interface that defines write and read methods for objects to serialize their state into a Bundle. This provides a structured way to handle object serialization within the FXGL engine.

fxgl-core/src/main/kotlin/com/almasb/fxgl/core/serialization · high confidence

The fxgl-core module now includes a new logging system, providing developers with configurable log outputs to the console or files, support for multiple severity levels (DEBUG, INFO, WARN, FATAL), and the ability to customize message formatting and date-time patterns.

fxgl-core/src/main/kotlin/com/almasb/fxgl/logging · high confidence

The fxgl-core module now includes a new time package containing the core timer infrastructure. This adds the Timer class for scheduling actions at intervals or after delays, the LocalTimer interface and OfflineTimer implementation for tracking elapsed time (including persistence across application stops), and the TimerAction class to manage individual scheduled tasks with pause, resume, and expiration capabilities.

fxgl-core/src/main/kotlin/com/almasb/fxgl/time · high confidence

A new GameDifficulty enum has been added to the gameplay module, defining four distinct challenge levels: EASY, MEDIUM, HARD, and NIGHTMARE. This allows games to programmatically adjust their behavior and difficulty based on the player's selected setting.

fxgl/src/main/kotlin/com/almasb/fxgl/gameplay · high confidence

A new dark CSS theme (fxgl\_dark.css) has been added to the FXGL asset set, defining visual styles for custom controls such as buttons, list views, choice boxes, and spinners. This change establishes a consistent dark appearance for the user interface, including specific styling for button states (hover, pressed, disabled) and list view scroll bars.

fxgl/src/main/resources/fxglassets/ui/css · high confidence

FXGL now includes a core finite state machine implementation that supports a parent-child state hierarchy. Users can define states with lifecycle hooks (onCreate, onDestroy, onEnteredFrom, onExitingTo) and configure substates to run concurrently with their parent or exclusively. The StateMachine class manages transitions between parent and substates, tracks active states, and provides a utility to check if a state belongs to the current hierarchy.

fxgl-core/src/main/kotlin/com/almasb/fxgl/core/fsm · high confidence

Added ParticleComponent and ParticleSystem classes to the fxgl-core module. ParticleComponent allows attaching particle effects to game entities, managing emission, updates, and recycling of particle objects via a pool. ParticleSystem provides a standalone particle system for use in non-game contexts like menus or UI, allowing emitters to be added and removed with position tracking.

fxgl-core/src/main/kotlin/com/almasb/fxgl/particle · high confidence

A new standalone dialogue editor application has been added to the fxgl-tools module, providing a dedicated interface for creating and managing game dialogues. The editor features a resizable 1600x900 window with manual resizing enabled, snap-to-grid functionality, color-blind mode, and audio line visualization. It includes mouse gesture support for dragging nodes and utilizes persistent storage for user preferences, offering a specialized development environment separate from the main game runtime.

fxgl-tools/src/main/java/com/almasb/fxgl/tools/dialogues · high confidence

The networking module (fxgl-net) has been merged into fxgl-io, introducing a new abstract client-server architecture for TCP and UDP connections. This includes base classes for Client and Server, connection management with message handling, and specific implementations for TCP endpoints. Additionally, a new HttpClientService is provided to allow sending HTTP requests (GET, POST, PUT, DELETE) as background tasks.

fxgl-io/src/main/java/com · high confidence

A new 3D sample application has been added to the sandbox that demonstrates first-person shooter mechanics. Users can navigate the environment using WASD keys and shoot targets with the primary mouse button. The sample utilizes the 3D camera system, enabling an FPS-style view where the cursor is hidden, and includes a scoring system that tracks successful hits on targets, which animate and disappear upon collision.

fxgl-samples/src/main/java/sandbox/test3d/firingrange · high confidence

The 3D sandbox directory now includes a suite of new sample applications that showcase FXGL's 3D features. These samples demonstrate first-person and third-person camera controls, 3D entity animation and rotation, 3D collision handling, and the rendering of custom 3D models (OBJ) and skyboxes. They also illustrate the use of 3D primitives like cuboids and pyramids, Phong materials, and lighting within a 3D scene.

fxgl-samples/src/main/java/sandbox/test3d · high confidence

Developers can now use built-in 3D shapes including Cuboid, Torus, Prism, Cylinder, Pyramid, and Cone, all extending the new CustomShape3D base class which provides vertex access and material helpers. The scene3d package introduces Model3D for managing mesh hierarchies with copy support, a draft OBJ loader interface (Model3DLoader), and a Prefabs API that includes a ready-to-use animated Door entity. Additionally, a new Skybox system allows rendering background environments using images (ImageSkybox), custom drawing on canvases (CanvasSkybox), or generic nodes (NodeSkybox).

fxgl/src/main/kotlin/com/almasb/fxgl/scene3d · high confidence

The CircleNN sample in the sandbox directory now provides a complete playable game where the user controls a circle entity using WASD keys and the mouse to shoot at other circles. The game features AI-controlled circles that move randomly, collide with blocks, and shoot at the nearest player circle. New gameplay mechanics include power-ups (Shield, Slow Time, Rage) that modify entity behavior, a ranking system that increases a circle's damage upon killing another, and a UI that displays the player's current rank. The implementation includes specific components for block collision, player input, and visual effects like explosions and screen shake.

fxgl-samples/src/main/java/sandbox/circlegame · high confidence

The FXGL library introduces a new Domain Specific Language (DSL) in the \com.almasb.fxgl.dsl\ package to simplify game development. \EntityBuilder\ allows developers to construct game entities with a fluent API, supporting 2D and 3D positioning, scaling, rotation origins, bounding boxes, and event handlers like \onClick\ and \onActive\. \EventBuilder\ provides a concise way to define timed or conditional events that fire on the event bus. Additionally, \KeyInputBuilder\ and top-level functions in \FXGLForKt\ offer a streamlined syntax for registering keyboard and mouse input actions, making it easier to handle user input in both Java and Kotlin projects.

fxgl/src/main/kotlin/com/almasb/fxgl/dsl · high confidence

The \fxgl.dsl.components\ package now includes a suite of new components to simplify common game logic. For movement, \WaypointMoveComponent\ and \RandomAStarMoveComponent\ enable path-based and random navigation, while \TopDownMoveComponent\ provides grid-style movement with collision blocking. \FollowComponent\ now supports configurable move delays, and \ProjectileComponent\ allows disabling auto-rotation. State and behavior are handled by \ActivatorComponent\ for toggleable states, \IntervalSwitchComponent\ for periodic value toggling, and \EffectComponent\ for managing temporary entity effects. Visibility and lifecycle are managed by \OffscreenCleanComponent\, \OffscreenInvisibleComponent\, and \OffscreenPauseComponent\ (which pauses other components when off-screen), as well as \ExpireCleanComponent\ for timed removal. Additional utilities include \DraggableComponent\ for mouse interaction, \LiftComponent\ for oscillating movement, \RechargeableComponents\ (Health/Mana) with percentage bindings, and \AccumulatedUpdateComponent\ for frame-skipping updates.

fxgl/src/main/kotlin/com/almasb/fxgl/dsl/components · high confidence

Services extending EngineService now have access to a comprehensive set of lifecycle hooks, including onVarsInitialized, onGameReady, onGameReset, onMainLoopPausing, and onMainLoopResumed, allowing for precise control over initialization, game state transitions, and pause/resume events. Additionally, the new @Inject annotation enables services to declare dependencies on other services, which are automatically resolved during the engine initialization phase.

fxgl-core/src/main/kotlin/com/almasb/fxgl/core · high confidence

The \fxgl-scene\ module now includes a dedicated UI package (\com.almasb.fxgl.ui\) providing a suite of styled JavaFX components and factory services. Users can now utilize FXGL-branded controls such as \FXGLSlider\, \FXGLCheckBox\, \FXGLListView\, and \FXGLTextFlow\ for consistent styling. The \FXGLDialogFactoryServiceProvider\ introduces new dialog capabilities, including \choiceDialog\ for selecting from lists or enums, and \messageDialog\/\confirmationDialog\ for user interaction. Additionally, the \InGamePanel\ class offers semi-transparent, animated panels for in-game UI overlays, while \MDIWindow\ provides a lightweight, non-native window implementation with resizing and dragging support. The \FXGLUIFactoryServiceProvider\ centralizes the creation of these UI elements and supports dynamic property views for various data types.

fxgl-scene/src/main/kotlin/com/almasb/fxgl/ui · high confidence

Added a set of JavaScript sample scripts in the assets/scripts directory that demonstrate the scripting engine's capabilities. These include examples for handling entity lifecycle events (onActivate, onRevive, onDeath), updating entity properties (rotation, color, position binding), and implementing basic cutscene logic with dialogue lines and quest conditions. The samples illustrate how scripts can interact with the game world, such as moving entities, showing UI elements, and managing local state.

fxgl-samples/src/main/resources/assets/scripts · high confidence

Added new Kotlin-based sample applications to the FXGL library, including a target-practice game demonstrating physics and collision handling, a sandbox environment for testing DSL features like event builders and conditional logic, and a pathfinding demo using A\* grid navigation. These samples illustrate how to use FXGL's Kotlin DSL for game logic, input handling, and entity management.

fxgl-samples/src/main/kotlin/dev · high confidence

The FXGL Intelligence module introduces a new Remote Procedure Call (RPC) service that enables remote applications to invoke functions on the game engine via WebSocket, alongside new data classes for representing WebAPI media input devices (audio and video). This allows developers to integrate external tools or services that can trigger game logic remotely and select specific camera or microphone inputs for intelligence features.

fxgl-intelligence/src/main/kotlin/com/almasb/fxgl/net · high confidence

Added new sample applications in the sandbox RTS directory: DragDropEntitiesSample demonstrates draggable entities with keep-on-screen constraints; EntityActionSample showcases the Action API for queuing, canceling, and managing entity actions like following and moving; RTSApp provides a real-time strategy game template with click-to-move unit control and visual click feedback; RTSFactory defines the entity factory for spawning units in the RTS sample.

fxgl-samples/src/main/java/sandbox/rts · high confidence

A new ReflectionFunctionCaller class has been added to the core reflection package, allowing methods on any object to be invoked dynamically by name. This component supports two invocation modes: 'call' accepts string arguments and automatically converts them to target types (including int, double, boolean, list, and now enum constants), while 'invoke' accepts arguments of any type directly. Users can register objects to expose their methods and customize string-to-object conversions, providing a flexible way to trigger game logic or other behaviors without hardcoding method calls.

fxgl-core/src/main/kotlin/com/almasb/fxgl/core/reflect · high confidence

Added a collection of TMX level files (e.g., mario, lag, flipped\_tiles) to the samples resource directory. These files serve as sample assets for testing and demonstrating Tiled map integration, including features like tile flipping, GID-based objects, and map properties.

fxgl-samples/src/main/resources/assets/levels/tmx · high confidence

The fxgl-scene module now includes a comprehensive set of new UI capabilities. A new DialogService and DialogFactoryService provide blocking dialogs for messages, confirmations, inputs, errors, progress, and a new choice box that supports List, Enum, and varargs options. The UI toolkit adds FXGL-styled controls (FXGLButton, FXGLChoiceBox, FXGLScrollPane, FXGLSpinner) and a customizable ProgressBar with animations. A SoftwareCursor allows custom in-game cursors, and a PropertyView framework with factories for Point2D and Vec2 enables editable property views.

fxgl-scene/src/main/java/com · high confidence

The dialogue editor now includes several new UI components: an error icon to indicate incomplete paths, an expandable text area that adjusts its height to fit content, a custom context menu rendered within the same window, a node inspector pane for viewing and editing dialogue node properties, a selection rectangle for multi-node selection, and a start node icon. These components enhance the user experience when creating and editing dialogues.

fxgl-tools/src/main/kotlin/com/almasb/fxgl/tools/dialogues/ui · high confidence

The fxgl-intelligence module introduces a new WebAPIService that automates headless browser interactions (Chrome or Firefox) to access JavaScript-driven implementations. This service manages a WebDriver lifecycle, allowing users to execute scripts and monitor browser console logs, which are automatically routed to FXGL's debug logging system for easier debugging of web-based intelligence features.

fxgl-intelligence/src/main/kotlin/com/almasb/fxgl/intelligence · high confidence

This release introduces several new gameplay systems to the FXGL engine. The Achievement system allows developers to define and track player milestones based on game variables, firing events when unlocked or when progress is made. A new Cutscene and Dialogue subsystem enables scripted narrative sequences, including RPG-style text cutscenes, video playback, and complex branching dialogue graphs with variable substitution and function calls. The Inventory system provides a stack-based item management solution with configurable capacities and a ready-to-use list view for UI integration. Finally, a Minigame framework is added, featuring built-in mini-games for random occurrences, trigger sequences, sweet spot timing, trigger mashing, lock picking, and circuit breaking, allowing for interactive skill checks within the game.

(repo-wide) · high confidence

The advanced samples directory now includes a suite of new demonstration applications showcasing FXGL capabilities. These include CustomServiceSample and CustomServicesSample for engine service registration and overriding, DialogueSample for in-game dialogue graphs, EmbeddedSample for embedding FXGL within standard JavaFX applications, and FullscreenSample with a custom intro scene. Additional samples cover GraphVis for force-directed graph visualization, InputCapture for recording and replaying input sequences, Localization for multi-language support, ManualResize for window resizing, Raycast for physics-based line-of-sight, SaveGameVarsSample and SaveLoadSample for persistent data storage, SnookerPhysicsSample for complex 2D physics interactions, UINineSliceSample for scalable UI textures, and ViewportSample for camera effects like shake, flash, and fade.

fxgl-samples/src/main/java/advanced · high confidence

Added two new sample applications in the sandbox animation module: AnimSample, which demonstrates the new onCycleFinished callback for repeatable animations, and SequentialAnimSample, which shows how to chain multiple distinct animations (translate, scale, rotate) into a single sequence.

fxgl-samples/src/main/java/sandbox/anim · high confidence

Added new sample applications in the sandbox.trade module: ArcadeShopSample, which implements a sub-scene shop where players can purchase upgrades for ATK, DEF, and HP stats using a list view, and ShopSample, which provides a basic game world with a player entity and a placeholder shop sub-scene. These samples demonstrate FXGL's UI factory services, sub-scene management, and game state handling for trading mechanics.

fxgl-samples/src/main/java/sandbox/trade · high confidence

The core library now includes a new \AsyncService\ abstract class that allows game logic to run asynchronously on background threads while safely synchronizing results back to the JavaFX thread during game updates. Additionally, a new \Concurrent\ object provides a centralized API for executing tasks, scheduling delays, and managing background threads, which are now configured as daemon threads to prevent blocking application shutdown.

fxgl-core/src/main/kotlin/com/almasb/fxgl/core/concurrent · high confidence

Added several new benchmark samples in the sandbox/benchmark directory to help users evaluate FXGL performance under various conditions. These include BenchmarkManyStaticEntitiesSample for testing static entity rendering and pathfinding, BenchmarkSample for comparing JavaFX UI node updates versus component-based updates, BenchmarkSpawnManyEntitiesSample for measuring entity spawn/remove throughput, MassUnitsRTSSample for A\* pathfinding performance with many units, PhysicsBenchmarkSample for collision detection stats, and TiledBenchmarkSample for measuring TMX map loading times with configurable iterations and map choices.

fxgl-samples/src/main/java/sandbox/benchmark · high confidence

This update introduces several new data structures and expands the capabilities of PropertyMap. A new MovingAverageQueue class provides a buffer for tracking moving averages, while UnorderedPairMap allows for key-value storage where key order is irrelevant. PropertyMap now supports arithmetic operations (multiply, divide) on integer and double properties, includes a forEach iteration method, and implements SerializableType for serialization support. Additionally, a bug fix ensures that setting the same object reference to a PropertyMap value correctly fires listeners, and internal listeners are now properly cleaned up when properties are removed.

fxgl-core/src/main/kotlin/com/almasb/fxgl/core/collection · high confidence

Added two new collision handler classes to the FXGL DSL: CollectibleHandler, which removes a collectible entity from the world upon collision (optionally playing a sound and executing a custom action), and OneTimeCollisionHandler, which disables further collisions for a specific entity type after the first interaction while allowing a custom action to run. These handlers simplify common game logic patterns involving item collection and single-use interactions.

fxgl/src/main/kotlin/com/almasb/fxgl/dsl/handlers · high confidence

The core utility package now includes several new components: a \Platform\ enum with logic to detect Windows, Mac, Linux, Android, iOS, Browser, and Embedded environments; a \ResourceExtractor\ to unpack native libraries and resources from the JAR to the local file system; a \LazyValue\ class for caching expensive computations; input validation predicates (\ALPHANUM\, \ALPHA\); a \tryCatchRoot\ helper for exception handling; and utility objects like \EmptyRunnable\ and \PauseMenuBGGen\.

fxgl-core/src/main/kotlin/com/almasb/fxgl/core/util · high confidence

The \fxgl-core\ module now includes foundational utility interfaces and classes to support object lifecycle management, memory pooling, and grid-based logic. \Copyable\ and \Disposable\ provide standard contracts for cloning and resource cleanup, while \Updatable\ and \UpdatableRunner\ allow objects to be driven by a central update loop. A new object pooling system (\Pool\, \Pools\, \ReflectionPool\, \Poolable\) enables efficient object reuse to reduce garbage collection overhead. Additionally, a new grid system (\Grid\, \Cell\, \NeighborSelectionStrategy\) has been added to \fxgl-core.collection.grid\, supporting configurable neighbor selection (4 or 8 directions) and pixel-based lookups, replacing the previous grid implementation that lived in \fxgl-ai\.

fxgl-core/src/main/java/com · high confidence

A new set of developer utilities has been added to the library, providing a command-line console for executing commands and inspecting variables, a debug camera scene accessible via Ctrl+arrow keys for navigating the game world, and a dev pane that displays game variables, allows toggling debug views (such as entity bounding boxes), and shows temporary debug messages. These tools are integrated into the DevService and are only active when the application is not in release mode and the developer menu is enabled.

fxgl/src/main/kotlin/com/almasb/fxgl/dev · high confidence

The fxgl-io module now includes a new FileSystemService that manages file operations via background IO tasks. This service supports mobile environments by routing storage to private device storage on mobile devices while using the user directory on desktop. It also enforces write protection: if the isFileSystemWriteAllowed flag is false, any attempt to create, write, or delete files will be blocked with a warning, addressing issue \#847.

fxgl-io/src/main/kotlin/com/almasb/fxgl/io · high confidence

A new Java module named com.almasb.fxgl.test has been introduced to provide test utilities. This module explicitly requires javafx.graphics and org.junit.jupiter.api, and exports its own package, addressing Java module system compatibility issues when importing test classes from other modules.

fxgl-test/src/main/java · high confidence

The gesture recognition module now includes services for detecting hand landmarks from both live video input and static images. HandTrackingService allows users to select specific video input devices and provides real-time 3D landmark data, while HandTrackingFromImageService enables hand detection from provided images. Both services integrate with a new HandLandmarksView component that visualizes the detected hand skeleton using configurable scaling and visibility settings, supporting up to two simultaneous hands.

fxgl-intelligence/src/main/kotlin/com/almasb/fxgl/intelligence/gesturerecog · high confidence

Developers can now view real-time performance metrics directly in the game window via a new ProfilerService. This service adds three overlay charts—FPS, CPU time per frame (ms), and RAM usage (MB)—that update every frame and log summary statistics (average, min, max, and estimated GC runs) when the game exits.

fxgl/src/main/kotlin/com/almasb/fxgl/dev/profiling · high confidence

Added three new sample applications to the intermediate AI pathfinding package: AStarPathfindingSample, which demonstrates A\* search on a grid with interactive wall placement; MazeGenerationSample, showing how to construct and traverse mazes with NPC pathfinding; and RandomPathfindingSample, illustrating random NPC movement using A\* on a map-based grid.

fxgl-samples/src/main/java/intermediate/ai · high confidence

Added four new sample applications in the intermediate animation package to demonstrate FXGL's animation capabilities: AnimatedPathSample shows how to animate a node along a custom JavaFX Shape path; AnimatedStringSample demonstrates text interpolation using AnimatedString; AnimatedTextureSample illustrates sprite sheet animation with AnimatedTexture, including features like playing from a specific frame, looping, and reversing; and PropertyAnimationSample showcases animating various JavaFX properties such as dimensions, colors, and effects.

fxgl-samples/src/main/java/intermediate/animation, fxgl-samples/src/main/java/tutorial · high confidence

Three new sample applications have been added to the intermediate.particles package to demonstrate advanced particle system capabilities. FireworksSample shows how to create multi-stage firework effects using projectile components and particle emitters. ImageToParticlesAnimationSample demonstrates converting image pixels into individual entities and animating them along paths. RainSample illustrates particle colorization techniques using multiply and toColor operations on source textures.

fxgl-samples/src/main/java/advanced/particles, fxgl-samples/src/main/java/intermediate/particles · high confidence

A new sample application (InventorySample) has been added to the sandbox inventory package, demonstrating how to implement a simple inventory system. This example shows users how to pick up and drop items using the Inventory and InventoryListView components, including handling item configurations and UI interactions for adding and removing items from the inventory.

fxgl-samples/src/main/java/sandbox/inventory · high confidence

The core math package now includes a new Vec3 class for 3D vector operations (dot/cross products, local mutations) as a lightweight alternative to JavaFX Point3D, a seedable PerlinNoiseGenerator providing 1D noise for effects like movement or lighting, and a Distances object that calculates the precise distance between two Rectangle2D bounding boxes.

fxgl-core/src/main/kotlin/com/almasb/fxgl/core/math · high confidence

Added MinimapView, which renders a scaled overview of the game world with configurable background and entity colors, and introduced ScrollingBackgroundView and SelfScrollingBackgroundView to handle background scrolling—either by binding to the viewport position or by moving automatically at a specified speed.

fxgl/src/main/kotlin/com/almasb/fxgl/dsl/views · high confidence

The view component package introduces a new modular design with several new classes: ChildViewComponent serves as a base for components that add child nodes to the entity's view; GenericBarViewComponent provides a customizable progress bar for displaying properties like health or mana; TextViewComponent displays static text; and TrailParticleComponent adds a spark particle effect to entities. These components simplify adding visual elements and effects to game entities.

fxgl/src/main/kotlin/com/almasb/fxgl/dsl/components/view · high confidence

The \fxgl-io\ module now includes a new \NetService\ that provides methods to create TCP and UDP servers and clients, supports custom message types via configuration objects, and includes a \downloadTask()\ method for downloading files from URLs with optional progress callbacks. The change also introduces configuration data classes (\ServerConfig\, \ClientConfig\, \UDPServerConfig\, \UDPClientConfig\) and reader/writer factories for handling different message types (Bundle, ByteArray, String) over TCP and UDP.

fxgl-io/src/main/kotlin/com/almasb/fxgl/net · high confidence

Added two new sample applications in the advanced net package: FileDownloadSample, which demonstrates downloading a file with a progress dialog, and NetworkingSample, which illustrates TCP server and client communication with synchronized state.

fxgl-samples/src/main/java/advanced/net · high confidence

Added a collection of new sandbox samples in the FXGL particle system module, including attractor physics, firework explosions, motion blur trails, and pixel-based morphing animations, providing interactive demonstrations of various particle effects and behaviors.

fxgl-samples/src/main/java/sandbox/particles · high confidence

Added five new sample applications in the sandbox.joints package to demonstrate FXGL's physics engine capabilities: DistanceJointSample, PrismaticJointSample, RevoluteJointSample, RopeJointSample, and RopeJointSample2. These samples allow users to interactively explore how distance, prismatic, revolute, and rope joints behave with physics bodies, including features like mouse-controlled entity spawning and joint creation/removal.

fxgl-samples/src/main/java/sandbox/joints · high confidence

Added two new interactive physics demonstrations to the advanced samples. The Flying Keys sample introduces a game where physics-enabled button entities (representing alphabet characters) are subject to randomized gravity, allowing users to observe dynamic body behavior in a chaotic environment. The Mass sample demonstrates direct manipulation of body mass properties using Box2D's MassData API, featuring a seesaw simulation where users can adjust the mass of new balls via keyboard inputs (E, P, Q, O) to see how different weights affect physical interactions and balance.

fxgl-samples/src/main/java/advanced/physics · high confidence

Added two new samples in the sandbox AI pathfinding area: MapGenerationSample demonstrates procedural content generation (PCG) for maps using noise-based height maps and biome data, while SenseAISample introduces a draft of the SenseAI system, allowing NPCs to react to auditory stimuli (hearing noise) and adjust their movement speed and state (Calm, Alert, Aggressive) accordingly.

fxgl-samples/src/main/java/sandbox/ai · high confidence

A new interactive sample, ScaleAndRotateSample, has been added to the sandbox animations directory. It demonstrates how to apply rotation and scale transforms to a rectangle using the FXGL animation builder, specifically highlighting the use of origin points (Point2D) to control the pivot of these transformations. The sample allows users to cycle through four different animation configurations by pressing the 'F' key, showing both default and custom origin behaviors.

fxgl-samples/src/main/kotlin/sandbox/anim · high confidence

The sandbox view area now includes four new sample applications demonstrating specific FXGL capabilities. DevMenuSample shows how to enable and interact with the developer menu, including binding game variables to UI text and handling input. PropertyMapViewSample demonstrates the new PropertyMapView UI component, which automatically generates a view from a PropertyMap and updates when values change. VideoSample illustrates loading and playing video files using the asset loader. WobbleEffectSample showcases the WobbleEffect visual effect applied to game entities, allowing users to trigger vertical and horizontal wobbling animations via keyboard input.

fxgl-samples/src/main/java/sandbox/view · high confidence

Added new sample applications in the sandbox.net package to demonstrate FXGL capabilities: HandTrackingSample shows gesture-based drawing using HandTrackingService; MultiplayerSample demonstrates TCP-based multiplayer with entity, input, property, and custom event replication, including a ping display; SpeechRecogSample illustrates speech-to-text input via SpeechRecognitionService; TTSSample provides text-to-speech output with voice selection via TextToSpeechService; and UDPSample showcases UDP networking with a server and client exchanging messages.

fxgl-samples/src/main/java/sandbox/net · high confidence

Added four new sample applications in the sandbox view package: BasicEntityViewApp demonstrates basic entity creation with WASD controls and a generic bar view; DestructibleApp showcases physics-based destruction where bricks break into smaller fragments using axis-aligned subdivision; DevVarSample illustrates dynamic world property updates and UI text binding; and AASubdivision provides the underlying utility for spatial partitioning used in the destruction sample.

fxgl-samples/src/main/kotlin/sandbox/view · high confidence

The sandbox saving sample now includes a working example of game state persistence using the FXGL profile system. The SaveSample application enables user profiles and registers a SaveLoadHandler that serializes entity data (such as player ID) into Bundles during save operations and retrieves them during load. A new PlayerControl component manages player movement and implements isComponentInjectionRequired() to return false, ensuring proper component lifecycle handling within the entity system.

fxgl-samples/src/main/java/sandbox/saving · high confidence

The texture module has been refactored and expanded with several new capabilities. Users can now create and control sprite animations via the new AnimatedTexture and AnimationChannel classes, which support multiple animation channels, custom start frames, and frame offsets. A new GLImageView class provides experimental support for rendering textures using custom GLSL fragment shaders. Additionally, a NineSliceTextureBuilder allows for scalable UI elements by defining corner, side, and center regions, while a ScrollingView enables infinite horizontal or vertical scrolling of background images.

fxgl-core/src/main/kotlin/com/almasb/fxgl/texture · high confidence

The repository now includes a Code of Conduct, a Contribution Guide, and a license header template to standardize community interaction and development workflows. The Contribution Guide outlines the development workflow, coding standards, and community roles, while the Code of Conduct establishes expectations for respectful behavior. Additionally, the project documentation has been expanded with Chinese and Russian translations of the README, and the main README has been significantly enriched with badges, setup instructions, and community information.

(repo-wide) · high confidence

The default menu system has been completely redesigned, introducing a new base class (FXGLMenu) and a new default implementation (FXGLDefaultMenu) that features particle effects, animated transitions, and a simplified API. The game scene now supports 3D environments via a new Camera3D class and FPS-style mouse controls, while the error reporting UI has been updated to use a portable MDI window instead of a native dialog.

fxgl/src/main/kotlin/com/almasb/fxgl/app/scene · high confidence

A new sample application demonstrating SubScene navigation has been added to the sandbox. It includes a main menu with buttons to navigate to About, Options, and Play screens, using a custom event system to manage transitions between these sub-scenes.

fxgl-samples/src/main/kotlin/sandbox/subscene · high confidence

The fxgl-core library now includes a module-info.java file, formally declaring it as a Java module (com.almasb.fxgl.core). This change exposes a consolidated set of packages—including previously separate modules like animation, audio, input, localization, logging, texture, and time—under the core module. It also declares transitive dependencies on Kotlin stdlib and JavaFX graphics/base, and opens specific entity and pathfinding packages for reflection, enabling better encapsulation and compatibility with the Java Platform Module System.

fxgl-core/src/main/java · high confidence

The FXGL library now utilizes the Java Platform Module System, exposing a consolidated \com.almasb.fxgl.all\ module that aggregates core, IO, and scene functionalities. This change provides a unified entry point for applications, explicitly declaring transitive dependencies on JavaFX modules (base, graphics, controls, fxml, media) and third-party libraries like Jackson and Gluon Attach. It also defines specific package exports and opens internal packages (such as DSL components, dev tools, and app services) to the core module to support reflection and service discovery, standardizing how the engine is integrated into modern Java projects.

fxgl/src/main/java · high confidence

The fxgl-scene module is now explicitly defined via a module-info.java file, establishing its dependencies on fxgl-core and JavaFX controls, and exporting packages for scene, UI, and notification components to other modules.

fxgl-scene/src/main/java · high confidence

New isometric map files (iso.tmx and iso1.tmx) have been added to the sample assets, providing tilesets and layer data for testing experimental features.

fxgl-samples/src/main/resources/assets/levels/tmx/iso · medium confidence

The animation subsystem has been merged from the separate fxgl-animation module into fxgl-core, removing the previous dependency on fxgl-entity. This change introduces a new fluent DSL for building animations, including support for 3D transformation origins (pivot points), a new AnimatedImage type for pixel-level animation, and a bobbleDown effect. It also adds a seeded 1D noise generator and allows translation animations to default to the object's current position if no start value is specified.

fxgl-core/src/main/kotlin/com/almasb/fxgl/animation · high confidence

The audio implementation has been merged from the separate fxgl-media module into fxgl-core, introducing a unified audio service that supports both desktop (JavaFX MediaPlayer/AudioClip) and mobile (Gluon Attach) platforms. This change brings native music pausing when the application is minimized (controlled by the isPauseMusicWhenMinimized flag) and ensures audio services load correctly on embedded devices by providing dummy audio fallbacks when mobile audio services are unavailable.

fxgl-core/src/main/kotlin/com/almasb/fxgl/audio · high confidence

The EventBus in fxgl-core now includes a removeAllEventHandlers method, allowing applications to cleanly unsubscribe from all registered events at once. This change, introduced alongside the migration of event handling code into fxgl-core, simplifies lifecycle management by providing a single call to clear all subscriptions rather than requiring individual removals.

fxgl-core/src/main/kotlin/com/almasb/fxgl/event · high confidence

The scene management logic has been extracted into a new \fxgl-scene\ module, introducing core classes such as \Scene\, \SubScene\, and \SceneService\. This change provides developers with direct access to scene lifecycle methods (like \onExit\), global services including the event bus and always-on input via \SceneService\, and convenient properties for preferred width and height that automatically adjust based on auto-scaling settings. The module also establishes a structured hierarchy for accessing specific game scenes (intro, loading, game, main menu, game menu) and supports subscene stacking.

fxgl-scene/src/main/kotlin/com/almasb/fxgl/scene · high confidence

The input handling logic has been moved from the separate fxgl-input module into fxgl-core, consolidating the Input, Trigger, and UserAction classes. This change introduces an InputModifier enum (CTRL, SHIFT, ALT) to properly handle key combinations and fixes an issue where modifier keys were not released correctly when other keys were released. Additionally, UserAction now supports double-press detection via a configurable doublePressTimeThreshold and new onDoubleActionBegin callbacks, while TriggerListener provides dedicated onKey and onButton callbacks that fire before generic onAction events.

fxgl-core/src/main/kotlin/com/almasb/fxgl/input · high confidence

The localization infrastructure, including the Language class with native name support and the LocalizationService for managing string bundles and lazy loading, has been moved from the separate fxgl-localization module into fxgl-core. This change consolidates the core localization logic into the main library module, making it immediately available without requiring an additional dependency.

fxgl-core/src/main/kotlin/com/almasb/fxgl/localization · high confidence

The profile functionality has been moved into the fxgl-io module, introducing a new SaveLoadService that manages game state persistence. This service provides a handler-based architecture for saving and loading data, including a convenience method addWorldPropertiesHandler() that automatically serializes and restores world properties. Users can now register custom SaveLoadHandlers to control what data is persisted, while the service handles the underlying file system operations for writing, reading, and deleting save files.

fxgl-io/src/main/kotlin/com/almasb/fxgl/profile · high confidence

The fxgl-io module now exposes the net and profile packages alongside the existing io package, effectively merging the functionality of fxgl-net and fxgl-profiles into this single module. The module requires java.net.http, enabling the new HttpClientService for sending HTTP requests, and requires com.gluonhq.attach.storage for storage integration. It also opens the io and profile packages to the core module for reflection-based access.

fxgl-io/src/main/java · high confidence

The native backend for controller input has been replaced with a new implementation using SDL2. This change introduces a JNI layer that initializes the SDL game controller subsystem, enumerates connected controllers, and exposes methods to update state, check button presses, and read axis values. The implementation now returns the number of connected controllers upon connection and handles cleanup by closing controllers and quitting the SDL subsystem.

fxgl-controllerinput/src/main/native · high confidence

The FXGL engine now uses a new abstract GameApplication class as the primary entry point for game applications, replacing the previous launch mechanism. This change introduces embeddedLaunch() and embeddedShutdown() methods, allowing developers to start and stop an FXGL instance within an existing JavaFX application without exiting the JavaFX runtime, which is useful for embedding games in larger desktop applications. The initialization flow is now more structured, with specific callbacks for settings, input, game variables, and game logic, and includes a workaround for a JavaFX bug on Linux. Additionally, the new entry point automatically detects mobile platforms and sets the native flag accordingly, and provides a more robust error handling mechanism during launch.

fxgl/src/main/java/com · high confidence

This change introduces several new services and refactors existing ones within the application layer. A new OSService provides OS-level functionality, including screen capture, process execution, and a RobotKeyboard for input simulation. The dialog system is replaced by a new FXGLDialogService that manages a dedicated sub-scene for modal dialogs, adds a drop shadow effect, and supports choice boxes for lists and enums. Asset loading is overhauled via a new FXGLAssetLoaderService that caches Model3D objects, allows loading from URLs, and adds shortcuts for cutscenes and videos. Additionally, an IOTaskExecutorService manages background tasks without showing error dialogs if a fail action is defined, and an UpdaterService checks for newer FXGL versions in non-release modes.

fxgl/src/main/kotlin/com/almasb/fxgl/app/services · high confidence

The asset loading system has been restructured to introduce a generic \AssetLoaderService\ that enables loading assets from both file names and direct URLs, addressing previous limitations where modules could not access the FXGL module directly. This change also expands the \AssetType\ enum to include new asset categories such as VIDEO, MODEL3D, and UI, allowing for more diverse asset handling within the library.

fxgl-core/src/main/kotlin/com/almasb/fxgl/core/asset · high confidence

The notification system in fxgl-scene has been updated to allow passing a JavaFX Node as an icon when pushing notifications, enabling richer visual feedback alongside the message text. Additionally, changes to the NotificationService implementation ensure that setting background and text colors correctly updates the view in real-time, resolving a previous issue where style changes were not reflected.

fxgl-scene/src/main/kotlin/com/almasb/fxgl/notification · high confidence

The MultiplayerService has been redesigned to provide built-in round-trip time (ping) monitoring for connections, accessible via the new pingProperty method, and now supports sending custom spawn data when spawning entities over the network. This update introduces a new NetworkComponent for entity identification, a NetworkSpawnData wrapper to serialize spawn parameters, and a comprehensive set of ReplicationEvents (including PING/PONG, entity lifecycle, input, and property updates) to handle synchronization between clients.

fxgl/src/main/kotlin/com/almasb/fxgl/multiplayer · high confidence

The application startup and core engine logic have been restructured to improve modularity and initialization control. A new \ApplicationMode\ enum (DEBUG, DEVELOPER, RELEASE) now governs logging verbosity and exception reporting, while the \Engine\ class serves as the central hub for service initialization, dependency injection, and main loop execution. The \FXGLApplication\ entry point has been updated to support both standalone JavaFX launching and embedded integration via \embeddedLaunchFX\, with font loading and service initialization moved to background tasks to reduce startup latency. Additionally, the \GameController\ interface now exposes explicit methods for scene navigation (intro, main menu, game menu, loading, play) and engine state control (pause, resume, exit), providing a cleaner API for managing game flow.

fxgl/src/main/kotlin/com/almasb/fxgl/app · high confidence

The dialogue editor now applies specific CSS styles to enhance the user interface, including a distinct visual indicator (azure border) for the currently selected node view. The entry also introduces styling for the main UI tab pane, defining appearance for selected and unselected tabs, and adds a styled context menu with a gradient background and rounded corners.

fxgl-tools/src/main/resources · high confidence

Added Zeph test level asset; Added concurrency and async service tests; Added test assets for AI, dialogues, JSON, levels, scripts, and UI; Added test coverage for IO, Net, and Profile services; Added test coverage for core collection utilities; Added test resources for FXGL UI styling; Added test resources for text and tiled level parsing; Added tests for EngineService default methods; Added tests for EventBus functionality; Added tests for UI components and font factory; Added tests for reflection utilities and foreign function calling; Added tests for the Bundle serialization utility; Added tests for the finite state machine implementation; Added unit tests for FXGL core entity system and AI; Added unit tests for FXGL texture system components; Added unit tests for LocalizationService; Added unit tests for NotificationService; Added unit tests for core collection, grid, and pathfinding utilities; Added unit tests for core math utilities; Added unit tests for core utility classes; Added unit tests for input handling and modifier logic; Added unit tests for the Grid Cell class; Added unit tests for the animation system; Added unit tests for the audio loader; Added unit tests for time management components; Expanded test coverage for FXGL core systems; Initial unit tests for the Scene class; New test utilities for JavaFX initialization and field injection.

This change updates the FXGL framework's Maven build configuration to target Java 25 and JavaFX 25.0.1, while upgrading core dependencies including Kotlin to 2.3.0, Jackson to 2.19.4, Gluon Attach to 4.0.24, and JUnit Jupiter to 6.0.2. The build also configures JaCoCo 0.8.14 for test coverage and sets up the Sonatype Central Publishing plugin for artifact deployment.

(dependencies) · high confidence

The new fxgl-tools module (com.almasb.fxgl.tools) explicitly requires the Jackson databind library, making JSON processing capabilities available to tools within this module.

fxgl-tools/src/main/java · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 33 → 52 (+19.6)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 50 → 61 (+11.0)
• Architecture 96 → 100 (+4.4)
• Maturity 46 → 60 (+14.3)
• Readiness 19 → 49 (+30.9)
• Security 36 → 68 (+31.7)
• Accessibility 47 (new)

• Coverage not measured — test suite did not build
• Dimension evaluation failed
• Duplicated block (11 lines × 2) (fxgl/src/main/kotlin/com/almasb/fxgl/app/scene/FXGLDefaultMenu.kt)
• Duplicated block (12 lines × 2) (fxgl-io/src/main/kotlin/com/almasb/fxgl/io/FileSystemAccess.kt)
• Duplicated block (12 lines × 2) (fxgl-scene/src/main/kotlin/com/almasb/fxgl/ui/FXGLDialogFactoryServiceProvider.kt)
• Duplicated block (13 lines × 2) (fxgl-samples/src/main/kotlin/sandbox/anim/ScaleAndRotateSample.kt)
• Duplicated block (13 lines × 2) (fxgl-tools/src/main/kotlin/com/almasb/fxgl/tools/dialogues/ui/NodeInspectorPane.kt)
• Duplicated block (13 lines × 2) (fxgl/src/main/kotlin/com/almasb/fxgl/app/MainWindow.kt)
• Duplicated block (13 lines × 3) (fxgl-core/src/main/kotlin/com/almasb/fxgl/entity/level/tiled/TilesetLoader.kt)
• Duplicated block (17 lines × 2) (fxgl/src/main/kotlin/com/almasb/fxgl/achievement/AchievementService.kt)
• Duplicated block (18 lines × 2) (fxgl-core/src/main/kotlin/com/almasb/fxgl/entity/level/tiled/TilesetLoader.kt)
• Duplicated block (18 lines × 2) (fxgl/src/main/kotlin/com/almasb/fxgl/app/MainWindow.kt)
• Duplicated block (20 lines × 2) (fxgl-core/src/main/kotlin/com/almasb/fxgl/entity/level/tiled/TilesetLoader.kt)
• Duplicated block (24 lines × 2) (fxgl-core/src/main/kotlin/com/almasb/fxgl/physics/BoundingShape.kt)
• Duplicated block (25 lines × 2) (fxgl-core/src/main/kotlin/com/almasb/fxgl/entity/level/tiled/TMXLevelLoader.kt)
• Duplicated block (6 lines × 2) (fxgl/src/main/kotlin/com/almasb/fxgl/scene3d/Cuboid.kt)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 19 more

• AABB.raycast (cognitive 24) (fxgl-core/src/main/java/com/almasb/fxgl/physics/box2d/collision/AABB.java)
• AStarPathfinder.findPath (cognitive 50) (fxgl-core/src/main/java/com/almasb/fxgl/pathfinding/astar/AStarPathfinder.java)
• AStarPathfinder.findPath (cyclomatic 22) (fxgl-core/src/main/java/com/almasb/fxgl/pathfinding/astar/AStarPathfinder.java)
• Ambiguous handler registration. Two methods exist for adding message handlers: one generic and one with 'FX' suffix. It is unclear if the 'FX' version ensures the handler is invoked on the JavaFX Application Thread, or if it's just a naming convention. This lack of clarity forces users to guess or check implementation details.
• Animation.onUpdate (cognitive 16) (fxgl-core/src/main/kotlin/com/almasb/fxgl/animation/Animation.kt)
• Array.removeAll (cognitive 20) (fxgl-core/src/main/java/com/almasb/fxgl/core/collection/Array.java)
• ClassTooLong: Body (fxgl-core/src/main/java/com/almasb/fxgl/physics/box2d/dynamics/Body.java)
• ClassTooLong: Collision (fxgl-core/src/main/java/com/almasb/fxgl/physics/box2d/collision/Collision.java)
• ClassTooLong: ContactSolver (fxgl-core/src/main/java/com/almasb/fxgl/physics/box2d/dynamics/contacts/ContactSolver.java)
• ClassTooLong: Entity (fxgl-core/src/main/java/com/almasb/fxgl/entity/Entity.java)
• ClassTooLong: FXGLDefaultMenu (fxgl/src/main/kotlin/com/almasb/fxgl/app/scene/FXGLDefaultMenu.kt)
• ClassTooLong: ParticleSystem (fxgl-core/src/main/java/com/almasb/fxgl/physics/box2d/particle/ParticleSystem.java)
• ClassTooLong: PrismaticJoint (fxgl-core/src/main/java/com/almasb/fxgl/physics/box2d/dynamics/joints/PrismaticJoint.java)
• ClassTooLong: World (fxgl-core/src/main/java/com/almasb/fxgl/physics/box2d/dynamics/World.java)
• Collision.collideEdgeAndCircle (cognitive 18) (fxgl-core/src/main/java/com/almasb/fxgl/physics/box2d/collision/Collision.java)
• Collision.collidePolygonAndCircle (cognitive 18) (fxgl-core/src/main/java/com/almasb/fxgl/physics/box2d/collision/Collision.java)
• Contact.update (cognitive 23) (fxgl-core/src/main/java/com/almasb/fxgl/physics/box2d/dynamics/contacts/Contact.java)
• ContactManager.addPair (cognitive 21) (fxgl-core/src/main/java/com/almasb/fxgl/physics/box2d/dynamics/ContactManager.java)
• ContactManager.addPair (cyclomatic 17) (fxgl-core/src/main/java/com/almasb/fxgl/physics/box2d/dynamics/ContactManager.java)
• ContactManager.collide (cognitive 17) (fxgl-core/src/main/java/com/almasb/fxgl/physics/box2d/dynamics/ContactManager.java)
• …and 351 more

• 5 commits — 3 feature/other, 2 fixes

• fxgl-core/src — 3 commits
• fxgl-io/src — 1 commit
• fxgl-samples/src — 1 commit

• fix: fix: ReflectionFunctionCaller now correctly auto-converts String to enum
• fix: fix: recycle particle instead of emitter position back to pool in ParticleSystem
• change: docs: fix small typo in TCPReaderFactory comment
• change: feat: expose MassData and added new sample code to demonstrate mass use case
• change: moved MassSample to advanced package

• Containers 0 added · 0 removed · contexts 7 added · 0 removed · edges 15 added · 0 removed

• fxgl
• fxgl-core
• fxgl-intelligence
• fxgl-io
• fxgl-samples
• fxgl-scene
• fxgl-tools

• fxgl → fxgl-core (coupling)
• fxgl → fxgl-io
• fxgl → fxgl-scene (coupling)
• fxgl-intelligence → fxgl-core
• fxgl-io → fxgl-core
• fxgl-io → fxgl-scene
• fxgl-samples → fxgl
• fxgl-samples → fxgl-core
• fxgl-samples → fxgl-io
• fxgl-samples → fxgl-scene
• fxgl-scene → fxgl-core
• fxgl-tools → fxgl (coupling)
• fxgl-tools → fxgl-core
• fxgl-tools → fxgl-io
• fxgl-tools → fxgl-scene

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

AlmasB/FXGL was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.