RafaelBarbosatec/bonfire

Bonfire is a game development framework built on top of the Flame engine for Flutter, providing a comprehensive suite of tools for creating 2D games. It features a mixin-based architecture that simplifies the implementation of core game mechanics such as movement, collision, physics forces, and declarative AI behaviors. The system supports diverse gameplay styles through specialized player and enemy components, extensive map rendering capabilities including Tiled and Spritefusion integration, and utilities for UI, lighting, and procedural generation.

30 changes.

This period centered on the Bonfire 4.0 release, which restructured the library around an API-first mixin architecture and a simplified, velocity-based movement system. The work introduced comprehensive new features including a behavior tree system, configurable lighting, parallax backgrounds, and a robust joystick input system, while establishing a clean public API surface. It also delivered a fully scaffolded example project demonstrating these capabilities with specialized player types, enemy AI, and interactive UI components.

48 changes.

This period centered on the Bonfire 4.0 engine overhaul, introducing a mixin-based API structure, a declarative behavior system for AI, and robust support for infinite map rendering. It also significantly expanded the framework's capabilities with a new Scene Builder for scripted sequences, comprehensive input and gesture handling, and a rich library of NPC, enemy, and ally components. The work was complemented by extensive example applications demonstrating these new features across various game genres and mechanics.

28 changes.

This period focused on expanding the engine's map rendering capabilities by adding comprehensive support for Tiled and Spritefusion formats, including infinite worlds and network loading. It also introduced advanced physics systems for forces and elastic collisions, alongside new input handling and map navigation features.

The example application now includes a dedicated home page (\HomePage\) that serves as the central navigation hub for all Bonfire feature demos. This page presents a categorized menu (Map, Input, Player, etc.) allowing users to browse and launch specific examples such as Tiled maps, various input gestures, and player controllers. A \HomeRoute\ class has also been added to manage the root navigation route, enabling users to easily access the example gallery from the app's entry point.

example/lib/pages/home · high confidence

This change introduces a complete Flappy Bird clone example built on the Bonfire game engine. The implementation includes the core game loop and UI in \lib/game.dart\ and \lib/main.dart\, featuring a bird component with gravity and tap-to-jump mechanics, a pipe generation system with collision detection, and a parallax scrolling background. A score overlay displays the number of pipes passed, and a 'Game Over' dialog allows players to reset the level.

_awesome/flappy\bird · high confidence

The library now includes a new \Ally\ class and its variants (\RotationAlly\, \SimpleAlly\) in the \lib/npc/ally\ directory. These classes extend the existing \Npc\ base and mix in \WithLife\, allowing allies to have health points and configurable attack reception origins (e.g., only from enemies). \RotationAlly\ supports sprite animations for idle and run states with angle-based movement, while \SimpleAlly\ uses direction-based animations for multi-directional movement.

lib/npc/ally · high confidence

Introduces a new \lib/npc\ module providing base and specialized NPC classes for game entities. The \Npc\ base class combines movement and vision mixins, while \RotationNpc\ adds sprite animation support for top-down perspectives, and \SimpleNpc\ provides directional animation capabilities for enemies.

lib/npc · high confidence

Introduces the \SpritefusionMap\, \SpritefusionMapLayer\, and \SpritefusionMapLayerTile\ data models in the \lib/map/spritefusion/model\ directory. These classes provide the structure for representing map data, including properties like tile size, map dimensions, layer names, collider settings, and tile coordinates, along with serialization support to and from JSON.

lib/map/spritefusion/model · high confidence

A new example page, SpritefusionPage, has been added to demonstrate rendering a map using the Bonfire game engine's Spritefusion integration. This page configures a BonfireWidget with a directional joystick controller and loads a map definition from the 'spritefusion/map.json' asset, setting a specific tile size and camera zoom level.

example/lib/pages/map/spritefusion · high confidence

A new ColorFilterComponent has been introduced to apply color overlays to the game view. This component uses a GameColorFilter configuration to determine the overlay color and blend mode, rendering the effect on the canvas when enabled. It also supports animated transitions between colors via an animateTo method, allowing for smooth visual changes with configurable duration and easing curves.

_lib/color\filter · high confidence

The example application now includes a new interactive demo page for physics forces. This page showcases various force behaviors, including acceleration, linear forces, resistance, and elastic collisions with bounciness, allowing users to visualize and test these mechanics within the Bonfire engine.

example/lib/pages/forces · high confidence

The example application now includes a new \HomeContent\ widget that displays an introductory section for the Bonfire framework. This widget features an animated GIF, a headline, and a descriptive text explaining that Bonfire is a game development framework for Flutter/Flame, along with a version indicator in the bottom-right corner.

example/lib/pages/home/widgets · high confidence

The example app now includes an infinite map demo that uses a small Tiled pattern to create an endless world. As the player moves, new map chunks spawn seamlessly in all directions while distant chunks are unloaded, with the origin chunk remaining active. The demo also features a custom column object that is recreated for each chunk to make the repetition visible.

example/lib/pages/map/infinite · high confidence

A new mini-map widget has been added to the game UI, providing a real-time overview of the game world. It displays tiles, the player, enemies, NPCs, and allies using customizable colors and rendering callbacks. The widget supports configurable size, zoom level, and styling (background, border, margins) and updates periodically to reflect the current camera position.

_lib/widgets/mini\map · high confidence

The example app now includes dedicated pages demonstrating parallax scrolling backgrounds for both the Bonfire and Flame rendering backends. Users can view the Bonfire-specific implementation in \bonfire/bonfire\_parallax\_page.dart\ (using \loadCameraParallaxComponent\) and the Flame-specific implementation in \flame/parallax\_page.dart\ (using \loadParallaxComponent\), each configured with a tiled map, gravity, and joystick controls.

example/lib/pages/parallax · high confidence

This location introduces a complete platformer game example built on the Bonfire engine. It adds the core game loop and UI (main.dart, game.dart), a player character (FoxPlayer) with double-jump and tree-climbing mechanics, frog enemies that patrol and attack on contact, and collectible gems that trigger a win state. The entry also includes the Tiled map assets (platform\_map.tmj, tilesets) and sprite definitions required to render the level and entities.

_awesome/platform\game · high confidence

The example app now includes a new platformer player demo that demonstrates how to configure a player character with both joystick and keyboard input. The example uses the new \playerControllers\ parameter in \BonfireWidget\ to attach a directional joystick with an action button and a keyboard controller configured to accept the space key for jumping. The player character utilizes the \WithForces\ mixin for gravity-based physics and includes a custom hitbox for collision detection.

example/lib/pages/player/platform · high confidence

The input example now includes a tap gesture demo where a barrel decoration displays 'Touch me' and moves in a random direction when tapped.

example/lib/pages/input/tap · high confidence

The example app now includes a new top-down player rotation demo. This addition introduces a \HumanTopdownPlayer\ component with specific sprite animations and collision handling, along with a corresponding page that configures the game world using a Tiled map and a directional joystick controller.

example/lib/pages/player/rotation · high confidence

The example application now includes a new Critter NPC implementation in the shared NPC module. This entity demonstrates how to combine collision detection and random movement behaviors, automatically switching between wandering when the player is not observed and approaching the player when within vision range.

example/lib/shared/npc/critter · high confidence

The Punnyworld example now includes new Tiled map files (compressed.tmj, embeded.tmj, pathfinding\_map.tmj, simple\_map.tmj) and an updated tileset definition (punyworld\_tileset.tsj). These assets provide pre-configured levels with specific layers for base terrain, decorations, and enemies, supporting features like pathfinding and object-based enemy placement within the example game.

example/assets/images/tiled/punnyworld · high confidence

The library now includes a custom QuadTree broadphase implementation to optimize collision detection when a game contains many collidable entities, particularly static ones like walls or platforms. This is exposed via the \CustomHasQuadTreeCollisionDetection\ mixin for \FlameGame\ and the \CustomQuadTreeCollisionDetection\ class, which replace the standard broadphase logic. Users can initialize this system by calling \initializeCollisionDetection\ with map dimensions and optional tuning parameters (max objects, max levels, minimum distance), allowing for potentially better performance in complex scenes compared to the default collision detection method.

_lib/collision/quad\tree · high confidence

The Solaria example now includes a new tilemap (\map.tmj\) and its associated tileset definition (\solaria\_tiles.tsj\). The map defines a 45x30 orthogonal grid with layers for base water, water, grass, and decoration, utilizing an 8x8 pixel tileset image (\solaria\_tiles.png\) containing 1680 tiles. This provides the visual data required to render the Solaria example scene.

example/assets/images/solaria · high confidence

Introduced the \SpritefusionWorldBuilder\ class in the \lib/map/spritefusion/builder\ directory, which enables the construction of game worlds from Spritefusion map data. This builder reads map definitions, loads associated tileset images, and generates the corresponding layer structures and game components, including support for custom object builders and collision detection based on map configuration.

lib/map/spritefusion/builder · high confidence

A new \WorldMapBySpritefusion\ class has been introduced to support loading maps generated by the Spritefusion tool. This component integrates with the Bonfire engine by utilizing \SpritefusionWorldBuilder\ to parse map data and register game components, enabling users to render Spritefusion-based maps within the game world.

lib/map/spritefusion · high confidence

The example app now includes two new pages demonstrating Tiled map integration: a local asset-based map view (TiledPage) and a network-loaded map view (TiledNetworkPage). Both pages configure the BonfireWidget with a joystick controller, a camera zoomed to fit 20 tiles, and a custom object builder that renders 'spikes' from the map data.

example/lib/pages/map/tiled · high confidence

New Tiled tileset definition files (0x72\_DungeonTilesetII\_v1.json and tileset1.8.tsj) have been added to the example assets. These files define a dungeon tileset created with Tiled 1.9.0, including specific tile configurations for collision detection via object groups and tile animations, providing the necessary data for rendering and physics in the example application.

example/assets/images/tiled/tileset · high confidence

The example now includes a Wizard NPC component that features a tap-to-interact gesture. When tapped, the camera animates to focus on the wizard and displays a multi-turn dialogue box (featuring a quote from Alice in Wonderland) using the game's TalkDialog system; the camera automatically returns to its previous zoom and position when the dialogue is closed.

example/lib/shared/npc/wizard · high confidence

The example application now includes a new character customization interface within the LPC mini-game. This update introduces a 'ButtonInterface' widget that provides an 'Edit Character' button, and a 'DialogCustomCharacter' widget that allows users to modify character appearance. Users can now select body types (Light, Brown, Skeleton, Orc), hair styles (Empty, Single, Curly, LongKNot, XLong), and toggle equipment slots (Helm, Chest, Leg, Gloves, Arms, Feet), with changes applied to the game sprite in real-time.

_example/lib/pages/mini\games/lpc/widgets · high confidence

The example app now includes two new input demonstration pages: one for handling drag gestures on game objects (using the \DragGesture\ mixin) and another for moving the camera via mouse or touch gestures (using the \MoveCameraUsingGesture\ mixin). These pages showcase how to integrate specific input behaviors into game decorations within the Bonfire framework.

_example/lib/pages/input/drag, example/lib/pages/input/move\_camera\mouse · high confidence

The example application now includes a new player controllers page that demonstrates how to configure multiple input methods for different players. It shows a setup where the primary player uses a directional joystick, while a second player is controlled via keyboard inputs (both arrow keys and WASD), illustrating the library's capability to handle concurrent player controllers within a single BonfireWidget instance.

_example/lib/pages/player\controllers · high confidence

The example/shaders directory now includes GLSL fragment shader source files: baseShader.frag provides a basic texture mapping effect, while waterShader.frag and waterShaderV2.frag implement water distortion effects using noise textures, time-based scrolling, and color mixing. These files serve as reference implementations for Flutter shader effects within the example project.

example/shaders · high confidence

The example application now includes a set of utility classes in the shared utilities folder to manage sprite animations for various game entities. New files define sprite sheets for the player (knight), enemies (goblin), NPCs (critter, wizard), and generic characters (person), providing pre-configured idle and run animations. Additionally, a common sprite sheet utility was added to load visual effects such as explosions, attack effects, and environmental items like chests, torches, and potions, simplifying asset management in the example.

example/lib/shared/util · high confidence

The example assets now include a new large map file (bigMap.json) created with Tiled, providing a more complex test case for map rendering and layer handling within the example application.

example/assets/images/tiled · high confidence

The example application now includes a dedicated lighting demonstration page. This page renders a map using the Bonfire engine with a dark ambient lighting overlay and registers a custom 'torch' map object. The torch is implemented as an animated game decoration that emits a pulsing, semi-transparent orange light, allowing users to see how dynamic lighting effects interact with game objects in the example.

example/lib/pages/lighting · high confidence

The example application now includes a new page demonstrating mouse input handling. This page renders a barrel component that visually displays real-time mouse screen position, click events (both on the component and the screen), and scroll delta, allowing users to see how mouse interactions are captured and reported within the game engine.

example/lib/pages/input/mouse · high confidence

The example app now includes a dedicated path-finding demo accessible via the '/path-finding' route. This page loads a specific Tiled map ('punnyworld/pathfinding\_map.tmj') and instantiates a HumanPathFinding player that mixes in the WithPathFinding capability. Users can tap anywhere on the screen to command the player to move to that position, with the path visualized using a stroke width of 2 and barrier detection configured to consider all barriers, not just visible ones.

_example/lib/pages/path\finding · high confidence

A new performance demonstration page has been added to the example app. It renders a game world using a Tiled map and configures a spawner to generate up to 100 enemy instances, allowing users to visually assess rendering performance. The page also includes a custom interface overlay that displays the current frame rate and the live count of active enemies.

example/lib/pages/performance · high confidence

The random map mini-game example now includes a new pirate player character. This addition introduces a \Pirate\ class that extends \SimplePlayer\ with collision handling, configured with a specific sprite sheet for idle and movement animations, a custom hitbox, and joystick-based movement (with diagonal movement disabled).

_example/lib/pages/mini\_games/random\map/player · high confidence

The example assets now include a complete set of tilemaps and tilesets for a platformer, featuring a parallax background map, a main platform map with enemy and gem object placements, and simpler test maps. The asset pack also introduces a props tileset and defines specific collectible items such as acceleration, linear, resistance, and bouncing gems within the level data.

example/assets/images/platform · high confidence

The example app now includes a new shader demonstration page that applies a fragment shader to the game map layer. This feature introduces a configuration panel allowing users to adjust visual parameters such as speed, distortion strength, opacity, light range, and tone/light colors in real-time. The implementation uses a dedicated controller to manage configuration state and a game component to bind the shader to the map layer, updating it dynamically as settings change.

example/lib/pages/shader · high confidence

The example app now includes a new 'simple player' demo located at /simple-player. This feature demonstrates a basic player setup using the HumanPlayer component, which supports movement via both a directional joystick and keyboard input. The example page configures the BonfireWidget with a specific tiled map, camera zoom settings, and a blue background to showcase this control scheme.

example/lib/pages/player/simple · high confidence

New Tiled map assets have been added to the example assets directory to support top-down game views. This includes a tileset definition (HouseTemplate\_Tileset.tsj) and two map files: a simple 10x10 orthogonal map (simple.tmj) featuring a tiled floor and border, and an infinite map structure (infinite\_map.tmj) that includes a floor layer and an object layer with column placements. These assets provide the visual data required for the new top-down and infinite world examples.

_example/assets/images/tiled/simple\topdown · high confidence

Introduces CameraParallax and CameraParallaxComponent to enable parallax layers that move in sync with the game camera's position. This allows background elements to scroll at varying speeds relative to camera movement, creating a depth effect in the game world.

lib/parallax · high confidence

The example directory has been initialized as a standard Flutter application, including the generation of essential configuration files such as .gitignore, .metadata, analysis\_options.yaml (including flutter\_lints), and devtools\_options.yaml. This provides a clean, properly configured starting point for users to explore the library's capabilities without manual setup.

example · high confidence

The example application has been initialized with a new entry point in \example/lib/main.dart\ that configures the app for landscape mode on non-web platforms and sets up the main material theme. Additionally, a new spritesheet utility class has been added for the platform mini-game, providing static accessors to load and sequence sprite animations for the player, enemies, and collectibles.

example/lib, example/lib/core · high confidence

The library now provides a structured enemy hierarchy starting with a base \Enemy\ class that extends \Npc\ and includes life management via the \WithLife\ mixin. This base class is extended by three specialized implementations: \SimpleEnemy\ for 2D movement with directional animations, \RotationEnemy\ for top-down perspective enemies with angle-based movement and sprite animation loading, and \PlatformEnemy\ which adds platformer-specific capabilities like collision detection and jumping mechanics with configurable jump counts.

lib/npc/enemy · high confidence

A new \WithForces\ mixin and \ForcesApi\ have been added to the \lib/forces\ directory, providing a simpler, more realistic physics system for \SimpleMovement\. This system allows developers to apply gravity, wind, friction, and air drag to game objects, with support for both local and global force settings. The API includes methods to configure mass, drag coefficients, and custom forces, enabling more nuanced control over object movement and interaction with environmental factors.

lib/forces · high confidence

Added a new background rendering system in the \lib/background\ directory, consisting of a \GameBackground\ base class and a \BackgroundImageGame\ component. This allows developers to define parallax images as backgrounds that automatically adjust their position based on the camera's movement and zoom level, supporting configurable offsets, scaling factors, and layer priorities.

lib/background · high confidence

Adds a new turn-based game experience built on the Bonfire engine, featuring a grid-based map with collision detection and pathfinding. Players control ally characters (Hero, Knight) and face enemy characters (Necromancer, Ghost), each with distinct melee and ranged attack capabilities. The game enforces a turn structure where each side can perform a limited number of actions before switching turns, with a UI overlay indicating the current turn and action count, and a win/lose condition triggered when one side is defeated.

_awesome/turn\game · high confidence

A new MapNavigator widget and its supporting controller/provider have been added to the library, enabling applications to switch between different game maps with animated transitions. The MapNavigator widget accepts a map of named map builders and an initial map, managing state via a MapNavigatorController that exposes methods like toNamed and toMap for programmatic navigation. The implementation uses an AnimatedSwitcher to handle visual transitions between maps, with configurable duration and curve, and properly disposes of the controller to prevent resource leaks.

_lib/widgets/map\navigator · high confidence

The lib/player module now provides distinct player implementations to support different gameplay styles. PlatformPlayer adds platformer-specific jumping logic (with configurable jump counts) and dedicated animation replacement for platform sprites. RotationPlayer supports 360-degree movement via joystick angle and handles idle/run sprite transitions. SimplePlayer offers a basic top-down movement model with directional animations. A base Player class consolidates life, vision, and joystick movement capabilities shared across these types.

lib/player · high confidence

The lib/widgets directory now features BonfireWidget, a new Flutter StatefulWidget that serves as the primary integration point for the Bonfire engine. This widget accepts configuration for player controllers, game maps, UI interfaces, and visual settings such as background color and camera configuration. It abstracts the underlying game initialization by supporting both default and quad-tree collision strategies via BonfireCollisionConfig, and exposes lifecycle callbacks like onReady and onDispose to manage game state and overlays.

lib/widgets · high confidence

The lib/scene\_builder library now provides a system for executing scripted sequences of actions within the game. This includes a base SceneAction interface for defining custom behaviors, a SceneBuilderComponent that manages the execution flow of an ordered list of actions, and a set of pre-built action types (such as await, callback, camera control, delay, and movement) exported for immediate use. Users can now attach this component to their game to trigger complex, time-based event chains.

_lib/scene\builder · high confidence

The multi-scenario mini-game now allows players to move between different map biomes. A new \maps.dart\ file defines the available maps (biome1, biome2) and configures map sensors that handle transitions, passing player position and direction to the next area. The \MultiScenario\ widget has been updated to use \MapNavigator\, which manages the switching between these maps and renders the \BonfireWidget\ with the appropriate map and player state for each scenario.

_example/lib/pages/mini\_games/multi\scenario · high confidence

The library now includes \GameDecoration\ and \GameDecorationWithCollision\ classes, allowing developers to add static or animated visual elements (like barrels or NPCs) to the game scene. \GameDecoration\ supports both static sprites and animations, while \GameDecorationWithCollision\ extends this to include optional shape hitboxes for map construction, such as those generated from Tiled maps.

lib/decoration · high confidence

The \lib/game\_interface\ directory now introduces a dedicated hierarchy for rendering Heads-Up Display (HUD) elements such as life bars, stamina indicators, and settings. \GameInterface\ acts as the root container with high rendering priority, managing the lifecycle of child components. \InterfaceComponent\ provides a base class for interactive UI elements, supporting sprite-based visuals (with selected/unselected states) and tap gesture handling. \TextInterfaceComponent\ extends this to render dynamic text labels, automatically calculating its size based on the text content. This structure allows developers to easily add and manage interactive UI overlays within the game.

_lib/game\interface · high confidence

The example now includes a Goblin enemy class that demonstrates the new behavior system. It uses mixins for collision, life bars, and random movement, and implements a behavior tree to switch between chasing the player, attacking at range (fireball), attacking in melee, and wandering randomly based on vision radius and game state.

example/lib/shared/enemy · high confidence

The \lib/joystick\ directory now contains a complete, new implementation of the game's joystick input handling, replacing previous versions. This includes \Joystick\ as the central controller, \JoystickDirectional\ for the main movement stick (supporting configurable size, alignment, and diagonal input), \JoystickAction\ for customizable button-like actions (supporting sprites, colors, and margins), and \JoystickMapExplorer\ to link joystick events to camera movement. Users will now interact with the game using this new, more flexible and configurable joystick system.

lib/joystick · high confidence

The example now includes a new Knight player character that supports both melee and ranged (fireball) attacks, with stamina management and a vision system that triggers a conversation dialog when an enemy is spotted. The fireball attack consumes stamina and projects a projectile with lighting effects, while the dialogue system pauses the game engine and displays a talk dialog with styled text and character sprites.

example/lib/shared/player · high confidence

Added a new mini-game example in the \lpc\ directory that demonstrates the Bonfire engine's player and animation capabilities. The example includes a \LPCGame\ widget configured with a joystick controller and a tiled map, alongside an \LPCPlayer\ entity that supports dynamic sprite composition. A key feature is the \CustomStatus\ system, which allows users to customize the player character's appearance (body type, hair, and equipment slots like helm, chest, and gloves) by compositing individual image assets into a single sprite sheet at runtime.

_example/lib/pages/mini\games/lpc · high confidence

Added a new \TalkDialog\ utility in \lib/util/talk\ that displays animated, typewriter-style dialogue using \Say\ objects. The dialog supports customizable text styling, character animation speed, background/person widgets, and alignment. It can be dismissed via tap or specific keyboard keys, and includes options for safe area usage and root navigator control.

lib/util/talk · high confidence

The \lib/map/tiled/model\ directory now includes four new model classes: \TiledDataObjectCollision\ for storing collision shapes and types, \TiledItemTileSet\ for tile-specific attributes like animations and flips, \TiledObjectProperties\ for object metadata and hitboxes, and \WorldBuildData\ which aggregates the map, game components, and specific \mapChildren\ for correct layer ordering. These classes provide the underlying data structures for parsing Tiled map elements and managing their rendering and collision properties within the game engine.

lib/map/tiled/model · high confidence

Added a new TiledWorldBuilder class that parses Tiled map data to construct game worlds. It supports orthogonal orientation maps and processes tile, object, and image layers, including handling layer types like 'above' and 'layered', dynamic tiles, and oversized tiles with bottom-left anchoring. The builder also allows registering custom object builders and supports rebuilding only object layers for infinite map scenarios.

lib/map/tiled/builder · high confidence

A new TypeWriter widget has been added to the library, enabling text to appear character-by-character with a configurable speed. It supports rich text styling via TextSpan, handles text alignment, directionality, and overflow, and allows users to specify a callback when the animation completes or to skip to the end immediately.

lib/widgets/typewriter · high confidence

The \lib/behavior/behaviors\ directory now includes a comprehensive set of behavior classes to compose game logic. Structural primitives include \BList\ (sequential execution), \BParallel\ (concurrent execution), and \BSelector\ (priority-based selection). Execution control is handled by \BOnce\ (one-shot actions), \BInterval\ (periodic execution), \BCondition\ (conditional branching), \BAction\ (custom callbacks), and \BCustom\ (generic boolean logic). AI-specific behaviors include \BCanSee\ and \BCanSeeType\ (vision checks), \BMoveToComponent\ (targeted movement), \BRandomMovement\ (patrol logic), \BSeeAndMoveToTarget\ (chase/close behavior), and \BSeeAndPositioned\ (maintaining distance).

lib/behavior/behaviors · high confidence

The example application now includes a dedicated collision page that demonstrates the updated physics engine. Tapping the screen spawns a collision component (circle or rectangle) configured with realistic elastic collision properties, including a bounciness of 0.85 and a minimum bounce velocity of 20.0. The component also utilizes the new force system with low friction (0.05), minimal drag (0.01), and moderate gravity (400), providing a more physically accurate interaction model for users testing collision behaviors.

example/lib/pages/collision · high confidence

Introduces a new behavior system that allows game components to define AI logic declaratively using a sequence of behaviors instead of imperative update loops. The system includes a base \Behavior\ class, a \BehaviorManager\ to handle frame-by-frame execution and sequencing, and a \UseBehavior\ mixin that integrates this manager into \GameComponent\s, enabling features like pausing, resuming, and runtime updates of behavior lists.

lib/behavior · high confidence

The \lib/util/direction\_animations\ directory now contains a new set of utilities for managing character animations. This includes \SimpleDirectionAnimation\ and \PlatformAnimations\ classes that support 8-directional movement (idle/run in all 8 directions) and optional jump animations. The system introduces \RenderTransformWrapper\ to handle canvas transformations like flipping and center adjustment, allowing for more flexible sprite rendering. A new \SimpleAnimationEnum\ defines the available animation states. This change provides a more robust foundation for character movement and animation compared to the previous implementation.

_lib/util/direction\animations · high confidence

A new elastic collision system has been introduced for game components, providing a simpler and more predictable alternative to the previous implementation. By mixing in \WithElasticCollision\, components gain realistic bounce behavior controlled by restitution (bounciness) and minimum velocity thresholds. The system includes an API for custom bounce callbacks and convenient extension methods to quickly apply preset behaviors such as rubber ball, basketball, or eternal bounce effects.

lib/collision/elastic · high confidence

The example application now includes a dedicated enemy demonstration page that showcases two distinct enemy types: a melee enemy that moves toward and attacks the player at close range, and a ranged enemy that maintains distance while attacking. These enemies utilize declarative AI behaviors (BSeeAndMoveToTarget and BSeeAndPositioned) from the Bonfire engine, featuring visual indicators like attack strokes and text labels, and are integrated into the app's navigation via a new route.

example/lib/pages/enemy · high confidence

The library now includes a new geometry module featuring \CircleShape\, \RectangleShape\, and \PolygonShape\ classes that extend a common \Shape\ base. These shapes support position updates and rendering via the Flame engine. Additionally, a \ShapeCollision\ class has been introduced to handle collision detection between these different shape types, implementing algorithms for rectangle-rectangle, circle-circle, rectangle-circle, rectangle-polygon, circle-polygon, and polygon-polygon interactions.

lib/geometry · high confidence

The \lib/input/gestures\ directory now includes a new set of gesture-handling mixins (\DragGesture\, \TapGesture\, \PinchGesture\, and \MoveCameraUsingGesture\) along with a \GestureEvent\ helper class. These additions allow game components to easily handle user interactions such as dragging objects, tapping UI elements, performing pinch-to-zoom gestures, and panning the camera via touch or mouse input, providing a structured way to manage pointer events within the game world and HUD.

lib/input/gestures · high confidence

The example application now includes dedicated UI components to display and manage player health and stamina. A new \BarLifeInterface\ renders visual bars for life (with color-coded feedback) and stamina, driven by a singleton \BarLifeController\ that manages state and notifications. A corresponding \BarLifeWidget\ provides a text-based overlay of current and maximum values. These are integrated into the \KnightInterface\, which also demonstrates new scene action capabilities, such as cinematic camera movements and enemy control switching.

example/lib/shared/interface · high confidence

The map system now supports infinite world maps that dynamically load and render tiles based on the camera's position and zoom level. A new \EmptyWorldMap\ class provides a minimal map implementation, while the \WorldMap\ class manages tile visibility using a quadtree and updates rendered tiles only when the camera moves or zoom changes, eliminating jank during navigation.

lib/map · high confidence

Added six new decoration components for the example game: BarrelDraggable (a draggable barrel with physics and text), Chest (an interactive chest that detects nearby players and dispenses potions), ColumnDecoration (a static obstacle with collision), PotionLife (a floating health item that heals players on contact), Spikes (a hazard that damages entities on contact), and Torch (a lighting source with animated flame and pulse effects).

example/lib/shared/decoration · high confidence

The example app now includes a new page demonstrating keyboard input handling within the game engine. This page renders a tiled map and places a barrel decoration that listens for keyboard events, displaying the typed characters in real-time on the screen.

_example/lib/pages/input/keyboard, example/lib/pages/map/terrain\builder · high confidence

Added a new keyboard input system (\lib/input/keyboard\) that allows players to control game characters using keyboard keys. The system includes a \Keyboard\ controller class that processes directional (WASD/arrows) and action key events, supporting diagonal movement when enabled. Configuration is handled via \KeyboardConfig\, which lets users enable/disable keyboard input, specify accepted keys, and choose between arrow keys, WASD, or both for directional controls. A \KeyboardEventListener\ mixin is provided for game components to receive and handle keyboard events.

lib/input/keyboard · high confidence

The \lib/lighting\ directory now contains a complete lighting subsystem, introducing \LightingComponent\ as the layer responsible for rendering light effects, \WithLighting\ as a mixin for game components to expose lighting capabilities, and \LightingApi\ to manage per-component light configuration. Users can now define circular or arc-shaped lights with customizable colors, radii, blur borders, and pulsing animations via \LightingConfig\, allowing for dynamic lighting interactions within the game world.

lib/lighting · high confidence

Added a new example page (\GameManualMap\) demonstrating a dungeon map setup in the Bonfire engine. This example features a procedurally generated tile-based map with walls, floors, and decorations (barrels, chests, spikes, torches), along with enemy spawning logic via a custom controller. It showcases manual control configuration by combining a directional joystick with action buttons and a keyboard input handler (spacebar for attack) within the \BonfireWidget\.

_example/lib/pages/mini\_games/manual\map · high confidence

Added a set of new utility classes in lib/map/util to support map rendering and asset handling. This includes MapAssetsManager for caching and loading sprites and animations, LayerMapper and MapLayerMapper for converting map data into game components, ServerImageLoader for fetching and caching images from remote URLs, and WorldMapReader as a factory for reading Tiled and Spritefusion map formats from assets or network sources.

lib/map/util · high confidence

Introduces a new \MatrixMapGenerator\ and associated classes (\MatrixLayer\, \TerrainBuilder\, \MapTerrain\) in the \lib/map/matrix\_map\ directory, enabling the creation of tile maps from 2D numeric matrices. This system supports axis inversion for easier array visualization, automatic sprite selection from sprite sheets based on tile adjacency (corners, edges, centers), and configurable collision hitboxes per terrain type.

_lib/map/matrix\map · high confidence

The library now exposes a comprehensive input handling module that adds support for mouse gestures (hover, scroll, and click events via the new MouseEventListener mixin), unified pointer event propagation through a new PointerDetector mixin, and a structured PlayerController system for managing joystick directions and action events. This change also introduces dedicated gesture handling for drag, pinch, and tap interactions, providing a more granular and extensible foundation for user input in the game engine.

lib/input · high confidence

The multi-scenario mini-game now includes a dedicated GamePlayer component that handles joystick-based movement intensity and defines a specific rectangular hitbox for collision detection. Additionally, a MapSensor component has been added to enable seamless navigation between game maps; when a player enters the sensor's area, the game automatically transitions to the target map while preserving the player's position and facing direction.

_example/lib/pages/mini\_games/multi\scenario/components · high confidence

The mini-games section now includes a new 'Random Map' example that procedurally generates a game world using Perlin noise. This example introduces a map generator that creates terrain tiles (water, sand, grass) and places decorative elements like trees, alongside a dedicated noise generator to handle the procedural data. The example game widget integrates these components to display the generated map within the Bonfire engine, demonstrating how to use player controllers and camera configurations with dynamically created game maps.

_example/lib/pages/mini\_games/random\map · high confidence

Added six new action classes to the scene builder system to support complex game sequences: AwaitSceneAction for waiting on async operations, CallbackSceneAction for executing code until a completion callback is triggered, CameraSceneAction for animating camera movements to positions or targets, DelaySceneAction for pausing sequences, MoveToPositionSceneAction for moving game components to specific coordinates, and MoveWhileSceneAction for continuous movement based on runtime conditions.

_lib/scene\builder/actions · high confidence

The example app now includes a new mini-game demo located at \example/lib/pages/mini\_games/simple\_example\. This demo introduces a \SimpleExampleGame\ widget that configures a \BonfireWidget\ with a joystick-controlled player (\MyPlayer\), enemies (\MyEnemy\) that utilize random movement and collision, and a Tiled map (\mapa2.json\) featuring object spawning for health potions and draggable barrels. The entry point demonstrates how to wire together player controllers, map objects, and game components in a single, self-contained example.

_example/lib/pages/mini\_games/simple\example · high confidence

The example application now includes a new \GameTiledMap\ widget that demonstrates rendering a Tiled map with interactive game objects (goblins, torches, barrels, spikes, columns, chests, critters, and wizards). This example introduces support for multiple player controllers, allowing users to control the character via either an on-screen joystick (with melee and range attack actions) or a keyboard (using arrow keys, WASD, and spacebar). The game features a dark lighting overlay and a health bar interface, providing a complete playable demo for the Bonfire engine's tiled map capabilities.

_example/lib/pages/mini\_games/tiled\map · high confidence

Added a new top-down game example that demonstrates a player-controlled soldier with directional melee attacks, zombie enemies with random movement and vision-based AI, and interactive furniture (armchairs) that can be pushed using physics forces. The example also showcases integrated lighting effects, collision handling, and joystick-based input controls within the Bonfire engine.

_example/lib/pages/mini\_games/top\_down\game · high confidence

This release introduces a comprehensive set of new utility classes in the lib/util directory to support game development. Key additions include BarLifeComponent for rendering customizable health bars, DamageHitbox for managing damage-over-time and collision-based attacks, and FollowerWidget for overlaying Flutter UI elements that track in-game entities. The update also adds ComponentSpawner for periodic entity generation, QuadTree for efficient spatial queries, and various helper utilities such as BonfireUtil for angle/direction math, IntervalTick for timed events, and ValueGeneratorComponent for animated value transitions. These components provide foundational tools for building game mechanics, UI overlays, and performance-optimized spatial logic.

lib/util · high confidence

The multi-scenario mini-games example now includes dedicated utility files to manage game configuration. A new constants file defines the default tile size (32.0) and provides asset paths for two map biomes, while a new enum explicitly lists the available biome identifiers (none, biome1, biome2). These additions standardize how map data and asset references are handled within this specific example location.

_example/lib/pages/mini\_games/multi\scenario/utils · high confidence

Added a new set of utility extensions in lib/util/extensions to simplify common operations. ColorExtensions allows setting opacity on colors. RectExt provides methods for vector conversion, overlap detection, and inflation/deflation. SpriteFutureExt and FutureSpriteAnimationExt enable converting futures of sprites or animations into widgets. ImageExtensions adds methods to create sprite animations, get sprites, overlap images, and flip animations. Joystick extensions provide radial angle calculations for directional events. MovementExtensions introduces methods for moving towards targets, keeping distance, and positioning while maintaining distance, with support for axis restriction. IntIntExtensions helps with neighbor checks for coordinate pairs. PositionComponentExt simplifies accessing left, right, top, and bottom properties. ViewportExt provides a unified way to get the scale from different viewport types.

lib/util/extensions · high confidence

Users can now load maps that repeat infinitely in any direction using the new \WorldMapInfiniteByTiled\ component, which treats a small Tiled map as a repeating pattern and manages chunk loading/unloading to keep memory bounded. Additionally, the \WorldMapByTiled\ component now respects the \type=below\ layer flag to correctly handle Tiled layer ordering, ensuring decorations and objects are rendered with the correct priority relative to tile layers.

lib/map/tiled · high confidence

Users can now load Spritefusion-style maps using two new reader implementations: \SpritefusionAssetReader\ for loading map data from local application assets, and \SpritefusionNetworkReader\ for fetching maps from remote URLs with optional HTTP headers and caching support. These readers integrate with the existing \WorldMapReader\ interface to provide a unified way to access map data regardless of its source.

lib/map/spritefusion/reader · high confidence

Users can now load Tiled map data from remote HTTP/HTTPS sources, not just local assets. The new TiledNetworkReader fetches map JSON, tilesets, and layer images from a specified URI, caching them in memory and supporting orthogonal orientation. It also allows passing custom HTTP headers for authentication or other network requirements.

lib/map/tiled/reader · high confidence

The engine has been refactored to use a new mixin-based architecture (e.g., \WithLife\, \WithJumper\, \WithAttack\) that replaces the previous component-based approach. This change introduces dedicated API objects (such as \LifeApi\ and \JumperApi\) for managing game logic, adds new capabilities like A\* pathfinding (\WithPathFinding\) and per-cell movement (\WithMovePerCell\), and standardizes naming conventions with \With\ prefixes for all mixins.

lib/mixins · high confidence

Bonfire 4.0 introduces a major API restructuring to improve developer experience. Most mixins (e.g., Jumper, Sensor, PathFinding, Attack) now follow an API-first pattern, exposing functionality through named objects (e.g., \jumper.jump()\) instead of polluting the component namespace. The \Movement\ mixin is rewritten to be velocity-based and simplified, with several legacy members removed. Additionally, collision is now event-driven via \WithCollision\, and a new behavior tree system is introduced. The library also upgrades to Flame ^1.38.0.

(repo-wide) · high confidence

The lib/bonfire.dart entry point has been completely rewritten to replace the previous placeholder Calculator class with a full suite of exports. This change exposes the library's core modules, including game components, mixins (such as movement, collision, life, and vision), input handling, camera controls, map systems (Tiled, SpriteFusion, Matrix), and UI widgets. It also re-exports key Flame packages (collisions, components, effects, geometry, etc.) to simplify dependency management for consumers, effectively establishing the public API surface for the Bonfire engine.

lib · high confidence

The camera system has been replaced with a new \BonfireCamera\ implementation that extends Flame's \CameraComponent\. This change introduces a dedicated \CameraConfig\ class allowing users to configure movement windows, map area constraints, zoom, angle, and follow speed. The new camera supports animated transitions for position, zoom, and angle, as well as a shake effect for visual feedback. It also includes a custom follow behavior that respects the configured movement window to prevent jittery camera movement.

lib/camera · high confidence

The example application now includes a structured navigation drawer (home\_drawer.dart) that displays a version header and a list of collapsible sections. Each section can be expanded or collapsed with an animation, and selecting an item within a section triggers a callback and closes the drawer. This replaces the previous drawer implementation with a new widget hierarchy (HomeDrawer, SectionDrawerWidget, ItemDrawerWidget) that supports grouped navigation items.

example/lib/pages/home/widgets/drawer · high confidence

The lib/objects area introduces a new base GameObject class and specialized components including AnimatedGameObject, FollowerGameObject, AnimatedFollowerGameObject, and FlyingAttackGameObject. FlyingAttackGameObject now uses angle-based movement and destruction logic, applies damage via the WithLife mixin's handleAttack method, and prevents collision destruction when colliding with WithSensor components. The lifecycle callback onDestroy is now correctly invoked only when the object is actually being removed.

lib/objects · high confidence

The collision handling in lib/collision has been restructured to introduce a new BodyType enum (dynamic and static) and a dedicated CollisionApi class. This change replaces the previous SimpleElasticCollision approach with a more explicit WithCollision mixin and a robust collision resolution system that supports custom callbacks for blocking movement, handling blocked events, and resolving velocity reflections. Users will now interact with a clearer API for managing collision states and behaviors, with static bodies preventing movement and dynamic bodies reflecting velocity upon impact.

lib/collision · high confidence

The core game engine in lib/base has been restructured to improve performance and configurability. The new BaseGame class now uses a reusable list to collect gesture-handling components during the update loop, reducing per-frame allocations, and explicitly manages pointer and keyboard event dispatching. A new BonfireCollisionConfig system allows users to choose between a default collision detection setup and a QuadTree-based broadphase via BonfireQuadTreeCollision or BonfireWithCollision, enabling better performance for complex scenes. Additionally, the engine now supports configurable background colors and integrates lighting and color filter components directly into the camera viewport's HUD layer.

lib/base · high confidence

The map rendering and collision logic in lib/map/base has been restructured around new base classes: GameMap, Layer, Tile, TileComponent, TileLayerComponent, and TileWithCollision. TileComponent now handles sprite and animation rendering with bleeding-pixel correction, while TileWithCollision adds ShapeHitbox support for interactive tiles. TileLayerComponent manages tile visibility and performance via a QuadTree, supporting dynamic chunk loading for infinite maps. GameMap provides a unified interface for layer management, map bounds, and rendering priority, with specific support for infinite worlds and camera movement constraints.

lib/map/base · high confidence

The tree decoration component in the random map mini-game now includes a solid rectangular hitbox, ensuring that players cannot walk through the tree. This change fixes collision detection issues where the tree previously allowed passage, improving the physical interaction within the game world.

_example/lib/pages/mini\_games/random\map/decoration · high confidence

Added initial widget test file; Added test helpers for Bonfire game components; Initial test suite for core game mechanics.

The Bonfire package has been updated to version 4.0.0, requiring Dart SDK \>=3.4.0 and Flutter \>=3.22.0. The core dependency on the Flame game engine has been bumped to version 1.38.2, and the \a\_star\_algorithm\ dependency has been added at version 0.4.1. The \http\ dependency is now explicitly set to ^1.6.0, and the development linting tool has switched from \flutter\_lints\ to \flame\_lint\ version 1.2.1. Additionally, the package metadata has been updated with a new description, homepage, repository URL, and issue tracker link.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 67.

• Code Health 90
• Architecture 96
• Maturity 59
• Readiness 62
• Security 75
• Domain Modelling 100

• 300 commits — 260 feature/other, 40 fixes

• (root) — 80 commits
• (repo) — 46 commits
• lib/mixins — 42 commits
• example/lib — 32 commits
• .github/workflows — 11 commits
• lib/util — 11 commits
• awesome/README.md — 10 commits
• lib/map — 10 commits
• lib/base — 6 commits
• lib/behavior — 6 commits
• lib/objects — 6 commits
• games/README.md — 5 commits
• awesome/flappy_bird — 4 commits
• awesome/platform_game — 4 commits
• games/flappy_bird — 3 commits
• lib/collision — 3 commits
• awesome/turn_game — 2 commits
• example/.metadata — 2 commits
• example/android — 2 commits
• example/pubspec.lock — 2 commits

• fix: Fix #577
• fix: Fix minimap issues with non-1.0 zoom
• fix: Merge pull request #601 from juarezfranco/bugfix/tiled-oversized-and-layer-order
• fix: Merge pull request #607 from RafaelBarbosatec/revert-606-master
• fix: Merge pull request #608 from RafaelBarbosatec/revert-607-revert-606-master
• fix: Merge pull request #609 from RafaelBarbosatec/copilot/revert-merge-v4-0-0
• fix: Merge pull request #619 from RafaelBarbosatec/fix/v4-collision-bug-tests-migration
• fix: Revert "Merge branch 'v4.0.0' into master"
• fix: Revert "Revert "update""
• fix: Revert "update"
• fix: bump version to 4.0.0-beta.5, fix issue 592, and enhance path finding with area consideration
• fix: chore: fix
• fix: chore: fix imports
• fix: chore: fix lint
• fix: chore: fix lint
• fix: chore: fix onGameMounted
• fix: chore: fix size barlife
• fix: chore: some fix
• fix: chore: update changelog and version to 3.13.5, fix padding in BarLifeComponent
• fix: fix some lint
• …and 280 more

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

RafaelBarbosatec/bonfire 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.