Making What a Card Shows
Every piece of Weighted Maze comes to you in two parts. First a story. It’s a few paragraphs that put the piece in your head: what it does in the game, and roughly how. Then a card: the same piece written out exactly, every name and every number. Read the story, 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 to read it all now. Read the first two passages, Before your first card and The Set up card. After that, start Chapter 1, and come back when a card shows you something new.
The editor will feel strange at first. That passes. A chapter or two in, your hands will know where things are.
Before Your First Card
Everything your game is made of lives in the Resources panel on the left: Objects, Logic, tables, pictures and Scenes. To make something new, press Add at the bottom of the panel, and the Add Resource window asks what kind. Double-click a thing to open it. It opens in a tab of its own.
A card lists only what you change, and anything it leaves out stays the way the editor starts it.
Four Actions of this game stay out of the Action List until Advanced Mode is on. Set Data Cell and Reset Data Table come in Chapter 2. Tween and Control Tween come in Chapter 4. Choose Settings > Advanced Mode at the top of the editor, and they’re there. It changes nothing in your game, only what the editor shows you.
To run your game, press Play, the triangle at the top of the editor, and the game opens in a window of its own. Close that window, and the editor is back. Save as you go with Ctrl+S, at the end of each part at least.
The Set Up Card
Each chapter opens with a Set up card. It holds everything that isn’t an Object or its Logic: pictures, keys, settings, and where things go in the Scene. Each block starts with a heading in capitals.
ART names the pictures the chapter is about to use. They’re in your project already. The Starter Kit brought them, so there’s nothing to make. Chapter 1 uses all four: the Terrain Tiles, the Cell Outline, the Compass and the Panel.
GLOBAL VARIABLES are values the whole game shares, such as the words on the Status line. On a card each one has a $ in front, as in $status, so you can tell it from the values a Logic keeps. The name you type has no $: status. You make Globals from inside a Logic Component, on its Globals card (more on those cards below). Press its + button and choose New Global…. The Add Global window asks for a Name, a Type and a Default, the value it starts at. Press Add.
A new Global is a Number that starts at 0. Give it the card’s Type, name and Default. A line with nothing after “starts at”, such as $status, starts empty: pick its Type, then make sure its Default box is empty. A word in a Default box, such as Road, takes no quote marks. Once a Global exists, every other Logic can list it too. The same + offers it under Existing Globals. Chapter 1 makes its Globals once its first Logic Component is there.
GAME SETTINGS lines say where each field is. GAME SETTINGS > Display > Window means: open Game Settings, the button above the Resources, choose Display, and find the Window group. The field names under it are the ones you’ll see there. Enter them in the card’s order. Where the order matters, the chapter says why.
A SCENE block marked (new) is a Scene the chapter adds to your game. In Chapter 1 it’s the one your new project already has, given the card’s name, as the chapter shows. To reach a Scene’s own settings, open it and pick the arrow tool above the preview. Then click an empty spot. The Properties on the left show its Background Color and its Cameras and Views. The card’s Camera line gives the Main Camera’s Position, then its Visible Width and Visible Height, in meters. The View line is the Scene’s Main View, in pixels. Start Scene picks a Scene from a list, and a Scene is on that list only once it exists. So the card puts Start Scene after the Scene it names.
PLACE THESE lists what goes in the Scene. 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, and type the card’s X and Y.
Nearly everything in Weighted Maze sits on the screen: the title, the sidebar and its buttons, the orange ring and the compass. Their X and Y go into Screen Offset (px), counted in pixels from the top-left corner. Type them as the card has them, minus signs and all. A Y of -154 is 154 pixels down. Maze Rules and Map sit in the world instead. Neither has a picture. Their X and Y go into World Position, in meters.
Chapter 1’s card ends there. The next two blocks first come in Chapter 2, so you can leave them until then.
COMMANDS are the game’s controls. In Game Settings, choose Input Manager, then press Add Command to make one. A small window asks for the Command Name and the Input Type. Its own Add Command button makes it. A Button Command comes with one row that reads No Input Assigned. Click the row, and press the card’s key. A 2D Axis Command, such as Move Selection, comes with four rows: Left, Right, Up and Down. Each one takes its key the same way. Your Logic will ask whether Paint was pressed, and never care which key that was.
REMOVED lists what the game no longer has under that name. Some pieces go for good, and some come back with a new name, so read the chapter’s Set up before you delete anything. To delete one, right-click it in the Resources and choose Delete at the bottom of the menu. To rename one, choose Rename. A Logic Component you delete stays listed on the Objects it was attached to. So take it off them first. Open each one, switch to Logic, and press the red trash button on its row in Attached Logic.
A Placement’s Own Values
Some lines under a placement start with with, and each is a value that only this placement has. The four Terrain Buttons are one Object, placed four times, and with Per Instance Variables > Terrain = Forest is what makes the second one the Forest button.
Select the placement: click its name in the Scene Explorer on the right of the Scene. Its Properties open on the left. Look down them to Logic, where each Logic Component on the Object has a section. Under it is Per Instance Variables, with a box for each one, such as Terrain. Type the card’s value into it: Forest. It takes no quote marks. A placement the card gives no with line keeps the value its Object starts with. That’s why the first button needs none: it starts at Road.
An Object card may show a Sprite line, Tint (on its placement). That color belongs to each placement, not to the Object, and the Object editor has no field for it. Select the placement, and open Sprite under Rendering in its Properties. Click the Tint swatch, the small square of color, and type the card’s code into the HEX box.
An Object Card and Its Components
An Object is a thing in your game: a cell of the map, 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. Every Object whose card says Window / UI is a Screen UI Object. That’s all of them but two. Maze Rules and Map are each an Empty Object, with no picture and no words, only Logic. This is a Terrain Button, from Chapter 1.
Window / UIUIX 216, Y 48Terrain17Bold#203F43CenterVector-1PanelX 216, Y 48#EEE3CCShow Terrain ChoiceShow Terrain Choice DataThe 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, Text / UI shows words, and UI Interaction lets the player click it. Transform is on every Object from the start. It says where the Object is and how big.
A new Screen UI Object already has the card’s Presentation lines: Space is Window / UI, and Render Layer is UI. It comes with UI Interaction too. Keep that only where the card lists it, such as on the map’s cells and the buttons. Leave its fields as they are. On every other Object, remove it with the red trash button on its row in the Attached Components.
To attach a component, open a group in the Component Toolbox and click the component. Sprite and Text / UI are under Rendering. A Sprite asks for its picture first. Pick the card’s in the Add Sprite Component window, and press Add Sprite. Select a component in the Attached Components, and its Properties open on the left. The card’s lines are those Properties, in order.
Under Sprite, Transform > Size is the size the picture is drawn at. Z Index Within Object at -1 puts the picture behind the Object’s own words, so the button’s name shows on top. Scene Depth Draw Order decides which Object is drawn over which. The higher number is in front. The Sidebar Panel’s -20 keeps it under everything.
A Text / UI’s Font Size is a box, so type the card’s size into it. Emphasis has a B button, an I button and a list. Pick the card’s weight, such as Bold, in the list. Color is a swatch. Click it, and type the card’s code into the HEX box. Alignment is a row of three buttons, and Center is the middle one.
Rendering on a Text / UI is a list. Choose Vector, as the cards do. When you open that Object again, the list shows Editor Default. Your Vector is still there. It’s only the list that forgot.
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. So {$status} always shows what the Global Variable status holds.
A Data Structure line From Logic, as on this card, is one you don’t add yourself. The Logic Component it names supplies that Data Structure, so attach the Logic and the Object gets it.
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. Under Compatible Logic, click each Logic Component the card names. It joins the Attached Logic.
Some Object cards end with Shared Variables, as the Map’s does: mapCell, Map Cell. Those are values the Object holds for its Logic. They arrive with the Logic. Look in the Object’s Properties, under Variables: the Logic’s Shared Variables are there, each marked From Logic. Set the one the card names. For mapCell, its Value is a list, and you pick Map Cell.
A Data Structure Card
A Data Structure is a small form of named fields, and an Object carries one filled-in copy. Every Map Cell carries a Map Place, which holds the number of the cell it stands on. Make one with Add > Data Structure. Here is Map Place, the first one you’ll make, from Chapter 1.
The cell a piece of the map stands on. cell is its number: 0 is the top-left cell, and the numbers grow to the right, then down (its row of Maze Cells). Lay Out Map gives each Map Cell its cell right after creating it.
The sentence under the name is its Description. Type it in if you like. The game never reads it, but you will, months from now. 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 few Data Structures you’ll find already made, named for something else you made. A Logic Component’s own one, such as Show Terrain Choice Data, comes from its Data Structures card (the next passage). A table’s, such as Terrains Entry, comes with the table. Either way, fill in its fields from its card, the same way.
A Logic Component Card
A Logic Component is a piece of behavior you attach to an Object: how a button shows its terrain, how the search takes one Step. 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, the Logic that shows one Terrain Button’s name and its cost.
Shows one terrain the learner can paint with: its name and, unless it is a Wall, what entering it costs (from Terrains). The button is highlighted while its terrain is the brush. Each Terrain Button placement sets terrain, a row of Terrains (Road, Forest, Mud or Wall). chosenTint and plainTint are the button colors with and without the highlight.
Any Objectself.showTerrainChoiceDataText / UI- Action Name
isKnownTerrain- Table
"Terrains"- Row
self.terrain
isKnownTerrain.value == true- Component Value
self.showTerrainChoiceData.label- Value
self.terrain
data('Terrains', self.terrain, 'cost') >= 0- Component Value
self.showTerrainChoiceData.label- Value
self.terrain + " " + data('Terrains', self.terrain, 'cost')
- Component Value
self.text.text- Value
self.showTerrainChoiceData.label
self.terrain == $brush- Value
@self.chosenTint
- Value
@self.plainTint
The Logic opens on its canvas, the big space in the middle. Down the canvas’s left side is a column of small cards, one for each block that comes before the Events on your card. They’re Logic Component, Globals, Data Structures, Components, Per Instance Variables and Shared Variables. Each has a count and a + button.
The top of the card names the Logic Component and the Object it goes on, here the Terrain Button. That’s where you’ll attach it. The sentence under the name is its Description.
Attach to is a setting of the Logic itself. Click the Logic Component card’s heading to open it: Logic Component Name, Description, Dimension and Attach to. Most Logics in this game say Any Object there, which is how a new one starts. Any Object means any Object that has what the cards below it list. A few name one Object instead, such as Maze Rules. Pick it in the list.
DATA STRUCTURES are the forms this Logic hands to every Object it’s on. A line such as Map Place, self.mapPlace, is one you made before. Press the Data Structures card’s +, and pick it. It’s under Existing Data Structures. A line such as this one, Show Terrain Choice Data, belongs to this Logic and no other. Press + and choose New Data Structure. Myth makes it, names it after the Logic, and opens it, ready for the fields on its own card. Either way, the name on the right, self.showTerrainChoiceData, is the name the Logic reads it by. Myth gives it that name itself.
COMPONENTS are what the Object needs, such as self.text, a Text / UI. Most of them turn up on the Components card by themselves, as soon as an Action uses one. If the card’s line isn’t there yet, press + and pick it under Component types.
SHARED VARIABLES hold one value for each Object, the same for every copy of it, read as @self.chosenTint. Press + on the Shared Variables card. The Add Shared Variable window asks for a Name, a Kind, a Type and a Starting Value. The card gives all four, in its columns. Constant means the Logic reads it but never changes it.
PER INSTANCE VARIABLES hold one value for each placement, read as self.terrain. That’s how one Terrain Button can say Forest while the button under it, made from the very same Object, says Mud. Press + on the Per Instance Variables card. The Add Per Instance Variable window asks for a Name, a Type and a Starting Value.
The rest of the card is its Events, each with its Actions. The next passages are about those.
Events: The When Bars
An Event is a moment your Logic waits for: the Scene starting, a key pressed, a message arriving. Each Event on a card starts with a plain heading, such as When the Scene Starts. That’s the name Myth gives the Event itself. You never type it. It tells you which Event the card means, and it’s the name you’ll pick when an Action asks for an Event.
Under the heading is the When bar. It names the kind of Event, then its setting, if it has one: a Command, a Direction, a Global Variable or a Timer name. Press Add Event, the + in the toolbar above the canvas, and a window opens with a filter at the top. Type the kind’s name there, pick it, and press OK. Create, Scene Start and UI Activated ask for nothing more. Command Pressed and Variable Changed open a second window for their setting, such as which Command. Pick the card’s and press OK again.
The new Event appears on the canvas as a big block: its kind on top, then When, with the Event’s own sentence, such as On custom event placedOnMap. Every Event of the Logic sits on the canvas at once. The list in the toolbar, Event shown on the canvas, takes you to any one of them.
2D Direction Pressed, from Chapter 2, asks for its Command too. Its Direction is on the Event’s own block, a row of four buttons: Left, Right, Up and Down. It starts at Left, so press the card’s. A Recurring Timer, from Chapter 4, has a name you make up. Its second window can’t list it. Choose Type a timer name… and press OK. Then type the card’s name into the small window that comes next.
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 placedOnMap. To listen for a new one, open the Add Event window and choose Custom Events > Project Events > Add Custom Event…. Type its name. From then on it’s in the list for every Logic.
Sending often comes first. Trigger Custom Event has a Custom Event field, and it takes any name you type. So you can send a message before anything listens for it. Type it as the card spells it, and the listener you make later uses the same name. Trigger Custom Event rings the bell for every Object that listens. Trigger Custom Event on Object rings it on one Object only: the one its Applies To names, or its own when the card names none.
Modes
To the right of every Event block stands a smaller, pointed block, joined to it by an arrow. That’s the Event’s Mode, and the Event’s Actions hang under it. A new Event has one Mode. Its name may be the Logic Component’s, such as Show Map Cell, or a plain one, such as Mode 1. Until Chapter 3, that one is all you need, and the cards don’t mention it.
From Chapter 3, some Events behave in more than one way, depending on what’s going on in the game. Each way is a Mode of its own, with its own name and its own Actions, standing in a row to the right of the Event. On a card each one is a line under the When bar, such as Mode: Ready (Starting Mode). The card repeats the Event’s heading and its When bar above each Mode. It’s still one Event. On a Changes card, those repeated headings are never marked. Look at the Mode line instead. It’s green when the Mode is new, and red and struck through when it’s gone.
Right-click a Mode block and choose Rename Mode… for the card’s name. To add another, right-click the Event block and choose New Mode…, and type its Mode Name. Once an Event has several, its block gets two more settings. Modes reads One at a time or Combined, and every Event in this game starts on One at a time: one Mode answers, the others wait. Starting Mode picks the one that answers first, marked (Starting Mode) on the card. The card lists the Modes in their order. A Mode’s right-click menu has Move Left and Move Right to put them in that order.
Four Actions change Modes while the game runs. Switch Mode turns on one Mode and turns off all the others at once. Reset Modes goes back to the Starting Mode. In Chapter 5, Turn On Mode lets a second Mode answer as well. That one switches the Event to Combined, and the Modes that are on answer in their order. Turn Off Mode takes one away again.
These Actions pick the Event and the Mode from lists, by name. So make the Event and its Modes first. The Action that switches them comes last.
Actions, One at a Time
Under each Mode, the numbered rows of the card are its Actions, in order. On the canvas they’re blocks, joined by arrows into one line that runs down from the Mode’s block to End. Click an Action in the Action List on the right, and its block appears. The list’s groups start closed. Type the Action’s name into the search box at its top instead.
A new block lands a little to one side, apart from the line, with no arrow into it. A block like that does nothing when the game runs. So right-click it and choose Connect to sequence. It joins the end of the line, right above End, and an arrow runs to it. Join each Action as you add it.
When an Event has several Modes, each Mode has a line of its own. To add an Action to one of them, right-click that Mode’s block, or a block on its line, and choose Add unattached Action here. A window opens with the Actions in it. Pick one and press OK. Its block lands near that line, and Connect to sequence joins it there.
To put a block between two others, click the round handle at the bottom of the block it should follow. Then click the round handle at the top of the new block. The handles join blocks of one panel only. So between two blocks inside an If’s or a Repeat’s panel, add the new block with that block’s own Add inside item first. It lands in that panel, where the handles can join it.
Fill in the fields the card lists. The others keep the value they start with. So an Action with no lines under it is whole: add it, join it, and leave every field as it starts.
Some Actions have an Applies To line, naming the Object the Action works on. Without one, it works on this Object. On the block, it’s the box after the word on, which starts at Self. Pick or type the card’s name there.
Create Instance makes a new Object while the game runs. Its Object to Create names what kind of Object it makes, from your Resources. In Lay Out Map that’s @self.mapCell, the Shared Variable that holds Map Cell. Its Created As box starts at created. Type the card’s name over it, such as newCell. The Actions after it reach the new Object by that name.
Some Actions hand back an answer. On the card their first line is an Action Name, and on the block it’s the box after the word as. Type the card’s name there, with no quotes. Later Actions read the answer by that name. So isKnownTerrain.value is the true or false that a Check Data Row Exists gave.
Change Component Value changes one field of a component or a Data Structure, the one its Component Value path names. Type the path as the card spells it. The path self.text.text is the text of this Object’s Text / UI. The path self.mapPlace.cell is the cell field of its Map Place.
A Function goes in the same way as any Action, from the Functions group of the Action List. The card gives it a small Function tag. Its fields are the Function’s PARAMETERS, under the same names, such as cell. A field that takes an Object, such as rules, takes the card’s name for it.
Declare Variable makes a value that lives only while its Event or Function runs, such as row or markerOrder. Its block has a Type list, a Name and a value after the = sign. The Type starts at Number. A card gives a Type line only where it’s something else, such as Text.
Values, Quote Marks and All
Every value on a card is written the way its box should hold it. The name tells you where a value lives. A plain name, such as cell, is a Parameter of this Function or a Variable a Declare Variable made. A name with a $ in front, such as $brush, is a Global Variable. A name that starts self., such as self.terrain, is a Per Instance Variable, and one that starts @self., such as @self.chosenTint, is a Shared Variable. A value can also be a small formula. The formula data('Terrains', terrain, 'frame') reads one cell of the Terrains table. Type it as the card spells it.
Most boxes on the canvas read what you type as a formula. In those, a word needs quote marks, so the card gives it with them, as in the Table "Maze Cells". Without them, the box reads the word as the name of something else, and the editor marks it as an error. A word in single quotes, such as 'noRoute', is the same kind of word. The box redraws it in double quotes.
A few boxes take a word exactly as you type it. They hold a word on its own, never a formula. A Custom Event’s name is one. So is the Up that Move Selection hands to a Function in Chapter 2. Quote marks typed there become part of the word, so the card gives those words bare: Up, not “Up”.
Which kind is a box? You don’t have to work it out, because the card already has. A word shown with quote marks goes in with them, and a word shown bare goes in bare.
A word inside a formula always keeps its quote marks, as in Reset Trial’s data('Messages', 'ready', 'words'). So does a table’s name, in every Logic.
One formula turns up on many cards. dataRow('Maze Cells', 12) is the name of a table’s row, found by its number, counting from 0: here, Cell 12. A Row box takes either one, the row’s name or its number, so the cards use both. Type each the way its card has it.
A Yes or No field in a Logic Component is a list, holding Yes and No. In a Function, the same field is a box, and takes true or false. The card writes each one the way its field takes it.
A Change Variable has its one Variable box, then an Operator list, which starts at =. The Value then replaces what the Variable held. With +=, the Value is added to what it held instead, and *= multiplies. No Operator line on the card? It’s =. The Variable box takes every kind of Variable, written the way the card writes it, $ and self. and all. When you leave the box, a Declared name may show as self.row. It’s the same Variable.
If, Else and Repeat
An If runs some Actions only when its condition is true. On the canvas it’s a wide, pointed block, with a line marked True running down from it. That line is the card’s Then panel.
The condition is one box inside the block, and the card gives it after the word If. Click the box and type it as the card spells it, such as terrainRow >= 0. Enter, or a click somewhere else, keeps it. A condition can join two tests. && means and: both have to be true. || means or: one is enough.
To fill the True line, right-click the If and choose Add inside Then. A window opens with the Actions in it. Pick one and press OK. If the new block stands apart, join it with Connect to sequence. It joins the end of that If’s line. With one If inside another, right-click the If whose line the Action belongs on.
The card’s Otherwise panel is the If’s Else, the Actions for false. Right-click the If and choose Add Else. An Else block joins the If, on a line marked False beside it. Right-click the Else and choose Add inside Else for each of its Actions, and join each the same way. Otherwise gets a step number like everything else. It isn’t in the Action List, though.
A Repeat runs its Each time panel a set number of times, its Count. Lay Out Map’s Count is dataCount('Maze Cells'), the number of rows in Maze Cells, so it runs once for every cell. On the canvas a Repeat starts closed, one bar that reads Repeat, its Count, times. The small arrow at its left end opens it. It fills the way an If’s True line does: right-click it and choose Add inside Repeat. With one Repeat inside another, right-click the Repeat whose panel the Action belongs in, as with Ifs.
Inside a Repeat, local.index says which time round it is, counting from 0. Type it as the card does.
If and Repeat are in the Action List’s Logic group. The step numbers keep counting right through the panels, so step 4 may sit inside an If that began at step 3. The indent shows where each one belongs.
A Function Card
A Function is a small piece of Logic that does one job when it’s asked: find where a cell sits on the screen, or pick a cell’s picture. Make one with Add > Function, and give it the card’s name. Its card has PARAMETERS, then RETURN TYPE and ACTIONS. There’s no Event. Its Actions hang in one line on the canvas, from Start to End. They run each time another piece of Logic calls the Function. This is Cell Screen Position, from Chapter 1.
Where one cell's center is on the screen, in screen pixels. Cells count in reading order: Cell 00 is the top-left cell, and the numbers grow to the right, then down (a row holds Maze Settings columns cells). Maze Layout says where Cell 00 is and how far apart the cells are. x is measured right from the left edge of the screen; y is measured up from the top edge, so a cell below the top has a negative y, as Set Position takes it for a Screen UI Object anchored at the top-left corner.
- Name
column- Value
0
- Name
row- Value
0
- Name
right- Value
0
- Name
down- Value
0
- Variable
column- Value
cell % data('Maze Settings', 'rules', 'columns')
- Variable
row- Value
floor(cell / data('Maze Settings', 'rules', 'columns'))
- Variable
right- Value
column * data('Maze Layout', 'board', 'spacing')
- Variable
right- Operator
+=- Value
data('Maze Layout', 'board', 'originX')
- Variable
down- Value
row * data('Maze Layout', 'board', 'spacing')
- Variable
down- Operator
+=- Value
data('Maze Layout', 'board', 'originY')
- x
right- y
-down
PARAMETERS are the values a caller hands in. They’re on the Start block, at the top of the line. Press its + button, and the Add Parameter window asks for a Name, a Type and a Default, the card’s Starts at. A Parameter of type Object, such as Clear Trial’s rules, has a Settings arrow on its row. Open it. When the card names an Object, as rules names Maze Rules, set Compatibility Mode to Nominal and pick it in Object Type. When the card says Structural, keep that. Then press Add Required Component for each component the card lists under it, and pick its Component Type.
RETURN TYPE is what the Function hands back. Open the Function’s own card at the top of the left column, and pick it in the Return Type list. Cell Screen Position hands back a Cell Screen Position Result, a Data Structure with x and y. Make that Data Structure first, from its own card. Then it’s on the list. Other Functions hand back one plain value, such as Text.
The Return Action comes last in the line. For a Data Structure it has a box for each field, so x gets right, and y gets -down. For one plain value it has one box, Value.
A call to a Function has an Action Name, the box after as. The caller reads the answer by that name. When the answer is a Data Structure, add the field: place.x is the x of the call named place. When it’s one plain value, add .value: picture.value. Once you’ve typed it, the block shows it as picture alone. It’s the same answer.
A Data Table Card
A Data Table is a spreadsheet the game reads while it plays, one row for each thing. Make one with Add > Data Table. The Create Data Table window asks for its name. Here’s Terrains, from Chapter 1, and the Data Structure that comes with it.
103162-13One row of the "Terrains" Data Table.
A table’s columns are the fields of its own Data Structure, named after it: Terrains Entry for Terrains. Myth makes that Data Structure with the table. It starts with no fields. The table’s card names it at the top, beside the table’s own name. Its card lists the columns, so make them as you would any Data Structure’s fields. Open Terrains Entry from the Resources, and press Add Field for each line, with its name, type and default. They show up in the table at once, under Columns.
Then the rows, with Add Row, under the grid. Each row has a name in the grid’s Entry column, and a value under each column. Double-click a cell to type in it. Enter keeps what you typed. A new row starts with every column’s default, so set the defaults first. You’ll type only what differs. A default shown as (empty) is nothing at all. Leave that box clear. The card counts rows from Row 0, and the editor numbers them from 1. So the card’s Row 0, named Road, is the first row on your screen.
Maze Cells is long. It has 120 rows, one for each cell of the map. You won’t type them. Its card gives the table as a file to download, under IMPORT CSV. Make its columns first, from its Data Structure’s card. Then press Import CSV, under the grid beside Add Row, and pick the file. Myth Engine asks first, before it fills the table. Press Import CSV again. The card’s FIRST ROWS show how the table begins, and you can check yours against them.
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. That way 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. The blocks after it close up the line.
A struck step keeps the number it had, and sits right above the new steps that take its place. Every other step shows its number as it is now. So a step that stays moves down when new steps come in above it. When a step stays and only its values change, the new values are green, with the old ones struck under them. Everything else is already there. The Description at the top is always the new one, and it’s never marked.
This one, from Chapter 2, gives the Terrain Button its new Logic.
Window / UIUIX 216, Y 48Terrain17Bold#203F43CenterVector-1PanelX 216, Y 48#EEE3CCChoose TerrainChoose Terrain DataShow Terrain ChoiceShow Terrain Choice DataA piece that gets a new name comes on a new card instead, with no marks. The chapter tells you what changes in it.
If Your Game and a Card Disagree
It will happen. A value lands in the wrong field, or a step goes in the wrong panel. That’s how everyone learns this.
A piece that does nothing at all? Look first for a block standing apart from its line, with no arrow into it, and join it with Connect to sequence. A box the editor marks as an error? Count the quotes. A Mode that never answers? Look at the Event’s Starting Mode, and at the names in the Switch Mode that should turn it on.
Every chapter’s Goal offers that chapter’s finished game as a download. Open it with File > Open Project… and put it beside yours. Look at the piece that misbehaves. Go down it line by line and find where the two part ways. Or start the next chapter from the download. Nothing you built is wasted, because now you know where everything goes.
One difference is only a name. In the downloads, every Sprite is listed as UI Background, where yours shows its picture’s name. Both are the same Sprite.
Chapter 1 starts with an empty project, and ends with the map on the table and the compass waiting at the camp.