Making What a Card Shows
Every piece of Picture Puzzle comes to you in two parts. The first is a story. It’s a few paragraphs that put the piece in your head: what it does on the board, and roughly how. The second is a card, the same piece written out exactly, with every name and every number. Read the story. Then look at the card with that picture in mind, and build.
This page is about the cards. Each passage shows how to make one kind of thing in Myth Engine, in the editor’s own words. You don’t need all of it today. Read the first two passages, and then start Chapter 1. That chapter meets nearly every kind of card, so it sends you back here often, one passage at a time. A paragraph that opens with a later chapter, such as From Chapter 2, can wait until then.
The editor will feel strange at first. That’s true for everyone. It passes, and somewhere in Chapter 1 your hands start finding things before your eyes do.
Before Your First Card
Everything your game is made of lives in the Resources panel. It runs down the left side of the editor. Its Objects, its Logic, its tables, its pictures and its Scene are all there. To make something new, press Add at the bottom of that panel. The Add Resource window asks what kind. Double-click anything in the Resources, and it opens in a tab of its own.
A card lists what you change. Whatever it leaves out stays the way the editor makes it.
One thing only looks left out. It’s a Text that starts empty, which a card shows as (empty), or with nothing after “starts at”. The editor often puts a 0 in that box, so clear it.
This game needs Advanced Mode from the start. Chapter 1 builds the board in a Data Table while the game runs, and the two Actions that write there, Set Data Cell and Control Data Row, are Advanced Mode blocks. Chapter 5 adds three more, for the pieces’ glide and the Upload button: Tween, Control Tween and Run Code (JS). Choose Settings > Advanced Mode at the top of the editor. The bar along the bottom then says Advanced mode enabled. Only the editor changes. Your game stays exactly as it was.
To run your game, press Play, the triangle at the top of the editor. The game opens in a window of its own. Close that window, and you’re back. Save as you go with Ctrl+S, at the end of every part at least.
The Set Up Card
Each chapter that adds keys, settings or placements opens with a Set up card. It holds everything that isn’t an Object or its Logic. Each block starts with a heading in capitals. Chapter 1’s is the longest. That chapter goes down it with you, one block at a time.
ART names the pictures the chapter is about to use. They’re in your project already, because the Starter Kit brought every one of them. So there’s nothing to make. The list only says which ones matter now.
COMMANDS are the game’s keys, each under a name your Logic uses. Press Game Settings, the button at the top of the Resources panel. Choose Input Manager. Then press Add Command. A small window asks for the Command Name and the Input Type. Every Command in this game is a Button. The window has an Add Command button of its own. That one makes it.
A new Command has one row, and it reads No Input Assigned. Click it. Then press the card’s key, the one under Keybindings. Your Logic asks whether Reset was pressed, and never which key did it.
GLOBAL VARIABLES are values the whole game shares, such as $piecesHome, the count above the board. A card writes a Global with a $ in front, which is how you tell it from a Logic’s own Variables. On the Logic canvas, press the Globals card’s +. Choose New Global… and give the Add Global window its Name, Type and Default. Press Add to keep it. Type the name without the $. Everywhere else on the cards it’s written with one, and you type it that way.
GAME SETTINGS lines say where each setting lives. Take GAME SETTINGS > Display > Window. In Game Settings, choose Display, and find the Window group. The names under the heading are its fields. Enter them in the card’s order, top to bottom, and where the order matters, the chapter says why.
A SCENE block marked (new) is a Scene the chapter makes. In Chapter 1, it’s the Scene your new project already has. Give it the card’s name, Picture Table. To reach a Scene’s own settings, open it and pick Select, the arrow above the preview. Then click an empty spot, and the Scene’s Properties appear on the left. Click the Background Color swatch. Type the card’s code into the HEX box, and press Enter.
Start Scene comes after the Scene for a reason. It’s a list of your Scenes by name, and Picture Table is on it only once the Scene has that name.
PLACE THESE says what goes in the Scene, and where. Open the Scene, and the Place Scene Content panel is on its left. Your Objects are near its bottom, under Predefined Objects. Drag one onto the Scene, then type the card’s X and Y.
Nearly everything in Picture Puzzle sits on the screen: the title, the captions, the Preview, the buttons and the message. Their X and Y go into Screen Offset (px). It counts in pixels from the top-left corner of the game. Up counts as positive there. So the Game Title’s Y of -43 puts it 43 pixels below the top edge. Type the card’s numbers, minus signs and all.
Puzzle Rules is the one thing in the world instead. It has no picture, only Logic. Its X and Y go into World Position, in meters.
A Placement’s Own Values
Some lines under a placement start with “with”. Each one is a value that belongs to this placement alone. Chapter 1 places the Puzzle Button twice, and the “with” lines are what make one of them Shuffle and the other Reset.
A line that ends with (Edit Object Locally) changes one of the Object’s components, for this placement alone. Take with Text / UI > Text = Shuffle. Select the placement in the Scene, and its Properties open on the left. Press Edit Object Locally, near their top, and the Object’s components open for this one placement. Pick the component, and change the card’s field. The editor marks that component Override, because it now differs from the Object’s own. Back to Scene brings you back.
A line such as with Per Instance Variables > Command = Shuffle sets this placement’s own command. Look in its Properties, under Variables, and type Shuffle into Command. The Reset placement keeps Reset, the starting value. Both use Button Action, which reads that word to decide what to ask.
From Chapter 5, speed works the same way. A Speed Button’s Speed holds Slow, Steady or Fast. Match each field by name, because each placement has its own values.
In Later Chapters
From Chapter 2, some of the keys have names of their own, longer than a letter. Press the key itself. Its name appears in the row, such as Left Arrow, Enter or Escape.
From Chapter 2, GAME SETTINGS > General > Game State lists the states the game can be in: Playing and Solved. Your project has Playing already. For Solved, press Add Game State under Available Game States. Type its Game State Name, and press the window’s own Add Game State button.
From Chapter 5, Close Panel has two keys, F and Escape. Add Keybinding adds a row for the second one, and it takes its key the same way.
From Chapter 5, INPUT CONTEXTS says which Commands belong together. On the Input Manager’s left are the Input Contexts, and your project has one, Default. Beside them is the Command Set, the Commands of the context whose row is selected.
The line Puzzle Controls (rename Default) means: give Default that name. The pencil button beside its name, Edit, opens a window with the Input Context Name. Type the card’s, and press Save Input Context. A line marked (new) is a context of its own. Press Add Input Context, and type the card’s name in the window that opens. It starts Inactive at Start, as Lesson Panel Controls should. Its row is selected, too. So the Command you add next, Close Panel, goes into its Command Set.
An Object Card and Its Components
An Object is a thing in your game: a piece of the picture, a button, a line of words. Make one with Add > Object. The Create Object window asks for the card’s name and an Object Type.
When the card’s Transform says Presentation > Space Window / UI, the Object is a Screen UI Object. It lives on the screen, measured in pixels. Its Space and Render Layer are set already, and its Bounding Box starts at 32 by 32. Every Object in this game is one of these but Puzzle Rules. That one is an Empty Object, a Transform and nothing else. It holds only Logic.
Here is the Piece, from Chapter 1. Every one of the 64 pieces on the board is this one Object.
Window / UIUIX 68, Y 68-1Village Pieces 64X 68, Y 68Show Piece, Lay Out SlotSlot NumberThe card lists the Object’s components, with the fields to change under each one. A component gives an Object one ability. Sprite shows a picture, and Text / UI shows words. Data Structure gives the Object a small form of values to carry. UI Interaction lets the player press it. Transform is on every Object from the start. It says where the Object is in the game, and how big it is.
In the Object editor, Attached Components is the list at the top right. The Component Toolbox sits under it, in closed groups. Open a group, and click a component to attach it: Sprite and Text / UI are under Rendering. Select a component in Attached Components, and its Properties open on the left. The card’s lines are those Properties, in order.
The Transform’s Bounding Box is the Object’s own size, apart from its picture. Type the card’s numbers into its Size: 68 by 68 for a Piece.
A Sprite asks for its picture first. The Add Sprite Component window lists your pictures, so pick the card’s and press Add Sprite. Transform > Size is how big the picture is drawn, in pixels on the screen. Z Index Within Object at -1 keeps the picture one step behind anything else on the same Object, such as a button’s words.
The Village Pieces 64 picture is the whole Village cut into 64 frames, one for each piece. Every Piece shows one frame, and Chapter 1 says how it picks.
The Outline Square picture is white, and its Sprite’s Tint colors it. Give Tint the card’s HEX color. Every Piece starts with that dark green-gray edge around it, before any Logic changes the color. Chapter 2 teaches that edge to change color.
A Text / UI’s Font Size is a box. Emphasis has a B button, an I button and a list of weights. Pick the card’s weight, such as Bold or Semibold, from that list. Color is a swatch: click it, type the card’s code into the HEX box, and press Enter. Alignment is a row of three choices, and Center is the middle one. Rendering is a list. Pick the card’s, Vector.
From Chapter 5, one Sprite has a Scene Depth (Draw Order) line. It’s a box among the Sprite’s Properties. The higher number draws in front.
A Text with braces in it shows a live value, one that changes while the game runs. Type it into the Text field as the card spells it, braces and all. The Board Caption shows {$piecesHome} / {$gridSize * $gridSize}. As pieces come home, the first number grows.
The Message Line’s card has two lines more than the others. Text Bounds is a list, and Wrap to Width lets a long message wrap. Transform > Size X belongs to the Text / UI’s own Transform, the box its words fit in. It’s 900 pixels wide.
On a Screen UI Object, UI Interaction comes attached. Keep it only where the card lists it, as on the Puzzle Button. There it says (as it is added), so leave its fields the way they come. Every other Screen UI Object needs it gone. Press the red trash button on its row in Attached Components.
A Data Structure line From Logic names the Logic Components that need this Data Structure on their Object. Such a Logic brings it along. So don’t add it from the toolbox. Attach the Logic, as the next paragraphs show, and the Data Structure comes with it, already set to the card’s. Its line under Data Structure, Slot Number on the Piece, is then something to check.
Logic comes last on an Object card. It isn’t in the toolbox. Switch the list at the top right of the preview from Components to Logic. Now Attached Logic is on the left, and Compatible Logic is on the right. It holds only what fits this Object. Click each Logic Component the card names.
Some Object cards end with a list of Shared Variables, the values their Logic needs. These are values its Logic needs, shared by every copy of this Object. Attach the Logic first. In the Object’s Properties, open Variables, and find the rows marked From Logic. Set the card’s values there. Puzzle Rules holds Piece Outline in outline and Piece in piece. Its puzzleRules value names Puzzle Rules itself.
Per Instance Variables belong to each copy instead. The Object holds their starting values, and every new placement begins with those same values. A placement can change its own copy, as the Puzzle Button’s Command does.
A Data Structure Card
A Data Structure is a small form of named fields, and an Object carries one filled-in copy. Every Piece and every Piece Outline carries a Slot Number, which says which slot of the board it stands for. Make one with Add > Data Structure. The Create Data Structure window asks only for its Name, and a new one starts with no fields at all.
The slot a Piece or an Outline stands for: its row of Board Slots, 0 for the top-left slot, counting right, then down. Make Board gives each one its slot right after making it.
The sentence under its name is its Description. If you’d like it, type it into the Description box on the left, under the Name. The game never reads it, but months from now, you will.
Press Add Field for each line. A field has a Name, a Type and a Value, and the card’s default goes in Value. A new field comes as a Number with 0, which is what slot needs.
A Logic Component Card
A Logic Component is a piece of behavior you attach to an Object: how a Piece shows its part of the picture, how Puzzle Rules deals the board. Make one with Add > Logic Component. The Create Logic Component window asks for a Name and a Starter. Leave the Starter on Empty Logic Component. This card is from Chapter 1. It makes each Piece show the right part of the picture.
Shows the picture frame of the piece that Board Slots puts in this Piece's slot. Make Board gives each Piece its slot in its Slot Number (0 is the top-left slot, counting right, then down).
Any Objectself.slotNumber- Frame
data('Board Slots', self.slotNumber.slot, 'piece')
- Frame
data('Board Slots', self.slotNumber.slot, 'piece')
The top of the card names the Logic Component and the Object it attaches to. Lay Out Slot names two, the Piece Outline and the Piece, because both use it. The sentence under the name is its Description, yours to type or skip, in the Description box on the left.
Down the canvas’s left side are small cards for the Logic’s requirements. They include Globals, Data Structures, Components, Per Instance Variables and Shared Variables. Each has a +.
The Logic Component heading opens its settings. Give it the card’s Name and Description, if you’d like that description. Attach to says which Objects may carry it. Any Object is the starting choice. It must still carry the requirements listed on the cards below, such as Slot Number.
DATA STRUCTURES are forms this Logic needs on its Object. Show Piece needs Slot Number. Press + on Data Structures and pick it under Existing Data Structures. When a card names the Logic’s own form, use New Data Structure instead. Myth opens that form for its fields. Make them from its separate card.
COMPONENTS are other abilities the Logic needs, such as Sprite. They often appear when an Action uses them. If a listed one is missing, add it with the Components card’s +.
SHARED VARIABLES hold values shared by every copy of an Object. Make Board’s outline names the Object it creates. Press + on Shared Variables. The Add Shared Variable window asks for Name, Kind, Type and Starting Value. Match the card’s columns. Constant means this Logic reads the value without changing it. The Object’s card supplies the Object to pick later.
PER INSTANCE VARIABLES belong to each copy, so one placed button can differ from another. Button Action’s command lets two Puzzle Buttons ask for different things. Press + on Per Instance Variables. The Add Per Instance Variable window asks for Name, Type and Starting Value. The Scene’s placement can then set its own copy.
The rest of the card is its Events and Actions. Those come next.
Events: The When Bars
An Event is a moment your Logic waits for: the game starting, a key, a press on a button, a message arriving. Each Event on a card starts with a plain heading, such as On Placed on Board. That’s the name Myth gives the Event by itself, from its kind and its setting, so you never type it. Some read a little oddly. A button’s UI Activated Event is called On Hud Activated, and that’s the right one.
Under the heading is the When bar. It names the kind of Event, then its setting, if it has one, such as a Command.
Press Add Event, the + above the canvas. Its window has a filter at the top, so type the kind’s name there, pick it, and press OK. Game Start, Scene Start and UI Activated ask nothing more. Command Pressed asks for its Command in a second window, so make the Commands first. Pick the card’s, such as Reset, and press OK again.
Most Events in this game are a Custom Event. That’s a message one piece of Logic sends and others listen for, like a bell rung in one room and heard in another. Its When bar names the message, such as placedOnBoard. To listen for a new one, open the Add Event window and choose Custom Events > Project Events > Add Custom Event…. Type its name. Once some Logic sends that message or listens for it, it’s on the list already.
You can build the sending and the listening in either order. Trigger Custom Event rings the bell for every Object that listens. Trigger Custom Event on Object rings it for one Object only, the one its Applies To names. Either one’s Custom Event field takes the name exactly as you type it.
Every Event stands on the canvas at once. The toolbar’s Event shown on the canvas list takes you to one. Each has its own line of Actions, so work under the right Event.
From Chapter 2, the pointer comes in. Mouse Pressed on Object, Mouse Released on Object, Mouse Held and Mouse Release each ask for a Mouse button in a second window. Pick the card’s, left. Begin Step and End Step ask nothing more. They run at the start and at the end of every frame. Variable Changed asks for its Global Variable. Picture Complete’s is piecesHome, written there without the $.
From Chapter 5, Create and Step ask nothing more, and neither does Game State Changed. A Recurring Timer has a name you make up, so its second window can’t list it. Choose Type a timer name… and press OK. Then type the card’s name, pictureSort, into the small window that comes next.
Modes
Beside each Event stands a pointed block, joined to it by an arrow. That’s a Mode. Its Actions hang below it. With only one Mode, the card leaves its name out.
From Chapter 2, an Event may behave in several ways. Each way gets its own Mode. Each Mode has the Event heading above it, so you’ll see that heading more than once. It’s still one Event. The Mode marked Starting Mode answers first.
Right-click the first Mode and choose Rename Mode… for its name. Right-click the Event and choose New Mode… for the others. Type the card’s Mode Name. Once there are several, the Event’s Starting Mode list chooses which starts. Leave its Modes setting on One at a Time. One Mode answers while the others wait.
Switch Mode uses lists to pick the Event it switches and the Mode that answers next. So make the Event and its Modes before any Action that switches them. A Mode with no Actions stays empty. While it answers, that Event does nothing.
Actions, One at a Time
Under each Mode, the numbered rows are its Actions, in order. Arrows join them down to End. The Action List on the right holds the Actions in groups. Search for the name on the card and click that Action to place its block.
A new block stands apart from the line. No arrow reaches it yet, so the game runs straight past without ever using it. Right-click it and choose Connect to Sequence. It joins above End. Build down the card, joining each Action as you add it.
For an Event with several Modes, right-click the right Mode first. Choose Add Unattached Action Here. Pick the Action, and Connect to Sequence joins its block to that Mode’s own line.
To put an Action between two others, use the round handles. Click the lower handle of the block it follows, then the upper handle of the new block. Inside an If or Repeat, add the block inside that panel first. Handles join blocks within the same panel.
Fill in the listed fields, matching each name to the slot on that Action’s block. Leave the rest the way they start. An Action with no lines under it is whole: add it, join it, and leave it alone.
Some Actions have an Applies To line, naming the Object they work on. Without one, they work on this Object. On the block, it is the slot after on. It starts on Self. Type or pick the card’s Object, such as newOutline, an Object an earlier Action created.
Some Actions hand back an answer. On the card their first line is an Action Name, and on the block it’s the slot after as. Type the card’s name there, with no quotes. A later Action reads the answer by that name, a dot, and the part it wants. Lay Out Slot asks Slot Center for a slot’s middle, names the answer center, and then reads center.x and center.y.
A Change Variable sets one Variable to a Value. Type the Variable’s name as the card spells it, with its $ if it’s a Global. Beside it is an Operator list that starts at =, and then the Value replaces what the Variable held. With += the Value is added on. No Operator line on the card? Then it’s =.
A Function goes in like any Action, from the Functions group of the Action List. The card marks it with a small Function tag. Its fields are the Function’s PARAMETERS, written the editor’s way on the block. An input that takes an Object is a list, so pick the card’s name in it, such as puzzleRules.
Chapter 1 has a handful of Actions of its own.
- Create Instance makes a new Object while the game runs, which is how Make Board lays out 64 Outlines and 64 Pieces. Its Object to Create slot names the Object, such as @self.outline, the Shared Variable holding Piece Outline. Type the card’s name over the one in Created As, such as newOutline. The Actions after it use that name.
- Set Position puts this Object at an X and a Y at once. Its Position Relative to list says what they’re counted from. The card’s Screen means pixels on the screen, counted the same way as Screen Offset.
- Set Frame shows one frame of the picture. Frames count from 0.
- Control Data Row adds a row to a table by its name. Set Data Cell writes one value into a table, in the row and the column its boxes name.
- Generate Random Integer picks a whole number from its Minimum to its Maximum, both included. Shuffle Board reads its answer as
partner.value.
From Chapter 2, Change Sprite Tint Property colors this Object’s picture with the code in its Value. Set Game State picks a state from its Game State list.
From Chapter 5, some Actions answer a yes or a no, and they have an Action Name too. Check Input Context Active answers whether its Input Context is on. Check Game State answers whether the game is in the state picked in its Game State list. Check Cooldown Ready answers whether the cooldown named in its Cooldown Key has run out, and Start Cooldown starts one. Their answer is a .value of true or false, read by an If right after. Start Recurring Timer starts a timer by its name. Stop Recurring Timer stops it. Tween glides one value, named in its Value box, to its Target over its Duration in seconds. Control Tween ends a glide where it is. Set Visible, Set Sprite, Set Scale and Set Z Order each change one thing about how an Object is drawn, and their cards give the values.
Set Input Context Active turns one set of keys on or off. Pick the set in its Input Context slot. Active starts on, so a card with no Active line turns that set on. Type the card’s true or false when it gives one.
Change Component Value changes one field. Make Board uses self.makeBoardData.slotCount, the count in its own Data Structure. Type the path as the card spells it.
Declare Variable makes a value that lasts through this Event or Function call. Its block has a Type, a Name and a value after =. A new one is Number. The card gives a Type only when it differs.
Also from Chapter 5, Run Code (JS) holds a short program, in the language web pages use, which opens your computer’s file chooser for Upload. Its card gives the program whole, to copy into its box.
From Chapter 2, a new step sometimes goes between old ones. Use the round handles, as above. The card’s indent tells you which panel it belongs in. The steps after it keep their order.
Values, Quote Marks and All
Every value on a card is written for its slot on the canvas. Type it as shown. A plain name is a Function Parameter or a declared Variable. A name beginning with $ is a Global. A name beginning self. belongs to this Object. Shared Variables begin @self.puzzleRules, with @self. showing that all copies share this value.
A formula can read a table. The formula data('Board Slots', self.slotNumber.slot, 'piece') reads this slot’s piece. The table name and column name keep their quotes inside the formula. A row may be a number or its name.
Other slots name resources. There the name goes in bare, as the card shows. A text value goes in with quotes when the card gives them, such as “pieceSlide”. A Custom Event’s name goes in bare. It names a message instead of reading a formula.
Follow its card. Follow its card, quotes and all. A yes or no value is written true or false where the slot takes a formula.
If, Else and Repeat
An If runs its Then panel only when its condition is true. On the canvas it is a wide, pointed block. Its condition is one slot. Type the card’s formula there and press Enter. The formula may join tests: && means and, while || means or. Parentheses keep the joined tests together.
Right-click the If and choose Add inside Then for an Action in its True line. Pick the Action, then join it with Connect to sequence if it stands apart. Use the If whose panel needs it.
The card’s Otherwise is the If’s Else, for a false condition. Right-click the If and choose Add Else. Then right-click the Else and use Add inside Else for its Actions. The card numbers Otherwise too. It isn’t a separate Action in the list.
A Repeat runs its Each time panel a fixed number of times. Its Count slot holds that number or formula. Open it with the small arrow, then right-click it and choose Add inside Repeat. Join each Action inside that panel. Make Board’s Count is its slot count, so every slot gets a turn.
Inside a Repeat, local.index counts the turns from 0. The card’s indent shows what belongs inside. A step at the Repeat’s own indent follows the whole Repeat instead of running inside it. Step numbers count through the panels, so an indented step keeps its place in the same count.
A Function Card
A Function is a small piece of Logic with one job. It does it whenever another piece asks. Slot Center, from Chapter 1, answers where the middle of a slot is on the screen. Make one with Add > Function. The Create Function window asks only for its Name.
Answers where the center of a slot lies on the screen, in screen pixels. A Screen UI Object is placed from the top-left corner of the screen with +Y up, so x counts right and y is negative below the top edge. The board is a square of boardSide pixels whose top-left corner is boardLeft from the left edge and boardTop from the top edge; gridSize slots fill each row.
- Name
slotSide- Value
0
- Name
column- Value
0
- Name
row- Value
0
- Name
centerX- Value
0
- Name
centerY- Value
0
- Variable
slotSide- Value
$boardSide / $gridSize
- Variable
column- Value
slot % $gridSize
- Variable
row- Value
floor(slot / $gridSize)
- Variable
centerX- Value
$boardLeft + (column + 0.5) * slotSide
- Variable
centerY- Value
-($boardTop + (row + 0.5) * slotSide)
- x
centerX- y
centerY
Its card has PARAMETERS, RETURN TYPE and ACTIONS. There’s no Event. The Start block holds Parameters, with a + for Add Parameter…. Pick the card’s type first. Type its name and starting value in the row. An Object Parameter, such as puzzleRules, names the Object passed into this call. The pencil opens settings for Compatibility Mode and Object Type, where you give the Object its requirements. Match any requirements the card lists there.
For an Object Parameter on these cards, choose Object under Objects, Data Structures and Functions. Its Edit button opens the settings. Pick the card’s Compatibility Mode there, and its Object Type when it names one. A Structural Parameter may need Required Components instead. Color Outline’s outline needs Slot Number, with slotNumber as its Slot Name.
A Function hands back one value, or nothing. Open the Function card on the canvas’s left for its Return Type. Slot Center returns Slot Center Result, a Data Structure holding x and y. Make that form first. A Number return hands back one number instead.
The Actions run from Start to End each time the Function is called. Declare Variable makes its working values at the start. Return hands back the answer. For Slot Center it has one slot per field, x and y. Enter the card’s values in those slots.
No answer needed? Keep the Return Type on Nothing, so the caller only asks for the job. The Actions still run to finish the job.
A Data Table Card
A Data Table is a spreadsheet the game reads while it plays. Use Add > Data Table. The table comes with a Data Structure named after it: Messages Entry for Messages. Its fields become the table’s columns.
Here is Messages, from Chapter 1. Each row is something the Message Line can say.
Reset.Open Messages Entry from Resources. Use Add Field for each line on its separate card, with Name, Type and default Value. The fields appear as columns in Messages. Set these defaults before adding rows, so every new row starts with them.
Then the rows. Add Row sits under the grid. A new row starts with every column’s default. So set the defaults first, and you’ll type only what differs. Each row’s name goes in the grid’s Entry column, where the card puts it after Row 0, Row 1 and so on. Double-click a cell to type in it, and Enter keeps what you typed. The card counts rows from Row 0, and the editor numbers them from 1. So the card’s Row 0, reset, is your first row.
Board Slots shows ROWS 0, and that’s right. It starts empty. When the game begins, Make Board writes one row for every slot on the board.
Changes Cards
From Chapter 2 on, the game changes what you’ve already made. A Changes card shows the whole piece with the changes marked, so you can find your place. Lines marked Add, in green, are new: add them. Lines marked Delete, red and struck through, are gone: delete them. To take a block off the canvas, right-click it and choose Delete. Everything else on the card is there already. Sometimes every step of an Event goes. The Event stays, and its first new Action joins under the When bar, as it did when the Event was new.
Sometimes a step stays and only its values change. Then the new values are green, with the old ones struck beside them. This one, from Chapter 2, gives Pieces Home one more Event. It counts the pieces again after each exchange.
Keeps $piecesHome, the count the Board Caption shows, equal to the number of pieces in their home slots.
Any ObjectIf Your Game and a Card Disagree
It will happen. A value lands in the wrong box, or a step goes in the wrong place. That’s how everyone learns this.
A piece that does nothing at all? Look first for a block apart from its line, and join it with Connect to Sequence. A box with a red edge? Count its quote marks, and look for a missing one. A message that’s sent but never heard? Perhaps it’s spelled two ways, once where it’s sent and once where it’s heard.
Every chapter’s Goal holds that chapter’s finished project as a download. Open it with File > Open Project…. If yours has changes you haven’t saved, Myth offers to save them first.
Find the piece that misbehaves. Go down it line by line against yours, until the two part ways. Or start the next chapter from the download. Nothing you built is wasted, because now you know where everything goes.
Chapter 1 begins with a new, empty project. It ends with the whole Village on the board, dealt into the wrong slots, waiting for hands.