Skip to content
Bit Quirky Behavior Trees and
State Machines

Search documentation

All topics and APIs

Close returns focus to Search.

What are you looking for?

Try a common topic or enter a complete API identifier.

Browse the reference instead

Esc closes · Tab reaches results · Enter opens the focused link

v0.11.0
Menu

Release notes

What changed in the package, grouped by the part of the product it touches, with the date each change landed.

Package io.bitquirky.behavior is at 0.11.0, and everything on this page is in it. Dates are the day the change landed, newest first inside each group. The package’s own CHANGELOG.md carries the same history in date order with the engineering detail.

Changing versions? Upgrading has the order of operations.

  • 2026-10-19: Typing the name a node type shows, such as member condition or event condition, into the add-node search finds it.
  • 2026-09-22: Keyboard focus stays on the control you were using when an edit rebuilds the inspector, so arrowing a Repeat policy or tabbing off Count no longer leaves the rail with nothing focused.
  • 2026-09-21: Every explanatory line on the member binding rail fits on one line, and every text field on it uses the product’s dark field chrome.
  • 2026-09-18: A disabled node’s card draws its dashed frame, which a malformed style rule had been suppressing.
  • 2026-09-10: A dragged branch lands where the append preview said it would, and a decorator drag gives quiet feedback instead of repainting the row.
  • 2026-09-10: The inspector follows your selection, so selecting a node shows that node, and a decorator selection clears cleanly.
  • 2026-09-10: Toolbar search and node navigation work as one gesture: find a node, press Enter, land on it centered.
  • 2026-09-01: A created child appends at the end of its row, and the add-child action appears on hover instead of taking permanent canvas space.
  • 2026-08-28: Nodes place freely. Horizontal position sets sibling order, wires share one bus, and the first placement freezes the picture so a later reflow cannot rearrange your graph.
  • 2026-08-28: Every reorder path keeps the picture and the execution order identical, and a drop changes the graph rather than only its drawing.
  • 2026-08-27: Rename a node where its name is shown: click the name on the identity header at the top of the rail, or press F2.
  • 2026-08-25: Insert actions use one deterministic wire anchor, so the button stops sliding away from the pointer.
  • 2026-08-03: Static mode moves an existing branch or decorator by dragging it, preserving authored identity.
  • 2026-10-23: Live reads a running graph’s struct, list, array, and Unity object reference values in the Live values rows and the Live Blackboard panel, where they used to read (unavailable). A struct reads its public fields and public auto-properties in declaration order, a list or array its element count and first three elements, such as 5 elements · [1.5, 2, 4, …] (1 element for one), with every element in the row’s tooltip, a reference car-cpu-1 (Rigidbody), none, or missing (Rigidbody), and any other object its type, such as (RouteNote), the same reading a Live member card’s Current now gives. No reading runs your getters or ToString. A value that cannot be read states why, such as (type not loaded), and every non-value reads in the quieter ink.
  • 2026-10-20: A running instance’s own graph-held values get writable rows in the rail’s own Live values section on both the GameObject and the entity host, grouped TASK for a node’s authored comparison constant, BLACKBOARD for a field a node holds write access to (locked when its type has no live editor), and HOST OWNED, collapsed, for every value no node writes. A Task or State edit states the authored value it replaced and outranks the baked constant until the instance resets, never touching the saved graph; a Blackboard edit writes the instance’s own storage until the next graph or game write. A State’s own min_active_seconds gets the same treatment on the State Machine window’s own STATE group.
  • 2026-09-27: A graph that binds an explicit shared numeric source leads the Blackboard panel and the Live rail’s Blackboard values section with one SHARED card, distinct from the private rows beneath it, editable on both the GameObject and entity host and refreshed by an outside edit or a new-run reset.
  • 2026-09-26: A node missing declared read or write access to a blackboard value is refused with the exact node and value it names, and its refusal card now offers a one-click grant read access / grant write access repair, add-only and undoable.
  • 2026-09-16: The Blackboard panel collapses, maximizes, restores, and fills the rail width while it does it.
  • 2026-09-03: Declaring a variable starts with its name, then its type as the next step. A Component variable is declared holding the None it must hold, and the field explains itself on hover.
  • 2026-09-02: The blackboard is one graph-wide band beneath both editor rails, and every type selector orders its search by relevance.
  • 2026-07-28: Dictionaries get a real entry editor, one editor per shape at rail width in both graph windows.
  • 2026-07-28: Declared lists and arrays run on the entity path when their whole element shape is representable.
  • 2026-07-27: Editing a blackboard variable is one undo step, and member roles offer only the variables that fit them.
  • 2026-07-26: Managed blackboard values generate exact typed companions, so your own classes reach a graph without hand-written glue.
  • 2026-07-25: Blackboard variables store the value shapes your game already uses.
  • 2026-10-23: A member card’s outcome row spells equality = true and ≠ 0, the way its call line and the rail’s Operator choice do, instead of == and !=. Transition pills keep == and !=.
  • 2026-10-20: A Live edit typed into a surfaced indexed property binding’s Current row reaches exactly the entry its index arguments address. The edit used to hand the generated setter the typed value where the index belonged, so the setter threw and the card showed nothing.
  • 2026-10-19: A new member condition on a bool member starts as = true, so it saves without a fix, instead of starting with an empty value that blocked Save while its toggle read false.
  • 2026-10-19: While the game runs, a Reference target names the Agent running the graph and shows its current Object read-only, both in Live and in Static. Choosing a target type in Play Mode no longer throws.
  • 2026-09-23: An indexer binds on the entity path when its accessor forwards to one stored unmanaged container, a FixedList, a FixedString, or a fixed buffer, with a public Length or Count to bounds-check against. The entity picker names the reason when it refuses one.
  • 2026-09-22: A C# indexer such as this[int] is a bindable property: pick its exact signature, give each index a Constant or Blackboard value of the exact type, and read, write, bind two-way, or test one entry. A direction the declaration cannot serve is blocked with Choose Read, Choose Write, or Change property on offer. Dungeon Heist’s Guard_2 binds PatrolRoute.this[int] to tune one waypoint’s pause.
  • 2026-09-22: A ref parameter that writes back to its own Read variable reads Same variable, and choosing the Read variable as the destination keeps the two linked.
  • 2026-09-22: Binding one argument to a project value keeps the node’s own member on its card, so its remaining arguments stay authorable.
  • 2026-09-21: A void ref condition names the parameter it tests. The Comparison card’s Tested value row lists every ref parameter, a method with exactly one fills it in, and validation blocks a condition that names none. The picker says which parameter a void method would test, and rules out one with no ref parameter.
  • 2026-09-18: A member card keeps its content when an edit remounts its view, so binding an argument or ref parameter to a blackboard variable no longer leaves a bare card.
  • 2026-09-17: Changing where an argument gets its value keeps the graph valid. The old projected value is removed only when nothing else reads it, and undo restores the choice with its ownership.
  • 2026-09-14: Output destination fields line up with the arguments they belong to.
  • 2026-09-12: Racing Line’s CpuRace graph binds a private method end to end, passing four arguments in and connecting the returned context to the next node’s input.
  • 2026-08-15: Indexed properties keep one exact ordered identity from the graph file through to the generated call.
  • 2026-08-12: A params parameter takes individually authored values, an existing array, or an existing list, and it saves before you have chosen which.
  • 2026-08-10: ref parameter methods bind directly, with one linked read and write row, and work as member conditions, including a void method that adjusts a value in place.
  • 2026-08-07: Output-only parameters bake and execute through a real destination or fail closed.
  • 2026-08-05: A single non-public field opts in beside the other member kinds, without widening its declaring type.
  • 2026-08-03: Optional parameters keep their compile-time defaults instead of asking you to retype them.
  • 2026-07-31: Generic methods become selectable with constrained type recovery, close into ordinary authoring, and run through the same direct-call path as everything else.
  • 2026-07-24: Existing developer APIs bind without behavior-specific wrappers.
  • 2026-10-20: A Utility Selector branch whose first child refuses on the very evaluation it is chosen falls back to the next-highest score, where it used to be chosen again forever, and a NaN or infinite branch score faults that one agent instead of winning the comparison.
  • 2026-10-19: A tree evaluates on every timed tick, even when several ticks share one frame number: a GameObject agent in FixedUpdate during a slow render frame, or an entity system in FixedStepSimulationSystemGroup that passes Time.frameCount. After a Repeat restarted, the later ticks used to skip evaluation, so a moving agent overshot its target. A Time Limit now counts every one of those ticks’ time instead of only the first, so it no longer runs long.
  • 2026-09-30: Utility Selector scores every branch from live numbers and runs whichever one currently scores highest. Each branch takes one to eight CONSIDERATIONS, read directly or through a curve, combined by an AGGREGATION, with Finish first or Interrupt as its EXECUTION MODE, all authored in the editor with no C# to write.
  • 2026-08-09: Reactive interruption works from a member-backed condition, and a Repeat no longer skips its restart on a zero-length frame.
  • 2026-08-05: A Random Selector can end its pass without running a child, through Direct failure.
  • 2026-08-02: Random Selector is authorable branch by branch, weight by weight.
  • 2026-07-31: Repeat’s end policies are fully authorable, and their runtime contract is complete.
  • 2026-07-18: Self abort scope, the Conditional decorator, and until-failure repetition arrive together.
  • 2026-07-16: Reactive Lower Priority interruption and deterministic weighted selection arrive.
  • 2026-07-14: Visual behavior tree authoring with GameObject execution: the first release anyone could use.
  • 2026-10-23: A State’s min_active_seconds is set in Static: select a plain State and type seconds into its Minimum active time card’s minimum active seconds field. The edit is one undo step, saves into the State’s own parameters, and 0 removes the parameter. States and lifecycle has the walkthrough.
  • 2026-10-20: A State can author its own min_active_seconds, a minimum duration that gates its own outgoing transitions until it elapses since the state became active. Absent or 0 leaves transitions ungated; authored in the graph file’s own text, read and tuned on a running instance through the State Machine window’s Live values section.
  • 2026-10-19: A state’s hosted Repeat tree runs one cycle, and a Repeat action list or Active update group starts its next pass, on every timed tick, even when several ticks share one frame number. This covers GameObject agents in FixedUpdate and entity systems alike. Previously the later ticks in the same frame skipped their work.
  • 2026-09-08: Transition identity and routing are stable across renames and re-authoring, and creating a machine starts with its name.
  • 2026-09-05: Machines compose with each other and author real operations, without placeholder actions in between.
  • 2026-09-04: State cards lead with lifecycle and action information.
  • 2026-08-04: A transition predicate compares against a constant or a same-type graph value, and it executes the same way on every surface.
  • 2026-08-03: A state’s hosted behavior tree is assigned and triggered from the rail, and a transition condition reads a declared blackboard variable.
  • 2026-08-02: The editor authors Entry, Active update, and Exit groups, and the runtime runs all three from the graph file.
  • 2026-07-18: State-hosted trees arrive with transition weights and grouped conditions.
  • 2026-07-17: Action state machines are authorable, with the execution core behind them.
  • 2026-10-23: In Live, the State Machine window’s STATE row follows the State you select on the canvas, whether or not it is running, so you can tune a State’s min_active_seconds ahead of its next activation instead of racing its window. The row is labeled with the State’s id, such as recovering 2.2, with min_active_seconds on a quiet line beneath. With nothing, a transition, Any State, or the Entry state selected it shows the active State. The Entry state never has a row, because only a plain State carries the duration.

  • 2026-10-23: In Live, a member condition whose comparison constant carries an accepted live edit on the attached instance states the edited value on its canvas card and its Comparison card, the operand alone in a lighter instance-blue ink with an underline, so the card no longer contradicts the result the instance reports. Hovering the operand reads live edit on this instance · authored 3; Static and every other instance state their own value. Committing the authored value back ends the override, and every mark of the edit goes away.

  • 2026-10-23: A Live member card whose getter throws states it: Source reads (getter threw InvalidOperationException) and Health reads getter threw, while Current keeps the graph’s own value. The Console logs one error the first time, not on every refresh.

  • 2026-10-20: Select a live entity and the rail’s new Utility scores section lists each branch its Utility Selector has scored, under the branch’s own node label with its current score. The branch it last picked carries a chosen chip, which reads running while that branch is still working; a branch never scored stays off the list.

  • 2026-10-20: A Utility Selector leaves one trace entry each time its chosen branch changes, naming the old and new branch, every branch’s score from that tick, and the frame, readable as LastUtilityTrace on either host and silent on a tick where nothing changed.

  • 2026-10-20: BehaviorAgent gains a Manual update mode and TickManual, so a host that owns its own tick order can route through the same pause/step gate every Live window already honors, instead of bypassing it. The Live values section’s own rows carry two more tones beside the canvas legend: instance blue for an active override, red for a refused entry.

  • 2026-09-26: An unavailable selected Repeat reading in Live now says status not observed and run not observed instead of implying the decorator is idle or has not started. The entity selected-node summary also reads not observed when its status cannot be read; an observed Resting node still reads idle. Entity and GameObject bindings still show available readings. The selected-node summary and Repeat runtime labels now use consistent lowercase wording.

  • 2026-09-25: Selecting a Repeat pill in Live now shows that decorator’s retained status on entity and GameObject agents. A finished Count reads completed 3 of 3 instead of appearing to start another run; a finished Until Success reads completed without an invented total. Keep going shows the readings.

  • 2026-09-23: A Live member card edits more kinds: enums, vectors (including Vector3 and Quaternion), strings, and Unity object references, alongside numbers, bool, and char. A Vector3 value reads as its components and its Type row names UnityEngine.Vector3, where it had read Unmanaged16; a string reads as its text instead of None.

  • 2026-09-23: A card tells the truth in every state. A paused edit reads Edit accepted · waiting for step; Source differs appears only when both values exist and differ; a detached card’s no instance chip no longer borrows the read-only lock, and its details stay open. When an attachment is lost, the Blackboard values rows read cleared instead of their last numbers.

  • 2026-09-23: At narrow widths the toolbar fits its row: it drops the tick reading, then shows the verdict chips as glyphs with their words on the tooltip, so no control paints over another.

  • 2026-09-22: The Live rail resolves an attached graph’s blackboard variables again, so bound argument rows stop reporting a variable as missing while the Bindings chip reads valid.

  • 2026-09-16: Live attaches to an initialized agent whose component is disabled because your own code ticks it. Attaching adds no ticks of its own.

  • 2026-09-16: A live member’s value keeps updating while the game is paused, and a live object payload is refused before a read-only direction can be violated.

  • 2026-09-15: Live member health reasons stay stable instead of flickering between readings. Static and Live present a value the same way in the right rail.

  • 2026-09-09: Live reattaches after you restart Play Mode, with the identity checks that keep an old runtime from being drawn as a new one.

  • 2026-08-09: Dungeon Heist’s guard exposes its patrol speed as a two-way live binding you can edit mid-game.

  • 2026-08-07: One member-bound value can be inspected and edited on a running agent from the editor rail.

  • 2026-07-27: The live chrome and the durable console record arrive together, and the inspector reports the evaluation just run.

  • 2026-07-24: An entity can be inspected from Unity’s integrated Hierarchy while paused.

  • 2026-08-10: A static method with ref parameters binds on the entity path under the same read and write rules. out, in, and params stay refused there, each named in the refusal.
  • 2026-08-02: An entity target that does not resolve reads as a live reading instead of a graph fault.
  • 2026-07-31: Entity graphs bind existing ECS game logic and run it in a Windows player.
  • 2026-07-29: Entity member execution uses memory-safe typed dispatch.
  • 2026-07-27: Entity member nodes read and write your existing game code and call into it, including enabled state and exact buffer entries.
  • 2026-07-26: Entity graphs generate direct Burst member accessors.
  • 2026-08-25: Reference Scan repairs stale identities atomically, so a remap either lands everywhere or nowhere.
  • 2026-08-04: Grouped results match the evidence they were approved against.
  • 2026-07-29: A member rename keeps Reference Scan available rather than blocking it.
  • 2026-07-28: Reference Scan finds every stale graph reference in the project, closed graphs included, and generated member artifacts follow a deleted graph out.
  • 2026-10-19: Entering Play Mode saves first. Every open graph whose last Save is behind its autosave is saved, Play waits for its regenerated provider to compile, and then starts, so Play never runs a provider older than the graph on screen.
  • 2026-10-19: A graph you edit in a text editor so that it no longer validates, such as removing a node’s declared write access, imports once with its refusal instead of logging an “infinite import loop” error.
  • 2026-10-19: A graph whose reference slots hold project assets imports without “Unexpected recursive transfer” errors, and without running those assets’ OnEnable off the main thread.
  • 2026-10-19: Generated blackboard templates no longer raise “Main Object Name does not match filename” warnings on import.
  • 2026-09-22: Save regenerates the member provider again. Cmd/Ctrl+S and the toolbar Save bake the graph, so saving a changed binding no longer leaves Play running against a stale provider, and Save stays enabled after an autosave until that bake has run.
  • 2026-09-13: Provider references survive an invalid graph edit, so a half-finished repair does not cost you the generated binding.
  • 2026-09-12: Graph context is restored after a domain reload, and retained authoring transactions keep the canvas current.
  • 2026-09-10: Saved graph files import reliably, and type selection stays responsive while they do.
  • 2026-09-09: Saving a graph and Unity’s asset database agree on what happened.
  • 2026-08-05: Double-clicking a graph file with parse errors reports the path, the exact line, and the parser message in Unity’s console, and opens no half-initialized editor window.
  • 2026-07-25: Generated member providers use Windows-safe paths.
  • 2026-07-23: The Platformer graphs migrated forward, with member calls proven in an IL2CPP player.
  • 2026-07-08: Addressables support ships as an optional assembly.
  • 2026-10-01: Horde Survival’s brutes choose a tactic through a Utility Selector: rush scored from proximity, flank from the lower of flank range and ally density, retreat from a curve over health, every branch on Interrupt. Each tactic moves the brute differently, and its stance turns so you can read the choice without relying on color.
  • 2026-09-27: Horde Survival’s running director identifies its wave difficulty as a shared value, and raising it during play shortens upcoming waves and speeds up and raises the HUD plus the warning pulse and the warning tone together, without a restart. A new run restores the configured starting difficulty everywhere at once.
  • 2026-09-26: Platformer’s patrol keeps its next stop and pause progress in EnemyPatrol.bqbehavior itself, declared beside route, profile, and route_tag. Two enemies, Enemy Platform and Enemy Platform 2, now run that exact graph side by side with independent progress; Enemies.EvaluatePatrol still decides the route.
  • 2026-09-25: Horde Survival teaches one enemy’s Count 3 attack flurry, Until Success pursuit, and Forever decision loop. The graph grants an attack and tallies it; contact damage and cooldown remain game-system work.
  • 2026-09-23: Platformer’s player jumps after standing still. Once he had rested for about half a second, a jump press was ignored until he moved again.
  • 2026-09-23: Platformer’s slimes collide at their drawn height, so a stomp lands on the slime’s dome instead of a fifth of a tile above it. The Platformer clip was recaptured one physics step per frame, so it shows the moment the player’s feet touch the enemy.
  • 2026-09-22: Racing Line’s CpuRace graph advances its catch-up pressure once per tick, inside the surge condition that tests it. It had also bound the same method on a separate node, which moved the pressure at twice the configured rates.
  • 2026-09-18: New page, how the samples are built: the game logic assets, the runner-driven lifecycle, and the composition root the GameObject samples share.
  • 2026-09-17: Platformer patrols cross floor joins without stalling at a tile seam.
  • 2026-08-04: Horde Survival’s director reads its surge population from a declared graph value, surge_live_enemy_limit, starting at 2,200, instead of a literal buried in a predicate.
  • 2026-08-03: Horde Survival states its hosted surge lifetime explicitly.
  • 2026-07-30: Platformer’s multi-point patrol uses an authored route with a profile and a tag.
  • 2026-09-18: The C# API reference covers every assembly you receive: the product’s runtime, editor, and optional Addressables assemblies, plus the Bit Quirky Graph, Core, Command, and Tile libraries that ship with it. Every public symbol carries a summary.
Full-size image