Making What a Card Shows
Every piece of Crack the Safe 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 in the game, 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, then start Chapter 1. It meets most kinds of card, so it sends you back here often, one passage at a time. A paragraph that opens with a later chapter 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, 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.
To run your game, press Play, the triangle at the top of the editor. It 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 what isn’t an Object or its Logic. Each block starts with a heading in capitals. Chapter 1’s card is the longest, and that chapter goes down it with you.
ART names the pictures the chapter is about to use. The Starter Kit brought every one of them into your project already, 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, and choose Input Manager. Select the context’s row on the left first. Then press Add Command. The new Command belongs to that context. 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, and that one makes it.
A new Command has one row for its key, and it reads No Input Assigned. Click it. Then press the card’s key, the one under Keybindings. Your Logic asks whether Scan was pressed, and never which key did it.
GLOBAL VARIABLES are values the whole game shares, such as $entry, the number on the display. A card writes a Global with a $ in front. That’s how you tell it from the values a Logic keeps for itself. You make a Global from inside a Logic Component. Down the left of its canvas is a column of small cards. One is Globals. Press its + and choose New Global…. The Add Global window asks for a Name, a Type and a Default, the value it starts at. Type the name without the $, then press Add. Once it’s made, every other Logic finds it on the same +, under Existing Globals. It’s one Global, shared.
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, and they go in the card’s order, top to bottom. Where the order matters, the chapter says why.
A SCENE block marked (new) is a new Scene. In Chapter 1, it’s the Scene your new project already has, given the card’s name. To reach a Scene’s own settings, open it and pick Select, the arrow above the preview. Click an empty spot. Its Properties appear on the left. Click the Background Color swatch, type the card’s code into the HEX box, and press Enter.
Start Scene follows the Scene for a reason. It’s a list of your Scenes, and Safe Room is on it only once the Scene has that name. The list writes it Safe Room · 2D.
PLACE THESE says what goes in the Scene, and where. Open the Scene. The Place Scene Content panel is on its left, with your Objects near its bottom, under Predefined Objects. Drag one onto the Scene. Then type the card’s X and Y.
Nearly everything in Crack the Safe sits on the screen: the safe, the keypad, the words. Their X and Y go into Screen Offset (px), counted in pixels from the top-left corner of the game. Up counts as positive there. So the Game Title’s Y of -42 puts it 42 pixels below the top edge. Type the card’s numbers, minus signs and all.
Safe Rules is the one thing in the world instead. It has no picture, only rules. Its X and Y go into World Position, in meters. A placement marked hidden starts out of sight. A little under Screen Offset (px) in its Properties is a switch, Visible at Game Start. Turn it off.
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 Digit Key ten times, and the “with” lines are what make one of them a 1 and another a 7.
The line with Per Instance Variables > Digit = 1 is one of those. Select the placement in the Scene, and its Properties open on the left. Near their bottom is Logic, with a part for each Logic Component on the Object. In the Type Its Digit part is Per Instance Variables, and in it a box named Digit. The editor writes the name with a capital, so digit shows as Digit. Type the card’s number into it.
A line that ends with (Edit Object Locally) changes one of the Object’s own components, for this placement alone. Ten Digit Keys share one Object. Each shows its own number. Select the placement and press Edit Object Locally, near the top of its Properties. Pick the card’s component, Text / UI, and change its field. The editor marks that component Override, because it now differs from the Object’s own. Back to Scene brings you back.
From Chapter 5, a placement can say with Z-Index = 200. Select it in the Scene, open Rendering in its Properties, and type that number into Z-Index. The placement uses it to draw above the room.
In Later Chapters
From Chapter 2, GAME SETTINGS > General > Game State lists the states a trial can be in: Locked, Unlocked and Exhausted. Under General, open the Game State group. Press Add Game State under Available Game States, type its Game State Name, and press the window’s own Add Game State button. Initial Game State is a list under them.
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. A line such as (rename Default) means: press the pencil on Default’s row, Edit, and type the card’s name into Input Context Name. Then press Save Input Context. A (new) context comes from Add Input Context. Its Active at Start switch says whether it works from the first moment.
A Command can belong to both groups. Select the second context, then pick that Command in Reuse a Command…, below its Command Set. This keeps one Command and its keybinding in both contexts.
An Object Card and Its Components
An Object is a thing in your game: the safe, one key on the keypad, 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, and its Space and Render Layer come set already. Every Object in this game is one of these but Safe Rules. That one is an Empty Object, a Transform and nothing else, because it holds only rules.
Here is the Digit Key, from Chapter 1. All ten number keys are this one Object.
Window / UIUIX 68, Y 51018Bold#F5E9CACenterVector-1Safe KeyX 68, Y 51Safe RulesThe card lists the Object’s components, with the fields to change under each one. A component gives an Object one ability of its own. Sprite shows a picture. Text / UI shows words. UI Interaction lets the player click it, and Transform is on every Object from the start. It says where the Object is, and how big.
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 in it to attach it to the Object. Sprite and Text / UI are under Rendering. Data Structure is under Data. 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. A Digit Key’s is 68 by 51.
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. Z Index Within Object at -1 keeps the picture one step behind the Object’s words.
A Text / UI’s Font Size is a box. Emphasis has a list of weights, so pick the card’s, such as Bold. 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 Vector, as every card does. Open that Object again later, and the list says Editor Default. Your Vector is still there. It’s the list that forgot, not you, so leave it.
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 {$scans} follows the Global Variable scans, and {$high - $low + 1} works out a small sum as the game plays.
On a Screen UI Object, UI Interaction comes attached. Keep it only where the card lists it, as on the Digit Key. 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 gives the Object its own copy of a small form, such as Safe State on Safe Rules. Attach Data Structure from the toolbox, and pick the card’s in its list. From Chapter 3, one line says From Logic. That Data Structure belongs to the Logic it names, so attach the Logic, and it comes along already set.
From Chapter 3, the Code Mark’s Sprite has a Tint field for its first color. Pick it there. It comes before the Sprite’s Transform.
Logic comes near the end of an Object card. It isn’t in the toolbox. Switch the list at the top right of the preview from Components to Logic, and two lists appear: Attached Logic on the left, and Compatible Logic on the right. Click each Logic Component the card names. Its row in Attached Logic has a switch, and a card line such as Computer Role (turned off) means: turn that switch off.
Some cards end with Shared Variables, as the Digit Key’s does: safeRules, Safe Rules. That’s a value the Object keeps for its Logic, here the Object a key reports to. It arrives with the Logic. Switch the list back to Components, and look in the Object’s Properties under Variables. The Variable is there, marked From Logic. For an Object value, Value is a list: pick the card’s Object. A Boolean value is a switch. Yes means on, as worksInLesson needs on the lesson buttons in Chapter 5. A Per Instance Variables line on an Object card, such as the Back Key’s clickEvent, is in the same place. There you type the card’s word into its Value, for every placement at once.
A Data Structure Card
A Data Structure is a small form of named fields, and an Object carries one filled-in copy. Safe Rules carries Safe State, which holds the secret code. Make one with Add > Data Structure. The Create Data Structure window asks only for its Name.
What the Safe Rules Object carries for its Logic to share. code: the secret code that opens the safe. startsNewEntry: true when the next digit typed starts a new entry instead of adding to the one shown.
The sentence under its name is its Description. If you’d like it, type it into the Description box 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 Boolean’s Value is a switch. Default true means it’s on.
A few Data Structures you’ll find made already, each named after a table. Safe Settings Entry comes with the Safe Settings table. Fill in its fields from its card, the same way. A Data Table card says more.
A Logic Component Card
A Logic Component is a piece of behavior you attach to an Object: how a key types its digit, how the safe shows its door. 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 key on the keypad type its own digit.
A keypad button that types its digit when the player clicks it, the same as pressing its digit key on the keyboard.
Any Object- safeRules
@self.safeRules- digit
self.digit
The Logic opens on its canvas, the big space in the middle. Down the canvas’s left side is a column of small cards: Logic Component, Globals, Data Structures, Components, Per Instance Variables and Shared Variables. Each has a count and a + button. The lines at the top of your card, before its first Event, are made on these.
The card’s heading names the Logic Component and the Object it goes on, here the Digit Key. That’s where you’ll attach it. Under the name is its Description, yours to type or skip. Click the Logic Component card’s heading, and it’s there, under Logic Component Name. It also holds Attach to. Every Logic in this game says Any Object there, which is how each new one starts. Any Object will do. It only needs what the lines below ask for.
DATA STRUCTURES are the forms this Logic reads on the Object it’s attached to. New Safe reads Safe State, as self.safeState. Press the Data Structures card’s +, and pick it under Existing Data Structures. The name on the right, self.safeState, is the one the Logic reads it by. Myth names it. So New Safe reaches the code as self.safeState.code.
SHARED VARIABLES hold one value for the Object, the same for every placement of it. The Logic reads one with @self in front, as in @self.safeRules. Press + on the Shared Variables card. The Add Shared Variable window asks for a Name, a Kind, a Type and a Starting Value, and the card gives all four, in its columns. Constant means the Logic only reads it. An Object one starts at None. Later, the Object’s own card picks which Object it holds, as the Digit Key’s picks Safe Rules.
PER INSTANCE VARIABLES hold one value for each placement. The Logic reads one with self in front, as in self.digit. That’s how one Digit Key Object becomes ten keys, each typing its own digit. 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 game starting, a key, a click on a button, a message arriving. Each Event on a card starts with a plain heading, such as On Hud Activated. That’s the name Myth gives the Event by itself, from its kind and its setting, so you never type it. They come in a few forms: When the Game Starts, When Scan Is Pressed, On Variable Changed. 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 + in the toolbar 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, Create and UI Activated ask nothing more. Command Pressed asks for its Command in a second window, so make the Commands first. Variable Changed asks for its Global Variable, written there without the $. When a card’s When bar names no Global, pick Any Global Variable, first on that list. Game State Changed, from Chapter 2, asks nothing more either, and nor does Scene Start, from Chapter 3. From Chapter 5, On Enable and On Disable also ask nothing more.
The new Event appears on the canvas as a big block. Every Event of the Logic sits on the canvas at once, each with its own line of Actions below it. Beside each one is a smaller, pointed block, joined to it by an arrow, and the Event’s Actions hang under that. It’s the Event’s Mode. This game never needs more than one, so the cards leave it out, and its name doesn’t matter.
A Custom Event is a message one piece of Logic sends and another listens for, like a bell rung in one room and heard in another. Its When bar names the message, such as backClicked. 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 on Object rings the bell for one Object only, the one its Applies to names. From Chapter 4, Trigger Custom Event rings it for every Object that listens. Either one’s Custom Event box takes the name exactly as you type it. It can hold a Per Instance Variable instead, as Safe Button’s self.clickEvent does, so each button sends its own message.
From Chapter 5, a Recurring Timer goes off again and again. Its When bar gives its Timer name, one you make up, so its second window can’t list it. Choose Type a timer name…, press OK, and type the card’s name, computerTurn.
Actions, One at a Time
Under each Event, the numbered rows are its Actions, in order. In the editor, they’re blocks on the canvas, joined by arrows into one line that runs down to End. The Action List on the right holds every Action, in closed groups. Type an Action’s name into the search box at its top, and click it. Its block appears.
A new block lands a little to one side, with no arrow into it. A block like that does nothing at all when the game runs, however right its values are. Right-click it and choose Connect to Sequence. It joins the end of the line, right above End. Build down the card, and join each Action as you add it.
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. Inside an If or a Repeat, add the block from that block’s own menu first. If, Else and Repeat shows how.
Fill in the fields the card lists, and 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. On the block, it’s the box after the word on, and it starts at Self. With no Applies to line on the card, leave it there. From Chapter 2, Set Game State and Check Game State have no such box at all, because a Game State belongs to the whole game. Their cards still give an Applies to line. Leave it out.
Some Actions hand back an answer. On the card, their first line is an Action Name. On the block, it’s the box that comes right after the little word as. Type the card’s name there, with no quotes. A later Action reads the answer by that name and a dot. Show Safe Door asks Check Game State whether the safe is Unlocked, names the answer safeIsOpen, and reads safeIsOpen.value.
A Change Variable sets one Variable to a Value. On the canvas, its block starts with the word Set. 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 += it’s added on, with -= it’s taken away, and with *= it’s multiplied. No Operator line on the card? Then it’s =.
From Chapter 2, Declare Variable makes a value that lives only while its Function runs, such as Check Guess’s clue. Its block reads Declare, then a Type list, a Name, and a value after the = sign. The Type starts at Number. A card names a Type only when it’s another one.
Change Component Value changes one field. Its Component Value is a path with dots, typed as the card spells it. The path safeRules.safeState.startsNewEntry is the startsNewEntry field of the Safe State carried by the Object that safeRules names. Its Operator stays at =, as it starts.
A Function goes in like 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, and you type each value as the card has it. For an Object, that’s a name such as self, or @self.safeRules.
From Chapter 3, the game makes Objects as it plays. Create Instance makes one. Its Object to Create box names which. Its Created As box gives the new one a name, so the blocks after it can aim at it. Set Position then puts it at an X and a Y, counted from what its Position Relative To list says. Screen means screen pixels, the same as Screen Offset. Set Scale sizes it. At 1, it’s its own size, and at 0.5, half.
From Chapter 3, some steps sit inside a Region. A Region is a colored frame with a label, drawn around a few blocks so you can find them again. It changes nothing about when they run. Right-click the canvas and choose Draw Region, then drag around the blocks. Or select the blocks first and choose Region from Selection. Then type the card’s Label into the Region’s name box and pick its Color from the swatch beside it. On the card, a Region is a numbered line of its own, above its blocks, with its Label and Color. It isn’t in the Action List, though.
Values, Quote Marks and All
Every value on a card is written the way its box should hold it, so type it as you see it. The way a name starts tells you where its value lives. A plain name, such as digit in Type Digit, is a Parameter of this Function, or a value a Declare Variable made. A name with a $ is a Global. One that starts with self., such as self.digit, is a Per Instance Variable, or a field of a Data Structure, as in self.safeState.code. With an @ in front, as in @self.safeRules, it’s a Shared Variable.
A value can be a small formula too. The formula data('Safe Settings','Standard Safe','highestCode') reads one cell of the Safe Settings table: the row named Standard Safe, the column highestCode.
Most boxes read what you type as a formula. In those, a word needs quote marks, so the card gives it with them, as in data('Safe Copy','Unlocked','text'). Without them, the box thinks the word names something else. It marks it as an error. A few boxes hold a word exactly as you type it, such as a Custom Event’s name. The card gives those bare. So a word the card shows in quotes goes in with them, and a word it shows bare goes in bare.
Single and double quotes do the same job. Type whichever the card shows. A true or false goes into a box as that word. On a switch, true means on and false means off.
A few fields are lists, not boxes. Set Sprite’s Sprite lists your pictures, and Reset Data Table’s Table lists your tables. From Chapter 4, Set Logic State’s Logic Component lists your Logic Components. Pick the card’s name from that list. Safe Gold is one of the choices you’ll meet in this game. Set Logic State’s State starts at Enable. With no State line, keep it there.
If, Else and Repeat
An If runs some Actions only when its condition is true. It’s in the Action List’s Logic group. On the canvas it’s a wide, pointed block, and a line marked True runs down from it. That line holds the steps the card puts under Then.
The condition is one box inside the block. The card gives it after the word If, written exactly as you’ll type it. Click the box and type it as the card spells it, such as guess == code. Enter, or a click somewhere else, keeps it. From Chapter 2, a condition can join two tests. && means and: both have to be true.
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 its block stands apart, join it with Connect to Sequence, and it goes to the end of that If’s True line.
The card’s Otherwise 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, out to its right. Right-click the Else and choose Add Inside Else for each of its Actions, and join them the same way. On the card, Otherwise gets a step number of its own. It isn’t in the Action List, though.
Sometimes an Else holds nothing but another If, as in Check Guess, and the canvas draws the pair as one block: Else If. Add Else If, on the If’s menu, makes that pair in one move. Look at the card first. When an Otherwise holds only an If, use Add Else If. When it holds more, such as two Ifs one after the other, use Add Else, and build each one inside it.
Watch where each step sits after an If. The card’s bars show it. A step on the same bar as an If, right below that If’s last line, comes after the If, not inside it. If that If is itself inside another one’s True line, use the outer If’s Add Inside Then. The new block joins the end of that True line, below the inner If. Inside an Else, it’s the Else’s Add Inside Else. And a step at the very left comes after everything. Add it from the Action List, and Connect to Sequence joins it to the end of the main line.
A Repeat runs its steps a set number of times. That number is its Count. On the canvas, a Repeat starts closed, one bar with its Count on it, and the small arrow at its left end opens it. In Chapter 3, Lay Out Scan Record’s Count is codeCount, once for each code a safe can have. On the card, its steps sit under Each time. Right-click the Repeat and choose Add Inside Repeat for each. Inside a Repeat, local.index says which time round it is, counting from 0. Type it as the card has it. A step back at the Repeat’s own bar, below its last line, comes after the Repeat, as with an If.
The step numbers count right through the lines, so step 6 may sit inside an If that began at step 5.
A Function Card
A Function is a small piece of Logic with one job. It does it whenever another piece asks: take away the last digit, check a guess against the code. Make one with Add > Function, and give it the card’s name. This is Erase Digit, from Chapter 1.
Removes the last digit of the entry (Back). The next digit typed is added to what is left.
safeStateData StructureSafe State- Variable
$entry- Value
floor($entry / 10)
- Component Value
safeRules.safeState.startsNewEntry- Value
false
Its card has PARAMETERS and ACTIONS, and from Chapter 2 some have a RETURN TYPE. There’s no Event. Its Description, if you’d like it, goes on the Function’s own card, at the top of the column on the left, under its Function Name.
PARAMETERS are the values a caller hands in. They live on the Start block, at the top of the canvas, where the line begins. Press the + beside Parameters. The Add Parameter window asks for a Name, a Type and a Default. The card’s last column, Starts at, goes into Default.
An Object Parameter has more to it. Press the pencil on its row, and the Edit window opens with the rest. Under Compatibility Mode, the card’s word picks the button. When the card names an Object instead, as entryText names Entry Value, choose Nominal and pick that Object as its Object Type. A Structural one, such as safeRules, fits any Object that carries what’s listed under Required Components. Press Add Required Component. Pick the card’s Component Type, Data Structure, and its Required Schema, Safe State. Type the Slot Name last, safeState. That’s how the Function reads the code, as safeRules.safeState.code. The window keeps each change as you make it. Press Done to close it.
From Chapter 2, a RETURN TYPE says what the Function hands back. Open the Function’s own card, and pick it in its Return Type list. Check Guess hands back a Number. The Return Action comes last on its line, and its Value is what goes back. A caller reads the answer by its Action Name, with .value after it.
The ACTIONS hang in one line, from Start down to End, and they run each time another piece of Logic calls the Function.
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 only for its Name. Here is Safe Settings, from Chapter 1, and the Data Structure that comes with it. Its one row says what kind of safe the game deals: codes from 1 to 100, and a display that starts at 50.
110050One row of the Safe Settings Data Table, made by the engine for the table's rows: lowestCode, highestCode, startEntry (the table's description says what each column means).
A table’s columns are the fields of its own Data Structure, named after it: Safe Settings Entry for Safe Settings. Myth makes that Data Structure with the table. It has no fields yet. The table’s card names it at the top, beside the table’s own name. Open Safe Settings 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. Add Row is under the grid. A new row starts with every column’s default. Each row’s name goes in the grid’s Entry column, where the card puts it after Row 0. Double-click a cell to type in it. A Boolean cell has a switch instead: Yes is on, and No is off. Enter keeps what you typed. The card counts rows from Row 0, and the editor numbers them from 1. So Row 0, Standard Safe, is your first row.
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.
Delete an ordinary Action from the middle, and the remaining line closes over its gap. Add the replacement block, then join it between its neighbors with their round handles. Deleting an If or a loop leaves its inside blocks unattached, so keep the If when only its condition changes.
This one, from Chapter 2, gives the Safe a Logic Component that shows its door open. The Logic is new, so it’s marked Add.
Window / UIUIX 408, Y 408-1Locked SafeX 408, Y 408Sometimes a step stays and only its values change. Then the new values are green, with the old ones struck beside them.
If 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 standing apart from its line, with no arrow into it, and join it with Connect to Sequence. A box marked as an error? 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.
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 a dark room, a closed safe, and a keypad waiting for your fingers.