|
|
| |||
|
|
| |||
This is the complete list of commands available to you in Smash. First, a brief index of the commands is given, and a more detailed explanation follows.
Explanation of SyntaxThe syntax of each command is described by listing each command's arguments. If the argument is given in ()'s, it is a required parameter. If the argument is given in []'s, it is an optional parameter. The syntax of each argument type is given as follows:
|
| Command | Syntax | Followed By Code Block? | Description | Files |
| . | . [text] | No | set the area description text to text | .sma files, outside option blocks |
| , | , [text] | No | append text to the current area description text | .sma files, outside option blocks |
| ; | ; (text) | No | append text to the current area description text, but without an intervening space | .sma files, outside option blocks |
| p | p [text] | No | set the action description text to text | .sma files, anywhere, but usually inside option blocks |
| P | P [text] | No | append text to the current action description text | .sma files, anywhere, but usually inside option blocks |
| A | A (text) | No | append text to the current action description text, but without an intervening space | .sma files, anywhere, but usually inside option blocks |
| i | i [number] [image] | No | set the image to display, unless [number] is lower than that of a previous 'i' statement; if [number] and [image] are missing, stops an image from being displayed | .sma files, anywhere |
| S | S [number] [str-expd] | No | set status line number to str-expd; if str-expd is absent, erase the status line number; if number is absent, erase all status lines; the value of number for each status line indicates how they should be ordered | .sma files, anywhere |
| Command | Syntax | Followed By Code Block? | Description | Files |
| a | a (tag-exp) | No | put item tag-exp in the player's inventory | .sma files, anywhere |
| d | d [tag-exp] | No | drop item tag-exp from the player's inventory; if tag-exp is omitted, all items (including enumerated) are dropped | .sma files, anywhere |
| e | e (tag-exp) = (expr) | No | assign the inventory count of enumerated item tag-exp to expr | .sma files, anywhere |
| e | e (tag-exp) (op) (expr) | No | modify the inventory count of enumerated item tag-exp by op expr | .sma files, anywhere |
| D | D [tag-exp] | No | drop all regular and enumerated objects from the inventory bag tag-exp; if tag-exp is omitted, all objects are dropped from all inventory bags | .sma files, anywhere |
| b | b (tag-exp) | No | switch to the inventory bag (tag-exp) -- note that "0" is the default inventory bag | .sma files, anywhere |
| B | B (tag-exp) | No | add the items in the inventory bag (tag-exp) to the current inventory bag -- note that this does NOT remove the items from (tag-exp) | .sma files, anywhere |
| Command | Syntax | Followed By Code Block? | Description | Files |
| s | s (var-exp) = (expr) | No | assign the state variable var-exp the value of expr | location files or functions called from location files |
| s | s (var-exp) (op) (expr) | No | modify the state variable var-exp by op expr | location files or functions called from location files |
| v | v (var-exp) = (expr) | No | assign the global variable var-exp the value of expr | .sma files, anywhere |
| v | v (var-exp) (op) (expr) | No | modify the global variable var-exp by op expr | .sma files, anywhere |
| t | t + (var-exp) = (expr) | No | make the timer called var-exp an incrementing timer and set it to expr | .sma files, anywhere |
| t | t - (var-exp) = (expr) | No | make the timer called var-exp a decrementing timer and set it to expr | .sma files, anywhere |
| t | t + (var-exp) (op) (expr) | No | make the timer called var-exp an incrementing timer and modify it by op expr | .sma files, anywhere |
| t | t - (var-exp) (op) (expr) | No | make the timer called var-exp a decrementing timer and modify it by op expr | .sma files, anywhere |
| t | t << (expr) | No | rewind all timers by expr (incrementing timers are decremented, and decrementing timers are incremented) | .sma files, anywhere |
| t | t >> (expr) | No | fast forward all timers by expr (incrementing timers are incremented, and decrementing timers are decremented) | .sma files, anywhere |
| z | z [lower-tag-exp] | No | zero (delete) all state variables; if lower-tag-exp is present, only zero that location's state variables | .sma files, anywhere |
| Z | Z | No | zero (delete) all global variables and timers | .sma files, anywhere |
| Command | Syntax | Followed By Code Block? | Description | Files |
| g | g (lower-tag-exp) | No | set the location to jump to to lower-tag-exp | .sma files, inside option blocks |
| G | G | Yes | execute the following block of code only if we have just arrived at this location via a "g" command | .sma files, outside option blocks |
| f | f (tag-exp) | No | call the function tag-exp, located elsewhere in the same file | .sma files, anywhere |
| f | f (lower-tag-exp1).(tag-exp2) | No | call the function tag-exp2, located in the file lower-tag-exp1.sma | .sma files, anywhere |
| ~ | ~ (tag) | Yes | defines the start of a function called tag | .sma files, outside code blocks |
| r | r (expr) | No | sets the function return value | .sma files, inside functions |
| c | c (expr) | Yes | execute the following block of code if expr evaluates to a non-zero value | .sma files, anywhere |
| C | C [expr] | Yes | executes the following block of code if expr is missing or evaluates to a non-zero value, and no prior connected c or C command succeeded | .sma files, only immediately after a c or C block |
| L | L (expr) | Yes | execute the following block of code if expr evaluates to a non-zero value, then loops back to the L command when it is done | .sma files, anywhere |
| R | R (expr) | Yes | execute the following block of code without initially evaluating expr, then loop back and treat the block like an L loop | .sma files, anywhere |
| l | l | No | lose the game | .sma files, anywhere |
| w | w [str-exp] | No | win the game; if present, str-exp is a |-delimited list of strings to use as Hall of Fame parameters | .sma files, anywhere |
| W | W [str-exp] | No | win the game but allow play to continue from that point; if present, str-exp is a |-delimited list of strings to use as Hall of Fame parameters | .sma files, anywhere |
| ^ | ^ (tag) (str-exp) | Yes | define a move option tag with text str-exp | .sma files, outside option blocks |
| * | * (tag) (str-exp) | Yes | define an action option tag with text str-exp | .sma files, outside option blocks |
| @ | @ (tag) (str-exp) | Yes | define a constant option tag with text str-exp and make it visible | copts.sma, outside option blocks |
| @ | @ (tag) (str-exp) | No | redefine constant option tag to have the text str-exp | .sma files, anywhere |
| @ | @ + [tag] | No | make constant option tag visible; if tag is omitted, make all constant options visible | .sma files, anywhere |
| @ | @ - [tag] | No | make constant option tag invisible; if tag is omitted, make all constant options invisible | .sma files, anywhere |
| Command | Syntax | Followed By Code Block? | Description | Files |
| x | x (expr) | No | set the random number seed | .sma files, anywhere |
| ! | ! [text] | No | cause an error with str-exp as the error message; useful only when debugging | .sma files, anywhere |
Sets the area description text. This text is used to describe your surroundings in the game. This is not used inside option code blocks, but it may be used in conditional code blocks if the description of the area might change depending on how things are in the game.
. You are in the middle of a vast canyon. The earth is dry and cracked. Birds circle about overhead. You feel very thirsty.
c s=0 . There is a switch on the wall. It is turned off. c s=1 . There is a switch on the wall. It is turned on.
Appends additional text after previously set area description text. If no text is supplied, a space character is appended.
Because it involves modifying the same text that the . command does, it is used in the same contexts. The first example below is functionality equivalent to Example 2 above but uses more compact code.
. There is a switch on the wall. c s=0 , It is turned off. c s=1 , It is turned on.
. You are in a bright sun room with windows and plants everywhere you look. c s=0 , There is a broken wristwatch here that appears to have been lost, stepped on, and inadvertently kicked into a corner.
See also: the ; command.
Append additional text after previously set area description text. This differs from the , command in that it does not insert an intervening space. Therefore, this command only tends to be used when displaying text items without spacing.
. There is a combination lock on the briefcase. It is set to c combo1=0 , A- C combo1=1 , B- C , C- c combo2=0 ; A- C combo2=1 ; B- C ; C- c combo3=0 ; A. C combo3=1 ; B. C ; C.
See also: the , command.
Sets the action text. This text is used to describe what happens as a result of an action taken by a user. Normally it is used inside option code blocks, to be executed when an option is selected, although it may be used outside option blocks in certain situations. It may also be used in the "start" file to set some introductory text which will be displayed when a user first starts the game, then never again. (This is a good place to put instructions.)
* eat Eat the tablecloth. p You eat the tablecloth. It tastes stale.
* pick Pick up the saw. c a:saw p You already have the saw! C p You pick up the saw. a saw
Appends additional text after previously set action text. If no text is supplied, a space character is appended.
Because it involves modifying the same text that the 'p' command does, it is used in the same contexts.
* 1 Walk through the force field. p You start toward the force field, c d:shield P but an electric shock throws you back. C P and your magnetic shielding protects you. The force field snaps and flares, but you pass safely into the room on the other side. g otherside
Appends additional text after previously set action text. Because it involves modifying the same text that the 'p' command does, it is used in the same contexts. This differs from the P command in that it does not insert an intervening space. Therefore, this command only tends to be used when displaying text items without spacing.
* 1 Construct a compound word. p You put your two words together and form the new word " c word1=0 A mail C word1=1 A fire C A police c word2=0 A man C word2=1 A woman C A person A ."
This command is used to set an image to be displayed.
Normally, the [number] argument is only present when multiple 'i' commands could be encountered during a single turn. When that happens, [number] is used to determine which image command will take effect. If [number] is present, the effects of a previous 'i' command will only be overridden if the [number] is equal to or larger than the [number] in the previous 'i' command. This is useful in situations where an 'i' command resides in a location file outside all option blocks and, in addition, an option block contains an 'i' command of its own. Usually in these cases, it is undesirable for the location-level 'i' command to override the effects of the previously executed 'i' command from the option block. If the location-level 'i' command has a priority of 0 and the option block 'i' command has a higher priority (or none at all), then the desired effect is achieved.
If [number] is omitted, the highest possible priority is assumed.
If neither a [number] or an [image] is supplied, no image will be displayed. [number] may not be present if [image] is not also present. Note that 'i' commands only take effect for the current turn, not any future turns.
Images must be JPG, GIF, or PNG files.
i 0 house.jpg * map Look at the map. i map.png
This command is used to set a status line. The line number is used only to determine how lines should be sorted; for example, if there is a status line 10 and a status line 20, then the status line 10 should be displayed first, regardless of which line was set first. If a text string is not supplied, it removes the status line. If neither a text string nor a line number is supplied, all status lines are removed.
Expressions stored within {}s are evaluated at the time the line is executed and are not re-evaluated. Expressions stored within []s are re-evaluated each time the status line is displayed.
S 1 You have made [S:moves] moves so far.
. You are in the middle of a four-way intersection. Each path leads to a different city that you may explore. Where do you wish to go? ^ n Go north. S 10 You are in the northern city. g northcity ^ e Go east. S 10 You are in the eastern city. g eastcity ^ s Go south. S 10 You are in the southern city. g southcity ^ w Go west. S 10 You are in the western city. g westcity
. Which of your friends would you like to take with you? c has_friend1 * no_1 Leave Friend #1. S 10 v has_friend1 = 0 C * yes_1 Take Friend #1. S 10 Friend #1 is with you. v has_friend1 = 1 c has_friend2 * no_2 Leave Friend #2. S 20 v has_friend2 = 0 C * yes_2 Take Friend #2. S 20 Friend #2 is with you. v has_friend2 = 1
* 1 Erase all status lines. p Ok. S
Adds an object to the player's inventory, where (tag-exp) is an object tag. If the player is already carrying the specified object, nothing happens.
* take Take the bucket. p Ok. a bucket
* take Take the item from a random box.
s item = r:3
p You take the item from box #{item}.
a box_item_{item}
Drops an object from the player's inventory, where (tag-exp) is an object tag. If the player doesn't have the specified object, nothing happens.
If (tag-exp) is omitted, all objects, regular and enumerated, are dropped from the player's inventory. This usage differs from the "D" command in that only the current inventory bag is affected.
* drop Drop the bucket. p Ok. d bucket
* drop Drop everything. p Ok. d
See also: the D command.
This command is used to set or modify how many of enumerated object with tag (tag-exp) the player is carrying. If an assignment operator (=) is provided, the number of objects the player is carrying is set to the value of the expression. Otherwise, the number of objects is modified by the operator provided.
* ap Take five apples. e apples = 5
* cr Take a crouton.
e croutons = e:croutons + 1
p Ok. You have {e:croutons} now.
* cr Take a crouton.
e croutons + 1
p Ok. You have {e:croutons} now.
* pick Pick a blade of grass. p Ok. You pick up a blade of grass. e grass + 1 c e:grass > 0 * drop Drop a blade of grass. p Ok. You drop a blade of grass. e grass - 1
* buy Buy the harpoon from the shopkeeper. c e:coins < 35 p You don't have enough money to buy the harpoon. C p You hand the shopkeeper 35 gold coins to buy the harpoon. e coins - 35 a harpoon
* take Double the number of fallen leaves you have. e leaves * 2
Drop all regular and enumerated items from the inventory bag [tag-exp]. If [tag-exp] is omitted, all objects are dropped from all inventory bags.
The need for this command is rare, but it can help if the state of the game needs to be reset. Note that if you're only using a single inventory bag in your game, the "d" command (which drops all items from the current inventory bag) works just as well.
* bj Bungee jump off the cliff. p You drop like a rock, the wind rushing at your face. When you reach the end of the cord, you find that it doesn't stretch as much as you would have liked; everything you are carrying lurches out of your grasp and plummets to the valley floor below you. D 0
* win Win the game. p You won! You start over at the beginning -- but this time, something isn't quite as it was the first time through. W z Z D v won_once = 1 g beginning
See also: the d command.
Switch the current inventory bag to (tag-exp). Note that the default inventory bag is "0". The visible effect of switching inventory bags is that the player will appear to have lost all inventory items and gained those items in the (tag-exp) bag, if any. But any items in the first inventory bag remain present and are regained when a "b" command is issued to switch back.
* rush Rush past the guards. p You try to rush past the guards, but they catch you, confiscate your possessions, and lock you up. b emptybag
* escape Escape from prison. p You bust out of jail when the guards aren't looking and recover your possessions. b 0
See also: the B command.
Adds the contents of inventory bag (tag-exp) to the current inventory bag. Note that the (tag-exp) inventory bag is NOT cleared of the items there, so if they are no longer required, you should issue a "D (tag-exp)" command immediately afterward.
* safe Recover your possessions from the safe. p You open the safe and recover the possessions you stored there previously. B safe D safe
See also: the b command.
This command is used to set or modify a state variable for the current location. If an assignment operator (=) is provided, the state variable is set to the value of the expression. Otherwise, the state variable is modified by the operator provided.
s state = 15 s count = 0
c time_left > 0 s time_left = time_left - 1
c time_left > 0 s time_left - 1
* bug Bug the old man to let you in his house. s old_man + 1 c old_man < 3 p "Go away," the man snarls. C p "Ok! Ok! Enough already. Get inside." The old man shoves you through the door. s old_man = 0 g inhouse
Note: To maintain compatibility with older code, (var-expr) is assumed to be "s" if it is missing. This use is deprecated and should not be used in new Smash code.
s = 15 s + 3 s - 5 s / 2
This command is used to set or modify a global variable. If an assignment operator (=) is provided, the global variable is set to the value of the expression. Otherwise, the global variable is modified by the operator provided.
v var = 5 v ate_boulder = 1
* 1 Talk to the old man.
v talked_to_old_man = .talked_to_old_man + 1
p You talk to the old man again.
You have talked to him {.talked_to_old_man} times.
* 1 Talk to the old man.
v talked_to_old_man + 1
p You talk to the old man again.
You have talked to him {.talked_to_old_man} times.
c light * off Turn off the light. p You turn the light off. v light = 0 C * on Turn on the light. p You turn the light on. v light = 1
Note: To maintain compatibility with older code, (var-expr) is prepended with a "v" if it consists only of digits. For example, if (var-expr) is "35", then "v35" is assumed. This use is deprecated and should not be used in new Smash code.
v 5 = 1 v 34 + 3 v 0 - 2 v 1 .| 7
This command is used to set or modify a timer. If an assignment operator (=) is provided, the timer is set to the value of the expression. Otherwise, the timer is modified by the operator provided. If there is a + symbol preceding (var-exp), the timer should be made an upward counting timer; if there is a - symbol, the timer should be made a downward counting timer.
t + moves = 0 t - countdown = 10
* 1 Talk to the fairy queen. t - moves_left = 15 p The fairy queen says, "You must beat me at chess in fifteen moves." c moves_left > 0 * 2 Plead with the fairy queen for more time. # Note: We must increment by 6, not 5, because one # move is wasted asking for the 5 extra moves. t - moves_left + 6 p The fairy queen says, "Well, ok, I'll give you five additional moves."
Rewind (<<) or fast-forward (>>) all timers by the value of (expr). Rewinding timers would mean incrementing downward counting timers and decrementing upward counting timers. Vice versa for fast forwarding. These commands can be used to make certain moves take more or less in-game time than others. Note that normally timers advance one unit per move, so rewinding timers by 1 effectively pauses timers for that turn.
* 1 Reread the instructions for this task. t << 1 p You need to find your way outside the house before it burns down. * 2 Hunt for a way out. p You search around but don't find anything. * 3 Look through all the papers in the drawer. p There are a lot of them, so it takes a while. t >> 1
Zeroes out (deletes) all state variables. If [lower-tag-exp] is present, only zero that location's state variables. The need for this command is rare; it is helpful in situations where you want to reset the state of the game.
Note this command, without an argument, deletes all state variables, not just the state variables for the current location. If you want to delete only the current location's state variables, you must specify the location by name, although, for locations no longer than eight characters in length, example 2 provides a shorthand way of accomplishing this without establishing a dependency on the current location name.
Also note that global variables, timers, and inventory items remain unchanged.
* s Start the game over. p You start over. z Z g beginning
* r Delete the state variables of the current location.
# Note: This only works if the current location is no longer than eight characters.
z {'S:loc}
See also: the Z command.
Zeroes out (deletes) all global variables and timers. The need for this command is rare; it is helpful in situations where you want to reset the state of the game.
Note that state variables and inventory items remain unchanged.
* s Start the game over. p You start over. z Z g beginning
* win Win the game. p You won! You start over at the beginning -- but this time, something isn't quite as it was the first time through. W z Z D v won_once = 1 g beginning
See also: the z command.
Specifies that the user should be moved to the location named (lower-tag-exp). This command is only used inside option blocks, with one exception: a "g" command must appear in the "start" file outside any code blocks in order to specify where the user should start the game.
Note that this command does not branch to the new location immediately but rather sets where the user should be moved to next. What this means is, code immediately following a "g" command will still be executed. Note that examples 2 and 3 below are equivalent.
^ n Go north. g lake
* leap Leap over the moving lava flow. p You hurl yourself over the moving lava flow. It's hot! g otherside
* leap Leap over the moving lava flow. g otherside p You hurl yourself over the moving lava flow. It's hot!
Begins a block of code that should only be executed if the player has just arrived at this location by a "g" command. "G" blocks must be located outside functions and option blocks. The intended use for "G" blocks is to initialize any state variables you plan to use within the location.
Note that "G" blocks will execute if you "g" to the location even when you're already there; so a location that has a "g" command to itself will force the "G" blocks to run again.
G s counter = 3 * 1 Wait. s counter - 1 c !counter p A rabid dinosaur zombie ninja bursts from the bushes and eats you alive! l
Executes the function named (tag-exp2), located in the file (lower-tag-exp1).sma. If (lower-tag-exp1) is missing, the function is assumed to reside in the current file. Note that if an unscoped state variable is referred to in a function, it refers to a state variable belonging to the player's current location, which is not necessarily the location where the function itself resides. Basically, the location the player is in (and, therefore, the set of state variables in use) never changes as a result of calling a function in a different file.
Note that when a function is called via the "f" command, as opposed to the f: operator, the function return value can still be retrieved by checking the value of S:return).
f describe_area
* exh Examine your hat.
f examine_hat
p The return value of examine_hat was {S:return}.
Normally, though, it is more readable and less error-prone to use the f: operator and read the function return value directly.
See also: the ~ and r commands.
Defines the function named (tag). It begins a code block containing the code to execute when the function is called. If the state variable is referred to in a function, the state variable for the location that the f command is executed in is the one that is used.
~ describe_area . It is nice out. c set_off_blast , Except for the high radioactivity from the nuclear blast you set off.
~ examine_hat c state_of_hat = 0 p Your hat is brand new. C state_of_hat = 1 p Your hat is looking rumpled around the edges. C state_of_hat = 2 p Your hat is ragged and stained. C p Your hat is a total wreck.
~ add_suicide_option * suic Kill yourself. p You die, by your own hand. Not very smart, was it? l
See also: the f and r commands.
Sets the function return value. The function return value is a numerical value that gets set to 0 when a function is called and is set by the "r" command. A function with no "r" command, therefore, has a return value of 0.
The function return value is what the f: operator evaluates to. It is also what S:return evaluates to.
Note that the "r" command does not cause the function to return; it simply sets what the function return value is.
~ generate_random_up_to_max_variable r r:max
~ get_damage_to_monster
c monster = 1
v hits = 10
C monster = 2
v hits = 30
C
v hits = 50
r hits + weapon - armor
p You hit the monster for {hits} damage!
v monster_hits = monster_hits - hits
Note that there is only one function return value, shared among all function calls. It is therefore important not to set the function return value prior to a function call, which would then overwrite the value. This problem can be avoided simply by making the "r" command the last command in a function. In the rare situation that this is not convenient, just make sure the "r" command occurs after any function calls.
~ function
r 5
p You have {f:get_number_of_fish} swordfish.
~ function
p You have {f:get_number_of_fish} swordfish.
r 5
~ function r 5 f set_status_lines
~ function f set_status_lines r 5
With correct placement of "r" commands, it will be perfectly safe to put function calls right on the "r" line, as in the following example:
~ function r f:part1 + f:part2 - f:part3 ~ part1 r 47 ~ part2 r 52 ~ part3 r 75
See also: the f and ~ commands.
Executes the following indented block of code only if (expr) evaluates to a nonzero value.
. You are in a room. c opened_cabinet , There is an open cabinet here. c !took_doll , There is a doll inside. c rug=1 , The rug has been lifted to reveal a trapdoor. c rug=2 , The rug has been torn from the nails that held it in place. There is a trapdoor in the middle of the room.
c a:17 , !torch_lit * light Light the torch. c d:18 p You have nothing to light it with. c a:18 p You light the torch with the matches. v torch_lit = 1
Executes the following indented block of code only if previous linked 'c' and 'C' commands failed and [expr], if present, evaluates to a nonzero value. The 'C' command can be thought of as an "else if" command.
* 1 Examine the hat. c state_of_hat = 0 p Your hat is brand new. C state_of_hat = 1 p Your hat is looking rumpled around the edges. C state_of_hat = 2 p Your hat is ragged and stained. C p Your hat is a total wreck.
* 2 Fight the battle. c a:sword c a:shield c a:shinguard p You start to stab at your opponent, but he swings first. The blow glances downward off your shield and is deflected by your shinguard. Then you spy an opening and thrust your sword home. Your opponent slumps to the ground. v won_fight = 1 C p You start to stab at your opponent, but he swings first. The blow glances downward off your shield and nicks your leg. Startled by the sudden stinging, you are thrown off your guard, and your opponent takes advantage of your momentary weakness. l C p You start to stab at your opponent, but he swings first. With no way to block the blow, it strikes home, and you die. l C p Without a sword, you quickly lose. l
Executes the following block of code repeatedly until (expr) evaluates to zero. Caution! Be careful not to create an infinite loop, that is, a situation where (expr) always evaluates to a nonzero value, so the block of code just keeps executing and executing.
Loops are useful if you need to do something repeatedly. Usually you would need to name variables or object tags with numbers to use loops effectively; for example, if you had 100 items, named item_1 through item_100, a loop could be used to add each one to your inventory, as shown in Example 2.
. You hug and kiss your beloved five times: v i = 0 L i < 5 , X O v i + 1
v i = 1
L i < 101
a item_{i}
v i + 1
p You see a multiplication table on the wall. It looks like this:<p>
P <table>
v x = 1
L x <= 10
P <tr>
v y = 1
L y <= 10
P <td>{x*y}</td>
v y + 1
P </tr>
v x + 1
P </table>
Executes the following block of code once without initially evaluating (expr), then loops back and thereafter treats the R command like an L command, where the code block is executed repeatedly until (expr) evaluates to zero. This is functionality equivalent to a "do/while" loop found in other programming languages. Caution! Be careful not to create an infinite loop, that is, a situation where (expr) always evaluates to a nonzero value, so the block of code just keeps executing and executing.
Normally, you will want to loop using the L command, but the R command can be useful if you find yourself writing code just before a loop, then repeating that code inside the loop. For example, this code:
v random_number = r:10 L random_number = 3 v random_number = r:10
...picks a random number between 0 and 9 that is not 3. A number from 0 to 9 is chosen, and if it is 3, another random number is chosen instead. The drawback to this algorithm is that the line of code that stores the random number is repeated. Instead, the following functionally-equivalent code can be used instead:
R random_number = 3 v random_number = r:10
It does not matter if the 'random_number' variable was previously defined or not, or, if so, what it was set to. The loop will always execute at least once, and so the 'random_number' variable will be set to a fresh random number before the random_number = 3 condition is ever evaluated.
* pick Pick a random number from 0-99 not divisible by 3 or 7.
R !(r % 3) | !(r % 7)
v r = r:100
p Ok! How about the number {r}?
* hunt Hunt around.
# Check to see if the player is missing any of items 0-99.
# If so, you find a randomly selected item. If not, you don't find anything.
v missing_an_item = 0
v i = 0
L i < 100
c d:item_{i}
v missing_an_item = 1
v i = 100
v i + 1
c missing_an_item
R a:item_{i}
v i = r:100
a item_{i}
p You hunt around and find Item #{i}! You pick it up.
C
p You hunt around but don't find anything.
Specifies that the player should lose the game. Note that this command does not branch to the "lose game" sequence immediately but rather sets that the "lose game" sequence should commence once control flow terminates naturally. What this means is, code immediately following a "l" command will be executed. Note that the two examples given below are equivalent.
One other thing to note. When a move is made that causes the player to lose the game with a "l" command, the player's saved game is not updated. That means that once the player reaches the "lose" screen, then hits "undo" to undo the move, no changes made during that move (for example, the setting of global variables) will be remembered.
* lose Lose the game. p You lost! l
* lose Lose the game. l p You lost!
Specifies that the player should win the game. Note that this command does not branch to the "win game" sequence immediately but rather sets that the "win game" sequence should commence once control flow terminates naturally. What this means is, code immediately following a "w" command will still be executed. Note that Examples 1 and 2 are equivalent.
* win Win the game. p You won! w
* win Win the game. w p You won!
If the Hall of Fame for the game has no extra game-defined parameters (in the game.txt file), then no [str-exp] argument should be present. Otherwise, there must be a [str-exp] argument, which must consist of a |-delimited set of string values that indicate what should be supplied in each game-defined Hall of Fame field. Example 3 shows a win command for a game with one extra "points" parameter. Example 4 shows a win command for a game with three extra parameters: points, bonuses, and rank.
* win Win the game.
p You won!
w {points}
* win Win the game.
p You won!
c rank=6
w {points}|{bonuses}|General
C rank=5
w {points}|{bonuses}|Colonel
C rank=4
w {points}|{bonuses}|Major
C rank=3
w {points}|{bonuses}|Captain
C rank=2
w {points}|{bonuses}|Lieutenant
C rank=1
w {points}|{bonuses}|Sergeant
C
w {points}|{bonuses}|Private
See also: the W command.
Same as the "w" command, except that after the "win game" message comes up and the Hall of Fame entry is supplied, the game does not terminate but rather lets the player continue playing. It is extremely rare that a game would ever use this command. One exception might be if the game developer wanted to allow the user to be able play through the game a second time with certain secrets unlocked as a reward for finishing the first time. In such cases, the "z", "Z", and/or "D" commands may also be helpful.
Great care must be taken not to code a game with a "W" command in such a way that a player can trivially enter many Hall of Fame entries.
* win Win the game. p You won! You start over at the beginning -- but this time, something isn't quite as it was the first time through. W z Z D v won_once = 1 g beginning
* win Win the game.
p You won! You start over at the beginning -- but this time, something
isn't quite as it was the first time through.
W {points}
z
Z
D
v won_once = 1
g beginning
Adds a new move option called (tag) and having the text (str-exp). Note that (tag) is not displayed or referred to anywhere else; it must exist simply to distinguish itself from other ^ options. The tag must be different from the tags of all other ^ options displayed at the same time, as well as different from any other ^ tag in the same file. (It may, however, reuse a tag used by a @ option, * option, object, or function.
The ^ command is followed by a block of code (which can legally but probably not practically be empty) that will be executed if and when the player selects this option.
^ n Go north. g house
c road_is_unobstructed ^ road Travel along the road. g uproad
Adds a new action option called (tag) and having the text (str-exp). Note that (tag) is not displayed or referred to anywhere else; it must exist simply to distinguish itself from other * options. The tag must be different from the tags of all other * options displayed at the same time, as well as different from any other * tag in the same file. (It may, however, reuse a tag used by a @ option, ^ option, object, or function.)
The * command is followed by a block of code (which can legally but probably not practically be empty) that will be executed if and when the player selects this option.
* t Talk to the geezer. p The geezer just wheezes and calls you a "young whippersnapper."
c light_is_on * off Flip the lightswitch. v light_is_on = 0 p Ok. The light is off. C * on Flip the lightswitch. v light_is_on = 1 p Ok. The light is on.
If this command is issued in copts.sma, it defines a new constant option called (tag) and having the text (str-exp). Note that (tag) is not displayed or referred to anywhere else; it must exist simply to distinguish itself from other @ options. The tag must be different from the tags of all other @ options displayed at the same time, as well as different from any other @ tag in the same file. (It may, however, reuse a tag used by a ^ option, * option, object, or function.
When used in copts.sma, the @ command is followed by a block of code (which can legally but probably not practically be empty) that will be executed if and when the player selects this option.
If the @ command is given outside the copts.sma, it may not be followed by a code block, and all it does is reassign the text associated with the option. For example, some constant option might have the text "Look at the broken sword." until some point in the game where you find a blacksmith who can fix the sword, at which point the text becomes, "Look at the reforged sword."
@ sword Look at the broken sword. p The silvery metal gleams in the light.
* 1 Ask the blacksmith to reforge the sword. p The blacksmith agrees. It is fixed! @ sword Look at the reforged sword. v sword_fixed = 1
With +, make the constant option [tag] visible and available to the user;
if [tag] is omitted, this is done for all constant options.
With -, make the constant option [tag] invisible and unavailable to the user;
if [tag] is omitted, this is done for all constant options.
c a:sword * d Drop the sword. p You drop the sword on the ground. @ - sword c d:sword * t Take the sword. p You take the sword. @ + sword
@ - * w Wake up. p Groggily, you open your eyes and look around. Now that you're awake, you can do other things besides just wake up. @ + g awake
Set the random number seed. Normally, this is not necessary, because Smash seeds the random number generator itself. However, this can be useful for causing random number sequences to repeat. Although the seed can be any numerical value, normally it is set to some previous value of S:rseed, which returns the current random number seed.
* 1 Remember the current random number seed.
v seed = S:rseed
* 2 Set the random number seed to what we remembered before.
x seed
* 3 Give me some random numbers.
p {r:1000} {r:1000} {r:1000} {r:1000}
In the above example, every time you select option 3, you'll get a different set of random numbers. However, if you select option 1, then option 3, you'll get the same set of random numbers as you'll get if you subsequently select option 2, then option 3 again.
The effect lasts across multiple turns, too. If you select option 1, then option 3 three times, you'll get the same twelve numbers as you will if you subsequently select option 2, then option 3 three times.
Throw an error. This command would not be used in a complete game, but it is a helpful debugging tool during game development.
. You are in a room.
c have_sword = 1
, You have a sword.
C have_sword = 0
, There is a sword on the floor.
C
! The value of "have_sword" was {have_sword}, an
unexpected value.