Griff 0.1.0-alpha.20

Griff 0.1.0-alpha.20 for 64-bit Windows, a pre-alpha: expect rough edges, and projects made with it may need changes in later versions.

Install it: download GriffEditor-prerelease-Setup.exe and run it. It installs Griff for you (no administrator needed, and the .NET 10 Desktop Runtime if it's missing), adds it to the Start menu and the desktop, and keeps it up to date: Griff looks for a newer pre-release (or release) after it starts and asks before restarting into it. The installer isn't code-signed yet, so Windows SmartScreen may warn that it's from an unknown publisher: pick More info, then Run anyway.

Or the portable copy: unzip Griff-0.1.0-alpha.20-win-x64.zip anywhere you can write to and run Griff.Editor.exe. It needs the .NET 10 Desktop Runtime and doesn't update itself.

More at https://griff.games/docs/getting-started/. The .nupkg and releases.*.json files are the installed editor's updates.

What changed

• Lines laid by dragging join the ones already there, with Joins ticked on a Line Tool (or on Line Tiles, for the Scene view's Line tool): dragged from a belt's end it carries the belt on, the old end turning to feed it (keeping its kind and speed) with a straight or corner tile, so the two are one line with one start and one end; ended on a belt's side it merges in, leaving that belt as it is; dragged out of a belt's side it splits off, that belt becoming a splitter. The ghost shows the join, and the optional Join Tile and Split Tile draw a merge and a split.
• A ParticleEmitter can draw frames of a sprite sheet: Columns and Rows cut the image as a Sprite's do, Frame shows one, and Frames (0-1, 3-4, 7) lets each particle pick one at random as it's born (from the game's random, so a rewind or a networked game repeats), or with Animate Frames step through them over its life. Left alone, particles draw the whole image as before.
• Conveyor cells can go at their own speeds, for a slow chute dropping onto a fast belt in the same line: a number after a Belts row's way (4 2 right 0.5), or LayPath(points, speed: 0.5f), SetSpeed and SetRunSpeed from a script. An item changes speed at the edge between two cells with no pause, with one item a cell or a Spacing, still the same at 16x and after a rewind, and Moving Arrows and Belt Tiles step at each cell's speed. An Out Conveyor Port gives back an item it's still holding with Withdraw("Deck 2") (it's never sent), or all of them with Clear().
• A scene simulation's game gets the project's Controls, step rate and save version as Play does, so a script asking for one of its input actions by name no longer throws on every run; and a run whose game or strategy throws says in the Warnings which script and line it came up through (Flow.cs(57)) with the scripts' frames, and when the scripts were rebuilt under it.
• A saved game keeps the game's model, not just its scene: scripts' private fields and the plain objects, lists and dictionaries they hold (shared ones shared, cycles closed), the entities and components they point to, and scripts' systems, read back by name so the next build of the scripts loads them. A coroutine isn't saved: each script hears OnLoaded once its fields are back, to start its work again. [NotSaved] leaves a field out, ISavesState lets a script save its own way, and an ISaveUpgrader can change the saved fields too.
• Conveyors carry several items to a cell: with a Spacing (0.25 is four to a cell) items glide on smoothly a set distance apart, round corners, and pile up packed at a full end or before a full machine, still the same at 16x and after a rewind. An under cell lets a crossing line pass beneath a belt, neither waiting for the other; a full closed loop keeps going round; a splitter's Filters send named items one way and the rest another; Moving Arrows and Belt Tiles move the belts' look with the items; and an Out port's Holds is a machine's tray (Give returns false and the port is Full once it holds that many). Scenes from before keep one item a cell.
• Juice with no code, each off until it's set: a Button's Hover Grow, Press Shrink and Pop Time make it pop under the mouse and as it's pressed, easing its size and shade; a Text showing an Output with a Count Time counts up or down to a new number; a Layout with Slide slides its children to new places; a Camera kicks one way and back (Kick By, Kick Time, its Kick action, Game.KickCamera); and a TweenPlayer plays a little scale, move, turn and fade of how something is drawn, eased and looped if wanted, as it appears or on a message: a card popping in, a stamp landing, a coin bobbing.
• Lists the player puts in order: a Layout with Reorderable ticked lets a row be dragged up or down (or about a grid) with the mouse or a finger, the other rows sliding out of the way and the list scrolling near its end, or lifted with keys or a controller (Grab Action) and moved with the arrows. A plain click still clicks the row's Button, Esc or a drop off the list puts it back, and each move raises Reordered(row, from, to) and sends a Reorder Message; Move and Layout.MoveIn serve scripts with ▲ ▼ buttons or a list of their own, and Save Order As keeps the order in the save data.
• An arrow on the HUD pointing the way to something off the screen: Entity → UI → Edge Pointer (an EdgePointer) sits on the screen's edge toward its Target, turned to point at it and sliding along the edge as the camera pans and zooms, hides once the target is in view (or sits over it), shows how far off it is, and glides the camera there when it's clicked.
• A Selectable's area turns with its entity, so a parked truck turned 90 degrees is clicked, boxed and marked as it lies, and a Button on a Selectable or inside one (a worker's own button) no longer stops Selection Controls selecting it: the click selects and the button still fires.
• The editor writes a line to the Windows Application log as it starts (with its version) and as it closes, saying why (the Exit command, an agent's App.Exit, its window closed, restarting into an update), and an error from outside the UI as it ends: an editor that went with no closing line was ended from outside.
• Fixed: a camera's Edge Scroll no longer pans while the mouse rests on the HUD at the screen's edge (a button row along the bottom, an open panel), as the wheel and drags already didn't; beside it, the edge still pans.
• Fixed: an agent taking a key off an action in Game → Controls (pressing a key's × through ui_invoke) no longer fails; RemoveBinding("Esc") takes one off the selected action by its name.

Changes since v0.1.0-alpha.19

• Release 0.1.0-alpha.20: the changelog's Unreleased becomes its entry. (0fd78a8)
• Keep the conveyor timing tests from failing on a busy machine: the two Conveyor test classes run in a Timing collection of their own, after the rest, and the 960-item loop is timed by its fastest run of 100 steps. A step takes about 1.6 ms alone against its 3 ms limit, but the suite's other classes running beside it pushed the average over. (18528d9)
• Update three templates' playthrough fingerprints for fields only: Contraption's and RpgStats' for the Particle Emitter's Columns, Rows, Frame, Frames and Animate Frames, and BunnyMark's for the Camera's Kick By and Kick Time and the Text's Count Time, which the juice change missed. Each plays as before: its description without those fields hashes to the old fingerprint. (e5a9700)
• Let a line laid by dragging join the ones already there, with Joins ticked on a Line Tool (or on Line Tiles, for the Scene view's Line tool): dragged from a belt's end it carries the belt on, the old end turning to feed it (keeping its kind and speed) with a straight or corner tile, so the two are one line with one start and one end that carries an item all the way; ended on a belt's side (or its start) it merges in, leaving that belt as it is with the cell before it pointing in; dragged out of a belt's side it splits off, that belt becoming a splitter. Belts crossed on the way are still laid over and turned. LineDrag.Join works it out from any line's ways, each LineCell says how it joins (Continues, Feeds, Merge, Split), the ghost shows the join, and Line Tiles' optional Join Tile and Split Tile draw a merge and a split. Without Joins lines are laid as before. The tilemaps guide, the known gaps, the changelog and a line-joins demo say so. (a3e0645)
• Let a Particle Emitter's Frames be typed as text, frame numbers and ranges as an Animation clip writes them, and list it in the field editor audit. (4161676)
• Let a Particle Emitter draw frames of a sprite sheet: Columns and Rows cut its image as a Sprite's do, Frame shows one frame, and Frames ("0-1", "3-4, 7", "3-0" as Animation clips write them) gives each particle a random one of them as it's born, from the game's random so a rewind and a network game stay exact, or with Animate Frames steps through them over its life. An emitter without them draws as it did. The scripting guide, the changelog and a particle-frames demo say so. (6b814ec)
• Let a Conveyor's cells go at their own speeds, for a slow chute dropping onto a fast belt in the same line: a number after a Belts row's way ("4 2 right 0.5") is that cell's speed in cells a second (0 keeps the conveyor's Speed, so scenes from before play as they did), set from a script with LayPath(..., speed), SetSpeed and SetRunSpeed (the run through a cell, up to a merge, a splitter or a cell of another speed, as RunThrough lists it) and read with SpeedAt; Lay keeps a turned cell's speed. An item changes speed at the edge between two cells with no pause, with one item a cell and with a Spacing (a tunnel going as fast as the belt into it), i...

Griff 0.1.0-alpha.19

Griff 0.1.0-alpha.19 for 64-bit Windows, a pre-alpha: expect rough edges, and projects made with it may need changes in later versions.

Install it: download GriffEditor-prerelease-Setup.exe and run it. It installs Griff for you (no administrator needed, and the .NET 10 Desktop Runtime if it's missing), adds it to the Start menu and the desktop, and keeps it up to date: Griff looks for a newer pre-release (or release) after it starts and asks before restarting into it. The installer isn't code-signed yet, so Windows SmartScreen may warn that it's from an unknown publisher: pick More info, then Run anyway.

Or the portable copy: unzip Griff-0.1.0-alpha.19-win-x64.zip anywhere you can write to and run Griff.Editor.exe. It needs the .NET 10 Desktop Runtime and doesn't update itself.

More at https://griff.games/docs/getting-started/. The .nupkg and releases.*.json files are the installed editor's updates.

What changed

• Lines with corners laid by dragging, for belts, pipes and rails: Line Tiles on a tilemap (a straight piece and a corner, each drawn once, optional end pieces) are laid turned to follow the line, by the Scene view's new Line tool (L; Z turns a single cell or swaps the corner) and in the game by a Line Tool: the player presses, drags and lets go, a ghost shows the line green where it fits and red on walls, past Max Cells or where a script's CanLay says no, and letting go lays belts on its Conveyor and tiles on its Tiles map and raises Placed. The line goes the way the drag started and turns one corner by itself; R (the new Rotate action) turns a single cell or swaps the corner.
• project.griff changed outside the editor (a text editor, a pull, an agent) is read again by itself: its controls, step rate and start scene take over, in the Controls window and a running game too.
• A script saved while the game plays starts the game over with it, as a fresh Play would, rather than swapping it into the game as it stands, which started each script again (spawning what its Start spawns twice) without its own fields, and had the others read scripts that hadn't started yet.
• entity_update's remove takes off a component whose script is gone, by the name scene_tree shows it with (ShopSign (missing)), as Remove Component does.

Changes since v0.1.0-alpha.18

• Release 0.1.0-alpha.19: the changelog's Unreleased becomes its entry. (9b5a27f)
• Give the controls list test an action of its own that isn't built in, now that Rotate is. (06dc17c)
• Pick the line-tool demo's Line tool by its palette button, as the Inspector has the keys at that point, and point at the running game while it plays. (ec5ccdd)
• Lay belts, pipes and rails by dragging a line round a corner: one rule (LineDrag) runs a line from the cell pressed on to the one under the mouse, along the way the drag started (or the longer way) and round one corner, each cell pointing on to the next. Line Tiles on a tilemap name a straight piece and a corner, each drawn once and laid turned to follow the line (TileTurns.Pointing and Corner; a corner turning the other way is mirrored), with optional end pieces. In the Scene view the new Line tool (L) drags one out with its tiles shown faintly and lays it as one undo step (Z turns a single cell or swaps the corner; PaintLine for agents). In the game a Line Tool lets the player press, drag and let go: a ghost tints each cell with an arrow, red off the map, on walls, on movers, past Max Cells or where a script's CanLay says no, and letting go lays the cells that fit on its Conveyor (a new Lay of many cells) and as its Tiles map's line tiles, then raises Placed and sends its Message; Dragging, Cells, Line and Lay serve scripts that lay build orders instead. A new built-in Rotate action (R) turns a single cell or swaps the corner, a right-click drops the line, and Selection Controls leave the mouse to a Line Tool in hand. The tilemaps, players and editor guides, the known gaps, the changelog and a line-tool demo say so. (9913411)
• Name the script-reload demo's spawned sign Greeting, so it isn't counted with the Platformer template's own Sign. (791b0a4)
• Read project.griff again when it changes outside the editor, start the game over when a script is saved while it plays, and let entity_update remove a component whose script is gone. The project file is watched as tables and prefabs are: an outside edit (a text editor, a pull, an agent) is read once it settles (Project.ReloadManifest, the workspace's ProjectSettingsChanged), so its controls, step rate and start scene reach the Controls window, the names fields check against and a running game; the editor's own saves read back as nothing new, and a file that doesn't read keeps the settings and says so in Output. Since the editor saves its project settings as they're made, the file always wins. A script recompiled mid-play no longer swaps into the game as it stands, which started each script again (a second spawn of what its Start spawns) without its own fields while others read scripts not yet started: the game plays again from the scene as it was when Play was pressed, with as many players, as a fresh Play would. entity_update's remove takes a missing component by the name scene_tree shows it with, "(missing)" or not. The editor, scripting and agents guides, the changelog and a script-reload-while-playing demo say so. (c60a2c4)

Griff 0.1.0-alpha.18

Griff 0.1.0-alpha.18 for 64-bit Windows, a pre-alpha: expect rough edges, and projects made with it may need changes in later versions.

Install it: download GriffEditor-prerelease-Setup.exe and run it. It installs Griff for you (no administrator needed, and the .NET 10 Desktop Runtime if it's missing), adds it to the Start menu and the desktop, and keeps it up to date: Griff looks for a newer pre-release (or release) after it starts and asks before restarting into it. The installer isn't code-signed yet, so Windows SmartScreen may warn that it's from an unknown publisher: pick More info, then Run anyway.

Or the portable copy: unzip Griff-0.1.0-alpha.18-win-x64.zip anywhere you can write to and run Griff.Editor.exe. It needs the .NET 10 Desktop Runtime and doesn't update itself.

More at https://griff.games/docs/getting-started/. The .nupkg and releases.*.json files are the installed editor's updates.

What changed

• Conveyor belts on a grid: a Conveyor lays directed belt cells on a tilemap's cells (rows like 4 2 right, or LayPath from a script) and carries items along them a cell apart at its Speed, backing up behind a full end; a belt joining another from the side merges, taking turns, and a split cell hands items round its belts. A Conveyor Port on a machine takes what reaches a belt's end into its inventory (until it Holds enough, leaving the wrong item waiting) and puts what it makes on a belt. Belts are walls to grid movers (WalkTo goes round them) and crossings let them over, items move in fixed steps of game time so a line plays out the same at 16x, and hundreds of items are drawn a quad each.
• Turned and flipped tiles: a tilemap cell can hold its tile turned a quarter, a half or three quarters, or flipped, so a belt, an arrow or a pipe is drawn once and painted pointing any way, animated tiles too. While painting, Z turns the brush (Shift+Z back) and X flips it (Shift+X upside down); the palette and the cell under the cursor show it turned, Ctrl-click picks up a cell's turn, and undo takes turns back with the tiles. Scripts lay tiles turned with SetTile(x, y, tile, TileTurn.Turn90) (and FillRect, FloodFill), read them with GetTurn and change them with SetTurn. The turns are the map's own grid, Turns: maps that turn nothing save exactly as before. Slope tiles collide turned.
• Graphs in the game: Entity → UI → Chart draws a line or bar chart of a few series (a name and a color each, the last Keep points of each) for the HUD or the world, with value lines and their numbers, a legend and X Labels along the bottom. A script feeds it (chart.Add("Cards", 120), Set, Clear), or with no code a series names an output of its Track entity (Cards: #4C9AFF = Cards Today) and the chart takes a point of it every Sample Every seconds of game time. Its range fits the points to a round number unless Max says. Rewinds and network games keep its points.
• Rooms found from walls: a Wall Rooms on a tilemap finds the closed rooms and open areas its walls make (solid tiles, Wall Tiles such as doors counted as shut, and colliders on Wall Layers), each with an id it keeps as walls change, its cells and area and whether it's open to the outside. It works them out again only when the walls change, raises Changed and sends its Message, answers which room a cell, point or entity is in and what's in a room, shows Closed, RoomArea:<name> and RoomId:<name> as outputs, and tints each room with Show.
• Fixed: while the game runs, what you type in an Inspector text field (a tilemap's rows, a long text) is no longer put back by the live values before you leave the box; a text field is shown again only when its value changes.

Changes since v0.1.0-alpha.17

• Release 0.1.0-alpha.18: the changelog's Unreleased becomes its entry. (7e2da47)
• Take the puzzle tutorial's pictures again, for the tilemap's new Turns field and the palette's turn keys. (c0148cd)
• Keep what's typed in an Inspector text field while the game runs: the live refresh now shows a text or list-of-lines field again only when its value changes, so a tilemap's rows or a long text typed during play stays until the box is left instead of being put back by the next refresh. The tile-turns demo points at the running game, not the Scene view, while it plays. (ee83db2)
• Carry items along belts on a grid with no code: a Conveyor lays directed cells on a tilemap's cells (Belts rows such as "4 2 right", "5 2 right crossing" or "9 2 down split", or Lay, LayPath and Remove from a script) and moves items a cell apart at its Speed, one to a cell, waiting in a cell's middle when the one ahead is full so a full end backs the line up. A belt running into another's side merges, the two taking turns, and a split cell hands items round the belts leading out of it, passing over a full one. A Conveyor Port on a machine takes what reaches a belt's end into its inventory (Items, and Holds to stop at so many; the wrong item waits and the port is Blocked) and puts what it holds, or what a script Gives it, on a belt; Received, Sent, ReachedEnd and a port's Message tell scripts and counters. Items move in fixed steps of game time, so a line is in the same place after the same game time at 1x, 16x Time.Scale and 16x fast-forward, and rewinds put items back partway between cells; the host moves them in a network game. Solid belts are walls to grid movers on their Layer (WalkTo goes round them) and crossings aren't. The conveyor draws its items itself, a quad or an Item Images image each, culled and optionally sorted by Y, so hundreds cost little. The tilemaps and players guides, the known gaps, the changelog and a conveyors demo say so. (6930931)
• Let a tilemap cell hold its tile turned or flipped, so a belt, an arrow or a pipe is drawn once and painted pointing any way: a Tilemap's Turns is a grid of its own lined up with Tiles (. as drawn, 1 to 3 quarter turns clockwise, 4 to 7 the same mirrored first), and a TileTurn (Turn90, Turn180, Turn270, FlipX, FlipY, turned further with Turned, FlippedX and FlippedY, Apply for directions) says how. Scripts lay tiles turned with SetTile(x, y, tile, turn), FillRect and FloodFill, read them with GetTurn and change them with SetTurn; plain SetTile lays a tile as drawn. Turned tiles draw turned, animated ones too, and slope tiles collide turned (flipped or turned a quarter a rising slope falls, upside down it's a solid block). While painting, Z turns the brush a quarter (Shift+Z back) and X flips it (Shift+X upside down): the palette and the cell under the cursor show it turned, the hint says how, Ctrl-click picks up a cell's turn, and undo takes turns back with the tiles. A new [OmitWhenEmpty] leaves Turns out of scene files while it's empty, so maps that turn nothing save byte for byte as before (and the game fingerprint, which skips what the files leave out, is unchanged). The tilemaps and scripting guides, the known gaps, the changelog and a tile-turns demo say so. (08d3c7e)
• Draw graphs in the game: Entity > UI > Chart makes a Chart, a line or bar graph (Kind) for the HUD or the world, of a few Series (a name and a color each, "Cards: #4C9AFF"), keeping the last Keep points of each so it scrolls. A script feeds it (Add, Add("Cards", n), Set, Clear, Points, SeriesNames, Bounds), or with no code a series names an output of its Track entity ("Cards: #4C9AFF = Cards Today", the Inspector offering the outputs) and the chart takes a point every Sample Every seconds of game time, in its own HUD step after Bars, so a sped-up game fills it as fast as it plays. Its range runs from Min up to a round number over the highest point (ChartRange.RoundUp, which the Tables panel's chart now uses too) unless Max says, with value lines and their numbers written short or as Format says, a Legend, X Labels along the bottom, and Size, Background, Grid Color, Text Color, Text Size, Font, Line Width and Order. It draws a quad a point and writes its numbers again only when its range changes; a rewind puts its points back and a network game sends the host's. The UI, scripting and editor guides, the known gaps, the changelog and a runtime-chart demo say so. (765ba82)
• Find the rooms walls make on a tilemap, for heat, air or occupancy rules: a Wall Rooms on the map joins floor cells side by side (four ways, six on a hex map) without crossing a wall, where walls are its solid tiles on any layer (as grid movers see them), its Wall Tiles even where they're walked through (a door counts as shut) and solid colliders on its Wall Layers, and a room reaching past the map's edge (or, with Empty Is Outside, an empty cell) is open to the outside. The rooms are worked out again only when the walls change, seen each step from what the walls are and where, and at the end of that step (a new Wall Rooms step of the Tilemaps system) it raises Changed and sends its Message. Each WallRoom has an Id it keeps as walls change (split, the bigger part keeps it; joined, the one it has most of), its Cells, Area and Open; scripts ask Room(id), RoomAt(cell or point), RoomOf(entity), EntitiesIn(room) and EntitiesIn(room), and Refresh() sees walls changed this step at once. Outputs Closed, RoomArea: and RoomId: show with no code, and Show tints each closed room. What the rooms were is a small list a rewind keeps, so ids come back with no change, and the derived cells are NotState. It isn't Griff.Room, the camera's rooms. The tilemaps and scripting guides, the known gaps, the changelog and a wall-rooms demo say so. (35b2099)
• Name the HUD tooltip test's button for a generic computer. (c2a80b8)

Griff 0.1.0-alpha.17

Griff 0.1.0-alpha.17 for 64-bit Windows, a pre-alpha: expect rough edges, and projects made with it may need changes in later versions.

Install it: download GriffEditor-prerelease-Setup.exe and run it. It installs Griff for you (no administrator needed, and the .NET 10 Desktop Runtime if it's missing), adds it to the Start menu and the desktop, and keeps it up to date: Griff looks for a newer pre-release (or release) after it starts and asks before restarting into it. The installer isn't code-signed yet, so Windows SmartScreen may warn that it's from an unknown publisher: pick More info, then Run anyway.

Or the portable copy: unzip Griff-0.1.0-alpha.17-win-x64.zip anywhere you can write to and run Griff.Editor.exe. It needs the .NET 10 Desktop Runtime and doesn't update itself.

More at https://griff.games/docs/getting-started/. The .nupkg and releases.*.json files are the installed editor's updates.

What changed

• Show a label only while the camera is zoomed in, on a backing box fitted to its words: a Show When's Zoom Below (for example 7) shows its entity while the main camera's Size is that or less and hides it when the camera pulls out (0 ignores the zoom, it needs no flag, and with a Needs Flag both must hold), and a Text's Background (a color, transparent by default) and Padding (world units) draw a box just behind the letters, as wide as the widest line and as tall as all of them with wrapping, alignment, Vertical Align, a HUD's scale and Order. The UI and text guides and the world-labels demo say so.
• Camera settings for the player, and a glide that hands the camera back. A Toggle set to EdgeScroll and a Slider set to PanSpeed (Game.EdgeScroll, Game.PanSpeed) let a player turn the screen's edges panning off or on and scale the pan speed of every Camera Controls: the toggle's choice wins over the camera's own Edge Scroll once made, the speed multiplies Pan Speed (1 changes nothing), and both are remembered and kept through a New Game. CameraControls.GlideTo(target) (an entity, a name or a point, with an optional Size and seconds; Glide To for a Button or Trigger) glides the view there at the Size it has and leaves the camera the player's on arrival, with no Release to time; a pan key, a drag or the wheel during the glide cancels it. The players and UI guides and the camera focus demo say so.
• A balance simulation can play the whole game over time: tick Play a whole scene over time in the Simulations panel and each run plays a Scene headless, steps back to back on every core, until its Time Limit, the scene changing, Game.Quit or End when (a flag, or Director.Cash < 0). A SimulationScript is its strategy: Setup before the first step, Act every Act every seconds of game time (and while a panel pauses the game), IsOver and Done, playing through the game's own components with run.Game. Flags set before it starts, Close panels that pause it skips an opening letter, Step rate plays in coarser steps, and Track every takes a point every so many seconds with every point kept (charts thin them for drawing; Export writes them all to ... over time.csv). Seeds, sweeps over a table's cell and a side's table of strategies work as for a matchup.
• Select things as in a strategy game with no code: Selection Controls on the camera and a Selectable (a Kind, In Box, Clickable, an area) on workers, machines or trucks. A click picks one, a left-drag boxes those inside (not what's off In Box), Shift adds or takes out, a double-click picks every one of that kind on screen, Ctrl and a number keeps a control group that the number picks again (twice quickly moves the camera there), and Esc clears the selection, after any window open over the game has closed and before the game menu opens. A right-click with something selected raises Commanded(target, point, selected) for the game to carry out; markers (an outline or a nine-sliced Marker Image) go round what's selected, and Busy leaves the mouse to a tool in hand. Its keys are new built-in actions (Select, Command, AddToSelection, AssignGroup, Group1 to Group9) that Game → Controls and Rebind buttons change, and the strategy Commander now selects by the same rules and actions, playing as before.

Changes since v0.1.0-alpha.16

• Release 0.1.0-alpha.17: the changelog's Unreleased becomes its entry. (2880ce9)
• Select things as a strategy game does, outside the Strategy module: Selection Controls on the camera and a Selectable (Kind, In Box, Clickable, an area from its Size, Button, collider or sprite) on workers, machines or trucks. A click picks the one on top, a left-drag boxes what's In Box, Shift adds or takes out, a double-click picks every one of that kind on screen, Ctrl and a number keeps a control group that the number picks again (twice quickly moves the camera to it), and Esc clears: with something selected it claims Back, after a window open over the game has closed and before the game menu opens. A right-click with something selected raises Commanded(target, point, selected) and uses the press up, so it doesn't drag the camera too; clicks on buttons, pop-ups and what's pinned to the screen don't select, and Busy (or a Busy Flag) leaves the mouse to a tool in hand. Markers go round what's selected (an outline or a nine-sliced Marker Image) and the box is drawn while dragging. Its keys are new built-in input actions (Select, Command, AddToSelection, AssignGroup, Group1 to Group9) that Game > Controls and Rebind buttons change. The rules are SelectionState's, answered by an ISelectionRules: the strategy Commander now keeps one and reads the same actions, with the same default keys, so it plays as before (the Strategy template's fingerprint is unchanged) and its keys rebind too. The players guide gets a section on it, with the scripting, editor and genres guides, the known gaps, the changelog and an rts-selection demo. (2d5b95c)
• Open the scene-simulations demo's simulation from the Data menu's list of them, and keep the world-labels demo's labels to one line, as the Inspector's Text box takes them. (b86a1ef)
• Show a label only while the camera is zoomed in, on a backing box fitted to its words: a Show When's Zoom Below shows its entity while the main camera's Size is that or less (0 ignores the zoom; with a Needs Flag both must hold), and a Text's Background and Padding draw a box just behind the letters, measured from the laid-out lines so it follows wrapping, alignment, Vertical Align, HUD scale and Order. Templates play as before; their fingerprints change only for the two new Text properties. The UI and text guides, the changelog and a world-labels demo say so. (294c849)
• Let a player set the camera: Game.EdgeScroll (a Toggle's Setting EdgeScroll, null until chosen, then winning over every Camera Controls' own Edge Scroll) and Game.PanSpeed (a Slider's Setting PanSpeed, times each Pan Speed, 1 by default) are saved as griff. settings a New Game keeps. CameraControls.GlideTo (an entity, a name as an action, or a point, with an optional Size and seconds) is a FocusOn that ends on arrival at the Size it has, leaving the camera the player's with no Release to time, and a pan key, drag or the wheel cancels it. The players and UI guides, the changelog and the camera focus demo say so. (eaaa5c8)
• Let a balance simulation play the whole game over time: a simulation with a Scene (Play a whole scene over time in the Simulations panel) plays that scene headless in each run, steps back to back on every core with no frame pacing, until its Time Limit, a scene change, Game.Quit or End When (a flag, or an output against a number such as Director.Cash < 0). Its SimulationScript is a strategy: Setup before the first step, Act every Act Every seconds of game time (and while a panel pauses the game), IsOver and Done, playing through the game's own components with run.Game. Flags set before it starts, Close Panels skips an opening letter, Step Rate plays coarser steps, and Track Every takes a point every so many seconds with every point kept (the chart and the lines thin them for drawing; Export writes them all to "... over time.csv"). Seeds, sweeps over a table's cell and a side's table of strategies work as for a matchup; the summary says how many game steps a second were played. Matchups and existing simulations play as before. The data tables guide, the known gaps, the changelog and a scene-simulations demo say so. (8f73404)

Griff 0.1.0-alpha.16

Griff 0.1.0-alpha.16 for 64-bit Windows, a pre-alpha: expect rough edges, and projects made with it may need changes in later versions.

Install it: download GriffEditor-prerelease-Setup.exe and run it. It installs Griff for you (no administrator needed, and the .NET 10 Desktop Runtime if it's missing), adds it to the Start menu and the desktop, and keeps it up to date: Griff looks for a newer pre-release (or release) after it starts and asks before restarting into it. The installer isn't code-signed yet, so Windows SmartScreen may warn that it's from an unknown publisher: pick More info, then Run anyway.

Or the portable copy: unzip Griff-0.1.0-alpha.16-win-x64.zip anywhere you can write to and run Griff.Editor.exe. It needs the .NET 10 Desktop Runtime and doesn't update itself.

More at https://griff.games/docs/getting-started/. The .nupkg and releases.*.json files are the installed editor's updates.

What changed

• A Table Values line can set a list of names: a property that is an IReadOnlyList<string> (a script's Priorities, a Game Speed's Speeds) takes a text cell split on commas and line breaks, each name trimmed and empty ones dropped, and the Inspector marks it as set from the table like any other field. The data tables guide and its demo say so.

• Fixed: dragging the view of a camera with Camera Controls no longer swings back and forth after the mouse moves (on a 60 Hz screen it kept rocking while the button was held, at two steps a frame or fast-forwarded it got worse, and the strategy camera's edge scroll and minimap drag stuttered the same way): the camera goes by where the mouse is on the screen and the camera as it is now, not the world point found through the camera as last drawn, so the view goes where the mouse takes it and stays. Dragged past a Stay Inside edge, dragging back moves it at once, and an agent's game_input drag moves the view as far as the drag. Scripts get Input.MouseOnScreen.

Changes since v0.1.0-alpha.15

• Release 0.1.0-alpha.16: the changelog's Unreleased becomes its entry. (7af63f8)
• Keep a Camera Controls drag steady: the camera moved by the mouse went by Input.MouseWorld, which the loop finds once a frame through the camera as last drawn (between its last two steps, a whole step behind on a 60 Hz screen), so a drag chased the camera's own last move and kept swinging back and forth while the button was held, worse at two steps a frame and running away fast-forwarded. The host now also gives where the mouse is on the view (Input.MouseOnScreen, -1..1 each way, null for a mouse put straight in the world), and the drag, the wheel's zoom toward the mouse, edge scroll and the HUD check find the world point under it through the camera as it is now, so the view goes where the mouse takes it and stays, on any screen and at any speed; dragged past a Stay Inside edge it takes hold where the view stopped, so dragging back moves it at once. The strategy camera's edge scroll and minimap drag, which stuttered the same way, go by it too, a viewport camera's mouse is placed by it, and an agent's game_input drag moves the screen spot as far as the drag rather than leaving a world point the camera ran after. The players and agents guides and the changelog say so. (25670eb)
• Let a Table Values line set a list of names: a property that is an IReadOnlyList (a script's Priorities, a Game Speed's Speeds) takes a text cell split on commas and line breaks, each name trimmed and empty ones dropped, so one cell reading Console=1, Unload=2 starts as those two. It counts as settable, so the Inspector marks it as set from the table and Sets validation no longer flags it. The data tables guide, the changelog and the data-tables demo say so. (077116f)

Griff 0.1.0-alpha.15

Griff 0.1.0-alpha.15 for 64-bit Windows, a pre-alpha: expect rough edges, and projects made with it may need changes in later versions.

Install it: download GriffEditor-prerelease-Setup.exe and run it. It installs Griff for you (no administrator needed, and the .NET 10 Desktop Runtime if it's missing), adds it to the Start menu and the desktop, and keeps it up to date: Griff looks for a newer pre-release (or release) after it starts and asks before restarting into it. The installer isn't code-signed yet, so Windows SmartScreen may warn that it's from an unknown publisher: pick More info, then Run anyway.

Or the portable copy: unzip Griff-0.1.0-alpha.15-win-x64.zip anywhere you can write to and run Griff.Editor.exe. It needs the .NET 10 Desktop Runtime and doesn't update itself.

More at https://griff.games/docs/getting-started/. The .nupkg and releases.*.json files are the installed editor's updates.

What changed

• A value saved under a name starting settings. (a Toggle's or Slider's Save As settings.difficulty, a Toggles List's settings.fire.{row}) is the player's setting: a New Game keeps it, as it keeps volumes and controls.
• A Toggles List makes an on/off switch for each row of a data table: put it on an entity with a Layout (an options panel), name its Table, and while the game runs it makes a row for each table row with its label (Label Column, else the row's name) and a real Toggle kept in the save data as Save As says (fire.{row}), starting as the Default Column says until the player flips it or the game has one saved. Hide leaves rows out, and a Template entity styles the rows. Scripts read the switches with Game.SaveData.GetBool("fire.Rain").
• Fast-forward that stays exact: a Game Speed (Gameplay) runs the game at its Speed (speed buttons set it with Do Set Speed, Faster or Slower), and while it's Exact a faster game takes more steps of the usual length rather than longer ones (Time.FastForward from a script), so a sim plays out the same at 16x as at 1x. With a plain high Time.Scale, a Grid Movement now takes every cell a long step covers, so walkers no longer fall behind in game time.

Changes since v0.1.0-alpha.14

• Release 0.1.0-alpha.15: the changelog's Unreleased becomes its entry. (06c0d7a)
• Keep a game's own settings through a New Game: a value saved under a name starting "settings." (a Toggle's or Slider's Save As "settings.difficulty", a Toggles List's "settings.fire.{row}") is the player's setting, kept by SaveData.ClearProgress as the volumes and controls Griff keeps under "griff." are, and SaveData.IsSetting says so to scripts. The UI guide, the changelog and the toggles-list demo show it. (a244452)
• Speed a game up and keep it exact: Time.FastForward (and a Game Speed component's Speed while it's Exact, set by speed buttons with Do Set Speed, Faster or Slower) takes that many steps of the usual length each frame rather than longer ones, so walkers, physics, timers and coroutines play out step for step as at 1x, with UnscaledDelta still real time for the camera and menus. A fast-forwarded frame spends at most a twentieth of a second on steps, so a machine that can't keep up runs the game slower rather than skipping any; it does nothing in a network game or while a panel pauses. With a plain high Time.Scale, a Grid Movement now takes every cell a long step covers (each checked and planned, round corners; a press is still one cell), where it used to lose the step's spare time and walk 2.7 times slower at 16x. Templates play as before. The UI, scripting, players and editor guides, the known gaps (Spawner and Shooter still act once a step under long steps), the changelog and a fast-forward demo say so. (326785e)
• Let demos tick yes/no cells and reach an entity inside another: a yes/no cell is changed the way the grid takes it (F2, Space, Enter) rather than by clicking a box that only shows it, an empty one reads as no, and expectvalue and the game points take a path, "Smoke/Switch", for an entity inside another with a name others share. The toggles-list demo uses them, picks the yes/no type by its name and clicks a row's switch. (df92891)
• Add a Toggles List: an on/off switch for each row of a data table, a real Toggle remembered in the save data under a Save As pattern ("fire.{row}") and starting as a yes/no Default Column says until the player flips it, with a Label Column, Hide, a Template entity and the Controls List's look. The UI guide, the changelog and a toggles-list demo say so. (0c8bc7f)

Griff 0.1.0-alpha.14

Griff 0.1.0-alpha.14 for 64-bit Windows, a pre-alpha: expect rough edges, and projects made with it may need changes in later versions.

Install it: download GriffEditor-prerelease-Setup.exe and run it. It installs Griff for you (no administrator needed, and the .NET 10 Desktop Runtime if it's missing), adds it to the Start menu and the desktop, and keeps it up to date: Griff looks for a newer pre-release (or release) after it starts and asks before restarting into it. The installer isn't code-signed yet, so Windows SmartScreen may warn that it's from an unknown publisher: pick More info, then Run anyway.

Or the portable copy: unzip Griff-0.1.0-alpha.14-win-x64.zip anywhere you can write to and run Griff.Editor.exe. It needs the .NET 10 Desktop Runtime and doesn't update itself.

More at https://griff.games/docs/getting-started/. The .nupkg and releases.*.json files are the installed editor's updates.

What changed

• A Needs Flag can name several flags joined by "or": run.Contracts or run.Work holds while either is set, on a Show When, panel, door, switch or spawner.
• An Animation clip whose frames are written high to low plays backward: Open 0-3 once, Close 3-0 once opens a door and closes it with the same frames. The Clip Editor previews it backward too.
• A Show When (Gameplay) shows anything only while a flag holds (Needs Flag run.Contracts, or not Tutorial), hidden with what's inside it otherwise and looked at every frame: a HUD that brings in its tools as goals are met, whose hidden buttons can't be clicked or set off by their shortcuts. A flag (or any saved value) named run. lasts one run: kept while the game runs and in its saved games, but not written down, so it's unset the next time the game starts. A New Game already forgets every flag.
• A dialogue's Stop action (on a button or trigger) and Game.EndDialogue(dialogue) end it at once, even mid-line, as saying its last line would: the box hides, the pause is let go, its Message is sent and Finished is raised, with CutShort true. For a Skip button on a cutscene or a tour.
• Camera Controls can take the camera over for a while: FocusOn(entity, size) glides to a character (or a point) and follows it at a closer Size, inside Stay Inside, while the player's pan, drag and wheel wait; Release() zooms back out to the Size it had and hands the camera back where it is. Focus Size and Focus Seconds set the defaults, and a Trigger or a Do button can do Focus On and Release, for a guided tour or a cutscene with no code.
• Agents' clicks in game_input land on a button pinned to the screen even after the camera has moved: put on the HUD, the agent's mouse rests on its spot on the screen as a real one does, so clicking again where it rests clicks a panel that opened there again.
• Fixed: the editor's Step Frame (F10) no longer takes F10 from a game that is playing: it steps a paused game only, and while a game plays, a plain Game menu shortcut goes to the game when one of its input actions is bound to that key. Pause (F6), Stop (Shift+F5) and Play Fullscreen (Alt+Enter) still always work.
• Scripts can have Esc before the game menu does: override ClaimsBack (protected override bool ClaimsBack => tool is not null;) and while it's true Esc and B don't open a Panel on its Open On (or close one the game goes on behind), so a builder's Esc puts the tool down first and the next Esc opens the menu. Only a running script claims it, never one behind a pausing panel.
• Fixed: a press a panel acts on no longer reaches the game in the same frame. The Esc that closes the game menu doesn't also put a tool down or skip a tour, nor does a panel's Open On key, or Enter, A or a shortcut clicking a button that opens or closes a panel; Input.WasPressed sees the key the next time it's pressed. Rebinding a key doesn't fire its new action either.
• A Button with Over Panels keeps taking clicks and its shortcuts while a panel it isn't on is open, even one that pauses the game: a menu bar's Game button opens the game menu over a letter, on top of it, and closing the menu leaves the letter open.
• A Panel with Popup ticked is a fly-out, dropdown or context menu: a mouse press off it closes it and does nothing else (no button there clicks, scripts don't see the press, and Game.MouseOnUi is true for it), and clicking one of its buttons closes it once the button has done what it does, so a pick on a tool palette's fly-out closes it and an OpenPanel button on it opens its window in its place.

Changes since v0.1.0-alpha.13

• Release 0.1.0-alpha.14: the changelog's Unreleased becomes its entry. (9d4e6c1)
• Name the play shortcuts that always win, or wait for a paused game, by their command classes rather than id strings, as the editor reaches commands. (04cb26d)
• Let panels and the game's own keys share Esc and the mouse: a script claims Back by overriding ClaimsBack (true while a tool is in hand), so Esc and B put the tool down before they open a Panel on its Open On or close one the game goes on behind, and the next Esc opens the menu; only a running script claims it, never one behind a pausing panel. A press a panel acts on is used up for the rest of the frame (InputState.Use: not pressed, not buffered, not sent to a network host), so the Esc that closes the game menu no longer also drops the tool or skips a tour, and neither does an Open On key, Enter, A or a shortcut clicking a button that opens or closes a panel, nor the key a Rebind button takes; every template plays to the same last bit with it, so it is a fix, not an option. A Button with Over Panels keeps its clicks and shortcuts while a panel it isn't on is open, even a pausing one, so a menu bar's Game button opens the game menu over a letter and closing the menu leaves the letter (the arrows stay on the panel). A Panel with Popup closes on a mouse press off it, which goes no further (no button clicks, scripts don't see it, Game.MouseOnUi is true for it and for a press on its backdrop), and closes once one of its buttons has done what it does, so an OpenPanel choice opens its window in its place. Templates' fingerprints change for Over Panels and Popup only (the same without them). The UI and scripting guides, the changelog and a panel-input demo say so. (21526dc)
• Let a Needs Flag name several flags joined by "or": "run.Contracts or run.Work" holds while either is set (each part can be "not" one), on a Show When, a panel, a door, a switch, a spawner or a hotspot, as all of them ask Game.FlagHolds. The Inspector checks each flag named, Show When's note reads the whole condition, and the UI guide, the known gaps, the changelog and the unlocks demo (a group's icon shown once any of its tools is unlocked) show it. (c054931)
• Play an animation clip backward when its frames are written high to low: "Close 3-0" plays 3, 2, 1, 0 where it used to play 0 up to 3, so a door opens and closes with the same frames. AnimationClip says so (Backward), Clips writes it back the way it was typed, Animation.PlaysBackward tells a script, the Inspector's clip rows and the Clip Editor keep a clip's way as its frames change, and the Clip Editor's preview and frame strip run it backward. The scripting guide, the known gaps, the changelog and the Clip Editor demo (a clip looping backward over the whole sheet) show it. (d89410e)
• Let a game that plays in the editor keep its own keys: Step Frame (F10) is for a paused game only, and any other plain Game menu shortcut goes to the game when one of its input actions is bound to that key, while Pause (F6), Stop (Shift+F5) and Play Fullscreen (Alt+Enter) always win. The editor guide and the changelog say so. (33a89f3)
• Give the camera-focus demo's walker a position with its depth, as the demos' Transform.Position takes. (c547ff8)
• Let Camera Controls take the camera over for a while, for a guided tour or a cutscene: FocusOn(entity or point, size, seconds) glides to it, easing the camera's Size to the one asked for (Focus Size by default, its own with none) over Focus Seconds of real time, then keeps a moving character in the middle of the view, inside Stay Inside, while the player's pan, drag and wheel wait; Release() zooms back out to the Size it had before the first FocusOn and hands the camera back where it is. Focus On (by name) and Release are actions, so a Trigger or a Do button can run a tour with no code, and IsFocused and FocusTarget say what it's doing; with neither called, cameras behave as before. Also make an agent's click with game_input land on a button pinned to the screen after the camera has moved: the agent's mouse, put on a button or the HUD, now rests on its spot on the screen as a real mouse does, so clicking again at the point it was put at clicks a panel that opened there again, where it used to land on the world point the panel had left. The players and agents guides, the changelog and a camera-focus demo show it. (eb79768)
• Show an entity only while a flag holds, let flags last one run, and end a dialogue from a script: a Show When component (Needs Flag, "not" too, empty leaves the entity alone) shows its entity while its flag holds and hides it otherwise, looked at each frame in a new Show When step before the menus, so a hidden button's click and shortcut do nothing; a saved value or flag named "run." is kept while the game runs and in its saved games but never written down (SaveData.LastsOneRun), so an unlock doesn't carry into the next start, as a New Game already forgot every flag. A dialogue's Stop action and Game.EndDialogue end it at once, even mid-line, as its last line would (box hidden, pause and time scale given back, Message sent, Finished raised), with Dialogue.CutShort saying it was skipped. The story and UI guides, the known gaps, the changelog and an unlocks-and-ski...

Griff 0.1.0-alpha.9

Griff 0.1.0-alpha.9 for 64-bit Windows, a pre-alpha: expect rough edges, and projects made with it may need changes in later versions.

Install it: download GriffEditor-prerelease-Setup.exe and run it. It installs Griff for you (no administrator needed, and the .NET 10 Desktop Runtime if it's missing), adds it to the Start menu and the desktop, and keeps it up to date: Griff looks for a newer pre-release (or release) after it starts and asks before restarting into it. The installer isn't code-signed yet, so Windows SmartScreen may warn that it's from an unknown publisher: pick More info, then Run anyway.

Or the portable copy: unzip Griff-0.1.0-alpha.9-win-x64.zip anywhere you can write to and run Griff.Editor.exe. It needs the .NET 10 Desktop Runtime and doesn't update itself.

More at https://griff.games/docs/getting-started/. The .nupkg and releases.*.json files are the installed editor's updates.

What changed

• Camera Controls pans with four new built-in actions, PanUp, PanDown, PanLeft and PanRight (WASD, the arrows and the D-pad as before), so Game > Controls and players can rebind them, and a game can take W or S for something else.
• A button's Shortcut Action clicks it with an input action instead of a fixed key, so a menu key shows in Game > Controls and players can rebind it.
• A Bar can be drawn with pictures: its Fill Image is revealed as it fills, in its Direction, cut off rather than squeezed, over a Background Image that can be a nine-slice. Its colors tint them.
• Agents: ui_invoke on a path ending at a property, or with an argument the tool doesn't take (a method beside the path), no longer answers with what the property holds as though something had been called: it says what went wrong. Every MCP tool now refuses arguments it doesn't take, and ui_invoke reads lists and objects by name of anything it can read, so Project.SetControlsAsync with [{"PauseTime": ["Space"]}] sets and saves a project's controls.
• A script spawned during the game no longer stops it with "The behavior isn't running in a game yet" when a Tooltip, Text, Counter, Bar or wire shows one of its outputs that uses Game: a script's outputs are read once it has started, from the next step. A Tooltip now reads its output only while it's the one hovered.
• A Grid Movement can walk somewhere by itself: give it a Destination (cells or an entity), use its Walk To action, or call WalkTo from a script, and it goes to the nearest free cell round walls, solid things and other movers, waits when someone's in the way, and steps aside in a narrow aisle so two walkers get past each other. Arrived and Blocked say how it went, and a tilemap's FindSteps plans such a way for scripts.

Changes since v0.1.0-alpha.8

• Release 0.1.0-alpha.9: the changelog's Unreleased becomes its entry. (3e5ea27)
• Grid movers walk somewhere by themselves: Grid Movement's Destination (cells, or an entity's name), its Walk To action and WalkTo from scripts send it to the nearest free cell, the shortest way round solid tiles, solid colliders (only those on its new Blocking Layers, when it has any) and other movers, planning again at every cell; it waits for a mover in its way (Blocked, Is Waiting), and two walkers face to face in a one-cell aisle untangle after Give Way seconds, one stepping aside to a free cell off the other's way. Arrived and its messages say how it went, all of it worked out where the game is run, the same every time and after a rewind. The grid search behind chases and patrols now finds the nearest of several goals, and with GridWalls it moves into Griff.Scenes so a tilemap's FindSteps can plan the same way in cells for scripts. Templates with a grid mover keep their play (fingerprints take the new properties); the players guide, scripting reference, known gaps, changelog and a grid-walking demo describe it. (d0f6988)
• Make ui_invoke say when nothing was called instead of seeming to succeed: a path ending at a property (ProjectSession's "Project", with the method put in a "method" argument the tool doesn't take) answered with what the property holds, "Project "My Game"", as though the call had been made, so an agent took its project settings for changed. That's refused now, naming how to call a method of what it holds; the MCP server refuses any argument a tool doesn't take, saying what it takes, rather than dropping it; and agents' values read lists and objects by name of anything they can read, and values that parse themselves from text (a key or button), so Project.SetControlsAsync with {"PauseTime": ["Space"]} sets and saves a project's controls as the Controls window does. game_input lists the "wait" a single step can take. (f1b42a8)
• Read a script's outputs only once it has started: a Tooltip, Text, Counter, Bar or wire showing an output of a script spawned this step read its getter before the script's Start, and a getter using Game threw "The behavior isn't running in a game yet". ComponentOutputs.CanRead keeps every reader (OutputReader, ComponentOutputs.Read, a minigame's score) off a script still to start in a running game, so it's read from the next step, and a Tooltip reads its output only while it's the one hovered instead of every tooltip every frame. (b4a35d9)
• Draw a Bar with pictures: its Fill Image is laid over the whole bar and shown only as far as it's full in its Direction (the source rect cut, not the picture squeezed), the trail shows the same picture, and its Background Image is drawn whole or, with a Background Slice, as a nine-slice through the same pieces a sliced sprite is drawn with (Quads.NineSlice, which Sprite now uses too). Fill, Background and Trail tint them, and a bar without pictures draws exactly as before; scripts pass a BarImages to drawing.Bar. The ui guide and a demo show it, and the templates with a bar take the new properties in their fingerprints (each plays exactly as before without them). (f317034)
• Click a button with an input action: Button.ShortcutAction names one beside Shortcut, so a menu key shows in the Controls window and follows the project's controls and the player's Rebind. It keeps Shortcut's rules (not while the button can't be clicked or a panel it isn't on is open, not on Enter, Space or A while another button is picked), and an action with Esc among its keys makes the button its panel's way back, as an Esc Shortcut does. Template fingerprints take the new field (each plays the same without it); a demo shows the pan keys and a Shortcut Action rebound. (5c19832)
• Pan Camera Controls with input actions, so every key of a game can be rebound: four new built-in actions, PanUp, PanDown, PanLeft and PanRight, keep WASD, the arrows and the D-pad as their defaults, show in the Controls window like Jump (saved only where a project changes them), and follow Input.Rebind, so a game can move panning to other keys or take W and S off it for something else. The left stick still pans; Pan With Keys reads the actions in place of the fixed keys. (be952e4)

Griff 0.1.0-alpha.8

Griff 0.1.0-alpha.8 for 64-bit Windows, a pre-alpha: expect rough edges, and projects made with it may need changes in later versions.

Install it: download GriffEditor-prerelease-Setup.exe and run it. It installs Griff for you (no administrator needed, and the .NET 10 Desktop Runtime if it's missing), adds it to the Start menu and the desktop, and keeps it up to date: Griff looks for a newer pre-release (or release) after it starts and asks before restarting into it. The installer isn't code-signed yet, so Windows SmartScreen may warn that it's from an unknown publisher: pick More info, then Run anyway.

Or the portable copy: unzip Griff-0.1.0-alpha.8-win-x64.zip anywhere you can write to and run Griff.Editor.exe. It needs the .NET 10 Desktop Runtime and doesn't update itself.

More at https://griff.games/docs/getting-started/. The .nupkg and releases.*.json files are the installed editor's updates.

What changed

• Camera Controls: put it on the camera and the player pans with the arrow keys or WASD, drags the world with the middle or right mouse button, zooms toward the mouse with the wheel between a smallest and largest size, and can pan at the screen's edge. Stay Inside keeps the view inside a level, even as the level grows. No code needed.
• A camera's Hud Size keeps the HUD the same size and in the same place on the screen while the camera zooms, and its buttons still click where they're drawn.
• The Scene view shows anything pinned with a Screen Anchor where the game will show it, in its corner of the camera's frame, and dragging it there sets its Offset.
• Sort Group: a thing made of several sprites (a stack of crates on a pallet, a machine and its operator) sorts by Y as one, so characters walk in front of all of it or behind all of it.
• Tilemaps with no image can give each tile number its own Placeholder Colors, with an optional Placeholder Grid, to block out floors and walls before there's any art.
• Text can hang from the top or stand on the bottom (Vertical Align) and wrap between words to a Wrap Width.
• Layout lines up an entity's children in a list, a row or a grid: cards and rows spawned into it take their places, and removing one closes the gap. It can clip what doesn't fit and scroll with the wheel.
• Tooltip shows a box by the mouse after a short delay, or writes into a Text you name, while the mouse rests on an entity. A script can set what it says, or it can show an output.
• Game > New Random Numbers Each Game starts each Play with different random numbers, instead of the same ones every Play until the editor restarts.
• Game > Play Fullscreen (Alt+Enter) plays the game over the whole screen, and switches back to the Game tab without stopping the game. F6, F10 and Shift+F5 now also work while a game running in the Game tab has the keyboard.
• For agents (MCP): clicking a button by its label finds a button whose label is on the button itself, Scene_Open takes a scene's name, and Edit_Undo and Edit_Redo can name the scene or prefab to undo in.

Changes since v0.1.0-alpha.7

• Release 0.1.0-alpha.8: the changelog's Unreleased becomes its entry. (c3f5d98)
• Add a changelog to the Releases page: site/src/data/changelog.md says what changed in each release in plain words, newest first, with an Unreleased section that collects changes as they're made, and the page lists it below the downloads, even offline. tools/changelog.ps1 turns Unreleased into a release's entry before tagging, and a release's GitHub notes start with that entry. The releases so far are filled in, and Unreleased has what's coming in the next. (6469532)
• Keep Screen Anchor and Camera Controls the components they are, state and settings with no runtime in them: laying out what's pinned to the screen (in the game and in the Scene view) moves to Runtime.ScreenLayout, and panning and zooming a camera to the View system, as the layers ask. The field editor audit lists Camera Controls' Stay Inside. (abb5426)
• Play fullscreen from the editor: Game > Play Fullscreen (Alt+Enter) moves the running game, or the open scene played straight away, into a borderless window filling the screen the editor is on, and again brings it back to the Game tab still playing, so a game can be tried at a player's screen size. The Game menu's shortcuts (Pause, Stop, Step Frame) now reach past a running game in either window, paused the timeline shows over it to rewind, a breakpoint or an error pause brings it back, and the game's own Fullscreen setting follows and sets it (Play still starts in the tab). The state is PlayMode.IsFullscreen, for agents too; the editor guide and a demo show it. (b3a3b4d)
• Keep the tests in step with the new steps and properties together: the frame takes Camera Controls, Layouts and Tooltips in their places, the Views that sort groups name Sort Group, and every template's fingerprint takes cameras' Hud Size and tilemaps' placeholder settings (each plays exactly as before without them). The text wrap demo gives its position all three numbers. (e9584db)
• Keep a tooltip's box the size it is on the screen as the camera zooms, as the rest of the HUD does with the camera's Hud Size. (f6a2dec)
• Let demos point at a game that has no strategy game: the Strategy HUD a demo's game clicks and hovers check for is none when the game doesn't run the Strategy module, rather than an error, which stopped every gameclick and gamehover outside strategy games. (4c66262)
• Fix three MCP rough edges: game_input finds a Button by the label Text on its own entity, Scene_Open takes a scene by name or path through a "scene" argument, and Edit_Undo and Edit_Redo take an optional "document" (an open scene or prefab) to act on when it isn't the active one, so an agent says which one it means. Commands can now declare an optional argument (CommandTarget.Optional). (641412b)
• Offer a project setting that starts each game's random numbers from the clock: every game one running editor makes copied the same numbers (Rand's outside numbers are never drawn on, so the copy never moved), so a game that rolls its offers in Start dealt the same ones each Play. Game > New Random Numbers Each Game (off unless turned on, saved in project.griff) reseeds a new game from the clock, its rewinds still exact since the numbers are in the snapshot. (4d32f2b)
• Add a Tooltip component: resting the mouse on anything, a sprite in the world with no button or a control on the HUD, shows its text after a delay in a box by the cursor, pinned to the screen, or writes it into a named Text and puts back what that said once the mouse leaves; a script sets its Value, or it shows an output as a Text does. Only the topmost under the mouse shows, the screen's before the world's, and the Inspector's preview of an output reads from the entity its output field names rather than the first entity field. (79c4628)
• Add a Layout component that lines up an entity's children in a list, a row or a grid of Columns, with Spacing, Padding and a Size to start from, so cards and rows spawned into it (Game.Spawn(prefab, parent)) take their places in order with no position set and close up when one is destroyed or hidden. It arranges after LateUpdate in the game and on every edit in the Scene view; with Clip, its children's draws are cut to its area (any component can clip what's inside it through IClipsChildren, drawn as a narrower view by every renderer) and the mouse wheel over it scrolls a row at a time. UI guide, known gaps and a demo say how. (46ac829)
• Let text hang from its entity and wrap to a width: a Text's Vertical Align (Middle, the default, as before; Top, the first line's top at the entity however many lines follow; Bottom, the last line's bottom there) and Wrap Width (world units, 0 for none) are laid out by the glyph atlas with the font's own letter widths, through TextWrap.Break, which the average-letter wrap of dialogue boxes now uses too; drawing.Text takes both, a typewriter types out the whole text's layout so words don't jump lines, and dialogue choices under the mouse and scoreboards pinned to the screen follow the alignment. The playthrough fingerprints take in the two new properties (the play is the same without them). (971297a)
• Give image-less tilemaps a placeholder color per tile: a map with no Image takes Placeholder Colors (tile N draws in color N, times the Tint, going round the list) and an opt-in Placeholder Grid (a thin line round each tile, a shade off its color), which its layers share, so a level's floors, wall tops and wall faces can be blocked out before any art. The Scene view's palette and the tile fields show a tile of each color to paint with; with no colors, maps draw as before. (c487350)
• Sort a group of sprites as one: a Sort Group on an entity (a pallet with a stack of crates, a machine with its operator) makes it and everything inside it sort at its root's Order, Z and feet (plus a Ground Offset), its parts by their own Order and then hierarchy order within it, so a character walking past a stack in a top-down game draws in front of all of it or behind all of it rather than between its parts. The game, the chunked build of a big scene, the Scene view and Views.DrawOrder/DrawParts sort the same way, and a tilemap's rows sorting by Y interleave with groups as with any sprite. (6cd127d)
• Add Camera Controls, to pan and zoom a camera with no code: on the camera of a management, building or strategy game, the arrow keys and WASD (or a stick) pan at Pan Speed screen heights a second, the middle or right mouse button (Drag Button) drags the world along, the wheel zooms toward the mouse by Zoom Step between Zoom Min and Zoom Max, Edge Scroll pans at the screen's edge, and Stay Inside keeps the view inside a tilemap, collider or sprite read each frame, so a level that grows lets it reach further (Follow...

Griff 0.1.0-alpha.7

Griff 0.1.0-alpha.7 for 64-bit Windows, a pre-alpha: expect rough edges, and projects made with it may need changes in later versions.

Install it: download GriffEditor-prerelease-Setup.exe and run it. It installs Griff for you (no administrator needed, and the .NET 10 Desktop Runtime if it's missing), adds it to the Start menu and the desktop, and keeps it up to date: Griff looks for a newer pre-release (or release) after it starts and asks before restarting into it. The installer isn't code-signed yet, so Windows SmartScreen may warn that it's from an unknown publisher: pick More info, then Run anyway.

Or the portable copy: unzip Griff-0.1.0-alpha.7-win-x64.zip anywhere you can write to and run Griff.Editor.exe. It needs the .NET 10 Desktop Runtime and doesn't update itself.

More at https://griff.games/docs/getting-started/. The .nupkg and releases.*.json files are the installed editor's updates.

Changes since v0.1.0-alpha.6

• Release without running the tests on the runner: its software OpenGL refuses offscreen contexts now and then, and failed CI and the release on commits whose suites pass on a machine with a GPU, so the suites are run there before tagging (Cutting a release, site README) and the Release run only builds, packs and publishes. (c48f6c0)