Components

Every component that can be added to an entity, by category: what it does and what each property takes. This page and the ones it links to are written from the code when the site is built (the same text component_describe gives an agent), so a new component appears here by itself.

Rendering

• Animation: Plays frames of the entity’s sprite sheet: FrameCount frames starting at FirstFrame.
• Camera: What the game sees.
• Light: Lights up the dark around its entity: a torch, a lamp, a glowing mushroom, the player’s lantern.
• Parallax: Makes a background layer scroll slower than the world as the camera moves, for depth: far hills at 0.2, near trees at 0.7.
• ParticleEmitter: Sprays small fading quads: smoke, sparks, dust, explosions.
• ScreenEffects: Changes the look of the whole screen, HUD included: a dark vignette round the edges, an old TV’s scanlines and curved glass, big chunky pixels, color fringes, and the colors themselves (saturation, contrast, brightness, a tint, or a handheld’s four greens).
• SortGroup: Draws the entity and everything inside it as one thing among the rest: a pallet with a stack of crates on it, a machine with its operator, a truck with its label.
• Sprite: Draws an image (or a solid rectangle when no image is set) at the entity’s transform.
• Text: Draws a line (or lines) of text at the entity.
• Tilemap: A grid of tiles from one or more tileset images, drawn and (optionally) collided with as a whole.
• Trail: Leaves fading copies of its entity’s Sprite behind as it moves: dashes, speed, ghosts, bullets with streaks.
• TweenPlayer: Plays a little animation of how its entity is drawn, with no code: grown or shrunk (Scale), moved (Move), turned (Rotate) and faded (Fade) at once, eased, as it appears (OnStart), when its Message is sent, or from a script with Play.
• Viewport: Draws the camera on its entity into part of the screen, over the main camera’s view: a minimap in a corner, one player’s half of a split screen, a first-person window (a camera with a First Person View) inside a 2D game.
• Weather: Rain, snow, falling leaves or rising embers all over the view, wherever the camera goes.

Physics

• Body: Makes an entity with a Collider move under velocity and gravity and collide with solids.
• BoxCollider: A box for collisions, centered on the entity (plus Offset) and scaled by its transform.
• CircleCollider: A circle for collisions, centered on the entity (plus Offset).
• HingeJoint: Pins its Body to another body (To), or to a point in the world, at one point (its Anchor), so it turns there: a wheel on a cart, a door, a flipper, a seesaw, a windmill.
• PolygonCollider: A shape for collisions with straight sides between its Points: a ramp, a wedge, a rock, a hill, a boat’s hull, a cup.
• Rope: A rope from its entity to another (To), to a point in the world, or hanging loose: it hangs and sags under gravity, swings, lies over what it falls on and wraps round corners, and holds what’s tied to it no further than its Length: hang a crate or a lamp from the ceiling, tie a balloon to a box, tow a cart, swing a wrecking ball.

Movement

• CameraControls: Pan and zoom with no code, for management, building and strategy games: put it on the camera, in place of a Follow.
• Chase: Goes after a Target once it’s within Range, with no code: zombies, bats, homing mines.
• Follow: Moves the entity after another one, smoothly: a camera after the player, a pet after its owner.
• GridChase: Steps its GridMovement after a Target once it’s within Range, tile by tile and around walls, with no code: a roguelike’s monsters, a maze’s ghosts, a dungeon’s slimes.
• GridMovement: Steps tile by tile with no code, for puzzle games, roguelikes and old-school RPGs: as a player, each press of WASD, the arrow keys, the D-pad or the stick moves it one cell of the scene’s Tilemap, gliding there over StepTime, and holding a way keeps it walking.
• GridPatrol: Walks its GridMovement round a route of cells with no code: guards, villagers, a maze’s sentries, a block that slides back and forth.
• Mover: Moves its entity along a path with no code: moving platforms, lifts, saws, patrolling hazards.
• Patrol: Walks back and forth with no code, turning at walls, (optionally) at the edges of what it stands on, and at Left and Right when they’re set: a platformer’s basic enemy.
• PlatformerMovement: A platformer’s player with no code: runs with A/D, the arrow keys, the D-pad or the stick, and jumps with the Jump action (Space or the gamepad’s A), forgivingly: a jump pressed just before landing still happens, and one pressed just after running off a ledge still counts.
• TopDownMovement: A top-down player with no code: moves in eight directions (or four) with WASD, the arrow keys, the D-pad or the stick, never faster diagonally, with an optional dash.

Combat

• Attack: Close-up attacks with no code: a sword swing, a punch, a bite.
• Battler: A fighter in a turn-based battle, as in an RPG, with no code: on its turn it attacks its Foe, casts its Spell (paid for in Mana) or uses one of its Items, a potion that heals or a bomb that hurts.
• BumpAttack: A roguelike’s attack, with no code: its GridMovement stepping into something with Health on its Layers hurts it by Damage instead of bumping, with a lunge toward it and back over a step’s time.
• DamageOnTouch: Hurts whatever with Health it touches, with no code: spikes, lava, enemies, bullets.
• Health: Hit points.
• Shooter: Fires copies of a Prefab with no code: turrets, cannons, a boss’s spread, or the player’s own gun (see Action).

Gameplay

• Conveyor: Belts on a grid that carry items: a factory’s lines from machine to machine.
• ConveyorPort: Where a machine meets a Conveyor, at the cell it stands on: an In port takes what reaches the end of a belt pointing into its cell (or ending on it) into the machine, and an Out port puts what the machine made onto the belt on its cell, or one next to it leading away.
• Counter: Keeps count and shows it in its entity’s Text: a score, coins, kills.
• Draggable: Something the player picks up with the mouse and drops somewhere else: a card, a puzzle piece, an item in an inventory, a word to put in order.
• DropTarget: A place to drop Draggable things: a slot in an inventory, a card’s place on the table, a hole a puzzle piece fits, a bin.
• FallingBoard: A falling-block board, with no code: pieces of four blocks drop in at the top one after another, the player slides and turns them as they fall, and each locks where it lands.
• GameSpeed: The game’s speed, with no code: a sim’s speed buttons (pause, 1x, 2x, 4x, 16x) set it with their Do action (“Set Speed” with 4, or Faster and Slower), and so can a Trigger on a key’s message or a script.
• Grabber: Picks up Draggable things with a button and carries them, for games played with a controller or keys: a cursor moved with the stick or the D-pad (give it a TopDownMovement or a GridMovement), or a character who carries things about.
• Inventory: What an entity is carrying: keys, potions, the parts of a machine, gold, blocks.
• Lifetime: Destroys its entity after Seconds of game time, optionally fading it out first: bullets, effects, popups.
• LineTool: Lets the player lay a line on the grid by dragging, as a factory game’s belt tool does: press on a cell, drag, let go.
• MatchBoard: A match-3 board, with no code: the gems are the tiles of its entity’s Tilemap, one kind per tile number in Gems.
• MessageScope: Keeps the messages this entity and everything inside it send to part of the scene instead of everyone: a board’s Score, a switch’s On Message, a goal’s Covered.
• PauseGroup: Makes its entity and everything inside it a group that can be paused on its own while the rest of the game runs on: a match-3 minigame on an arcade cabinet, one player’s half of a split screen, the world behind a shop.
• Pickup: Something to collect, with no code: coins, gems, hearts, keys.
• Selectable: Something the player selects as in a strategy game, with a SelectionControls: a worker, a machine, a truck.
• SelectionControls: Selecting as in a real-time strategy game, with no code: put it on the camera, and Selectable on what can be selected.
• ShowWhen: Shows its entity only while a flag holds, with no code: a HUD whose tools appear one by one as goals are met, a sign that’s put up once the guard has been talked to.
• Spawner: Spawns copies of a prefab every Interval seconds at its position, with no code: enemy waves, falling rocks, collectibles that come back.
• TacticsControls: Lets players command their TacticsUnits with the mouse, or with a cursor moved by the arrow keys or the stick: click one of your units whose team’s turn it is to pick it, and the cells it can walk to light up in MoveColor, with the cells it can hit from them in AttackColor; hover a cell to see the way it would go.
• TacticsUnit: A unit in a tactics game, with no code: on its team’s turn you pick it, see the cells it can walk to (and the cells it can hit from them), then click one to walk there and click an enemy in reach to attack it.
• Team: Puts an entity, and everything inside it, on a team: any genre’s team, the same one a turn order’s Teams, a strategy faction or a network game’s Teams name.
• TeamColor: Paints the Sprite on this entity in the color of the team of whoever it’s part of: a strategy unit’s or building’s faction color, a network game’s player color (see Network Settings’ Color Players), so a band or banner on a character shows whose it is.
• Trigger: When a message arrives, does something with no code: “when Score arrives, Damage the Boss by 2”, “when Beat arrives, End Turn”, “when Matched arrives from Board A, Fire the Cannon”.
• TurnOrder: Turn-based play with no code: teams take turns, each acting on its own turn while the others wait.
• TurnTaker: Takes turns in the TurnOrder that covers it: it acts only on its Team’s turn.

Level

• Autosave: Saves the game by itself while its scene is played, in a slot of its own (“Auto”) that a Continue button loads like any other saved game, it being the latest: as the scene starts (a checkpoint as the player arrives), every few minutes of play, and as the game is closed.
• Bouncer: A spring, jump pad or bumper, with no code: bodies touching it from the Direction side are sent flying that way at Strength.
• Checkpoint: A place to come back to: when something it accepts (see Layers) touches it, it becomes the active checkpoint, and a Health with Health.Respawn comes back here after dying.
• Crumble: A platform that gives way, with no code: once something on its Layers stands on it, it shakes for Delay seconds and falls away, coming back Respawn seconds later.
• Door: Takes whoever uses it somewhere else, with no code: a level’s exit to the next Scene, or a door or teleporter to the Target entity in this one.
• DungeonGenerator: Fills its Tilemap with a dungeon made from a Seed, with no code: rooms of different sizes joined by corridors, walled in.
• Goal: A place to push a crate to, for Sokoban-style puzzles, with no code: it’s covered while a grid crate (a Pushable with a GridMovement) rests in its cell, and once every goal with the same AllCoveredMessage is covered, that message is sent: the puzzle solved.
• KeepBetweenScenes: Carries its entity (and everything inside it) into the next scenes the game goes to, still running: the player with their health and inventory from level to level, a music player that doesn’t restart, a score kept on screen.
• Ladder: Something to climb: a PlatformerMovement touching its collider climbs it with up and down, without gravity, and jumps off it with Jump.
• LineTiles: The tiles a line laid on this tilemap is drawn with: a straight piece and a corner, each drawn once and turned to follow the line (see TileTurn), and if you like, pieces for its two ends.
• Minigame: Plays another scene on top of this one as a minigame, with no code: an arcade cabinet in a platformer that opens a match-3 board, a lock picked in a falling-blocks puzzle, a card duel in an adventure.
• MinigameRoot: The game puts this on the entity a minigame is played in (see Minigame and a trigger’s Play Minigame): what the minigame scene had, under one entity of its own, set beside the rest of the world.
• MoveHistory: Undo and restart for grid puzzles, with no code: each step a grid player takes (with any crates it pushes) is a move.
• Pushable: A crate that bodies push along by walking into it, with no code: sideways in a platformer, any way in a top-down game (when its Body’s Gravity Scale is 0).
• RememberScene: Makes the scene it’s in remember how it was left: going to another scene and coming back finds it as it was (crates where they were pushed, enemies beaten, doors opened, pickups taken, a boss’s health) rather than as the scene file has it.
• Room: One room of a level, for a camera that moves room by room (a Metroidvania, a dungeon, Celeste’s screens).
• Switch: Turns things on and off with no code: levers, pressure plates, buttons, locks.
• WallRooms: The rooms walls make on a tilemap’s grid, for heat, air, occupancy or anything else that goes by room: every patch of floor cells joined side by side (four ways; six on a hex map) without crossing a wall.

Story

• Backlog: A log of the lines said so far, to read back: each with who said it and the choices picked, newest at the bottom, scrolled with the mouse wheel, the arrow keys, the D-pad or stick, Page Up and Down, or by dragging it (a finger on a touch screen).
• Dialogue: Lines of talk shown one after another in a dialogue box, with choices that branch it, flags that remember what was said, and no code.
• DialogueBox: Makes an entity a dialogue box that shows who’s talking: the Speaker’s name in its NameTag and their picture in its Portrait, each hidden when there’s nothing to show (a sign, someone without a portrait).
• Speaker: Someone who talks in dialogue: the name shown over what they say and their portrait, in a DialogueBox.
• Typewriter: Types out its entity’s Text a letter at a time, for dialogue and story cards.

UI

• Bar: A bar that fills up to show Value out of Max: health, a boss’s health, charge, a timer.
• Button: Makes the entity clickable: it lightens under the mouse, darkens while held, and clicks when the mouse is released over it.
• Chart: A line or bar graph for the HUD or the world: a few series (a name and a color each) of numbers, the last Keep of each, drawn in its Size with value lines and their numbers, a legend and labels along the bottom.
• Choice: Turns a Button into a picker of one of several Options: “Difficulty: Normal”.
• ControlsList: A controls screen with no hand-placed buttons: while the game runs it makes a row for each input action, its name and a Rebind button showing its keys (“Drop Tool” and “Esc / Right Click”), that the player clicks and then presses a new key for.
• EdgePointer: Points the way to something off the screen, as a strategy game’s objective marker does: while its Target is out of the camera’s view, the entity sits on the screen’s edge (in by Margin) where the line from the screen’s middle to the target crosses it, turned to point at the target, and slides along the edge as the camera pans or zooms.
• Layout: Lines up the entity’s children in a list or a grid, so nothing has to place them: a board of offer cards, a list of quest rows, a shop’s shelf.
• Panel: A menu that opens over the game and closes again: a pause menu, an options panel, a shop, a map.
• SaveSlot: Shows a saved game’s slot, for a save or load screen: the game’s screenshot, when it was saved, and the line being said then (or “Empty”).
• ScreenAnchor: Pins the entity to a point on the screen, for HUDs and menus: a score in the top-left corner stays there whatever the window’s shape, and it doesn’t move when the camera follows the player or shakes.
• Slider: A bar the player drags (or moves with the arrow keys, D-pad or stick once picked) to choose a number between Min and Max.
• Stars: A row of stars, so many of them filled: how well a level went, out of three.
• TextField: A box to type into: a player’s name, the address of a game to join.
• Toggle: Turns a Button into a switch: each click flips IsOn, and its label can say which way it’s set (“Sound: On”).
• TogglesList: A screen of on/off switches with no hand-placed buttons: while the game runs it makes a row for each row of a data table, its label and a Toggle button, each remembered in the save data under its own name (SaveAs, e.g.
• Tooltip: Says something about the entity while the mouse rests on it: after Delay it shows Value in a box by the cursor, pinned to the screen, or writes it into the Text named in Into (an info line on the HUD).

Audio

• BackgroundMusic: Music for the scene: it starts when the scene does, crossfading over Fade seconds from whatever was playing.
• BeatClock: Keeps time with the music: counts its beats and bars as they’re heard (allowing for the sound card’s delay and the player’s own audio offset, Game.AudioOffset, which a Calibration measures), and sends BeatMessage on every beat and BarMessage on the first beat of every bar, so sound players, counters, scripts and BeatPulses can follow along, and Spawners, Shooters, Movers and Switches with Beats set step to it.
• BeatPulse: Bops its entity on the beat of a BeatClock: it’s drawn bigger by Size as each beat lands and shrinks back before the next, ahead by the player’s visual offset so it’s seen on the beat that’s heard.
• Calibration: Measures how late this player hears the game’s sound (speakers with a delay of their own, like Bluetooth headphones) or sees its screen, and offers to set their offset to it: it plays clicks (or, measuring Visual, flashes its light in silence) on a steady beat, the player taps along with its TapAction, a click or a touch for a few bars, and it works out how long after each beat the taps came, leaves out the odd ones and offers their average as the Result, which its Apply action makes the player’s Game.AudioOffset (or VisualOffset), kept in their save data.
• SoundPlayer: Plays its Sound when something happens, with no code: whenever its Message is sent (by a pickup, a switch, a counter, an enemy’s death message or Game.Send), and when it appears if OnStart is ticked.
• SoundSource: A sound that plays over and over where its entity is: a waterfall, a crackling fire, a humming machine.

Adventure

• Hotspot: Something in an adventure to look at and use with the mouse, with no code: a door, a key on the floor, a painting, a character to talk to.
• InventoryBar: An adventure’s inventory, with no code: a bar along the bottom of the screen showing what the walker’s Inventory holds, each item’s icon and name.
• UseWith: What using an item on a Hotspot does, with no code: a key on a door, a coin given to a beggar, a bone thrown to a dog.
• WalkArea: Where an adventure’s characters can walk (see Walker): a shape drawn round the floor of a room, its points dragged, added and taken off in the Scene view.
• Walker: The player’s character in a point-and-click adventure, with no code: a click on the floor (a WalkArea) walks there, round whatever’s in the way along the shortest way; a click off it walks as close as it can; a click on a Hotspot walks over to it and uses it, a right click looks at it.

Blocks

• BlockBuilder: Digs up and puts down the blocks of a Blocks world with the mouse: hold the left button on a block to mine it (it goes in the Inventory), and click the right button to put down the Item (the one picked on the Hotbar).
• Blocks: Makes a Tilemap a world of blocks to dig up and build with: what each tile gives when it’s mined, what each item puts down, how long blocks take to break, blocks that can’t be broken, sand that falls, and torches that glow.
• Crafting: Makes things from what the Inventory holds.
• Hotbar: A row of slots along the bottom of the screen showing what the Inventory holds, with how many.
• WorldGenerator: Fills its Tilemap with a world made from a Seed: rolling hills of grass over dirt, stone below with caves and veins of ore, sand, trees, and a floor that can’t be dug through.

Cards

• Card: A playing card, with no code: it draws itself as a card of its Color with its Title along the top, its Value in the corner, a picture (Image) and its rules Text, or as its back while it’s face down.
• CardEffect: What a card does, with no code: as it’s played (or drawn, discarded, or each turn while it’s on the table) it deals Damage, gives back Heal, has you Draw cards, has its target’s side Discard, gives you GainMana, raises a number (Buff) or does any action (Do), like a Trigger, so a card can drive another part of the game.
• Deck: A pile of cards to draw from, with no code: its cards are the entities inside it with a Card (the last one is the top), or made from a Table, one for each row, as the game starts.
• Hand: The cards a player holds, fanned out along the bottom of the screen, with no code.
• PlayZone: A place on the table cards are played onto, with no code: drag a card from a Hand onto it (or click the card, then it) and it slides into place, laid out in a row or a pile.

Contraptions

• SandboxTools: Garry’s Mod style tools for building contraptions while the game runs: grab and throw things, freeze them in place, spawn props, weld, hinge and rope them together, wire buttons to lamps, thrusters and wheels’ motors, and remove them.
• Weld: Sticks its entity to another, so the two move as one: a plank with a cab, a box with a thruster.

Data

• TableValues: Gives its entity’s other components their values from a row of a table, with no code: an enemy’s Health and Damage from the Enemies table’s Slime row.

Fighting

• CharacterSelect: A fighting game’s character select, with no code: each player at this machine moves their own cursor over the characters’ cards (the entity’s children, in order, one for each of its Characters) with their own keys or controller and picks one with a button; once everyone has, the picks are kept in the save data and Scene loads, where a VersusMatch puts them in.
• ComputerFighter: Has the computer play a FightingCharacter, for one player against the computer and for a training dummy: it walks in, attacks with the fighter’s own moves when it’s close enough, guards (low against a low) as its opponent attacks, jumps in with an air move now and then, and cancels a hit into a special.
• FightingCharacter: A fighting game’s fighter with no code: walks forward and back, jumps (up, forward or back) and crouches on the directions, faces its opponent by itself, and does its Moves, each written in numpad notation (5P a standing punch, 2K a crouching kick, 236P a quarter circle forward and punch, 623P a dragon punch, [4]6P a charge) and played from an animation clip whose hitboxes (drawn in the Clip Editor) are the part that hits, over the startup, active and recovery frames the move gives.
• Hitboxes: Hitboxes and hurtboxes for each frame of the entity’s animation, with no code: a fighter’s punch hits only on the frames its fist is out, and its head takes more than its legs.
• VersusMatch: A fighting game’s match between two fighters, with no code: rounds (best of three to start with) against a clock, each starting with “Round 1” and “Fight!” and ended by a knockout (a fighter’s Health running out) or by the time running out (more health left wins), the fighters back in their places at full health for the next; and once a fighter has won enough rounds, “Kenta Wins” and its WinMessage, which opens a panel with a rematch.

First Person

• Billboard: How a sprite stands in a FirstPersonView.
• Block: Shows the entity as a solid box of wall in a FirstPersonView rather than a flat sprite: doors, gates, pillars, secret walls.
• FirstPersonMovement: First-person controls with no code: W and S (or up and down) walk, A and D strafe, the left and right arrows turn, and the mouse looks around once the game is clicked (Esc gives the mouse back).
• FirstPersonView: Shows the game in first person, through the eyes of its Viewer: the level you paint as a top-down map is stood up around the player.
• Weapon: A gun held in first person, with no code: Fire shoots where the player looks.

Multiplayer

• Multiplayer: Makes the scene a multiplayer game.
• NameTag: Shows the name of the player an entity belongs to in its Text, e.g. on a child just above each player’s character, so everyone can see who’s who.
• Networked: How an entity takes part in a network game.
• PlayedBy: Which of the people playing at this one machine plays the entity (and everything inside it): Player 1, 2, 3 or 4, each with their own keys or controller.
• PlayerSpawn: A place players appear when they join, and when the scene starts.
• Scoreboard: Lists who’s in a network game in the entity’s Text, one player a line: name, team, score and ping, best score first.

Physics Games

• Breakable: Something that breaks when it’s hit hard enough, with no code: a plank of wood, a pane of glass, a stone block, a pig in a tower.
• Bumper: A pinball bumper, with no code: whatever touches it is knocked away hard, at Strength, as it flashes, pops, plays its Sound and scores its Points.
• Drain: The drain at the bottom of a pinball table, with no code: a ball that falls into it is lost, and the next of its Balls is served onto the PlungerServeDelay seconds later, until there are none left and the game’s over.
• Flipper: A pinball flipper, with no code: a paddle on a HingeJoint that snaps up while its button is held and drops back as it’s let go, hitting the ball hard and the same every time.
• Lane: A pinball rollover lane, with no code: a ball rolling through it scores its Points and lights it up.
• LevelGoal: What a physics puzzler’s level is for, with no code: knock out every target before the slingshot runs out of shots.
• Plunger: A pinball plunger, with no code: the ball rests on its tip; hold its button to pull it back (the longer, the further, up to all the way in PullTime seconds) and let go to shoot the ball up the lane, the harder the further it was pulled.
• Slingshot: A slingshot that launches things into a physics game, with no code: pull its pouch back with the mouse (or a finger) and let go, and the shot in it flies off the other way, the faster the further it was pulled.
• Target: A pinball target, with no code: the ball hitting it scores its Points and lights it up, and a drop target (Drops) falls out of the way.
• Tilt: Nudging and tilting a pinball table, with no code: its NudgeAction bumps the table, giving every ball on it a small push (and shaking the view), but nudge too often in a short time and it warns, then tilts: the flippers drop and stay down and the bumpers, kickers, targets and lanes go dead until the ball drains.

Rhythm

• NoteLanes: A rhythm game’s lanes, with no code: notes from a chart (a table of beats and lanes) scroll toward a hit line in time with the music, and the player presses each lane’s key, button or touch zone as its notes reach the line, holding a hold note down until its end.
• SongSelect: A rhythm game’s song select, with no code: the player moves up and down its songs’ cards (the entity’s children, in order, one for each of its Songs), left and right through the difficulties, hears each song as it’s picked out, and plays it with a press (or a click or a tap on its card); the song and difficulty are kept in the save data and Scene loads, where NoteLanes with a Saved Song and Saved Difficulty play them.

Strategy

• Building: A building: it stands still, takes up its Size on the map (units walk around it), and belongs to a team.
• Commander: The player’s strategy controls, on the camera: click or drag a box to select units, right-click to send them (to walk, attack, gather or build), hotkeys and the command card for everything else.
• Faction: A team in a strategy game: its name (the Unit.Team and Building.Team of everything it owns, the same teams every genre shares, see Teams), its color, and the resources it has to spend.
• Fighter: Fights for a Unit or a Building (a tower): it attacks enemies that come within its unit’s sight on its own, and whatever it’s told to.
• FogOfWar: Hides what the Commander’s team can’t see.
• Opponent: Lets the computer play a Faction: it keeps its workers gathering, trains more, puts up the buildings in Builds, trains an army, and sends it to attack once it’s big enough, a bigger one each time.
• Producer: Trains units at a Building: select it and press a unit’s hotkey (or click its button) to queue one up.
• Resource: Something workers gather: a gold mine, a tree.
• Unit: Something a team can select and order about with no code: click it (or drag a box round it) and right-click where it should go or what it should attack.
• Worker: Lets a Unit gather and build.

Visual Novel

• Character: Someone who appears on a visual novel’s Stage, inside it: on stage while their entity is shown, standing at one of the stage’s positions, looking as their Expression says.
• Stage: A visual novel’s stage: a background filling its Size, and the characters inside it (each a Character) standing at its named Positions.

Wiring

• Thruster: Pushes its Body (and whatever it’s welded to) along Direction while it has Power: wire a button to it to lift a platform or drive a cart.
• Wire: Connects an output of another entity to an input of this one, so one drives the other: a button’s “On” to a lamp’s “On”, a sensor to a door’s “Power”, a board’s “Score” to a display’s “Value”.
• WireButton: A button to press with Interact (E) with the mouse over it, or while standing on it.
• WireDisplay: Shows a number wired to its input “Value”, on its Text (or over it, without one).
• WireGate: A logic gate or bit of math for wiring contraptions: inputs A and B, output Out.
• WireLamp: A lamp to wire up: its input “On” lights it from 0 (dark) to 1 (full), tinting its sprite from OffColor to OnColor and turning up a Light on it.
• WireSensor: Notices things inside its collider (usually a trigger): output “Out” is 1 while anything is there, and “Count” says how many.