Upload data files

data/MiniScript-Manual.md

@@ -0,0 +1,1049 @@
+# MiniScript Manual
+
+*Learn to read, write, and speak the world's easiest computer language*
+
+Joe Strout
+MiniScript Maker
+
+Version 1.6.2
+Monday, July 22, 2024
+
+# Welcome to MiniScript
+
+*a high-level, object-oriented language that is easy to read and write*
+
+
+MiniScript is a modern scripting language designed to be clean, simple, and easy to learn.  It was designed from the ground up by borrowing only the best ideas from other languages such as Python, Lua, Basic, and C#.  If you know pretty much any other programming language, you’ll pick up MiniScript almost immediately.
+
+And if you’ve never written a line of code in your life, don’t panic!  MiniScript is the friendliest and most fun way to get started.  It’s much easier than you probably expect.
+
+Important: MiniScript is designed as an embedded programming language.  That means you will usually use it inside some other program, such as a video game.  You should find another document that describes how to access and use MiniScript within that other program.  This document only describes the MiniScript language itself, and the intrinsic functions that are common to most MiniScript applications.
+
+## Clean, Clear Syntax
+
+Let’s jump right in with an example, to see what MiniScript code looks like.
+
+```miniscript
+s = "Spam"
+while s.len < 50
+    s = s + ", spam"
+end while
+print s + " and spam!"
+```
+
+Each statement in MiniScript normally occurs on a single line by itself.  Notice that there are no semicolons, curly braces, or other markers at the end of a line.
+
+However, there is one exception: if you want to join multiple statements on one line, just to make your code  more compact, you can do this by separating the statements with a semicolon.  The following code is ugly, but legal.
+
+```miniscript
+s = "Spam"; while s.len < 50; s = s + ", spam"; end while
+
+print s + " and spam!"
+```
+
+In practice this feature is rarely used, but it's there if you need it.
+
+## Code Blocks
+
+If you’re used to C-derived languages (such as C, C++, C#, etc.), then you’re used to seeing curly braces around blocks of code.  MiniScript doesn’t roll that way; code blocks always begin with a keyword (if, for, while, or function) and end with a matching end statement (end if,  end for,  end while, or  end function).
+
+## Whitespace and Indentation
+
+You can insert spaces and tabs into your code pretty much wherever you want.  You can’t break up an identifier or keyword (pr int is not the same as print), nor omit a space between two identifiers or keywords (end if is correct, but endif would not work).  And  of course spaces within quotation marks go into your string exactly as you would expect.  But between numbers, operators, etc., you can include extra spaces however you like.  The following two lines are exactly the same, as far as MiniScript is concerned.
+
+```miniscript
+x=4*10+2
+x = 4 * 10 + 2
+```
+
+To make the structure of code more readable, it’s traditional to indent the lines within a code block by either a tab or two spaces.  But it’s not required.  MiniScript doesn’t care how or whether you indent your code, so do whatever works best for you.
+
+## Breaking Long Lines
+
+Unlike C-derived languages, there are no semicolons or other funny punctuation at the end of each line to let the computer know that the statement is over.  Instead, the line break alone is enough to signal that.  But what if you need to enter a statement longer than one line?
+
+MiniScript will recognize that a statement is incomplete, and continues on the next line, if the last token (before any comment — see below) is an open parenthesis, square bracket, or brace; or a comma, or any binary operator (such as +, *, and so on).  So, for example, you could do:
+
+```miniscript
+speech = ["Four score and seven years ago our fathers",
+  "brought forth on this continent, a new nation, conceived",
+  "in Liberty, and dedicated to the proposition that all",
+  "men are created equal."]
+```
+
+That's four lines, but only one statement as far as MiniScript is concerned.  That's because the first three lines each ends with a comma, which tells MiniScript that more is coming.
+
+## Comments
+
+Comments are little notes you leave for yourself, or other humans reading your code.  They are completely ignored by MiniScript.  Comments begin with two slashes, and extend to the end of a line.  So you can put a comment either on a line by itself, or after a statement.
+
+```miniscript
+// How many roads must a man walk down?
+x = 6*7  // forty-two
+```
+
+Just like indentation, comments are never required… but they’re probably a good idea!
+
+## Use of Parentheses
+
+Parentheses in MiniScript have only three uses:
+
+Use them to group math operations in the order you want them, just as in algebra.
+
+```miniscript
+x = (2+4)*7   // this is different from 2+4*7
+```
+
+Use them around the arguments in a function call, except when the function call is the entire statement.
+
+```miniscript
+print cos(0)   // parens needed; cannot just say: print cos 0
+```
+
+Use them when declaring a function that takes parameters (see the Functions chapter).
+
+Since other languages often require parentheses in lots of other places, it’s worth pointing out where parentheses are not used in MiniScript.  First, don’t put parentheses around the condition of an if or while statement (more on these later).  Second, parentheses are not needed (and should be omitted) when calling a function without any arguments.  For example, there is a time function that gets the number of seconds since the program began.  It doesn’t need any arguments, so you can invoke it without parentheses.
+
+```miniscript
+x = time
+```
+
+Finally, as mentioned above, you don't need parentheses around the arguments of a function that is the very first thing on a statement.  The following example prints ten numbers, waiting one second each, and then prints a message.  Notice how we’re calling print and wait without any parentheses.  But the range call, because it has arguments and is used as part of a larger statement, does need them.
+
+```miniscript
+for i in range(10, 1)
+  print i
+  wait
+end for
+print "Boom!"
+```
+
+## Local and Global Variables
+
+A variable is a word (also called an identifier) associated with a value.  Think of variables as little boxes that you can store data in.  You create a variable simply by assigning a value to it, as in many of the examples we’ve already seen.
+
+```miniscript
+x = 42
+```
+
+This line creates a variable called x, if it didn’t exist already, and stores 42 in it.  This replaces the previous value of x, if any.
+
+Variables in MiniScript are dynamically typed; that is, you can assign any type of data (see the chapter on Data Types) to any variable.
+
+Variables are always local in scope.  That means that a variable called “x” inside one function has nothing at all to do with another variable called “x” in another function; each variable is scoped (restricted) to the current function executing at the time of the assignment.
+
+However, MiniScript also supports code outside of any function, as in all the examples we’ve seen so far.  In this context, local and global variables are the same.  In other words, assigning 42 to x outside of a function creates a global variable called x.  Such global variables may be accessed from any context.
+
+Note that when a context has a local variable of the same name as a global, an identifier will always resolve to the local variable first.  Similarly, a simple assignment statement within a function will always create a local variable, rather than a global one.  In cases where you really need to access the global variable instead, there is a globals object that provides this access.  (See the Intrinsic Functions chapter for more detail on globals.)
+
+```miniscript
+demo = function
+  print x           // prints the global x (40)
+  x = 2             // creates a local ‘x’ with a value of 2
+  print x           // prints the local x (2)
+  print globals.x   // prints the global x again (40)
+  globals.x = 42    // reassigns the global x
+  print x           // still the local value (2)
+  print globals.x   // prints the new global value (42)
+end function
+
+x = 40   // creates a global ‘x’ with a value of 40
+```
+
+demo     // invokes the function above
+
+Overuse of global variables can sometimes lead to tricky bugs, so it’s best to use them sparingly and rely on local variables as much as possible.  MiniScript is designed so that this good practice is what happens naturally.
+
+## Math-Assignment Operators
+
+As a convenient shorthand, the math operators (+, -, *, /, %, and ^) may be used in math-assignment form.  This does a math operation with a variable, and assigns the result back to that variable.  For example, the math-assignment form:
+
+x += 1
+
+means exactly the same thing as:
+
+```miniscript
+x = x + 1
+```
+
+The previous rules about local and global variables still apply.  So, to update a global variable in math-assignment form, you would write something like this.
+
+globals.x *= 5
+
+This works not only for numbers, but for any data type where the operator used is defined.  For example, if the global x in the example above were "ha", then after executing that line, the value of x would be "hahahahaha".
+
+## MiniScript is Case-Sensitive
+
+Uppercase and lowercase matters in MiniScript.  The print intrinsic function must be typed exactly print, and not Print, PRINT, or any other variation.  The same applies to any variables, functions, or classes you define.
+
+While how you use case in your own identifiers is up to you, a common convention is to capitalize classes (e.g. Shape), but use lowercase for variables.  Thus the following would be a perfectly sensible bit of code.
+
+```miniscript
+shape = new Shape   // create a Shape object called shape
+```
+
+While we're on the subject of conventions, in most cases you should avoid starting any global variables or function names with an underscore.  Identifiers starting with an underscore are often used by the host environment for special “under the hood” code, and name collisions there could cause problems.
+
+# Control Flow
+
+*looping and branching*
+
+Control flow is how you make code execute multiple times, or execute only under certain conditions.  Without it, your scripts would be limited to starting at the first line, executing each line exactly once in order, and ending after the last line.
+
+MiniScript includes one kind of branching (conditional) structure, and two kinds of loops.
+
+## Branching with if
+
+Use an if…then statement to specify some condition under which the following statements should be executed.  The basic syntax is:
+
+```miniscript
+if condition then
+  …
+end if
+```
+
+When the condition is not true, MiniScript will jump directly to the end if statement.
+
+```miniscript
+if x == 42 then
+  print "I have found the Ultimate Answer!"
+end if
+```
+
+The whole set of lines, from if…then to end if, is known as an if block.
+
+Sometimes you want to do something else when the specified condition is not true.  You can specify this with an else block before the end if.
+
+```miniscript
+if x == 42 then
+  print "I have found the Ultimate Answer!"
+else
+  print "I am still searching."
+end if
+```
+
+Finally, you can check for additional conditions by adding else-if blocks as needed.  Here's a slightly more practical example that converts a number to words.
+
+```miniscript
+if apples == 0 then
+  print "You have no apples."
+else if apples == 1 then
+  print "You have one apple."
+else if apples > 10 then
+  print "You have a lot of apples!"
+else
+  print "You have " + apples + " apples."
+end if
+```
+
+In this case, the first condition that matches will execute its block of lines.  If none of the conditions match, then the else block will run instead.
+
+Note that for all these forms, the if, else if, else, and end if statements must each be on its own line.  However, there is also a "short form" if statement that allows you to write an if or if/else on a single line, provided you have only a single statement for the then block, and a single statement for the else block (if you have an else block at all).  A short-form if looks like this:
+
+```miniscript
+if x == null then x = 1
+```
+
+…while a short-form if/else looks like this:
+
+```miniscript
+if x >= 0 then print "positive" else print "negative"
+```
+
+Notice that end if is not used with a short-form if or if/else.  Moreover, there is no way to put more than one statement into the then or else block.  If you need more than one statement, then use the standard multi-line form.
+
+## Looping with for
+
+A for…in statement loops over a block of code zero or more times.  The syntax is:
+
+```miniscript
+for variable in list
+  …
+end for
+```
+
+The whole block is referred to as a for loop.  On each iteration through the loop, the variable is assigned one value from the specified list.  You'll learn more about lists in the Data Types chapter, but for now, it's enough to know that you can easily create a list of numbers using the range function.
+
+This example counts from 10 down to 1, and then blasts off.
+
+```miniscript
+for i in range(10, 1)
+    print i + "..."
+end for
+print "Liftoff!"
+```
+
+See the range function in the Intrinsic Functions chapter for more options on that.
+
+Instead of a list, you can also iterate over a text string.  In this case the loop variable will be assigned each character of the string in order.
+
+Finally, it is also possible to iterate over maps.  Again, maps will be explained in the Data Types chapter, but just keep in mind that when you use a for statement with a map, then on each iteration through the loop, your loop variable is a little mini-map containing key and value.  For example:
+
+```miniscript
+m = {1:"one", 2:"two", 3:"three"}
+for kv in m
+  print "Key " + kv.key + " has value " + kv.value
+end for
+```
+
+This prints out each of the key-value pairs in the map.
+
+## Looping with while
+
+The other way to loop over code in MiniScript is with a while loop.  The syntax is:
+
+```miniscript
+while condition
+  …
+end while
+```
+
+This executes the contained code as long as condition is true.  More specifically, it first evaluates the condition, and if it's not true, it jumps directly to end while.  If it is true, then it executes the lines within the loop, and then jumps back up to the while statement.  The process repeats forever, or until the condition becomes false.
+
+This is illustrated by the very first example in this manual, repeated here.
+
+```miniscript
+s = "Spam"
+while s.len < 50
+    s = s + ", spam"
+end while
+print s + " and spam!"
+```
+
+This code builds a string (s) by adding more spam to it, as long as the string length is less than 50.  Once it is no longer less than 50, the loop exits, and the result is printed.
+
+## Break and Continue
+
+There are two additional keywords that let you bail out of a while or for loop early.  First, the break statement jumps directly out of the loop, to the next line past the end for or end while.  Consider the following.
+
+```miniscript
+while true     // loops forever!
+  if time > 100 then break
+end while
+```
+
+Whenever you see while true (or while 1, which is equivalent), it is an infinite loop — unless there is a break statement in the body of the loop.  As soon as that break statement executes, we jump directly out of the loop.  It works for for loops in exactly the same way.  In the case of nested loops, break breaks out of only the innermost loop.
+
+The continue statement skips the rest of the body of the loop, and proceeds with the next iteration.  This is often used for "bail-out" cases in a large loop, where under certain conditions you want to skip an iteration and just go on with the next one.
+
+```miniscript
+for i in range(1,100)
+  if i == 42 then continue
+  print "Considering " + i + "..."
+end for
+```
+
+This will print out the numbers 1 through 100, except for 42, which is skipped.  Note that if you simply changed continue to break in this example, the loop would print the numbers 1 through 41, and then stop.
+
+## The Nature of Truth
+
+We have talked about evaluating conditions as true or false, without explaining what that really means.  Usually you don't need to worry about it, but here are the details anyway.
+
+```miniscript
+Boolean (true/false) values in MiniScript are represented as numbers.  When conditions are evaluated for if and while statements, a value of 0 (zero) is considered false; any other value is considered true.  In fact the built-in keywords true and false are exactly equivalent to the numbers 1 and 0 respectively.
+```
+
+When you use comparison operators such as == (equal), != (not equal), > (greater than), and <= (less than or equal), these compare their operands and evaluate to either 1 (if true) or 0 (if false).
+
+See the Numbers section of the Data Types chapter for more boolean operations you can apply to numbers (including and, or, and not).
+
+Finally, in a context that demands a truth value — that is, in an if and while statement, or as an operand of and, or, and not — other data types will be considered false if they are empty, and true if they are not empty.  So an empty string, list, or map is equivalent to 0 (zero), and any non-empty string, list or map is equivalent to 1 in these contexts.  The special value null is always considered false.
+
+
+# Data Types
+
+*things you can store and manipulate*
+
+Variables in MiniScript are dynamically typed; you can store any type of data in any variable.  But what types of data are there?  In MiniScript, there are four primary data types: numbers, strings, lists, and maps.  There are a couple of other more obscure types, such as function and null.  Everything else, including classes and objects, is actually a special case of a map.
+
+## Numbers
+
+All numeric values in MiniScript are stored in standard full-precision format (also known as “doubles” in C-derived languages).  Numbers are also used to represent true (1) and false (0).
+
+Numeric literals are written as ordinary numbers, e.g. 42, 3.1415, or  -0.24.
+
+You can use the following operators on numbers (where a and b are numbers).
+
+| a + b | addition | numeric sum of a and b |
+| a - b | subtraction | numeric difference of a and b |
+| a * b | multiplication | a multiplied by b |
+| a / b | division | a divided by b |
+| a % b | modulo | remainder after dividing a by b |
+| a ^ b | power | a raised to the power of b |
+| a and b | logical and | a * b, clamped to the range [0,1] |
+| a or b | logical or | a + b - a*b, clamped to the range [0,1] |
+| not a | negation | 1 - abs(a), clamped to the range [0,1] |
+| a == b | equality | 1 if a equals b, else 0 |
+| a != b | inequality | 1 if a is not equal to b, else 0 |
+| a > b | greater than | 1 if a is greater than b, else 0 |
+| a >= b | greater than or equal | 1 if a is greater than or equal to b, else 0 |
+| a < b | less than | 1 if a is less than b, else 0 |
+| a <= b | less than or equal | 1 if a is less than or equal to b, else 0 |
+
+Note that and, or, and not are not functions; they are operators, and go between (or in the case of not, before) their operands just like all the others.
+
+You can check whether a variable contains a number with the isa operator.  There is an intrinsic class called number, and  x isa number  returns true (1) whenever x is, in fact, a number.
+
+## Strings
+
+Text values in MiniScript are stored as strings of Unicode characters.  String literals in the code are enclosed by double quotes (").  Be sure to use ordinary straight quotes, not the fancy curly quotes some word processors insist on making.
+
+If your string literal needs to include quotation marks, you can do this by typing the quotation marks twice.  For example:
+
+```miniscript
+s = "If you do not help us, we shall say ""Ni"" to you."
+```
+
+Strings may be concatenated with the + operator, and if you try to add a number and a string together, the number will be automatically converted to a string and then concatenated.  Strings may also be replicated (repeated) or cut down to a fraction of their former selves, by multiplying or dividing them by a number.
+
+```miniscript
+s = "Spam" * 5   // SpamSpamSpamSpamSpam
+s = s / 2        // SpamSpamSp
+```
+
+The full set of string operators is shown below; s and t are strings, and n and m are numbers.
+
+| s + t | concatenation | string formed by concatenating t to s |
+| s - t | subtraction (chop) | if s ends in t, returns s with t removed; otherwise just returns s |
+| s * n | replication | s repeated n times (including some fractional amount of s) |
+| s / n | division | equivalent to s * (1/n) |
+| s[n] | index | character n of s (all indexes are 0-based; negative indexes count from end) |
+| s[:n] | left slice | substring of s up to but not including character n |
+| s[n:] | right slice | substring of s from character n to the end |
+| s[n:m] | slice | substring of s from character n up to but not including character m |
+| s == t | equality | 1 if s equals t, else 0 (all string comparisons are case-sensitive) |
+| s != t | inequality | 1 if s is not equal to t, else 0 |
+| s > t | greater than | 1 if s is greater than (collates after) t, else 0 |
+| s >= t | greater than or equal | 1 if s is greater than or equal to t, else 0 |
+| s < t | less than | 1 if s is less than (collates before) t, else 0 |
+| s <= t | less than or equal | 1 if s is less than or equal to t, else 0 |
+
+The table above does not include and, or, and not, but these operators work perfectly well on strings through boolean coercion (see "The Nature of Truth" in the previous chapter).  In any boolean context, s is considered true if it contains any characters, and false if it is the empty string.
+
+Also not listed is behavior of the isa operator with strings.  There is an intrinsic type called string, and s isa string returns true (1) for any string s.
+
+The slice operators deserve a bit of explanation.  The basic syntax is s[n:m], which gets a substring of s starting at character n, and going up to (but not including) character m, where we number characters starting from 0.  But this basic syntax is extended with a handful of neat tricks:
+
+You may specify just a single index, leaving out the colon, to get a single character.  Thus s[0] is the first character, s[1] is the second, etc.
+
+You may use a negative index, and it will count from the end.  So s[-1] is the last character, s[-2] is the next-to-last, etc.  This works for any of the slice indexes.
+
+You may omit the first index from the two-index form, and it will default to 0.  This is a handy way to get the first n characters of a string.  So s[:3] returns the first 3 characters of s; s[:-3] returns all but the last three characters of s.
+
+You may omit the last index from the two-index form, and it will continue to the end of the string.  Thus, s[3:] skips the first three characters and returns the rest of the string.
+
+The way these indexes work results in a lot of very handy properties.  For example, s[:n] + s[n:] == s for any value of n from 0 through s.len; in other words, there is a very natural syntax for splitting a string into two parts, which is a fairly common thing to do.
+
+Finally, note that strings are immutable; just like numbers, you can never change a string, but you can create a new string and assign it to an existing variable.  The following example shows one correct and one incorrect way to change “spin” into “spun”.
+
+```miniscript
+s = "spin"
+s = s[:2] + "u" + s[3:]   // OK
+```
+
+s[3] = "u"   // no can do (Runtime Error)
+
+## Lists
+
+The third basic data type in MiniScript is the list.  This is an ordered collection of elements, accessible by index starting with zero.  Each element of a list may be any type, including another list.
+
+You define a list by using square brackets around the elements, which should be separated with commas.
+
+```miniscript
+x = [2, 4, 6, 8]
+```
+
+The code above creates a list with four elements and assigns it to x.  But again, list elements don't have to be numbers; they can also be strings, lists, or maps.  Here's another example.
+
+```miniscript
+x = [2, "four", [1, 2, 3], {8:"eight"}]
+```
+
+Working with a list is very much like working with a string.  You can concatenate two lists with +, replicate or cut a list with * and /, and access elements or sublists using the same slice syntax.  Here are the operators valid on lists, where p and q are lists, and n and m are numbers.
+
+| p + q | concatenation | list formed by concatenating q to p |
+| p * n | replication | p repeated n times (including some fractional amount of p) |
+| p / n | division | equivalent to p * (1/n) |
+| p[n] | index | element n of p (all indexes are 0-based; negative indexes count from end) |
+| p[:n] | left slice | sublist of p up to but not including element n |
+| p[n:] | right slice | sublist of p from element n to the end |
+| p[n:m] | slice | sublist of p from element n up to but not including element m |
+
+In addition, you can use x isa list to check whether any variable x contains a list.
+
+The slice operators work exactly the same way as with strings.  So p[-1] is the last element of list p; p[3:] skips the first three elements and returns the rest of the list, and so forth.
+
+However, there is one important difference: lists are mutable.  You can change the contents of a list (by assigning to p[n] or using one of the list methods like p.push), and no matter how many different variables are referring to that list, they will all see the change.  The following example illustrates.
+
+```miniscript
+a = [1, 2, 3]   // creates a list and assigns to a
+b = a           // assigns that SAME list to b
+```
+
+a[-1] = 5       // changes the last element of our list to 5
+
+```miniscript
+print b         // prints: [1, 2, 5]
+```
+
+Because a and b both refer to the same list, any changes (mutations) made to that list can be seen from either variable.
+
+If you want to be sure you have a fresh copy of a list, rather than a shared reference, a common trick is to use [:] to make a slice that includes the entire list.  This copies the elements into a new list.  Compare the following example to the previous one.
+
+```miniscript
+a = [1, 2, 3]   // creates a list and assigns to a
+b = a[:]        // assigns a COPY of that list to b
+```
+
+a[-1] = 5       // changes the last element of our first list to 5
+
+```miniscript
+print b         // prints: [1, 2, 3]  (our copy hasn't changed)
+```
+
+## Maps
+
+The final basic data type in MiniScript is the map.  A map is a set of key-value pairs, where each unique key maps to some value.  In some programming environments, this same concept is called a dictionary.
+
+Create a map with curly braces around a comma-separated list of key-value pairs.  Specify each pair by separating the key and value with a colon, as shown here.
+
+```miniscript
+m = {1:"one", 2:"two", 3:"three"}
+```
+
+The map created here contains three key-value pairs, each mapping a number to a string (which happens to be the English word for that number in this example).
+
+Map keys should be numbers or strings, and must be unique; if you reuse a key, the previous value is replaced.  (Technically a key may be a list or another map as well, but in this case, it's important that you do not mutate the key, or the behavior is undefined.)  Values may be any type, including lists or maps.  Order within a map is not preserved; for loops iterate over a map in arbitrary order.
+
+Maps support only a handful of operators (d and e are maps, k is a key, and v is a value):
+
+| d + e | concatenation | map formed by assigning d[k] = v for every k,v pair in e |
+| d[k] | index | value associated with key k in d |
+| d.k | dot index | value associated with (string) k in d |
+
+There are two ways to get and set members of a map.  The first is to use the square-brackets index operator, just as with strings or lists, except that in the case of a map, the key can be a string as well as a number (or even a list or another map, if you are very careful).
+
+```miniscript
+d = {"yes":"hai", "no":"iie", "maybe":"tabun"}
+print d["maybe"]       // prints: tabun
+```
+
+d["maybe"] = "kamo"
+
+```miniscript
+print d["maybe"]       // prints: kamo
+```
+
+The second way is using the dot indexer.  This works only in the special case where the key is a string that is a valid identifier: it begins with a letter, and contains only letters, numbers, and underscores.  In this case you can write the key after a dot rather than enclosing it in square brackets and quotation marks — the key essentially becomes an identifier in the language.  The following is functionally equivalent to the previous example.
+
+```miniscript
+d = {"yes":"hai", "no":"iie", "maybe":"tabun"}
+print d.maybe          // prints: tabun
+d.maybe = "kamo"
+print d["maybe"]       // prints: kamo
+```
+
+This dot indexer is mostly syntactic sugar that makes accessing elements of a map easier to read and write.  But there are some subtle differences in cases where the map represents a class or object, as described in the next chapter.
+
+Finally, like the other basic types, there is an intrinsic class that represents maps — map in this case.  So x isa map will return true for any map (including any class or object, as you'll see in the next section).
+
+## Type Checking
+
+The isa operator was mentioned several times above.  This is how you can check, at runtime, what sort of data you have.  In many cases you won't care, thanks to MiniScripts automatic type conversion.  But sometimes you do.
+
+Suppose for example you want to make a method that prints its argument surrounded by parentheses... but if the caller passes in a list, then you want to join the elements of that list with commas.  You could accomplish that with isa.
+
+```miniscript
+spew = function(x)
+    if x isa list then x = x.join(", ")
+    print "(" + x + ")"
+end function
+```
+
+
+spew 42                 // prints: (42)
+
+spew [18, 42, "hike!"]   // prints: (18, 42, hike!)
+
+## Extending Built-In Types
+
+The four built-in types — number, string, list, and map — are just ordinary maps, like your own classes (which you'll learn about next, I promise).  You can add new methods to them, and then invoke those methods using dot syntax on ordinary numbers, strings, lists, and maps.  (The only limitation is that you can't use dot syntax with a numeric literal.)  If this sounds like Greek to you, don't worry — it's an advanced feature, and one most users will never need.
+
+## Complete Operator List
+
+The table below shows all the operators in the MiniScript language, along with their precedence.  Operands in an expression chain will always be grouped by higher-precedence operators before lower-precedence ones; e.g., x + y * z is processed as x + (y * z), because the * operator is higher precedence than the + operator.
+
+| Operator | Meaning | Precedence |
+|---|---|---|
+| A = B | assignment | 0 |
+| A or B | logical OR: true if either operand is true | 1 |
+| A and B | logical AND: true if both operands are true | 2 |
+| not A | logical negation: true if its operand is false, and vice versa | 3 |
+| A isa B | type checking | 4 |
+| A == B | equality comparison: true if operands are equal | 5 |
+| A != B | inequality comparison: true if operands are not equal | 5 |
+| A > B | greater-than comparison | 5 |
+| A < B | less-than comparison | 5 |
+| A >= B | greater-than or equal-to comparison | 5 |
+| A <= B | less-than or equal-to comparison | 5 |
+| A + B | addition or concatenation | 6 |
+| A - B | subtraction or string trimming | 6 |
+| A * B | multiplication or replication | 7 |
+| A / B | division or reduction | 7 |
+| A % B | modulo (remainder) | 7 |
+| -A | unary minus (numeric negation) | 8 |
+| new A | instantiation | 9 |
+| @A | address-of (reference function without invoking it) | 10 |
+| A ^ B | power: A raised to the power of B | 11 |
+| A[B] | indexing | 12 |
+| A[B:C] | slicing | 12 |
+| A(B, C...) | calling a function | 12 |
+| A.B | dot operator | 12 |
+
+# Functions and Classes
+
+*the building blocks of sophisticated software*
+
+A function is essentially a sub-program that does some particular task.  We've already seen some of the functions built into MiniScript, such as time and range, and even print.  There are many more of those, which will be documented in the next chapter.  But the real power of a programming language comes from defining your own functions.
+
+Beyond that, as a program grows in size and complexity, it becomes useful to start organizing it into classes.  A class is basically a collection of functions and data, where objects of a class share the same functions but may have unique data.
+
+## Functions
+
+A function in MiniScript is a special data type, at the same level as numbers, strings, lists, and maps.  You can define a function with the function keyword, assign it to a variable, and then invoke it via that variable, just like the built-in functions.  Here's an example.
+
+```miniscript
+triple = function(n=1)
+    return n*3
+end function
+print triple      // prints: 3
+print triple(5)   // prints: 15
+```
+
+This declares a function that triples any value given to it, and assigns that function to a variable called triple.  The triple function is then invoked, with and without an argument.
+
+The syntax for declaring a function is:
+
+```miniscript
+function(parameters)
+…
+end function
+```
+
+where parameters is a comma-separated list of zero or more parameters, each of the form name or name=defaultValue.  When a function is invoked, arguments will be matched up to the functions by position.  If fewer arguments are given than parameters are defined, the remaining parameters are given their default values — and if no default value was defined for that parameter, then it is set to null.
+
+Note that the parentheses after the function keyword are required only if there are parameters.  In the case of a function with no parameters, the parentheses are not required (and by standard convention, should be omitted).
+
+It's important to understand that a function is itself a bit of data.  It's just that, whenever looking up the value of a variable, MiniScript checks for this special function data type; and if found, it invokes that function, rather than returning the function itself.
+
+Usually that is exactly what is wanted, as in the example above.  But occasionally you may want to copy the function reference, rather than invoking the function.  You can do this by prepending your identifier with an @ (read “address of”).  Example:
+
+```miniscript
+triple = function(n=1)
+    return n*3
+end function
+x = @triple
+print x(5)      // prints: 15
+```
+
+Here we've again declared a function and stored it in a variable called triple.  Then we copy the address of that function into another variable called x.  At this point we can invoke the function either way, via triple or via x, and both do exactly the same thing.  Had we left out the @ on the assignment, MiniScript would have instead evaluated the function  triple refers to, and assigned the result (3) to x.
+
+Here's a more realistic example.  We'll define a function called apply which can apply a given function to each element of a list.  Then we can invoke this on a list with any function, simply by using @ to refer to the function we want to apply.
+
+```miniscript
+apply = function(lst, func)
+  result = lst[:]                  // make a copy of the list
+  for i in indexes(result)
+    result[i] = func(result[i])    // apply func to each element
+  end for
+  return result                    // return modified result
+end function
+
+print apply([1, 2, 3], @triple)    // prints: [3, 6, 9]
+```
+
+To summarize, you invoke a function by simply using any identifier that refers to it.  You avoid this invocation, and refer instead to the function itself, by putting @ before the identifier.
+
+## Nested Functions
+
+MiniScript allows you to define functions within functions.  This is an advanced feature that most users may never need, but it can come in handy on occasion, especially in conjunction with something like the “apply” method above.  Just as with any other local value, you might want to avoid cluttering the global namespace just for a function that you only use in one place.  Here’s a simple example that assumes we have the apply method defined above.
+
+```miniscript
+doubleAll = function(lst)
+  f = function(x)
+    return x + x
+  end function
+  return apply(lst, @f)
+end function
+```
+
+So inside the function referred to by the (global variable) doubleAll, we define another function, and assign it to the (local variable) f.  Then we pass that function in as the second argument to the apply function (or more pedantically, to the function referred to by the apply global variable).
+
+When you have a nested function like this, it can access the local variables of the function that contains it.  Just as with global variables, it can do this without any prefix (as long as there isn’t some local variable with the same name getting in the way).  But to assign to a variable of the outer function, you must use the special identifier outer.  Here’s an example.
+
+```miniscript
+makeList = function(sep)
+    counter = 0
+    makeItem = function(item)
+        outer.counter = counter + 1
+        return counter + sep + item
+    end function
+    return [makeItem("a"), makeItem("b"), makeItem("c")]
+end function
+
+print makeList(". ")
+```
+
+Here, makeList refers to the outer function, and makeItem is the inner (nested) function.  Notice how makeList has a local variable called counter, initialized to 0.  But the inner function both reads that value, and updates it using outer.counter.  Work through this code carefully to see if you can figure out what it prints... and then try it and see if you were right!
+
+Again, this nested-function business is an advanced feature which beginners can safely forget about.  But for advanced users, it is a language feature worth understanding.
+
+## Classes and Objects
+
+MiniScript supports object-oriented programming (OOP) via prototype-based inheritance.  That is, there is fundamentally no difference in MiniScript between a class and an object; the difference, when it exists at all, lives solely in the intent of the programmer.
+
+A class or object is a map with a special __isa entry that points to the parent (prototype).  This is an implementation detail you rarely need to worry about, because it is handled automatically by the following rules:
+
+When you create a map using the special new operator, the __isa member is set for you.
+
+When you look up an identifier in a map, MiniScript will walk the __isa chain looking for a map containing that identifier.  The value returned is the first value found.
+
+Finally, the isa operator also walks the __isa chain, and returns true if any map in that chain matches the right-hand operand.  In other words, x isa y returns true if x is y, or any subclass of y.
+
+These simple rules provide almost everything needed for object-oriented programming.  A series of "classes" may be defined as maps containing functions and default data, which are inherited or overridden as needed.  An "object" is just another map, inherited from some class, which normally contains only custom data.
+
+Let's illustrate with an example.  We'll define a class called Shape, with a subclass called Square.
+
+```miniscript
+Shape = {}
+Shape.sides = 0
+
+Square = new Shape
+Square.sides = 4
+```
+
+A base class is just an ordinary map; in this case, we added a sides entry with a value of 0, signifying that “sides” is a bit of data we expect every Shape to have.  Then we created a subclass by using new Shape,  and assigned this to Square.  In Square, we overrode the value of sides (as all squares should have 4 sides).
+
+Now let’s create an instance of our Square class, again by using new.
+
+```miniscript
+x = new Square
+print x.sides      // prints: 4
+```
+
+Notice how we’re using the traditional OOP terminology of “class” and “instance” for convenience, but in reality, there are just three maps — Shape is the prototype of Square, and Square is the prototype of x.  The __isa member of each map points to the prototype, because we created them with new.
+
+Now let’s add a function to the Shape class, which should work for any shape subclass or object.
+
+```miniscript
+Shape.degrees = function
+  return 180 * (self.sides - 2)
+end function
+
+print x.degrees     // prints: 360
+```
+
+This example illustrates one additional rule important to object-oriented programming:
+
+When a function is invoked via dot indexing, it receives a special self variable that refers to the object on which it was invoked.
+
+So in the example above, we invoked the degrees function as x.degrees, which looks for a member called “degrees” in x (and its prototypes via the __isa chain).  And when that function is invoked, a special local variable called self is bound to the x object, i.e. the first map in the search chain.  This allows class functions to access object data.
+
+There is just one more bit of special support for object-oriented programming, and that is the super keyword.  This is another built-in variable (similar to self) defined when you invoke a method via dot syntax, but when you call another method via super, it invokes that method on the base class, while keeping self bound to the same value as in the current function.  In other words, super lets you call a superclass method, even if you've overridden it.  Continuing the previous example, suppose we want to define a subclass of Square that always has 42 more degrees than nonmagical shapes would have:
+
+```miniscript
+MagicSquare = new Square
+MagicSquare.degrees  = function
+    return super.degrees + 42
+end function
+
+y = new MagicSquare
+print y.degrees    // prints: 402
+```
+
+Notice how the MagicSquare.degrees function calls super.degrees.  That causes MiniScript to walk the __isa chain, looking for the first implementation of degrees it can find.  That would be Shape.degrees, so it invokes that, with a self still bound to y.
+
+
+## Extending the Built-In Types
+
+There are maps that represent each of the basic data types: number, string, list, and map.  These contain the built-in methods for those types.  By adding new methods to one of these maps, you can add new methods usable with dot syntax on values of that type.
+
+For example, while there are built-in string methods .upper and .lower to convert a string to upper- or lower-case, there isn’t a method to capitalize a string — that is, convert only the first letter to uppercase.  But you could add such a method in your program as follows.
+
+```miniscript
+string.capitalized = function
+    if self.len < 2 then return self.upper
+    return self[0].upper + self[1:]
+end function
+```
+
+The function itself is fairly simple: if our string (self) is less than 2 characters long, just uppercase the whole thing; otherwise uppercase the first letter, and append the rest.  But because we have assigned this function to string.capitalized, that is, added it to the string map, we can call it with dot syntax on any string.
+
+```miniscript
+print "miniScript".capitalized      // prints: MiniScript
+```
+
+
+There is one limitation to this trick.  Numbers are a little different from other data types; MiniScript does not support dot syntax on numeric literals.  So
+
+```miniscript
+x = 42
+x.someMethod
+```
+
+works fine (assuming you have defined an appropriate number.someMethod function), but
+
+```miniscript
+42.someMethod
+```
+
+does not.
+
+
+# Intrinsic Functions
+
+*built-in functions you can rely on*
+
+MiniScript comes with a standard set of built-in (or intrinsic) functions.  Many of these are globals (i.e., referred to by variables in the global space).  Others (particularly functions intended for use with strings, lists, and maps) are normally invoked via dot syntax after an identifier.
+
+In fact, though, all intrinsic functions that use dot syntax are written in such a way that they can also be invoked as global functions.  So, for example, you can get the length of a string s by typing s.len, but you can also do the same thing as len(s).
+
+The following tables list the standard intrinsic functions, divided by data type on which they operate.  Keep in mind that MiniScript is intended to be embedded in some host environment, such as a game or application.  The host will normally add additional intrinsic functions particular to that environment.  Please consult the documentation or help materials for your host environment for information on these extra functions.
+
+## Numeric Functions
+
+MiniScript includes a selection of trigonometric functions, which all work in radians (rather than degrees), and other math functions, as well as random numbers and conversion of numbers into strings.
+
+In the following table, x is any number, i is an integer, and r is a number of radians.
+
+| abs(x) | absolute value of x |
+| acos(x) | arccosine of x, in radians |
+| asin(x) | arcsine of x, in radians |
+| atan(y, x=1) | arctangent of y/x, in radians (returns correct quadrant if optional x parameter is used) |
+| bitAnd(x, y) | treats x and y as integers, and returns bitwise "and" of a and b |
+| bitOr(x, y) | treats x and y as integers, and returns bitwise "or" of a and b |
+| bitXor(x, y) | treats x and y as integers, and returns bitwise "exclusive or" of a and b |
+| ceil(x) | next whole number equal to our greater than x |
+| char(i) | returns Unicode character with code point i (see string .code for the inverse function) |
+| cos(r) | cosine of r radians |
+| floor(x) | next whole number less than or equal to x |
+| log(x, base=10) | logarithm (with the given base) of x, i.e., the value y such that base^y == x |
+| pi | 3.14159265358979 |
+| range(x, y=0, step=null) | returns a list containing values from x through y, in increments of step; step == null is treated as a step of 1 if y > x, or -1 otherwise |
+| round(x, d=0) | x rounded to d decimal places |
+| rnd(seed=null) | "if seed=null, returns random number in the range [0,1); |
+| if seed != null, seeds the random number generator with the given integer value" |
+| sign(x) | sign of x: -1 if x < 0; 0 if x == 0; 1 if x > 0 |
+| sin(r) | sine of r radians |
+| sqrt(x) | square root of x |
+| str(x) | converts x to a string |
+| tan(r) | tangent of r radians |
+
+## String Functions
+
+All string functions except slice are designed to be invoked on strings using dot syntax, but can also be invoked as globals with the string passed in as the first parameter.  Note that strings are immutable; all string functions return a new string, leaving the original string unchanged.  In the following table, self refers to the string, s is another string argument, and i is an integer number.
+
+| .code | Unicode code point of first character of self (see numeric char function for inverse) |
+| .hasIndex(i) | 1 if i is in the range 0 to self.len-1; otherwise 0 |
+| .indexes | range(0, self.len-1) |
+| .indexOf(s, after=null) | 0-based position of first substring s within self, or null if not found; optionally begins the search after the given position |
+| .insert(index, s) | returns new string with s inserted at position 0 |
+| .len | length (number of characters) of self |
+| .lower | lowercase version of self |
+| .remove(s) | self, but with first occurrence of substring s removed (if any) |
+| .replace(oldval, newval, maxCount=null) | returns a new string with up to maxCount occurrences of substring oldval replaced with newval (if maxCount unspecified, then replaces all occurrences) |
+| .upper | uppercase version of self |
+| .val | converts self to a number (if self is not a valid number, returns 0) |
+| .values | list of individual characters in self (e.g. "spam".values = ["s", "p", "a", "m"] |
+| slice(s, from, to) | equivalent to s[from:to] |
+| .split(delimiter=" ", maxCount=null) | splits the string into a list by the given delimiter, with at most maxCount entries (if maxCount is unspecified, then splits into a list of any size) |
+
+## List Functions
+
+All list functions except slice are designed to be invoked on lists using dot syntax, but can also be invoked as globals with the list passed in as the first parameter.  Lists are mutable; the pop, pull, push, shuffle, and remove functions modify the list in place.  To use a list like a stack, add items with push and remove them with pop.  To use a list like a queue, add items with push and remove them with pull.
+
+In the following table, self is a list, i is an integer, and x is any value.
+
+| .hasIndex(i) | 1 if i is in the range 0 to self.len-1; otherwise 0 |
+| .indexes | range(0, self.len-1) |
+| .indexOf(x, after=null) | 0-based position of first element matching x in self, or null if not found; optionally begins the search after the given position |
+| .insert(index, value) | inserts value into self at the given index (in place) |
+| .join(delimiter=" ") | builds a string by joining elements by the given delimiter |
+| .len | length (number of elements) of self |
+| .pop | removes and returns the last element of self (like a stack) |
+| .pull | removes and returns the first element of self (like a queue) |
+| .push(x) | appends the given value to the end of self; often used with pop or pull |
+| .shuffle | randomly rearranges the elements of self (in place) |
+| .sort(key=null) | sorts list in place, optionally by value of the given key (e.g. in a list of maps) |
+| .sum | total of all numeric elements of self |
+| .remove(i) | removes element at index i from self (in place) |
+| .replace(oldval, newval, maxCount=null) | "replaces (in place) up to maxCount occurrences of oldval in the list with newval |
+| (if maxCount not specified, then all occurrences are replaced)" |
+| slice(list, from, to) | equivalent to list[from:to] |
+
+
+## Map Functions
+
+Functions on maps are very similar to functions on lists. Maps (like lists) are mutable; the push, pop, remove, and shuffle methods modify the map in place.  You can treat a map like a set using push, which inserts 1 (true) for the value of the given key, and pop, which returns a key and removes it (and its value) from the map.  Keep in mind that the order of keys in a map is undefined.
+
+In the following table, self is a map, i is an integer, and x is any value.
+
+| .hasIndex(x) | 1 if x is a key contained in self; 0 otherwise |
+| .indexes | list containing all keys of self, in arbitrary order |
+| .indexOf(x, after=null) | first key in self that maps to x, or null if none; optionally begins the search after the given key |
+| .len | length (number of key-value pairs) of self |
+| .pop | remove and return an arbitrary key from self |
+| .push(x) | equivalent to self[x] = 1 |
+| .remove(x) | removes the key-value pair where key=x from self (in place) |
+| .replace(oldval, newval, maxCount=null) | replaces (in place) up to maxCount occurrences of value oldval in the map with newval (if maxCount not specified, then all occurrences are replaced) |
+| .shuffle | randomly remaps values for keys |
+| .sum | total of all numeric values in self |
+| .values | list containing all values of self, in arbitrary order |
+
+## System Functions
+
+The following functions relate to the operation of MiniScript itself, or interact with the host environment.  The latter (print, time, and wait) are only quasi-standard, in that support for them depends on the host application, and so they may not function in some environments.
+
+| globals | reference to the global variable map |
+| intrinsics | a map containing all the global intrinsic functions |
+| locals | reference to the local variable map for the current call frame |
+| print(x, delim) | convert x to a string and print to some text output stream, optionally followed by delim; if delim is not specified, the output is followed by a line break in most environments |
+| refEquals(a,b) | returns 1 if a and b refer to the same instance (not just equal values) |
+| stackTrace | returns the current call stack, as a list of strings |
+| time | number of seconds since program execution began |
+| wait(x=1) | wait x seconds before proceeding with the next MiniScript instruction |
+| yield | wait for next invocation of main engine loop (e.g., next frame in a game) |
+
+# Examples
+
+*small programs that do interesting things*
+
+While we’ve given short examples of MiniScript code throughout this manual, this chapter presents several longer, more interesting examples.  Many of the tasks illustrated are taken from RosettaCode, an online database of programming challenges with solutions in many languages.  You can go there to compare the MiniScript solution to any other language; you may be amazed how much more readable MiniScript is than the alternatives.
+
+## FizzBuzz
+
+FizzBuzz is a [standard](http://rosettacode.org/wiki/FizzBuzz) introductory-level programming challenge.  The task is simple: print the numbers 1 through 100, but: for multiples of three, print “Fizz” instead of the number; for multiples of five, print “Buzz” instead of the number, and for any number that’s a multiple of three and five, print “FizzBuzz”.
+
+There are clearly many ways to tackle this; here’s one.
+
+```miniscript
+fizzBuzz = function(n)
+  for i in range(1, n)
+    s = "Fizz" * (i%3==0) + "Buzz" * (i%5==0)
+    if s == "" then s = str(i)
+    print s
+  end for
+end function
+```
+
+fizzBuzz 100
+
+Instead of just hard-coding a loop from 1 to 100, we’ve made a function that can FizzBuzz up to any number.  Within that function, the only clever bit is line 3, which takes advantage of a couple of MiniScript features.  First, comparisons (such as i%3==0 — read “i mod 3 equals zero”) evaluate to 1 when true, or 0 when false.  Second, you can multiply a string by a number to repeat it that many times.  This means that if you multiply a string by a condition, you get either the original string (if the condition is true) or the empty string (if it is false).
+
+That lets us easily generate “Fizz”, “Buzz”, and “FizzBuzz” depending on what our loop counter is divisible by.  Line 4 simply fills in the number if we don’t get one of those strings. (Quiz: can you rewrite this line to use the same multiply-by-condition trick as line 3?)
+
+## Filter
+
+Here’s another [RosettaCode task](http://rosettacode.org/wiki/Filter): select certain elements from an Array into a new Array in a generic way.  To demonstrate, select all even numbers from an Array.
+
+```miniscript
+filter = function(seq, f)  // filter seq to where f is true
+  result = []
+  for i in seq
+    if f(i) then result = result + [i]
+  end for
+  return result
+end function
+
+isEven = function(x)
+  return x % 2 == 0
+end function
+
+list = [2,3,5,6,8,9]
+print filter(list, @isEven)
+```
+
+This is a pretty straightforward conversion of the task description into MiniScript code.  Our filter function takes a list and a function, and builds a new list by appending each element where the function, applied to that element, is true.
+
+We illustrate by making an isEven function that returns true only when its argument mod 2 is zero (i.e., the argument is evenly divisible by 2).  Then we pass @isEven to find just the even elements of a given list.
+
+## Greatest Common Divisor
+
+Here’s a [function](http://rosettacode.org/wiki/Greatest_common_divisor) that finds the biggest number that can divide evenly into two given numbers.  Middle schoolers everywhere will soon be out of work.
+
+```miniscript
+gcd = function(a, b)
+  if a == 0 then return b
+  while b != 0
+    newA = b
+    b = a % b
+    a = newA
+  end while
+  return abs(a)
+end function
+print gcd(-21, 35)
+```
+
+The algorithm here, known as the “Euclidian algorithm for finding the GCD,” is clever.  The actual MiniScript code is simple.
+
+## Maximum Element
+
+MiniScript does not have a standard intrinsic for finding the maximum element of a list.  But you can easily add it yourself, using this code.
+
+```miniscript
+max = function(seq)
+    if seq.len == 0 then return null
+    max = seq[0]
+    for item in seq
+        if item > max then max = item
+    end for
+    return max
+end function
+print max([5, -2, 12, 7, 0])
+```
+
+Pretty simple stuff.  Line 2 checks to make sure the sneaky user hasn’t given us an empty list; if they have, we return null, as there is no sensible max in that case.  Otherwise, we just suppose it’s the first element, and then loop over each element in the list, keeping the biggest.
+
+Notice that the max variable assigned to on line 1 is in the global variable space, while the max assigned on lines 3 and 5 (and then returned on line 7) is local to a function.  These happen to have the same name, but have nothing to do with each other.  As a matter of style, it might have been better to name the local variable result rather than max.  But it seemed like a good opportunity to demonstrate how local and global variables are separate, even if they have the same name.
+
+## Titlecase
+
+MiniScript has intrinsics to convert a string to all upper- or lower-case letters.  But what if you want to capitalize just the first letter of each word, and lowercase the rest?
+
+```miniscript
+titlecase = function(s)
+    result = ""
+    for i in s.indexes
+        if i == 0 or s[i-1] == " " then
+            result = result + s[i].upper
+        else
+            result = result + s[i].lower
+        end if
+    end for
+    return result
+end function
+print titlecase("SO LONG and thanks for all the fish")
+```
+
+We just iterate over the string, capitalizing each letter that is either the very first character in the string, or is preceded by a space, and lower-casing the rest.
+
+## Titlecase (version 2)
+
+The previous version of Titlecase works fine, but is somewhat suboptimal, because it grows a string by adding to it character by character.  This recopies the earlier characters in the string many times.  The following code shows a better way.
+
+```miniscript
+titlecase = function(s)
+    result = s.split("")
+    for i in s.indexes
+        if i == 0 or s[i-1] == " " then
+            result[i] = s[i].upper
+        else
+            result[i] = s[i].lower
+        end if
+    end for
+    return result.join("")
+end function
+print titlecase("SO LONG and thanks for all the fish")
+```
+
+Here we start by splitting the string into characters (by using the empty string as the delimiter to split on).  Then we iterate over the string, updating each character in our list, and join them back together at the end.

data/QuickRef.md

@@ -0,0 +1,209 @@
+# Welcome to MiniScript!
+
+MiniScript is a high-level object-oriented language that is easy to read and write.
+
+# Clean Syntax
+
+Put one statement per line, with no semicolons, except to join multiple statements on one line.
+
+Code blocks are delimited by keywords (see below).  Indentation doesn't matter (except for readability).
+
+Comments begin with `//`.
+
+Don't use empty parentheses on function calls, or around conditions in `if` or `while` blocks.
+
+All variables are local by default.  MiniScript is case-sensitive.
+
+# Control Flow
+
+## if, else if, else, end if
+
+Use `if` blocks to do different things depending on some condition.  Include zero or more `else if` blocks and one optional `else` block.
+
+```basic
+if 2+2 == 4 then
+    print "math works!"
+else if pi > 3 then
+    print "pi is tasty"
+else if "a" < "b" then
+    print "I can sort"
+else
+    print "last chance"
+end if
+```
+
+## while, end while
+
+Use a `while` block to loop as long as a condition is true.
+
+```basic
+s = "Spam"
+while s.len < 50
+    s = s + ", spam"
+end while
+print s + " and spam!"
+```
+
+## for, end for
+
+A `for` loop can loop over any list, including ones easily created with the `range` function.
+
+```basic
+for i in range(10, 1)
+    print i + "..."
+end for
+print "Liftoff!"
+```
+
+## break & continue
+
+The `break` statement jumps out of a `while` or `for` loop.  The `continue` statement jumps to the top of the loop, skipping the rest of the current iteration.
+
+# Data Types
+
+## Numbers
+
+All numbers are stored in full-precision format.  Numbers also represent true (1) and false (0).  Operators:
+
+|Operator|Meaning|
+|-----|-----|
+`+`, `-`, `*`, `/`|standard math
+`%`|mod (remainder)
+`^`|power
+`and`, `or`, `not`|logical operators
+`==`, `!=`, `>`, `>=`, `<`, `<=`|comparison
+
+## Strings
+
+Text is stored in strings of Unicode characters.  Write strings by surrounding them with quotes.  If you need to include a quotation mark in the string, type it twice.
+
+```basic
+print "OK, ""Bob""."
+```
+
+Operators:
+
+|Operator|Meaning|
+|-----|-----|
+`+`|string concatenation
+`-`|string subtraction (chop)
+`*`, `/`|replication, division
+`==`, `!=`, `>`, `>=`, `<`, `<=`|comparison
+`[i]`|get character i
+`[i:j]`|get slice from i up to j
+
+## Lists
+
+Write a list in square brackets.  Iterate over the list with `for`, or pull out individual items with a 0-based index in square brackets.  A negative index counts from the end.  Get a slice (subset) of a list with two indices, separated by a colon.
+
+```basic
+x = [2, 4, 6, 8]
+x[0]   // 2
+x[-1]  // 8
+x[1:3] // [4, 6]
+x[2]=5 // x now [2,4,5,8]
+```
+
+Operators:
+
+|Operator|Meaning|
+|-----|-----|
+`+`|list concatenation
+`*`, `/`|replication, division
+`[i]`|get/set element i
+`[i:j]`|get slice from i up to j
+
+## Maps
+
+A map is a set of values associated with unique keys.  Create a map with curly braces; get or set a single value with square brackets.  Keys and values may be any type.
+
+```basic
+m = {1:"one", 2:"two"}
+m[1]   // "one"
+m[2] = "dos"
+```
+
+Operators:
+
+|Operator|Meaning|
+|-----|-----|
+`+`|map concatenation
+`[k]`|get/set value with key k
+`.`*ident*|get/set value by identifier
+
+# Functions
+
+Create a function with `function`, including parameters with optional default values.  Assign the result to a variable.  Invoke by using that variable.  Use `@` to reference a function without invoking.
+
+```basic
+triple = function(n=1)
+    return n\*3
+end function
+
+print triple      // 3
+print triple(5)   // 15
+f = @triple
+print f(5)   // also 15
+```
+
+# Classes & Objects
+
+A class or object is a map with a special `__isa` entry that points to the parent.  This is set automatically when you use the `new` operator.
+
+```basic
+Shape = {"sides":0}
+Square = new Shape
+Square.sides = 4
+x = new Square
+x.sides  // 4
+```
+
+Functions invoked via dot syntax get a `self` variable that refers to the object they were invoked on.
+
+```basic
+Shape.degrees = function()
+    return 180\*(self.sides-2)
+end function
+
+x.degrees   // 360
+```
+
+# Intrinsic Functions
+
+## Numeric
+
+|   |   |   |
+|---|---|---|
+abs(x)|acos(x)|asin(x)
+|atan(y,x)|ceil(x)|char(i)
+|cos(r)|floor(x)|log(x,b)
+|round(x,d)|rnd|rnd(seed)|
+|pi|sign(x)|sin(r)|
+sqrt(x)|str(x)|tan(r)	
+
+## String
+
+|   |   |   |
+|---|---|---|
+.indexOf(s)|.insert(i,s)|.len
+.val|.code|.remove(s)
+.lower|.upper|.replace(a,b)
+.split(d)| |
+
+## List/Map
+
+|   |   |   |
+|---|---|---|
+.hasIndex(i)|.indexOf(x)|.insert(i,v)
+.join(s)|.push(x)|.pop
+.pull|.indexes|.values
+.len|.sum|.sort
+.shuffle|.remove(i)|range(from,to,step)
+
+## Other
+
+|   |   |   |
+|---|---|---|
+print s|time|wait sec
+locals|outer|globals
+yield| |

data/day1.txt

@@ -0,0 +1,169 @@
+{chapterHead: "Day 1: First Steps", startingPageNum:7}
+
+{width: "50%"}
+![](Chapter1.svg)
+
+Q> Whether you want to uncover the secrets of the universe, or you just want to pursue a career in the 21st century, basic computer programming is an essential skill to learn.
+Q>— Stephen Hawking (theoretical physicist)
+
+A> **Chapter Objectives**
+A> - Learn how to run MiniScript code on the web.
+A> - Use the `print` command to make MiniScript display something on the screen.
+A> - Learn about numbers and strings.
+
+
+There are many ways to run MiniScript.  You may even find MiniScript within some commercial or open-source game or software tool.  But in this book we are going to cover just three.  The last of these will be Mini Micro, of which you got a glimpse in the Introduction.  In the middle will be command-line MiniScript.  But first, starting today, we begin with the simplest: running MiniScript right within your web browser.
+
+The home of MiniScript on the web is <https://miniscript.org/>, and you will find all sorts of useful resources there.  Today, follow the "Try-It!" link, or just go directly to:
+
+_
+: <https://miniscript.org/tryit/>
+
+This should bring up a page that looks something like the figure below.
+
+![MiniScript Try-It web page](TryItPage.png)
+
+The standard layout has a code editor (with a white background) on the left, and an input/output area (with a black background) on the right.  If you find that they are instead stacked vertically, try stretching out your browser window until they appear side-by-side.  This should work equally well on Mac, Windows, and Linux.  If you are using a tablet or mobile phone, you may not be able to accomplish this; that's OK.  You can still use it when they're stacked vertically.
+
+{i: "code editor, Try-It!"}
+[code editor]
+: a text editor specialized for writing program code
+
+Down below the editor and input/output area, you'll find a "Help & Information" area that is chock full of useful stuff.  By clicking on the items on the left, you can make explanations and reference material appear to the right.  Many of the items on the left are folders; you can twist those open by clicking the little triangle next to them, to drill down into more detailed topics within.  Explore this a bit; you are likely to use this information in the future when writing your own code.
+
+The code editor contains some sample MiniScript code to get you started.  As it's only Day 1, this code probably doesn't make much sense to you yet.  That's OK too.  You'll understand everything there in a couple of weeks.
+
+For now, just select all the code in that code editor, and delete it.  The code editor works just like any other text editor, word processor, or comment form you've ever used; the main difference is that it will automatically color your text as you type.  Don't worry about what the colors mean for now; they're mostly there to make your code look pretty!
+
+Now it's time to write your very first MiniScript program -- and for many readers, your first program of any sort.  We'll begin with the classic greeting program.  After clearing out the sample code, type this into the code editor on the Try-It! page:
+
+{caption: "Greetings program"}
+```miniscript
+print "Hello world!"
+```
+
+Type it exactly as shown here.  Notice that `print` is all lowercase; that's important.  Like most computer languages, MiniScript is *case-sensitive*, which means that if you get the capitalization wrong, it will not work.
+
+case-sensitive
+: a language or system where upper- and lower-case letters are considered different
+
+case-insensitive
+: a language or system where upper- and lower-case letters are considered the same
+
+After entering the above code, click the **Run Script** button.  You should see the words "Hello world!" appear in green text in the input-output area.  If you do, congratulations!  You just wrote your first program!
+
+If you *don't* see that, then you probably have a typo.  Congratulations to you as well, as you have discovered what happens when you make a mistake!  Go back and check your work carefully -- spelling and punctuation must match exactly.
+
+D> Computers work fast, but they are very picky about the details.
+
+If you weren't so fortunate as to make a mistake on your first attempt, then please do so now.  It's important not to be afraid of making a mistake.  It is impossible to hurt the computer by anything you type on the Try-It! page.  When the computer can't understand what you want, it never gets upset or impatient.  It just calmly points out where it got confused, and waits patiently for you to fix it.  So, with that in mind, please try this version of the program:
+
+{caption: "Incorrect greetings program"}
+```miniscript
+Print "Hello world!"
+```
+
+Can you spot the difference between this program and the first one?  We've used a capital "P" here.  Go ahead and enter this code, then click that **Run Script** button again!  You will get no output in the input/output area, and instead, an error message will appear below, along the lines of:
+
+```terminal
+Runtime Error: Undefined Identifier: 'Print' is unknown in this context [line 1]
+```
+
+This is MiniScript's way of telling you that it doesn't know what `Print` means -- even though it *does* know what `print` means, these are considered completely different words, because (again) MiniScript is case-sensitive.
+
+{i: "error, runtime"}
+Runtime Error
+: an error that occurs after the program starts running
+
+{i: "error, compiler"}
+Compiler Error
+: an error that happens even before the program starts running, when MiniScript is studying the code
+
+{i: "error, undefined identifier"}
+Undefined Identifier
+: a type of runtime error that occurs when you use a word MiniScript does not know
+
+Now you may be wondering, what about the words `Hello` and `world`?  Are these words that MiniScript knows?  The answer is no, and it doesn't need to, because we have enclosed them inside of quotation marks.  This is something like giving an actor lines in a language he doesn't speak.  A skillful actor can parrot the words exactly as written in the script, without having any idea what they mean.  Computers are the same way: anything you put inside quotation marks gets parrotted back without having any meaning to the computer.
+
+On the other hand, words that tell the computer to *do* something -- like `print` -- must *not* be in quotation marks, and they must be among the words the computer already knows.  Today, `print` is the only such word you're going to learn, but starting tomorrow you'll learn more, and by the end of the book you'll know all sorts of such words, and even how to add more.
+
+A pair of quotation marks surrounding some words is called a *string*.  This is because the characters (letters, numbers, etc.) are strung together in a certain order, like beads on a string.
+
+{i:"data type, string"}
+string
+: some letters, numbers, or punctuation surrounded by quotation marks
+
+The string in our program above was "Hello world!"  But it can be anything.  Try these:
+
+{caption: "More greetings"}
+```miniscript
+print "Greetings, program!"
+print "My name is 101001."
+print "@*#$!!  I spilled bits on my chips!"
+print "Later alligator!"
+```
+
+You can try out those lines one at a time if you like.  Or, you can type them all in at once, with each `print` statement on a new line in the code editor, as shown above.  In that case each message will appear in the output area, one after the other.
+
+Notice how the strings can contain any combination of letters, numbers, and punctuation.  They can even contain foreign characters or emoji; if you know how to type any of these, go ahead and give it a try.  It's all just strings to MiniScript.
+
+There is one exception, however.  What if you wanted to put quotation marks inside your string?  That's problematic, since the quotation marks are how MiniScript knows where the string ends.  If you stick some in the middle, it will think your string is done, and won't know what to do with the rest of it, resulting in an error.
+
+The solution is to enter the quotation marks *twice* if they occur within a string.{i: "quotation marks"}
+
+I> To include quotation marks in a string, enter them twice in a row.
+
+Here's an example:
+
+{caption: "Quotation marks within a string"}
+```miniscript
+print "Hello, ""Bob,"" if that is your real name."
+```
+
+Try that.  You should see in the output window that the doubled quotation marks have magically transformed into ordinary quotation marks.  This is just a trick to work around the problem of MiniScript knowing where your strings end, and it is the only character that is special in this way.
+
+You now know just about everything there is to know about defining a string.  Strings are one of the four basic types of data in MiniScript.  Before calling it a day, let's learn about one other type: numbers.
+
+{i:"number;data type, number"}
+Numbers are easy.  They are exactly what you think they are.  Here's an example:
+
+{caption: "The ultimate answer"}
+```miniscript
+print 42
+```
+
+Here, `42` is a number.  Nothing to it, right?  Numbers can be any size, and can include a decimal point or not.  They can also be written in *exponential notation*, which is sometimes convenient for very large or very tiny numbers.
+
+exponential notation
+: a way of writing numbers like 2.5E10, where the number after the "E" means to shift the decimal point that many places to the right (or to the left, if the number is negative)
+
+So 2.5E6 is 2.5 times a million (i.e., a 1 followed by 6 zeros), or 2.5 million.  2.5E-6 would be 2.5 times a millionth.  You won't need this form of numbers very often, but now you know it exists.
+
+W> Many regions of the world write their numbers differently, for example, with a comma instead of a period to separate decimals.  MiniScript, like most other computer languages, always uses a period as the decimal point, no matter where you are.
+
+W> Also, you may be used to writing large numbers with some grouping character before the thousands, millions, and so on.  That makes it easier for humans to read, but it only confuses computers.  So even a big number like 7,603,985,818 (the population of Earth at the time of this writing) must be written 7603985818.
+
+We'll end the chapter with one last little sample program.  This prints a variety of strings and numbers.  If you've just been reading and nodding at the examples above, you should be sure to type in this one.  Typing in code trains your fingers and your brain, and will make learning to code that much easier.
+
+{caption: "Printing strings and numbers"}
+```miniscript
+print "The answer to the Ultimate Question..."
+print "of life, the universe, and everything..."
+print "is..."
+print 3.14157
+print "...wait, no, it's actually:"
+print -2.5E6
+print "...no, I'm sorry, the answer is:"
+print 42
+```
+
+D> Were you surprised by how one of those numbers came out?  Strings appear exactly as you type them -- except for doubled quotation marks -- but numbers come out in a standardized format, which may be different from how they appear in your code.
+
+And that wraps up day 1!  You have taken your first steps down an incredibly rewarding path.  Let's review what you learned today:
+
+
+A> **Chapter Review**
+A> - You can run MiniScript code on the web at <https://miniscript.org/>.
+A> - You know how to use `print` to display strings and numbers.
+A> - You learned that MiniScript is case-sensitive, and how to recognize and correct mistakes in your programs.
+

data/day10.txt

@@ -0,0 +1,205 @@
+{chapterHead: "Day 10: Maps", startingPageNum:105}
+
+{width: "50%"}
+![](Chapter10.svg)
+
+Q> Feeling a little uncomfortable with your skills is a sign of learning, and continuous learning is what the tech industry thrives on!
+Q>— Vanessa Hurst (founder and CEO, CodeMontage)
+
+A> **Chapter Objectives**
+A> - Learn about the *map* data type.
+A> - Get or set map values with square brackets or dot syntax.
+A> - Iterate over a map with a `for` loop.
+A> - Get an overview of intrinsic map functions.
+
+{i:"map;data type, map"}
+You've already learned about numbers, strings, and lists.  There is one more basic data type in MiniScript: maps.  A *map* is like a two-column table, where each unique value on the left column is associated with some other value on the right.
+
+{caption:"An example map: four fictional heroes and their ages", hPad:10, vpad:3}
+| key | value |
+| --- | ----- |
+| Buffy | 17 |
+| Willow | 16 |
+| Xander | 17 |
+| Oz | 18 |
+
+The values in the left column are "mapped" to values on the right.  In some languages, this is called a *dictionary*, because you can think of a dictionary as a book that maps each word to a definition (or list of definitions).
+
+{i:"map;dictionary"}
+map
+: a data type that contains a list of key/value pairs, with each unique key associated with one value
+
+The keys in a map must be unique; in the table above, you can see that "Buffy", "Willow", "Xander", and "Oz" are all unique.  The values, however do not need to be unique; both "Buffy" and "Xander" map to 17 in this example, and that's fine.
+
+In MiniScript, you can create a map by enclosing it in curly braces, with the key/value pairs separated by commas like in a list.  Within each pair, put a colon between the key and value, like this:
+
+```miniscript
+ages = {"Buffy":17, "Willow":16, "Xander":17, "Oz":18}
+```
+
+This defines a map called `ages` containing four key/value pairs.  Try it!  Type the above assignment into your command-line REPL.  Then type
+
+```miniscript
+ages
+```
+
+to see what `ages` contains.  You'll get back a representation of the map — but it may not be in exactly the same order you defined it in.  It might, for example, look like this:
+
+```repl
+{"Buffy": 17, "Xander": 17, "Oz": 18, "Willow": 16}
+```
+
+A> Maps pay no attention to the *order* of their key/value pairs.  Never depend on getting them out in any particular order.
+
+This is different from a list, which preserve the order of their items.  So what good are maps then?  They're good for looking up (or storing) values by key.  In the same REPL as the above, try this:
+
+```miniscript
+ages["Oz"]
+```
+
+This should print `18`.  Notice that the syntax is similar to getting an element of a list or map, except instead of putting a numeric index in the square brackets, we're giving the key (index value) that we want to look up.
+
+And while you can't tell from such a simple example, it turns out that maps are *really really good* at this sort of look-up.  It basically doesn't matter how many items you have stored in a map; a lookup like this will be just as fast.  And this too is different from a list, where the average time to find an element depends directly on how many items are in the list.
+
+Now let's suppose Willow has a birthday.  Let's update her age to 17:
+
+```miniscript
+ages["Willow"] = 17
+ages
+```
+
+You should see that the value associated with the key "Willow" has been updated.  You can add new key/value pairs to the map in exactly the same way:
+
+```miniscript
+ages["Cordelia"] = 18
+ages
+```
+
+Now the map contains five key/value pairs.  Assignment to a map entry will just update the value if the given key is already in the map; otherwise, it will add a new key/value pair.
+
+Keys and values can be any data type.  Try another example:
+
+```miniscript
+d = {}
+d[1] = "uno"
+d["life"] = "grand"
+d["primes"] = [1,2,3,5,7]
+d
+```
+
+The first line above creates an empty map, that is, a map containing no key/value pairs at all.  Then we added three keys, one at a time: a number (1) and two strings ("life" and "primes").  The values here include both strings and a list; and of course you previously saw an example where the values were numbers.  A value could also be another map, and you can even use lists and maps as keys, though that is rare.
+
+## Square Brackets vs. Dot Syntax
+
+So far we have assigned and looked up values by putting the key in square brackets, just like indexing into a list or string.  But with maps, there is an alternate syntax that will turn out to be really handy.  It applies only in the special case where the key is (1) a string, and (2) a valid identifier — meaning that it starts with a letter or underscore, and contains only letters, numbers, and underscores (just like a variable name).
+
+In this case, you can just put the key *without quotation marks* after the map reference, separated by a dot.  If you still have `ages` and `d` defined in your REPL from the examples above, then try this:
+
+```terminal
+> ages.Oz
+18
+> ages["Oz"]
+18
+> d["life"] = "sweet"
+> d.life = "sweeter"
+> d
+{"life": "sweeter", 1: "uno", "primes": [1, 2, 3, 5, 7]}
+```
+
+The first two commands do exactly the same thing: look up the value of the key "Oz" in map `ages`.  Lines 5 and 6 each assign a new value to the key "life" in map `d`.  So the dot syntax is just another way of storing and retrieving values in a map.
+
+So why is that useful?  In a very small program, you can get away without being very organized about your data, because there just isn't very much of it.  But as your programs get bigger, it would get really tricky to come up with meaningful, unique variable names for all the values you need to handle, and to write code that works with them all.  Maps let you group your data in whatever way makes sense for your program.
+
+(Maps are also the basis for object-oriented programming in MiniScript, but that's such a big topic, we'll spend a whole chapter on it a couple days from now.)
+
+## Iterating Over Maps
+
+You already know to write a `for` loop to iterate over elements of a list, or characters in a string.  It turns out you can do the same thing to iterate over key/value pairs in a map.  When you do, the loop variable is set to little mini-maps containing "key" and "value" entries.  An example will make it clearer:
+
+```miniscript
+ages = {"Buffy":17, "Willow":16, "Xander":17, "Oz":18}
+for kv in ages
+	print "I see the key " + kv.key + " goes with value " + kv.value
+end for
+```
+
+Try it!  You can skip the first line above if you still have `ages` defined in your REPL, and it's OK if your values are a little different from mine.  The important thing is to see what the for loop does: it sets the loop variable, `kv`, to each of the key/value pairs in turn.  And you access that data in `kv` using `kv.key` or `kv.value`.
+
+Of course, you could have called the loop variable anything; it doesn't have to be "kv".  Here's different example:
+
+```miniscript
+nums = {"one":"uno", "two":"dos", "three":"tres"}
+for n in nums
+	print n.key + " in Spanish is " + n.value     
+	print n.value + " in English is " + n.key
+end for
+```
+
+Iterating over the map directly like this is usually the right thing to do.  However, as noted before, you don't have any control over the order in which the data comes out this way.  So, there is another approach that is often used, and that is to iterate over just the indexes (i.e. keys) of the map, in sorted order.  Try this (again skipping the first line if you still have `ages` defined from before):
+
+```miniscript
+ages = {"Buffy":17, "Willow":16, "Xander":17, "Oz":18}
+for name in ages.indexes.sort
+	print name + " is " + ages[name] + " years old."
+end for
+```
+
+This prints out the age of each hero — but importantly, it prints them out in alphabetical order.  How does this work?  The `indexes` intrinsic function returns all the keys of a map, as a list.  And `sort` is another intrinsic function that sorts a list into alphabetical or numeric order.  So when we use them together, like `ages.indexes.sort`, we get all the keys of the map, in order.
+
+But now we're iterating over just the keys.  So inside the loop, if we also need the value, we just look up the value in the map using square brackets (like `ages[name]` in this example).
+
+D> Confused?  That's OK.  There's a lot of new stuff here, and it's a lot to keep track of.  Just take it slow, and break the example above into smaller parts, inspecting each one with the REPL: `ages`, then `ages.indexes`, then `ages.indexes.sort`.  Then try a `for` loop over the result of that last one.  Step by step, it will all make sense.
+
+{gap:40}
+## Map Intrinsic Functions
+
+It will come as no surprise to you by now that MiniScript has a number of built-in (intrinsic) functions that work with maps.  You've already seen `indexes`, but there are many others.  As before, we're going to present the complete set now, but you are not expected to memorize this list.  Just familiarize yourself with what's available, so you know where to look later.
+
+{i:"functions, map;map functions"}
+{caption:"Intrinsic map functions", colWidths:"145,*"}
+| `.hasIndex(k)` | 1 if k is a key contained in `self`; otherwise 0 |
+| `.indexes` | a list containing all keys in `self`, in arbitrary order |
+| `.indexOf(x, after=null)` | first key in `self` that maps to `x`, or null if none; optionally begins the search after the given key |
+| `.len` | length (number of key/value pairs) of `self` |
+| `.pop` | removes and returns an arbitrary key from `self` |
+| `.push k` | equivalent to `self[k] = 1` |
+| `.remove k` | removes the key/value pair where key=`k` from `self` (in place) |
+| `.replace oldval, newval, maxCount=null` | replaces (in place) up to maxCount occurrences of oldval in the map with newval (if maxCount not specified, then all occurrences are replaced) |
+| `.shuffle` | randomly remaps values for keys |
+| `.values` | a list containing all values in `self`, in arbitrary order |
+
+MiniScript tends to use functions that are named the same way for multiple data types.  That's why the function that checks whether a map contains a certain key is called `hasIndex` rather than `hasKey`; this same function also works for lists and strings, and the term "index" works for all three, whereas "key" would make sense only for maps.  You see this also in the `indexOf` function, which returns the key (index) associated with a given value.
+
+You're only likely to need a few of the functions on this table.  We discussed `.indexes` earlier, for getting all the indexes (keys) in the map; in some cases you might also want `.values`, which returns all the values in the map.  The `.hasIndex` function is very useful, since you often want to check whether the map contains a particular key (if you try to index into the map with a nonexistent key, MiniScript will print an error).  Finally, you might need `.remove` to take a key/value pair (specified by the key) out of the map.
+
+Let's wrap up this chapter with a slightly longer, more interesting example.  Type in the program on the next page carefully, run it, and then teach it some vocabulary words.  You can enter English words and their equivalents in some other language, or you can go the other way (French to English for example).  If you don't know any other language, make one up!  And be sure to sometimes repeat words you've entered before, so it can show off its knowledge.
+
+{caption:Language-learning program}
+```miniscript
+print "Teach me a new language!"
+print "(or enter ""quit"" to quit)"
+vocab = {}
+while true
+    word = input("Word? ")
+    if word == "quit" then break
+    if vocab.hasIndex(word) then
+        print "I know that one!  It's: " + vocab[word]
+    else
+        vocab[word] = input("OK, how do you say that? ")
+        print "OK, I'll remember!"
+    end if
+end while
+print "You taught me " + vocab.len + " words.  Thank you!"
+```
+
+
+Then pause to think what you've accomplished here: a program that *learns*.  It starts off knowing nothing, but the more you interact with it, the more it knows.  Unlike people, it will remember each fact perfectly after being told only once, and it will never forget — until, of course, you stop the program!
+
+{pageBreak}
+A> **Chapter Review**
+A> - You learned how to map keys to values in MiniScript.
+A> - You discovered the two different ways to access elements of a map: with square brackets, or with dot syntax.
+A> - You learned to iterate over the key/value pairs of a map... and an alternate way to do it in cases where you need them in sorted order.
+A> - You got an overview of the built-in map functions.
+A> - You made a program that learns vocabulary, growing ever smarter as it runs.
+

data/day11.txt

@@ -0,0 +1,319 @@
+{chapterHead: "Day 11: Defining Functions", startingPageNum:115}
+
+{width: "50%"}
+![](Chapter11.svg)
+
+Q> You need to organize the code by breaking it into pieces.
+Q>— Barbara Liskov (2008 A. M. Turing award winner)
+
+A> **Chapter Objectives**
+A> - Learn how to define your own functions.
+A> - Start thinking about how to break big problems up into smaller, easier problems.
+A> - Learn the difference between local and global variables, and why these make your life easier.
+
+You've seen a lot of intrinsic (built-in) functions by now.  These are things like `rnd`, which returns a random number, and `ceil`, which returns the next integer greater than or equal to the number you give it, and `val`, which converts a string into a number.  Today you're going to learn how to add new functions of your very own!  This is a really important milestone, because it lets you break a big complicated problem up into a bunch of smaller, simpler problems, as we'll shortly see.
+
+Let's start by looking at an example: making a new function to help you calculate how much tip to leave at a restaurant in the United States.
+
+{caption:Tip example 1}
+```miniscript
+// Calculate the tip to leave at a restaurant.
+// Leave 20%, but never less than a dollar.
+tip = function(costOfMeal)
+    x = costOfMeal * 0.20
+    if x < 1 then x = 1
+    return round(x)
+end function
+
+print "Tip calculator!"
+print "$10 meal: $" + tip(10) + " tip"
+print "$30 meal: $" + tip(30) + " tip"
+cost = val(input("Cost of your meal? "))
+print "You should leave $" + tip(cost)
+```
+
+Run this code a few times, trying different amounts.
+
+D> Remember that you now know at least three ways to run MiniScript code: in the Try-It! page on the web; typed directly into the command-line REPL; and typed into a text file, which you then run with command-line MiniScript.  For this example, use whichever you like best!
+
+A function definition begins with `function` and ends with `end function` — similar to the `if`, `for`, and `while` blocks you already know.  After the `function` keyword must be parentheses, and then the name of any *parameters* you want to pass in to the function.  In the example above, there is one parameter, `costOfMeal`, which will get a number to use as the cost of the meal.
+
+parameter
+: a variable included as part of a function definition to hold a value passed in as argument
+
+argument
+: a value given as input to a function
+
+{i:"data type, function"}
+The complete function — everything from `function` to `end function` — is a value that normally gets assigned to a variable, which is `tip` in this example.  Functions are the fifth data type in MiniScript (after numbers, strings, lists, and maps).  If we didn't assign the newly created function to something, we would have no way to refer to it later.  So we assign it to (in this case) `tip`, and thereafter when we refer to `tip`, we are really calling this function.
+
+Between the `function` line and the `end function` line is any amount of MiniScript code, known as the *function body*.  That code will run every time the function is called.  In the example above, you probably noticed that we used the new `tip` function three times.  So that function body (lines 4-6) ran three times.
+
+This illustrates one of the important benefits of making a function: it allows you to do the same thing at several different places in your program, without having to actually repeat the code more than once.  In fact this is such a useful principle in programming, it has its own name: DRY.
+
+DRY (Don't Repeat Yourself)
+: The idea that a program should have no nontrivial lines of code that are repeated in more than one place.  When you find the need to repeat some code, you should instead move it into a function, and then call that function wherever you need.
+
+{i:"`return`"}
+The other thing to notice in this example is the `return` statement.  When the program reaches a `return` line, it immediately exits the function, and the value of that function (wherever it was called) is whatever value, if any, appears after `return`.  So in this example, we calculate the tip amount as `x`, and then `return x` — so whatever the value of `x` is at that point is what is *returned* to the caller as the output of the function.
+
+{gap:20}
+Let's look at another example.  
+
+{caption:Simple dice roller}
+```miniscript
+rollD6 = function()
+    return ceil(rnd * 6)
+end function
+
+die1 = rollD6
+die2 = rollD6
+total = die1 + die2
+print "You rolled " + die1 + " and " + die2 
+print "for a total of " + total
+```
+
+Here we defined a function called `rolld6`.  It doesn't need any parameters; each time you call it, it just returns a random number between 1 and 6, like a 6-sided die.  Notice that even though there are no parameters, we still need parentheses after the `function` keyword.  This is the only place in MiniScript where empty parentheses are ever needed!
+
+Once the `rolld6` function has been defined on lines 1-3, we call it two times on lines 5 and 6, each time assigning the result to a variable.  Then we report the value of each roll, along with the total.
+
+## Breaking Down Big Problems
+
+Programs can get pretty complicated.  Recall the programs you entered in Chapter 7.  They were only a few dozen lines long, but there was a lot going on, wasn't there?  To understand them, you pretty much had to grasp the whole program at once.  No one part of it made much sense without thinking about the rest at the same time.
+
+Most programs in the real world are much, much longer than the ones in Chapter 7.  How can anybody make sense of all that?  Here's the secret: we don't understand them all at once.  We break a big, complicated program down into a bunch of smaller, simpler subprograms (functions).  Each function is small and simple enough to understand on its own.  And then when we're reading the rest of the program, we'll see code that *uses* those small functions, but at that point we don't worry about how those functions work — we just assume they work and do what the function name suggests they do.  This is really no different from how you have been using built-in functions like `print` and `rnd` without worrying about how they work under the hood; you trust them to do their job, so you can focus on yours.
+
+So a big, complicated program is really just a bunch of little functions.  Indeed, if you ever find yourself writing a function that's more than about a page long, you should break it into smaller functions.  Each function should do just one thing, so it's easy to understand; and it should be assigned to a variable with a descriptive name, so readers of the code can correctly guess what it does without even looking at its code.  *That* is the magic trick that lets us write things like operating systems, massively multiplayer online games, weather simulations, flight control software, and anything else — they're written one small function at a time.
+
+You'll see this principle applied in all the programs in the rest of this book.  Never again will you see a long functionless code listing like those in Chapter 7.  We have a major power tool now, so we're going to use it!
+
+## Local and Global Variables
+
+It's time to introduce some important terminology.
+
+global scope
+: code or variables in a program that are not inside any function
+local scope
+: code or variables inside a function
+
+Before this chapter, everything we did was at the global scope (of course, since we hadn't learned about functions yet).  Code at the global scope starts executing at the top of the program, and proceeds line by line, of course honoring `if` blocks and `for`/`while` loops along the way.
+
+Code at the local scope, that is, inside a function, is not executed where it is defined in the program.  Instead MiniScript just tucks the function away until you actually call it.  You've seen this in the examples already.  In the dice program, for example, the `rollD6` function was defined at the top of the program (lines 1-3), but it wasn't executed until later code called it (lines 5-6).
+
+So that's one difference between local and global scope.  But there's an even more important difference that applies to variables in particular.
+
+global variable
+: a variable assigned at the global scope
+local variable
+: a variable assigned inside a function
+
+Local variables can only be accessed within the function where they were assigned.  They have no existence outside that function.  This sounds like a limitation, but it's a really useful limitation!  It means that you can use whatever variables you want inside a function, and not worry about whether some other function (or code at the global scope) might be using the same variable names.  Local variables are completely independent for every function call.
+
+Here's how it works: variables are actually stored in maps.  At the global scope, all the variables are stored in a special map called `globals`.  So when you do a simple assignment like
+
+```
+x = 42
+```
+
+this is really doing
+
+```
+globals["x"] = 42
+```
+
+D> Don't take my word for it -- *try it!*  Open up the MiniScript REPL and experiment: enter `x = 42`, then print `globals["x"]`.  Now try `globals["x"] = 123`, and print `x`.  What do you find?
+
+Inside a function, though, things are different.  Every time you make a function call, MiniScript creates a *new* map for the variables inside that call.  Since functions can call other functions (or even call themselves!), this can get pretty complicated, but don't worry, it's the sort of bookkeeping computers are good at.  So at the start of a function, there is a fresh new map, containing only the values of the parameters.
+
+Now inside a function, when you do an assignment, like
+
+```
+test = function()
+   y = "abc"
+end function
+```
+
+it is actually stored as the value for "y" in this local variables map.  That of course does not affect the globals map at all, nor does it affect the locals in any other function call.  And when the function exits — either via a `return` statement or by reaching the `end function` line — the local variables map is simply destroyed.  Poof!  Gone.
+
+So that's what happens when you assign to a variable: at the global scope, it stores the value in `globals`; and inside a function, it stores it in the local variables for that function call.  What about when you *use* the value of a variable?
+
+In that case, MiniScript first looks for that variable in the local variables map.  If it finds it, it returns that value and is done.  But if it doesn't find it, then it looks at the global variables.  And if it finds a matching variable, it returns you that value instead.  So global variables can always be accessed from anywhere in the program; that's why we call them "global."  But local variables can only be accessed inside the function where they were assigned; they're "local" to that function.  And if the same variable name is used as both a local and a global, you'll always get the local one, since locals are checked first.
+
+This is super important, and probably not completely clear if it's the first time you've encountered the concept.  Here's an example that will help.  Type this in carefully:
+
+```miniscript
+x = 0  // assign to x as a GLOBAL variable
+test = function()
+    print "Inside test: x is " + x  // read the GLOBAL variable x
+    x = 123  // assign to x as a LOCAL variable
+    print "Still inside test: x is now " + x  // read LOCAL x
+end function
+
+print "Here at the global scope, x is " + x  // read GLOBAL x
+test
+print "Back at global scope again, x is " + x // read GLOBAL x
+```
+
+When you run this, the output is:
+
+```terminal
+Here at the global scope, x is 0
+Inside test: x is 0
+Still inside test: x is now 123
+Back at global scope again, x is 0
+```
+
+Let's walk through it step by step.  Line 1 is code at the global scope, and it assigns to `x`, so that creates a global variable (actually the same as doing `globals["x"] = 0`).  Lines 2-6 define the function (and store it in another global variable called `test`).
+
+Line 8 runs next, and since it's at the global scope, it prints out the value of global variable `x`, which is 0.  Line 9 calls the `test` function.  So line 3 runs, and prints a variable called `x`... since there isn't a local variable with that name at this point, it prints out the value of the global variable again.
+
+Line 4 then assigns 123 to `x`.  This is inside a function, so it stores the value 123 in the local variables map under "x".  And on line 5, when we print the value of `x` again, it now finds this local variable, and prints out that value (123).  Notice that this assignment does nothing at all to the globals map.
+
+Then the function ends, and we pop back to where it was called.  Here on line 10, back at the global scope, we print out the value of `x` again, which prints out the global value — still 0.
+
+D> Almost all programming languages have a very similar concept of local and global variables, though they may differ in the details — in Lua, for example, assignment always creates a global variable by default, even inside a function.
+
+If that still seems confusing, don't let it worry you too much.  It will sink in as you use it.  As your programs get more complex, you'll discover that local variables are a wonderful invention; they give you a fresh sheet of scratch paper for every small task (function) you need to do, and then recycle that sheet completely when the task is done.  This keeps your workspace neat, and prevents your calculations in one place from messing up values somewhere else.
+
+## Building a Program, Piece by Piece
+
+Let's end the chapter with one more example — a shortish program that uses several functions.  But this time we're going to go through how you would actually write and test such a program.
+
+The task for this program is to convert normal text to Pig Latin — a word game in which the initial part of a word, up to the first vowel, is stripped off and then appended to the end of the word, followed by "ay".  Or for words that begin with a vowel, you just append "yay" to the end.
+
+Thinking about how to break this complex task down would go something like this:
+
+- Well, we want to operate on each word separately.
+- For a single word, we'll need to split it into the part before the first vowel, and everything after that point.
+- That requires knowing if a character is a vowel or not.
+
+The rest is pretty easy: just swapping the two parts and adding "ay" or "yay".  So now we have a plan; time to start coding!  And often the best way to begin is with the smallest, simplest function.  In this case, that would be a function to tell if a character is a vowel or not.  So we write that, and include some tests:
+
+{caption:Step 1 of our Pig Latin program}
+```miniscript
+// return true if c is a vowel, false if not
+isVowel = function(c)  
+    return "aeiou".indexOf(c) != null
+end function
+
+print isVowel("x")
+print isVowel("a")
+```
+
+We begin by writing a comment describing what we want to do.  Then we make a function, `isVowel`, that takes one character (`c`) as its parameter.  It uses `indexOf` to see whether that character is in the set of vowels.  `indexOf` returns `null` if the thing you're looking for is not found in the string you're searching; so if `"aeiou".indexOf(c)` is not equal to `null`, it means that `c` is one of those five letters. After the function, we put in a couple of tests — these should print 0 for "x" since that is not a vowel, and 1 for "a" since it is.
+
+(Type that in and verify that it works before moving on.)
+
+OK, that's a handy function that MiniScript didn't have before; now we have it.  Let's use it for the next bit: something to split a word into the part before the first vowel, and the part after.  Keep what you have above, and add this:
+
+{caption:Step 2 of our Pig Latin program}
+```miniscript
+// split a word into the part before the first vowel,
+// and the part from the first vowel to the end
+splitWord = function(word)
+    for i in word.indexes
+        if isVowel(word[i]) then return [word[:i], word[i:]]
+    end for
+    return [word, ""] // no vowel found!
+end function
+
+print splitWord("three")
+print splitWord("omlets")
+```
+
+Again, we begin with a comment.  That's always a good idea; it helps you focus on exactly what the function you're about to write should do, and when you come back to this code later, it reminds you what it does.
+
+Then we iterate over all the indexes in the given `word`.  If the word is five characters long, then `word.indexes` will be `[0, 1, 2, 3, 4]`.  The `if` statement uses our handy `isVowel` function to determine if character `i` of the word is a vowel; if it is, then we return a list containing the part of the word before that point, and the rest of the word.  Finally, after the for loop, we handle the unlikely case of no vowels at all.
+
+(Notice that our `for` loop here is using a local variable called `i`.)
+
+The test cases below the function should print out correct splits of the test words: `["thr", "ee"]` for the "three", and `["", "omlets"]` for "omlets" (since that one begins with a vowel).
+
+D> Testing as you go makes programming faster, better, and more fun!  Try to never write more than a handful of lines without testing them.
+
+Again make sure this is all working before the next part, in which we convert a single word into Pig Latin:
+
+{caption:Step 3 of our Pig Latin program}
+```miniscript
+// convert a single word into Pig Latin
+convertWord = function(word)
+    parts = splitWord(word)
+    if parts[0] == "" then return word + "yay"
+    return parts[1] + parts[0] + "ay"
+end function
+
+print convertWord("three")
+print convertWord("omlets")
+```
+
+I'm sure you're seeing the pattern by now, so we'll jump right into the meat of it: we call our own `splitWord` function to split the word into parts, which we store in local variable `parts`.  If the first part is empty, then we just return the word plus "yay"; otherwise we reverse the parts and append "ay", per the rules of the game.
+
+The two test cases here should print "eethray" and "omletsyay".
+
+Almost done!  Let's make a `convert` function that operates on a whole sentence.
+
+{caption:Step 4 of our Pig Latin program}
+```miniscript
+// convert a whole sentence into Pig Latin
+convert = function(sentence)
+    words = sentence.split
+    for i in words.indexes
+        words[i] = convertWord(words[i])
+    end for
+    return words.join
+end function
+
+print convert("this is a test")
+```
+
+Nothing too complicated here!  We split the sentence into words, and then run a `for` loop over their indexes.  (Note that we're using a local variable `i` here too — and this is completely unrelated to the other `i` used in `splitWord`.  They don't bother each other at all.)  Each word is converted and stored back into the list, and then we just join them back together.  The test case at the end should print "isthay isyay ayay esttay".
+
+And the program is now complete, apart from a main loop!  If you take out the test cases, and add a main loop to the end, it will look something like the complete program below.
+
+{caption:Complete Pig Latin program}
+```miniscript
+// return true if c is a vowel, false if not
+isVowel = function(c)  
+    return "aeiou".indexOf(c) != null
+end function
+
+// split a word into the part before the first vowel,
+// and the part from the first vowel to the end
+splitWord = function(word)
+    for i in word.indexes
+        if isVowel(word[i]) then return [word[:i], word[i:]]
+    end for
+    return [word, ""] // no vowel found!
+end function
+
+// convert a single word into Pig Latin
+convertWord = function(word)
+    parts = splitWord(word)
+    if parts[0] == "" then return word + "yay"
+    return parts[1] + parts[0] + "ay"
+end function
+
+// convert a whole sentence into Pig Latin
+convert = function(sentence)
+    words = sentence.split
+    for i in words.indexes
+        words[i] = convertWord(words[i])
+    end for
+    return words.join
+end function
+
+// main loop: convert sentences until empty input
+while true
+    inp = input("Plain sentence? ")
+    if inp == "" then break  // (enter empty string to exit)
+    print convert(inp)
+end while
+```
+
+And now you've seen how real programming is done!  A complex task was broken down into simpler tasks, and then written bottom up, starting with the tiniest, simplest function.  Each other function made use of the ones written before, so that none of them was particularly complex.
+
+A> **Chapter Review**
+A> - You learned how to define your own functions, with or without parameters.
+A> - You encountered the DRY (Don't Repeat Yourself) principle, and saw how to break big programs into lots of small functions.
+A> - You gained insight into how variables work under the hood, and the important difference between global and local variables.
+A> - You wrote a complex Pig Latin program by writing a bunch of simple functions that lean on each other to get the job done.

data/day12.txt

@@ -0,0 +1,223 @@
+{chapterHead: "Day 12: Object-Oriented Programming", startingPageNum:129}
+
+{width: "50%"}
+![](Chapter12.svg)
+
+Q> Controlling complexity is the essence of computer programming.
+Q>— Brian Kernigan (computer scientist, author)
+
+A> **Chapter Objectives**
+A> - Learn the basics of object-oriented programming.
+A> - Start thinking about how to make code that can be reused in different programs.
+
+By this point you've learned about all the important data types in MiniScript: numbers, strings, lists, maps, and functions.  That's it; there are no more data types to learn!  OK, technically `null` is its own data type, but it's a trivial one, and you already know about that too.
+
+So the rest of the book, including this chapter, is not going to teach you any more data types.  But we are going to look at a particular use of the map data type.  Maps are incredibly versatile, as we saw in Chapter 10.  By mapping keys to values, they can represent pretty much anything.  Now we're going to look at how you can use them to represent "classes" and "objects" to make your code simpler, more organized, and more reusable.
+
+## Classes and Objects
+
+{i:"OOP;object-oriented programming"}
+The terms *class* and *object* come from a long programming tradition called *object-oriented programming* (or OOP for short).  Let's define what they mean in MiniScript terms:
+
+class
+: a map that is used to represent a type or category of thing, such as a Person, a Sprite, a Projectile, etc.
+
+object
+: a map that is used to represent a particular thing; examples might be Bob (a Person), space invader #7 (a Sprite), a softball at a certain position (a Projectile), etc.
+
+Notice that both classes and objects are just maps, and indeed, there is very little technical difference between them as far as MiniScript is concerned.  The difference is in the intent of the programmer.  They are used in different ways: classes hold code and data that is common to lots of different things.  Objects are those individual things, which are instances of the class.
+
+
+All this is very abstract, so let's illustrate with an example.  Suppose you're writing a program to work with colored blocks.  And to make things simpler, imagine they're two-dimensional blocks, with only width and height and no depth — like what you might draw on a computer screen or graph paper.  Fire up your REPL (or the Try-It! page, or whatever other MiniScript context you prefer), and let's create a class called `Block`.
+
+```miniscript
+Block = {}
+Block.color = "white"
+Block.width = 1
+Block.height = 1
+```
+
+Line 1 here creates an empty map, and assigns it to `Block`.  Lines 2-4 stuff some values into that map, using dot syntax.  (Turn back to Chapter 10 if you need to review maps and dot syntax.)
+
+D> A common convention in the MiniScript world is to capitalize variable names that refer to a class.  We intend to use `Block` here as a class, so we write it with a capital "B".
+
+{i: "`new`"}
+Now let's create an instance of the `Block` class.  You do this using the `new` operator.  Continuing from the previous example:
+
+```miniscript
+b1 = new Block
+print b1.width
+```
+
+The first line also creates a map, but not just an empty map; it creates a map based on our previous `Block` map.  We say that `b1` "is a" `Block`, or you might say that `b1` "inherits from" `Block`.  These are all just ways of saying that `b1` was created from `Block` (or from some other map that itself *is a* `Block`).
+
+And that makes `b1` special, because it means that any time we look up a value in the `b1` map, if we don't find it there, we look at the map it inherits from.  That's how we are able to print `b1.width` above, even though we never assigned a "width" value to `b1`.  It's no problem; since `b1` doesn't have such a value itself, it returns the value from `Block` instead.
+
+D> Under the hood, what `new` does isn't all that complex: it creates a map, but sets the special key `__isa` to whatever value comes after `new`.  So in the example above, if you examine `b1`, you will find that `b1.__isa` is equal to `Block`.  This is how MiniScript keeps track of what a map was made from, and does all the OOP magic described in this chapter.
+
+EBOOK>Here's a diagram of how `Block` and `b1` are represented in memory.  Both are really just maps, but that special `__isa` entry in `b1` makes it an *instance* of class `Block`.
+
+{width:50%}
+![Memory diagram of class `Block` and instance `b1`.](BlockB1.svg)
+
+{i:"instance"}
+PRINT>A diagram of how `Block` and `b1` are represented in memory is at the top of the next page.  Both are really just maps, but that special `__isa` entry in `b1` makes it an *instance* of class `Block`.
+
+
+instance
+: another word for "object," used when you want to emphasize the object's class
+
+At this point you can get a glimmer of what makes OOP (object-oriented programming) so useful.  You may need a *lot* of blocks, and they probably have a lot of data and functions in common.  Instead of putting redundant copies of all those bits of data and code on every block, you can put it on their common base class (`Block`), and the individual blocks only need to store what makes them unique.
+
+Let's continue with the above example by giving Block a function or two.  Add this to your growing code:
+
+```miniscript
+Block.area = function()
+    return self.width * self.height
+end function
+
+Block.description = function()
+    return self.width + " x " + self.height + " " + self.color + " block"
+end function
+
+print b1.area
+print b1.description
+```
+
+{i: "`self`"}
+Here we added two functions to the `Block` class, `area` and `description`.  Each of these shows another OOP trick: the `self` keyword.  `self` is a special reference to the map a function was called on with dot syntax.  So if we call `b1.area`, then inside that `area` function, `self` refers to `b1`.  The example above should print `1` for the area, and "1 x 1 white block" for the description.
+
+So far we have only one object of type `Block`, which is a little pointless.  OOP becomes useful when there are many (or at least two) objects of the same kind.  So, let's create a second block and call it `b2`.  While we're at it, let's customize each of these blocks a bit so they're not boring 1-by-1 white squares.
+
+```miniscript
+b1.width = 3
+b1.color = "red"
+b2 = new Block
+b2.height = 5
+b2.color = "green"
+print b1.description
+print b2.description
+```
+
+{width:"50%", position:"bottom"}
+![Memory diagram of class `Block` with instances `b1` and `b2`.](BlockB1B2.svg)
+
+Now we're getting somewhere!  We changed our `b1` block so that it is red and has a width of 3.  We didn't change its height, so that's still 1.  Then we created another block, `b2`, with a height of 5 and a green color.  In this case we didn't change its width, so it gets 1 from `Block`.  Neither of them has a custom `description` method, so when we call `.description` on them, we're really calling `Block.description`, but with `self` referring to `b1` or `b2`, as appropriate.  That's why they each print out a correct description of themselves.  The first one (`b1`) should return "3 x 1 red block" while the second one (`b2`) prints "1 x 5 green block".
+
+That's the basics of OOP (object-oriented programming)!
+
+
+
+{gap:20}
+
+Let's reinforce it with a different example.  Suppose you're writing a program to keep track of cookies — it could be cookies baked, or cookies eaten; it's up to you!  But in any case your program will be dealing with a lot of cookies, and they are all pretty similar.  So it's a good idea to make a class to represent them.
+
+```miniscript
+Cookie = {}
+Cookie.radius = 3
+Cookie.area = function()
+    return pi * self.radius^2
+end function
+```
+
+Here we have created a class called `Cookie`.  Of course it's really just a map, but it's a map that we *think of* as a class; it's going to represent everything that's common about all cookies in our program.  That includes `radius`, which (unless we change it) is 3 centimeters, and an `area` function that can use that radius value to compute its area (using the standard formula for area of a circle).
+
+Now let's actually instantiate (make an instance of) the `Cookie` class by using `new`. 
+
+```miniscript
+c1 = new Cookie        
+print c1.area
+```
+
+This should print `28.274334`, which is the area of a cookie with a radius of `3`.  But let's suppose this is a somewhat larger cookie.  Change the radius to 4, and print its area again:
+
+```miniscript
+c1.radius = 4
+c1.area
+```
+
+This prints `50.265482`.  When we call the `area` method on `c1`, it invokes the code that's actually stored on `Cookie`, but the `Cookie.area` function uses `self.radius`.  In this case that is the radius of `c1`, which we just set to `4`.
+
+Let's make our `Cookie` class a little fancier.  We'll have it also keep track of how many chips are in the cookie, and use that (along with the area) to estimate how many calories the cookie has.  And while we're at it, let's also give our class a `description` method, similar to the one we had above for `Block`.  Just to show that there's nothing magic about the name `description`, we'll abbreviate it this time to just `desc`.
+
+```miniscript
+Cookie.chips = 0
+
+Cookie.calories = function() 
+    return 5 * self.area + 2 * self.chips
+end function
+
+Cookie.desc = function()
+    result = self.radius * 2 + " cm cookie"
+    result = result + " with " + self.chips + " chip"
+    if self.chips != 1 then result = result + "s"
+    result = result + " (" + round(self.calories) + " cal)"
+    return result
+end function
+```
+
+This assigns a new value (`chips`) and two new methods (`calories` and `desc`) to the Cookie class.  Because `c1` is a Cookie, it immediately gets to use this new stuff.  Add `print c1.desc`, and you should see "8 cm cookie with 0 chips  (251 cal)".
+
+Now instead of just creating a second cookie, let's create a whole batch of cookies!  And we'll make them all different, with a random radius and number of chips.
+
+```miniscript
+cookies = []
+for i in range(1, 9)
+    c = new Cookie
+    c.chips = floor(rnd * 10)
+    c.radius = 2 + 3 * rnd
+    cookies.push c
+end for     
+```
+
+This will create (and print) a list of ten random cookies.  If you examine this list carefully, you'll see that each has a radius, a number of chips, and an `__isa` key that points to `Cookie`.  But that list is hard to read; let's print them out a bit more nicely.
+
+```miniscript
+for item in cookies; print item.desc; end for
+```
+
+D> Tip: you can put several short statements on one line by separating them with semicolons.  This is especially handy in a REPL, since you can up-arrow to recall the whole multi-statement line at once, rather than having to repeat each statement one at a time.
+
+This should produce a result that looks something like this:
+
+```
+7.679863 cm cookie with 0 chips (232 cal)
+6.053417 cm cookie with 4 chips (152 cal)
+7.978822 cm cookie with 0 chips (250 cal)
+7.69492 cm cookie with 9 chips (251 cal)
+9.87915 cm cookie with 3 chips (389 cal)
+7.336143 cm cookie with 1 chip (213 cal)
+8.179308 cm cookie with 7 chips (277 cal)
+9.685048 cm cookie with 9 chips (386 cal)
+9.216735 cm cookie with 9 chips (352 cal)
+```
+
+{i:"`list.sort`;sorting;list, sorting"}
+Of course your numbers will be different, since they are random.  Just for fun, let's sort this list by radius.  The `list.sort` method takes an optional second parameter, which is the name of a key to sort by.  So we can do:
+
+```miniscript
+list.sort "radius"
+for item in cookies; print item.desc; end for
+```
+
+And now you should see the same batch of cookies, but ordered by radius.
+
+To review, in this example we created a class called `Cookie`, and then created a bunch of objects (which are also called instances of the class) and stored them in the list.  Each of our objects is a `Cookie`, and inherits all the properties and methods that `Cookie` defines.
+
+## Writing Reusable Code
+
+There are two reasons why object-oriented programming has become so popular in the last few decades.  One is that it helps keep big programs neat and organized, with all the functions for a particular kind of thing bundled together into classes.  The other is that it makes it easier to reuse code.
+
+Code reuse is kind of the holy grail of programming.  Faced with a need — say, drawing a little picture on the screen that can efficiently move, rotate, and change size — you only want to write code for that once, at most.  Then the *next* time you face that same need, you want to just pull that code off the shelf and use it again.  This is possible to do without OOP, but it's harder; you would have a collection of functions that might well conflict with other functions you already have in your program for other things.  And it would get even more difficult to manage as you start defining sub-kinds of objects, with behavior that is almost, but not quite, like the general kind.
+
+Conversely, with OOP, reusing code like that is substantially easier.  If you have a little picture-moving class — let's call it Sprite — then everything there is to managing sprites can be wrapped up in that class.  You can add that class to your program, and as long as you don't already have something called Sprite, it won't break anything.  (This, by the way, is why MiniScript is case-sensitive, and why we capitalize classes but not ordinary variables; it reduces the chance of conflicts, since `sprite` is not the same thing as `Sprite`.)  The Sprite class might have dozens of properties and methods, but they're all tucked neatly away under the Sprite class.
+
+Of course you could get *that* benefit just by stuffing a bunch of related methods into a map, without using any of the OOP features like `new` and `self`.  And in some cases that's all you need.  But when those methods operate on some cluster of data, like the block example above or the position, rotation, and size of a Sprite, then it becomes really handy to have those things defined as objects.
+
+As a new programmer, you may not see lots of opportunities to define your own classes right away, and that's OK.  You will, however, start *using* classes a lot after Chapter 14, because that's when we get into Mini Micro.  Mini Micro has a built-in Sprite class, along with other classes that represent sounds, files, displays, and so on.  You'll also see classes crop up here and there in the examples in the rest of this book.  (In fact some of the earlier examples could have been done more neatly using OOP, and believe me, it was a little painful to write them the old-fashioned way!)  
+
+
+A> **Chapter Review**
+A> - You learned about object-oriented programming (OOP), and how to do it in MiniScript using `new` and `self`.
+A> - You began thinking about how to write code that can be reused later (your future self will thank you).
+ 

data/day13.txt

@@ -0,0 +1,321 @@
+{chapterHead: "Day 13: Working with Files", startingPageNum:139}
+
+{width: "50%"}
+![](Chapter13.svg)
+
+Q> Knowledge is power.
+Q>— Francis Bacon (1561 - 1626)
+
+A> **Chapter Objectives**
+A> - Learn the command-line MiniScript functions for working with disk files.
+A> - Start using MiniScript as a superpower that lets you automate repetitive tasks.
+
+After twelve days of MiniScript, you now know all the essential points of the MiniScript language, as well as the intrinsic functions that are common to all MiniScript environments.  Congratulations!  That's a real achievement.
+
+Now we can start considering the additional functionality provided by certain MiniScript environments.  In Chapter 8, you installed command-line MiniScript, and hopefully you've continued to work with it for at least some of the examples since then.  If not, that's OK — but you might want to go back and brush up on it, since we're going to be using it for this chapter!
+
+In addition to all the standard MiniScript functionality, command-line MiniScript provides some extra functions and classes for working with disk files.  That is an extremely useful thing to do, as everything on a computer is organized into files and folders.  With the powers you gain today, you'll be able to create files, rename them, move them around, split them into parts, combine them together, and do all sorts of other tasks that would be much harder to do by hand.
+
+D> The file-related functions covered in this chapter also happen to be available in Mini Micro, which you'll start using in only two more days!  So while you're working with command-line MiniScript today, you're also getting a head start on Mini Micro.
+
+If you go back to the web page where you downloaded command-line MiniScript:
+
+_
+: <https://miniscript.org/cmdline/>
+
+...you will find the file-related functions listed there.  Note that because these are not part of the MiniScript core, they are *not* on the MiniScript Quick Reference sheet, nor in the MiniScript Manual.
+
+## Files, Folders, and Paths
+
+Let's begin my making sure we're all clear on some basic terminology that relates to computer files.
+
+file
+: a collection of bytes stored on disk.  Each file has a name (often including an extension at the end, like ".txt" or ".jpg"), the actual file content, and some other metadata like a creation date.  Things like pictures, text files, and word processing documents are all files.
+
+folder
+: a special kind of disk entry that contains files and other folders.  Sometimes called a *directory*.
+
+path
+: a string that uniquely identifies a file or folder location by specifying the sequence of nested folders needed to get there, as well as the file or folder name itself.  Each part of the path is separated by a slash (a forward slash on Mac, Linux, and Mini Micro; a backslash on Windows).
+
+Every desktop operating system provides some way to browse files and folders as little icons in a window.  But when you're working on the command line, you work with those same files and folders using paths and file names.
+
+Paths come in two types, absolute and relative.
+
+absolute path
+: a path that begins with a disk identifier, and lists all the folders from the very top level of that disk down to the file.  On Windows, absolute paths begin with a drive letter like "C:".  On other systems, absolute paths begin with a forward slash.
+
+relative path
+: a path that does not start at the top level of the disk, and so it can only be interpreted relative to some other folder.  Sometimes called a *partial path*.  A file name is an extreme case of a relative path.
+
+If we were not lazy, we would probably just use absolute paths all the time, since they are unambiguous.  But we are, so we use relative paths a lot.  How then can the computer know how to interpret them?  It does so by defining one folder in particular as the *working directory*, which is the base for any relative path.
+
+working directory
+: the folder that partial paths are considered to be relative to.  Sometimes called the *current directory* or *current folder*.
+
+## The file module
+
+{i:"module;`file` module"}
+Command-line MiniScript (and Mini Micro) tucks away all the file-related function inside a map called `file`.  That's just to avoid adding a dozen new identifiers into the global variable space; instead, it only adds one.  Because this map is *not* a class intended to be used with `new`, it is not capitalized.  We sometimes refer to such a map containing functions as a "module" (just to distinguish it frorm a class).  So, let's take a look at the `file` module.
+
+Start by firing up command-line MiniScript, and at the REPL prompt, type:
+
+```terminal
+> file.indexes
+```
+
+Recall that the `indexes` method, when called on a map, returns a list of all the keys in the map.  In this case, that tells you the names of all the functions in the file module.  There are a bit over a dozen.  The full set is shown below, but just like the tables of intrinsic functions in earlier chapters, don't try to memorize this.  Just skim it now, so you will know where to look if you need it later.
+
+{caption:"Functions in the `file` module", colWidths:"170,*"}
+| `file.curdir` | returns the current working directory |
+| `file.setdir(path)` | changes the current working directory |
+| `file.makedir(path)` | creates a new directory |
+| `file.children(path)` | returns list of files within the given directory |
+| `file.name(path)` | returns the file name from the given path |
+| `file.parent(path)` | returns the path to the directory containing the given path |
+| `file.child(parentPath, childName)` | combines the given directory path and file name, returning path to the child |
+| `file.exists(path)` | returns true if a file exists at the given path |
+| `file.copy(oldPath, newPath)` | copies a file to a new location |
+| `file.move(oldPath, newPath)` | moves/renames a file |
+| `file.delete(path)` | deletes a file |
+| `file.info(path)` | gets a map of details about a file including size, isDirectory, date, and (full) path |
+| `file.readLines(path)` | returns full contents of a text file as a list of strings |
+| `file.writeLines(path, data)` | writes out the given list as a text file, one line per list element |
+| `file.open(path, mode="rw+")` | opens or creates a file |
+
+About half of the functions are just for manipulating paths.  Try entering
+
+```repl
+> file.curdir
+```
+
+This should print your current working directory.  For me, that might be something like `/Users/jstrout/Documents`, but for you it will be different.  That's OK.  Now try
+
+```terminal
+> file.children
+```
+
+It should return a list of files in your current directory.  Hopefully those things look familiar!  Note that it may include some entries that you don't see when you look in the same folder graphically, using Finder or File Explorer.  Those are "hidden" files which the makers of macOS or Windows don't think you should see.  But MiniScript doesn't hide anything — you see what's really there!
+
+Notice that we didn't give `file.children` a path, so it just returned the contents of the working directory.  Now try it again, giving it either the name of a folder inside your working directory, or an absolute path to some other folder.  For example, on my machine I can do:
+
+```terminal
+> file.children "/Users/jstrout"
+```
+
+to get a list of all the stuff in my home directory.  But of course you'll need to change that to some directory on *your* system.  Experiment with this a bit.
+
+Now let's try changing the working directory.  Pick some folder you were able to get the children of, then pass its path to `file.setdir`, like this:
+
+```terminal
+> file.setdir "/Users/jstrout"
+```
+
+(again changing the path to something that exists on your machine).  If successful, this will return 1 (which means `true` in MiniScript, but is also sometimes used to indicate success, like getting a thumbs-up from the function).  Now if you enter `file.curdir`, it will report back the new working directory.  Doing `file.children` with no argument will list the files in that directory, and any partial paths will now be interpreted relative to that folder.  Again, experiment with this until it seems clear.
+
+Now let's consider how to build and take apart paths.  Let's introduce a variable, `p` for "path" (using a short name just to save us some typing).  Start by setting that to the current directory.
+
+```terminal
+> p = file.curdir
+> p
+```
+
+This should print out the path of your working directory, which is an absolute path that probably contains several parts.  Now pick the name of some file in that directory (use `file.children(p)` if you need to review what those files are).  To get the path of a file relative to `p`, you can use the `file.child` method, like so:
+
+```terminal
+> f = file.child(p, "SomeFile.txt")
+> f
+```
+
+That function basically just appends the file name you give it to the path, inserting the appropriate path separator for your platform (i.e. a forward or backward slash).
+
+Now, let's do the reverse: strip the last part of the path off, so that it refers to the parent folder.
+
+```terminal
+> file.parent(f)
+```
+
+This should strip the file name off, and get you back the path `p` that you started with.  Of course you could go further, and get the parent folder of `p` itself (`file.parent(p)`), or any other path, at least until you run out of path parts.
+
+There is another way to split up a path: you might want just the *last* part, stripping off everything before the final file or folder name.
+
+```terminal
+> file.name(f)
+```
+
+## Listing and Searching Files
+
+Let's combine what we've learned so far with one more function, `file.info`, that gets detailed a map of extra details about a file on disk.  These details include `size` in bytes, `isDirectory` (1 for true or 0 for false), `date` that the file was last modified, and `path`, which is the absolute path to the file.  This is a somewhat longer example, so you might put it into a text file and run it rather than typing it into the REPL.
+
+{caption:List files with detials}
+```miniscript
+p = file.curdir
+for f in file.children(p).sort
+	info = file.info(file.child(p, f))
+	padName = (f + " "*40)[:40]
+	padSize = (" "*8 + info.size)[-8:]
+	print padName + padSize + " " + info.date
+end for
+```
+
+This prints out all the files in the current directory, along with their size and modification date, all in neatly formatted columns.  A good demo, but not terribly useful since you can already browse the files with Finder or File Explorer.  So how about something that those can't easily do?  Let's say you were working on something yesterday, but you can't remember where you put it or what it was called.  Here's a little program that can search by whatever criteria you do remember:
+
+{caption:Find a file by any criteria}
+```miniscript
+// Find a file!  Run this from some folder you know contains what
+// you're looking for, even if it's buried several folders deeper.
+
+// Return whether the given file info represents a good candidate.
+isMatch = function(info)
+	// Here program whatever you can remember about the file 
+	// you're looking for.  An easy way is to return false for 
+    // anything that is NOT what you want.
+	if info.path[-4:] != ".txt" then return false
+	if info.date[:10] != "2020-04-27" then return false
+	if info.size < 1024 then return false
+	// If none of the above apply, then this might be a good file!
+	return true
+end function
+
+// Print the path of all good candidates in the given directory,
+// or any sub-folder (repeating to any depth).
+printMatches = function(dirPath)
+	for f in file.children(dirPath)
+		info = file.info(file.child(dirPath, f))
+		if info.isDirectory then
+			// We've found a subdirectory.  Print matches for THAT!
+			printMatches info.path
+		else if isMatch(info) then
+			// This file looks like a good match.
+			print info.path
+		end if
+	end for
+end function
+
+// Main program.  Let's just operate on the current directory
+// (wherever this script was run).
+printMatches file.curdir
+```
+
+Notice the trick here where the `printMatches` function calls itself for any subfolder it runs across.  This trick is called *recursion*.
+
+recursion
+: a programming technique where a function calls itself (directly or indirectly)
+
+Recursion works because variables are local, so the variable `f` (used in the `for` loop) in one call is not the same as the variable `f` in the next call.  Every call of the function gets its own local variables, so MiniScript never gets confused or loses track of what it was doing.
+
+Note that if you type in the above exactly as it is, and run it, it probably won't print anything.  That's because you probably don't have a text file created on April 27, 2020 somewhere under the folder where you run this.  So adjust the criteria in the `isMatch` function to fit some file you know you have, and be sure to run the script from somewhere higher up in the folder hierarchy above that file.
+
+## Creating, Reading, and Altering Files
+
+The rest of the methods in the `file` module are various ways to read or change the contents of your disk.  Most of these assume that you're working with text files, which includes specialized kinds of text like HTML (web pages), MiniScript script files, and so on.
+
+To begin, let's create a new file with MiniScript.  You can do this in the command-line REPL:
+
+```terminal
+> f = "Test.txt"
+> file.writeLines f, ["Hello world!", "This is a test."]
+29
+```
+
+D> Remember, when examples are given for the REPL, you only type what's next to the `>` prompt.  Lines without a prompt are output from MiniScript; you don't need to type those.
+
+Line 1 in the example above assigns a file name to `f`, and then the `file.writeLines` call on line 2 creates a file with that name in the default directory.  The contents of the file are the second parameter to `file.writeLines`.  This should be either a string, or a list of strings.  The return value (29 in this example) is the length of the file created, in bytes.
+
+To verify that it worked, switch over to File Explorer or Finder, and look in the folder you were using as your current directory.  You should see a new file there called "Test.txt", and if you open it up, you'll find it contains two lines, "Hello world!" and "This is a test."
+
+Switching back to MiniScript, you can verify that the file is there with `file.children`.  Then, let's read it from disk back into memory:
+
+```terminal
+> data = file.readLines(f)
+> data
+["Hello world!", "This is a test."]
+```
+
+Isn't that easy?  You already know how to work with strings and lists, so now that you can read and write a file as a list of strings, you can do almost anything with text files on disk!  Keep in mind that our file specifier here ("Test.txt") was just a file name, which is a minimal kind of partial path.  You can also use a longer partial path, or an absolute path.  Any of these ways of specifying the file will work.
+
+Now let's wrap up with other file operations you might need to do from time to time.  To make a copy of the file, just call `file.copy` with the path (partial or absolute) to the original file, and where you want the copy to be:
+
+```terminal
+> file.copy f, "Test Copy.txt"
+1
+```
+
+And now delete that copy using — you guessed it — `file.delete`:
+
+```terminal
+> file.delete "Test Copy.txt"
+1
+```
+
+If you want to move or rename a file, use `file.move`.  These sound like two different operations, but to the computer, they're really the same thing: changing the path at which a file is stored.  You can think of it as "moving" the file if you specify a path to a different directory, or merely "renaming" the file if you specify a different name in the same directory.
+
+```terminal
+> file.move f, "Toast.txt"
+1
+```
+
+Finally, if you need to create a directory in MiniScript, you can use `file.makedir`.
+
+```terminal
+> file.makedir "TestStuff"
+1
+> file.move "Toast.txt", file.child("TestStuff", "Toast.txt")
+1
+```
+
+In this example, the `file.makedir` call on line 1 creates a new folder, and then on line 3 we move the "Toast.txt" file into it, using `file.child` to construct a proper partial path for the destination.  That would be `TestStuff\\Toast.txt` on Windows, or `TestStuff/Toast.txt` on other platforms.
+
+## Using Your New Superpower
+
+As you become a programmer, you will be working with lots of files.  When you make games, you will have folders full of sprite images and sounds.  If you manipulate scientific data, you'll have files of data points that need summarized, analyzed, and collated.  If you do business programming, you'll have files of sales receipts, tax records, and email attachments.  Even if you just use programming for your own purposes around the house, you'll sooner or later see that you have thousands of photos or scans of children's drawings or *something* that could use some attention.
+
+When most people realize they need to rename, sort through, or otherwise work on hundreds or thousands of files, they have to either find some specialized tool that does that, or else they simply give up and abandon the idea.  But you're not most people.  You are learning how to code, and that makes tasks possible for you that would be impractical or impossible otherwise.
+
+I can't tell you exactly what those tasks will be and how to do them, because they're likely to be very specialized to your needs.  If they were *general* needs that lots of people have, there would probably already be some easy solution programmed by somebody else.  The real power of programming is that you can solve problems that are *not* common; problems that may be unique to you and what you want to accomplish.
+
+So, start thinking about it.  When you encounter a problem on a computer, especially if it involves some repetitive task that would have to be done a mind-numbingly large number of times, consider whether you could write a program to do it for you.  It might take you an hour or two to write and debug the program — but if it saves you weeks of work, or makes possible something that wouldn't be possible at all otherwise, it's worth it!
+
+Just to get those juices flowing, let's work through a small example.  Let's start by creating 14 fake data files called `Data1.dat` through `Data14.dat`:
+
+```terminal
+> for i in range(1,14)                                          
+>>> file.writeLines "Data" + i + ".dat", "42"                    
+>>> end for 
+```
+
+That alone was pretty neat — a lot faster than using a text editor to create the first one, then using File Explorer to manually copy it 13 times!  But that's just setting up our example.  Now let's suppose you're working with some other tool that needs files like these to be named with the index padded to 5 digits, and following a dash, like `Data-00012.dat`.  And imagine instead of 14, there were hundreds or thousands of these, so that manually renaming them would take too long.  MiniScript to the rescue!  
+
+This one is a little longer, so it's probably worth creating a script file (perhaps call it *renamer.ms* or something similar).
+
+{caption:File renamer}
+```miniscript
+for f in file.children
+	// make sure it's one of the files we care about
+	// (i.e. starts with Data, and ends with .dat)
+	if f[:4] != "Data" or f[-4:] != ".dat" then
+		print "Ignoring " + f
+		continue
+	end if
+	
+	// Extract the number (after "Data" but before ".dat")
+	num = f[4:-4]
+	
+	// Zero-pad it, and compute the new file name
+	num = ("00000" + num)[-5:]
+	newName = "Data-" + num + ".dat"
+	
+	// Rename the file, and print what we did
+	file.move f, newName
+	print "Renamed " + f + " to " + newName
+end for
+```
+
+Run this with MiniScript in the same folder as your data files, and voilà!  They are all instantly renamed according to the needed pattern.
+
+I've actually had needs like this from time to time.  If you haven't yet, it may not fully sink in how cool it is — but someday, you'll be faced with the need for something like this, and you'll be glad you have the ability to do it with code.
+
+A> **Chapter Review**
+A> - You learned about the `file` module in command-line MiniScript (also found in Mini Micro).
+A> - You know know how to create, delete, read, write, move, and rename files from your MiniScript code.
+A> - You'll be watching for opportunities to use this new ability to make the computer do boring, repetitive file-related tasks for you.

data/day14.txt

@@ -0,0 +1,439 @@
+{chapterHead: "Day 14: Sea Battle Game", startingPageNum:153}
+
+{width: "50%"}
+![](Chapter14.svg)
+
+Q> I don’t understand how people live without creating.
+Q>— Samuel L. Jackson (actor and producer)
+
+A> **Chapter Objectives**
+A> - Rest and recouperate.
+A> - Enter and play a somewhat larger MiniScript game.
+A> - Review & synthesize what you've learned so far.
+
+If you've been doing one chapter a day, you've now been building your programming skills for two weeks.  If you've been doing some other pace, that's fine too!  Either way, you've now learned all the core basics of programming:
+
+- strings, numbers, lists, and maps
+- variables
+- built-in functions like `print`, `input`, and `val`
+- looping with `while` and `for`
+- branching with `if`, `else if`, and `else`
+- defining your own functions
+- object-oriented programming with classes
+- reading, writing, and manipulating files
+
+And you've learned how to do all this both on the MiniScript Try-It! page on the web, as well as on the command line.  That's a lot of skill!
+
+Of course just knowing something is different from being able to do it well.  If you've never played the piano, someone could very quickly explain how to press the keys in order to make sound come out, and even to play some simple songs.  But you would obviously have plenty of room for improvement through practice.  Programming is the same way.
+
+You can get some idea of a programmer's level by showing them a page of code.
+
+1. The non-programmer can't really make heads or tails of it at all.
+2. A very new programmer will understand most or all of the syntax, and how to look up the bits they don't understand, but may still not grasp what the program is doing.
+3. An intermediate programmer will understand what the program's doing and how it works, though they may not have been able to write such a program themselves.
+4. An advanced programmer could have written the same program from scratch, given only a clear description of the desired behavior.
+
+You're probably at level 2 or so at this point, working towards level 3.  That's a fine place to be, and it's a place every advanced programmer has been.  To progress further, all you need is practice.  Just as when learning a musical instrument, the more you practice, the faster you will improve.
+
+One of the easiest and most quickly rewarding ways to practice is by typing in programs written by advanced programmers.  This is no different from a musical composer, who begins by playing music composed by others.  In following the footsteps of the creators before you, you learn a great deal about how to make your own creations.
+
+So today we're going to take a break from learning new things, and instead review and practice with a moderately-sized MiniScript game.  I encourage you not to skip typing this in on your own computer.  Typing it in engages your brain substantially more than just reading it.  Also, you are sure to make some mistakes in entering the code, and those *really* engage your brain as you track them down.  I can almost see your programming muscles growing stronger already!  Let's dig in.
+
+![](battleship.svg)
+
+## The *Sea Battle* Game
+
+The game today is a classic guessing game for two players, though in our implementation, one of those players will be the computer!  Each player has five ships of various sizes, arranged on a 9 by 11 grid.  The position of your opponent's ships are unknown to you.  On each turn, you guess a grid cell to fire at, and you are told only whether your shot hit a ship, or missed.  When all the cells covered by a ship have been hit, it sinks, and the first player to sink all of their opponent's ships wins the game.
+
+This game will be too big for the Try-It! page, so you'll need to use command-line MiniScript (or you can use Mini Micro, if you aready know how to do so).  Create a text file called "battle.ms", and enter the following:
+
+{caption: "Listing 1 (Sea Battle begins)."}
+```miniscript
+// Sea Battle
+print "Welcome to SEA BATTLE!"
+print
+```
+
+Save this somewhere that you can easily find the path to it on the command line.  You could save it right next to the `miniscript` executable if you want, and then running it would be a matter of changing to that directory (with `cd`), and then entering:
+
+```terminal
+miniscript battle.ms
+```
+
+For readers still not too used to the command line, this may be the hardest step, since I can't tell you exactly how to do it — it depends on what sort of computer you have, and where you have stored command-line MiniScript and your `battle.ms` file.  If you need to, go back and review Chapters 8 and 9, where we learned how to use command-line MiniScript to run a script file.  Make sure you can get this much to run before you go on.
+
+Notice what we did here: we began with just a tiny piece of the program.  This is the right way to approach any program, and is in fact exactly what professional programmers do!
+
+D> When building a large program, never try to do it all at once.  Instead, build it up from smaller pieces, always testing and debugging as you go.
+
+PRINT>Now that we have a working (trivial) script, the next most important thing we have to do is figure out how we are going to represent the data in the game.  Each player has a couple of map grids: one that shows their own ships, along with where their opponent has fired; and one that keeps track of where they have fired at their opponent.  Each cell in a grid is referred to with coordinates like "C5", where the letter (A-K) indicates the column, and the number (1-9) indicates the row.  See the diagram at the top of the next page.
+
+EBOOK>Now that we have a working (trivial) script, the next most important thing we have to do is figure out how we are going to represent the data in the game.  Each player has a couple of map grids: one that shows their own ships, along with where their opponent has fired; and one that keeps track of where they have fired at their opponent.  Each cell in a grid is referred to with coordinates like "C5", where the letter (A-K) indicates the column, and the number (1-9) indicates the row.  See the diagram below.
+
+![Conceptual diagram of the two map grids each player must keep: one for their own ships and where the opponent has fired, and one for where they have fired at the opponent.](BattleGrids.svg)
+
+There are several ways we could represent such a grid in MiniScript.  We could use a list of lists, indexed by row and column number.  But instead we're going to use the `map` data type, where the key is a coordinate string like "C5", and the value is a character that indicates an empty cell, a part of a ship, a hit, or a miss.
+
+So, having figured that out, go ahead and add the code in Listing 2 to your `battle.ms` file.  (Note that the line numbers start at 5 because line 4, not shown, is blank.)
+
+{caption: "Listing 2 (Sea Battle data model).", number-from: 5}
+```miniscript
+rows = "987654321".split("")
+cols = "ABCDEFGHIJK".split("")
+
+shipTypes = {
+  "Battleship": "BBBBB", 
+  "Destroyer": "DDDD",
+  "Cruiser": "CCC",
+  "Frigate": "FFF",
+  "Patrol Boat": "PP" }
+
+EMPTY = "."
+MISS = "w"
+HIT = "*"
+
+newMap = function()
+  m = {}
+  for r in rows
+    for c in cols
+      m[c + r] = EMPTY
+    end for
+  end for
+  return m
+end function
+
+print "rows: " + rows
+print "cols: " + cols
+print "test map: " + newMap
+```
+
+Those last three lines are just test code that we'll remove in a moment.  But when you run this, after the "Welcome to SEA BATTLE!" message, you should see `rows` printed as a list of strings from "9" to "1", and "cols" as a list of strings from "A" to "K".  You'll also see a test map printed as a rather large dictionary, with lots of coordinates like "A9" and "K5", all mapped to the string ".", which represents an empty cell.
+
+Strings like "." in this program are sometimes called *magic strings*.
+
+magic string
+: a string literal that has special meaning to the code, so that if you were to change it in one place without changing it elsewhere, the code would no longer work properly
+
+Magic strings are generally not considered a good thing, because it's so easy to mess them up.  So rather than using the string literals everywhere we need to refer to an empty cell, we assign this magic string to a variable called `EMPTY` on line 15 (and do something similar for the strings that represent a hit or miss).  Now, throughout the code, we use this variable instead of the string literal.  So if you decided you wanted to use something else — perhaps a space — instead of a dot to represent an empty cell, you would just change it on line 15, and the program would still work.
+
+You probably also noticed the `shipTypes` map, which maps each ship to a string of letters that will represent it on the map.  You can change those too, as long as you stick to two rules: all the letters for a particular ship must be the same, and no two ships can use the same letters.  We'll assume these rules later when working out whether a ship has sunk.
+
+Once you have that much working, let's keep going!  Delete those last few lines (29-31), and continue with Listing 3.
+
+{caption: "Listing 3 (Sea Battle input validation).", number-from: 29}
+```miniscript
+isRow = function(s)
+  return rows.indexOf(s) != null
+end function
+isCol = function(s)
+  return cols.indexOf(s) != null
+end function
+
+// Get coordinates from the user, and return as string in 
+// standard form, e.g. "A1" (to index into one of our sea maps).
+inputCoordinates = function(prompt)
+  while true
+    s = input(prompt).upper
+    if s.len == 2 and isRow(s[0]) and isCol(s[1]) then
+      return s[1] + s[0]
+    else if s.len == 2 and isRow(s[1]) and isCol(s[0]) then
+      return s
+    end if
+    print "Please enter a map position like A1 or G8."
+  end while
+end function
+
+print inputCoordinates("Map position? ")  
+```
+
+This part begins by defining a couple of handy functions to determine whether a given character is a valid row indicator (like "5") or column indicator (like "E").  They work by calling `indexOf` to find the index of the given character in our `rows` or `cols` list; if the character is not found, then `indexOf` returns `null`.
+
+Then we define an `inputCoordinates` function that displays a prompt asking the user for a grid coordinate, and keeps asking until it gets a valid answer.  It also standardizes that answer, so even if you enter "c5" or "5c" or "5C", it will be returned as "C5".
+
+Again we have tacked a bit of test code to the end of this block.  So, type in the above, and test it a few times, trying both valid and invalid map positions.  Make sure it works before moving on.
+
+What's next?  The game has two players, and the data for each player is identical: two map grids, plus a list of ships that haven't been sunk yet.  Any time you see a need for a collection of data, defining a class is probably a good idea; and if you have a need for two or more such collections, then a class is *definitely* a good idea.
+
+So in Listing 4, we will define a Player class, including a function to initialize it, and a function to print out its maps.  (In normal play we will never print the computer player's maps, but we might want to for debugging, so it's handy to have it as a general function on the Player class.)  Again, remember to remove the test code (line 50) from your script before adding the new code.
+
+{caption: "Listing 4 (Sea Battle Player class).", number-from: 50}
+```miniscript
+Player = {}
+
+Player.init = function()
+  self.myMap = newMap
+  self.targetMap = newMap
+  self.shipsLeft = []  // names of ships not yet sunk
+end function
+
+Player.print = function()
+  print "  YOUR SHIPS         TARGET MAP"    // 9 spaces in middle
+  print " +-----------+     +-----------+"    // 9 dashes per group
+  for r in rows
+    temp = [r, "|"]
+    for c in cols
+      temp.push self.myMap[c + r]
+    end for
+    temp.push "|    " + r + "|"
+    for c in cols
+      temp.push self.targetMap[c + r]
+    end for
+    temp.push "|"
+    print temp.join("")
+  end for
+  print " +-----------+     +-----------+"
+  print "  " + cols.join("") + "       " + cols.join("")
+end function
+
+p = new Player
+p.init
+p.print
+```
+
+Q> "Type it in, save it, test it out, HEY-O!"
+Q> —lyrics from hit single *Code Me* by Noobz 2 Guruz
+
+Each player has a map (created with the `newMap` function from Listing 2) called `myMap` that represents their own ships, and another one called `targetMap` that keeps track of where they have fired at the other player.  The `Player.print` function prints these out side by side.  It's a big function, but the structure is fairly simple: it loops over the rows, with smaller loops on each row looping over columns to print data from `myMap` (lines 63-65) and then `targetMap` (lines 67-79).  Count your spaces and dashes carefully as you type them in, and the result should look like this.
+
+{width:75%}
+![Output after Listing 4](battle-l4.png)
+
+It's starting to look like a game!  And you're more than a third done.  Maybe stretch your legs a bit, and then delete lines 77-79, and enter Listing 5.
+
+{caption: "Listing 5 (Sea Battle `writeToMap` function).", number-from: 77}
+```miniscript
+// Write a string representing a ship into our map, or optionally,
+// just check whether we COULD write such a string.  Return an
+// error string if it runs out of bounds or hits another ship;
+// or if everything is OK, then return null.
+Player.writeToMap = function(ship, position, horizontal, checkOnly)
+  c = position[0]    // column, e.g. "E"
+  r = position[1]    // row, e.g. "5"
+  for i in ship.indexes
+    // check and maybe write to the map
+    if self.myMap[c + r] != EMPTY then return "Position blocked"
+    if not checkOnly then self.myMap[c + r] = ship[i]
+
+    // then, advance to the next position (unless we're done)
+    if i == ship.len-1 then return   // all done!
+    if horizontal then
+      idx = cols.indexOf(c) + 1
+      if idx >= cols.len then return "Out of bounds"
+      c = cols[idx]
+    else
+      idx = rows.indexOf(r) + 1
+      if idx >= rows.len then return "Out of bounds"
+      r = rows[rows.indexOf(r) + 1]
+    end if
+  end for
+end function
+
+p = new Player
+p.init
+p.writeToMap "DDDD", "C4", true, false
+p.print
+```
+
+This is a somewhat tricky but important function.  The job of this function is to check whether a ship can be placed at a given position and orientation in the map, and optionally, to actually place it there by writing the letters that represent the ship into the map.  The function takes four parameters: the string representing the ship (e.g. "DDD" for the destroyer), a board position like "E5", a true/false value indicating whether the ship should be laid out horizontally, and another true/false value determining whether the function should only check if the ship fits, or actually write it to the map.
+
+Why do we have this check-only behavior?  Determining if the ship can fit is a bit tricky.  It doesn't fit if it goes off the edge of the grid, or if it hits a spot that is not empty (because some earlier ship was already using that spot).  If we're placing a big ship, the first few spots might be fine, but the next spot blocked.  If we were writing the ship letters into the map as we go, then after we discovered the problem, we'd have to go back and erase the already-written letters.  So instead, when placing a ship, we will call this function twice: once to check if it will fit (with the `checkOnly` parameter set to `true`), and then again to actually write it (with `checkOnly` set to `false`).
+
+The test code in Listing 5 is a bit thin.  But if all is working, you should see the destroyer placed as "DDDD" in cells C4 through F4.  If you want to add some additional tests to make sure it returns an error if you give it an invalid ship placement, feel free!  Move on when you're ready.
+
+The next step will be to use that function to let the player place a ship.  This function prompts the user for a location (using the `inputCoordinates` function from Listing 3) and an orientation, either horizontal or vertical.  Then it calls the `writeToMap` function above twice, once to check, and once to actually do it.
+
+{caption: "Listing 6 (Sea Battle `placeShipByInput` function).", number-from: 103}
+```miniscript
+Player.placeShipByInput = function(name)
+  self.print
+  print
+  self.shipsLeft.push name
+  ship = shipTypes[name]
+  while true // keep trying till we succeed
+    print "Placing " + name + " (size " + ship.len + ")."
+    pos = inputCoordinates("  Top-left coordinates? ")
+    hv = ""
+    while hv != "H" and hv != "V"
+      hv = input("  Horizontal or Vertical (H/V)? ").upper
+    end while
+    err = self.writeToMap(ship, pos, hv=="H", true) // just check
+    if err then
+      print err + ".  Please try again!"
+    else
+      self.writeToMap ship, pos, hv=="H", false // place ship
+      return     // and we're done
+    end if
+  end while
+end function
+
+p = new Player
+p.init
+p.placeShipByInput "Destroyer"
+p.placeShipByInput "Battleship"
+p.print
+```
+
+Run this several times, trying different positions and orientations, including some that would run off the map, or place the ships overlapping.  The code should detect the problem, and keep prompting you until you pick a valid place.
+
+We're also going to need a function to place ships randomly.  In the finished game, this is used by the computer player to place its ships.  However during development, I also used it for the human player, so that I could get into a game more quickly and test whatever I was working on without having to place each of my ships.
+
+(Note that you can save yourself a bit of typing by not deleting the test code from Listing 6, but instead only updating it to match Listing 7.)
+
+{caption: "Listing 7 (Sea Battle `placeShipRandomly` function).", number-from: 125}
+```miniscript
+Player.placeShipRandomly = function(name)
+  self.shipsLeft.push name
+  ship = shipTypes[name]
+  while true // keep trying till we succeed
+    pos = cols[rnd * cols.len] + rows[rnd * rows.len]
+    horizontal = (rnd < 0.5)
+    err = self.writeToMap(ship, pos, horizontal, true) // check
+    if err then continue
+    self.writeToMap ship, pos, horizontal, false // place ship
+    return      // and we're done
+  end while
+end function
+
+p = new Player
+p.init
+p.placeShipRandomly "Destroyer"
+p.placeShipRandomly "Battleship"
+p.print
+```
+
+Now we're getting there!  The core of the game is firing shots at your opponent's map.  We need a function that does that, checks the opponent's map, reports *hit* or *miss*, and records the shot in both player's maps.  That function is given in Listing 8.  (Lines 141 and 156 are long enough to wrap in this book, but just keep typing in your text editor; do not insert a line break.)
+
+{caption: "Listing 8 (Sea Battle `fire` function).", number-from: 138}
+```miniscript
+// Fire at the other player's map.
+// Print HIT or MISS, and return the name of the ship sunk (if any)
+Player.fire = function(pos, otherPlayer)
+  if otherPlayer.myMap[pos] == EMPTY or otherPlayer.myMap[pos] == MISS then
+    print "Miss!"
+    otherPlayer.myMap[pos] = MISS
+    self.targetMap[pos] = MISS
+  else
+    print "HIT!"
+    wait
+    otherPlayer.myMap[pos] = HIT
+    self.targetMap[pos] = HIT
+    // Check for a ship that's been sunk.
+    // Every ship has a unique letter, so we know it's sunken if
+    // that letter is not found anywhere in the map.
+    for name in otherPlayer.shipsLeft
+      if otherPlayer.myMap.indexOf(name[0]) == null then
+        // This ship is not found, so it has been sunk.
+        otherPlayer.shipsLeft.remove otherPlayer.shipsLeft.indexOf(name)
+        return name
+      end if
+    end for
+  end if
+end function
+
+p = new Player
+p.init
+p.writeToMap "DDDD", "C4", true, false
+p2 = new Player
+p2.init
+p2.fire "E6", p  // should miss
+p2.fire "E4", p // should hit
+p.print
+```
+
+When you run that, it should fire two shots: the first one at E6 misses, but the second one at E4 hits.  The result should look like the figure below.
+
+{width:"75%"}
+![Output after Listing 8](battle-l8.png)
+
+If you want to test this more thoroughly, try including enough `fire` calls to cover the entire ship.  Also, print out the result of the last one; the function should return the name of a ship sunk, or `null` if nothing is sunk.
+
+The last function we need for our Sea Battle game is one to choose the computer's move.  This is the AI (artificial intelligence) of the game... though our version is really not very intelligent.  It just chooses a move randomly.
+
+
+{caption: "Listing 9 (Sea Battle AI).", number-from: 163}
+```miniscript
+// Here is the "AI" of the game, that is, the code that decides
+// what to do on the computer's turn.
+ai = function()
+  while true  // repeat until we find spot we haven't tried
+    r = rows[rnd * rows.len]
+    c = cols[rnd * cols.len]
+    if comp.targetMap[c + r] == EMPTY then break
+  end while
+  print "I fire at " + c + r + "..."
+  sunk = comp.fire(c+r, human)
+  if sunk then print "Ha ha!  I sunk your " + sunk + "!"
+end function
+```
+
+No test code on this one, because it's referencing two global variables that we haven't defined yet.  So go ahead and remove the previous test code, add Listing 9, save it, and run it.  If you see just the welcome message, you're ready to move on to the next part, where we actually define those global variables.
+
+{caption: "Listing 10 (Sea Battle player setup).", number-from: 176}
+```miniscript
+// Set up the human player
+human = new Player
+human.init
+for s in shipTypes.indexes
+  human.placeShipByInput s  // (or placeShipRandomly to speed things up)
+end for
+human.print
+
+// Now set up the computer player
+comp = new Player
+comp.init
+for s in shipTypes.indexes
+  comp.placeShipRandomly s
+end for
+comp.print  // <-- Just for debugging.  (No cheating!)
+```
+
+When you run at this point, it should present you with a blank board, and then prompt you to place each of your ships, using the `for` loop on lines 179-181.  Your map layout is printed after each entry.  Then the computer very quickly places its ships, using its own `for` loop on lines 189-189, and that is printed as well, just so you can be sure it worked.
+
+And now we're almost done!  All that's left is the main game loop.  Be sure to comment out that `comp.print` call on line 190, since the game doesn't have much challenge if you know where the computer's ships are!
+
+{caption: "Listing 11 (Sea Battle main loop).", number-from: 190}
+```miniscript
+//comp.print  // <-- Just for debugging.  (No cheating!)
+
+// Main game loop
+while true
+  print
+  sunk = human.fire(inputCoordinates("Fire at coordinates: "), comp)
+  if sunk then print "You sunk my " + sunk + "!"
+  if not comp.shipsLeft then
+    print "You win.  Good game!"
+    exit
+  end if
+  print
+  ai
+  ai    // (a second time, to make game more challenging)
+  print
+  human.print
+  if not human.shipsLeft then
+    print "I win!  Thanks for the game."
+    exit
+  end if
+end while
+```
+
+And that's it!  Each time through the loop, we use `inputCoordinates` to get the human player's move, and `fire` at that location.  This returns the name of the ship sunk, if any; so we print that out on line 196.  If the computer doesn't have any ships left, then the human has won.
+
+Otherwise, we let the computer do its move via the `ai` function.  In fact we let it move *twice* (lines 202-203).  This is to compensate for the rather stupid AI.  I find that this makes for a pretty interesting game -- sheer dumb luck (times two) against human wit.  Give it a try, and see how you do!
+
+Remember, if you get errors or the behavior of the program is not what you think it should be, just go back and check your typing carefully.  Pay attention to spelling, capitalization, and punctuation.  Check the end of Chapter 7 for other trouble-shooting tips.
+
+## Going Farther
+
+You've worked hard today, building this game up section by section.  Hopefully you've also built some good habits that will serve you well in the future.  It would be completely reasonable to call it a day.
+
+But at some point, now or later, you may get the urge to pull this program out again and build on it.  The most obvious thing to improve is the AI.  Fortunately that's all contained in one function, `ai` (Listing 9).  Instead of picking randomly, you might try first guessing any spot next to a hit, and then guessing spots that are far away from any previous guess.
+
+Also, over the next week or two you're going to learn how to use Mini Micro.  This very same program will run as-is on Mini Micro, using the keyboard and text display... but Mini Micro can do so much more than that.  You may want to revisit Sea Battle and put a nice graphical interface on it, or add sounds (or both!).
+
+So think of what you did today as a starter kit.  You've assembled it according to the directions, but as you acquire more skills and tools, you can build on it to create something uniquely your own.
+
+A> **Chapter Review**
+A> - You built the *Sea Battle* game, pitting human versus computer in a classic game of strategy and luck.
+A> - You saw how to build up a big program as a series of smaller tests, stopping to test and debug at each step, rather than doing it all at the end.
+A> - You exercised everything you've learned about MiniScript so far, including functions and classes.  The more you use this stuff, the easier it will be!
+

data/day15.txt

@@ -0,0 +1,248 @@
+{chapterHead: "Day 15: Introducing Mini Micro", startingPageNum:171}
+
+{width: "50%"}
+![](Chapter15.svg)
+
+Q> Engineering isn’t just the physics of how a transistor works. It’s using the technology, and being creative with it, and solving problems that people have or creating something beautiful with it.
+Q>— Limor Fried (engineer, co-founder of Adafruit Industries)
+
+A> **Chapter Objectives**
+A> - Download and install Mini Micro.
+A> - Learn the basic Mini Micro commands needed to load and run programs.
+A> - Explore the nifty demos that come with it.
+A> - Review the difference between a programming *language* and a programming *environment*.
+
+This chapter begins the second half of the book, which is quite honestly the more fun half.  *Any* programming is fun, but the fun of text on a web page or terminal window pales in comparison to making pictures, animations, sound effects, and music!
+
+For the rest of this book you'll be using *Mini Micro*.
+
+Mini Micro
+: a neo-retro virtual home computer from an alternate, much cooler universe
+
+Mini Micro is an application you download install on your computer.  At the time of this writing, it runs on desktop computers (Windows, Mac, and Linux), though a version for mobile phones and tablets is in the works and may well be done by the time you're reading this.  Mini Micro is a MiniScript programming environment, and supports all sorts of fun features:
+
+- efficient, interactive graphics
+- synthesized and digitized sounds
+- mouse and keyboard input
+- gamepads and joysticks
+- simple networking
+
+Using Mini Micro, you can write your own games and simulations, package them up for any platform (including web browsers), and share them with your friends or post them on sites like itch.io.  The rest of this book will teach you what you need to know.
+
+## Installing Mini Micro
+
+You can download Mini Micro via the MiniScript home page at <https://miniscript.org>.  Just click the link that says "Boot up the Mini Micro".
+
+That will probably take you to a page that actually has Mini Micro running in demo mode, right within your web browser.  Scroll on down and look for the download links, then click the one for your platform (macOS, Windows, or Linux).
+
+On Mac or Windows, the download is a zip file.  Double-click that to open it up, and in the case of Windows, you should then drag the contents out into another folder (i.e. don't try to run it directly from the zip file).  On Linux, the download is a gzipped tar file; unpack that and place it wherever you like.
+
+Then double-click the Mini Micro application.  It should open a window that looks something like this:
+
+![Mini Micro.](MiniMicroBoot.png)
+
+The details will likely be different: the version number and build date will probably be later than this, and the tip that appears on the third line is selected randomly on each run.  But if you see a welcome screen that looks basically like this, with no error messages, then you are ready to go!
+
+If you do see an error message, the problem is most likely that it can't find or create a place to store your data.  In that case, notice the two slots at the bottom of the window, below the black screen.  Those represent *disk slots*.  Click the top disk slot, and choose "Mount Folder..." from the menu that appears.  Select or create an empty folder wherever you like to store your data (for example, under Documents in your home directory).  Then quit Mini Micro, and relaunch it.  The errors should be gone, as Mini Micro remembers where you previously told it to store your data.
+
+Before you move on, go back to the web page where you downloaded Mini Micro, and scroll down a bit more.  You should see a link that says "Mini Micro Cheat Sheet".  Download that too; it is a very short PDF that summarizes all the special Mini Micro functions and classes.
+
+## Basic Commands
+
+After the welcome messages, you will see a `]` prompt with a boxy blinking cursor, very much like a terminal window.  This is Mini Micro's command-line interface.  It is a REPL (Read, Eval, Print Loop) just like command-line MiniScript.  So everything you've learned in the last week still applies!  But there are some important differences.
+
+First, command-line MiniScript is a thin layer on top of your native operating system (Windows, macOS, or Linux).  So, for example, you have to use backslashes on Windows to separate parts of a file path.  But Mini Micro is a virtual computer with its own operating system, and works the same regardless of what kind of physical computer you have.  It always uses forward slashes in file paths, even on Windows.
+
+Similarly, command-line MiniScript is meant to integrate with the built-in command shell of your system.  You navigate in your file system with commands like `cd` and `ls` or `dir`, which are all built-in shell commands, not part of MiniScript; and then you run `miniscript` as a separate command when you want to enter the MiniScript REPL, or run MiniScript code stored in a file.  Mini Micro is different; the command shell is actually just MiniScript.  You don't "run MiniScript" in Mini Micro; it's *always* running.
+
+In this regard, Mini Micro is easier than command-line MiniScript.  The latter really requires you to know at least two languages: MiniScript, and your command shell language.  These have different syntax that you have to keep straight.  But in Mini Micro, it's all MiniScript, all the time; you only need to think about one language with one syntax.
+
+However, you will still need some commands for navigating around your virtual computer!  These are very much like the ones you used in your Windows or Unix/Linux shell, but they are actually just MiniScript functions.  These functions are predefined for you as part of the Mini Micro startup process, so they are ready for you to call right away.
+
+{i:"Mini Micro, commands;commands, in Mini Micro"}
+| `pwd` | print working directory |
+| `cd` *path* | change working directory |
+| `dir` | list directory contents |
+| `mkdir` *path* | create a new directory |
+| `delete` *path* | delete a file or empty directory |
+| `view` *path* | preview (almost) any file |
+| `clear` | clear the screen |
+| `load` *path* | load a program into memory |
+| `run` | run the currently loaded program |
+| `edit` | edit the currently loaded program |
+| `save` | save the current program to disk |
+| `reset` | clear loaded program and variables |
+
+Try it!  Type `pwd` into Mini Micro right now, and press Return.  You should see:
+
+```terminal
+]pwd
+/usr/
+```
+
+The current working directory on startup is "/usr/", which represents the root directory of the user disk.
+
+user disk
+: the place where all your files are stored; selected with the top disk slot, and referenced in file paths as `/usr`
+system disk
+: the read-only disk where all of Mini Micro's built-in code, images, sounds, and other data are stored; referenced in file paths as `/sys`
+
+Now try listing the contents of your user disk with `dir`:
+
+```terminal
+]dir
+/usr :
+  (Directory empty)
+```
+
+Assuming you just downloaded Mini Micro a few minutes ago, it's not surprising your user disk is empty!  Remember, this is just your *Mini Micro* user disk.  It's *not* the disk of your host (desktop PC) system, though of course ultimately your Mini Micro files must be stored there.  We'll get more into the relationship between your Mini Micro files, and the host files, a bit later.  For now let's get on to the fun stuff.
+
+## Running the Demos
+
+You may have caught above that there are two disks available in Mini Micro:       `/usr` and `/sys`.  (There can actually be a third, /usr2, which accesses a disk file or folder mounted in the second disk slot.  But let's ignore that for now.)
+
+The `/sys` disk is fun and important because it contains all the built-in goodies that come with Mini Micro.  This includes a bunch of fun demos (demonstration programs) and mini-games.  Our goal for today is just to play with these.  If you thought yesterday was hard work, don't worry — today is pure fun!
+
+Use the `cd` command to switch to the `/sys` disk, and then `dir` to list the directory contents.
+
+```terminal
+]cd "/sys"
+]dir
+/sys :
+  data/                                DIR  2020-02-23 06:39:44
+  demo/                                DIR  2020-03-26 12:32:28
+  help/                                DIR  2019-11-16 08:02:50
+  lib/                                 DIR  2020-03-13 11:54:12
+  pics/                                DIR  2020-03-13 13:02:16
+  sounds/                              DIR  2020-03-13 12:42:50
+  startup.ms                          8607  2020-03-17 17:16:14
+  tips.txt                            1229  2019-08-09 16:41:40
+```
+
+Notice that we had to put quotation marks around `"/sys"` in the `cd` command.  That's different from any Unix/Linux/Windows shell.  Why is that?
+
+D> Stop and see if you can answer that question yourself.  Cover up the rest of the page below while you think about it.  Hint: remember that Mini Micro doesn't have a separate command shell; it's all MiniScript, all the time.
+
+The reason quotes are needed is that `cd` here is just a MiniScript function, and    `"/sys"` is just a MiniScript string.  MiniScript requires strings to be quoted.  Without the quotation marks, it would look like you were trying to do math (`cd` divided by `sys`), and would not work at all.  So even though these *look* like standard shell commands, you must remember the quotation marks.
+
+D> Always put quotation marks around paths and file names in Mini Micro.
+
+Now examining the file listing that `dir` gave you, you can see a half-dozen subdirectories, plus a MiniScript file (`startup.ms`) and a text file (`tips.txt`).  Let's ignore those for a moment and focus on the subdirectories... and in particular, the `demo` directory.
+
+```terminal
+]cd "demo"
+]dir
+```
+
+I haven't included the result of this `dir` command for two reasons: the demos will have probably changed a bit by the time you read this, and in any case, there are too many!  When a directory listing is more than a screenful of lines, you will see something like `[3 more]` in inverse text at the bottom, and Mini Micro will wait for you to press a key.  At that point, press the spacebar or Return key to continue, or press Q or Escape to stop the listing there.
+
+{i:"`/sys/demo`"}
+What you find in this `/sys/demo` directory is a whole bunch of MiniScript programs.  Some of them are tiny, like `countdown.ms`, which is only 70 characters.  Others are quite large; the `speedConquest.ms` game is over 24 thousand characters!  A few are simple text demos that could have been done in command-line MiniScript or the Try-It! page, but most of them make full use of Mini Micro's power.
+
+To play any of these programs, you first `load` it with a full or partial file path, and then `run`.  For example:
+
+{i:"`/sys/demo`,`mochiBounce`"}
+```terminal
+]load "mochiBounce.ms"
+193 lines loaded from /sys/demo/mochiBounce.ms
+]run
+```
+
+{width:"75%"}
+!["Mochi Bounce" demo.](MochiBounce.png)
+
+PRINT>That should produce a screen that looks like this picture on the previous page.
+EBOOK>That should produce a screen that looks like the picture above.
+
+Now you can play the game!  Hold the space bar to make the mochi jump, and use the left and right arrow keys to make it veer left or right.  See how far you can climb!  Be sure your computer speakers are on to hear the sound effects.  The game will end when you miss, or you can exit out by pressing the Escape key.
+
+D> To exit out of most Mini Micro programs, press Escape.  If that doesn't work, you can always break out by pressing Control-C.
+
+To try the program again, just enter `run` again.  Or as a shortcut, you can press the up-arrow key to bring back the last command, and then hit Return.
+
+D> At any blinking input prompt, you can use the up and down arrows to step through previous inputs.
+
+That was fun!  Let's try a much simpler one.  Clear the screen, then load a different demo:
+
+```terminal
+]clear
+]load "countdown"
+]run
+```
+
+PRINT>This is a very simple program indeed.  But let's use it to explore editing and saving a program.  Enter `edit`.  The Mini Micro program editor opens, as shown in the picture on the next page.
+EBBOK>This is a very simple program indeed.  But let's use it to explore editing and saving a program.  Enter `edit`.  The Mini Micro program editor opens, as shown in the picture below.
+
+![Mini Micro code editor.](editCountdown.png)
+
+{i: "code editor, Mini Micro"}
+Here you can use the mouse and keyboard as you would in any code editor.  It supports undo and redo, cut/copy/paste, a sophisticated search & replace function, a Navigate menu (much more useful on bigger programs), and a Code menu that can insert various code snippets for you.  Hover over any of the buttons at the top of the screen for a moment, and the name of the function should appear to tell you what's what.
+
+Right now the program counts down from 10 to 1, waiting for 1 second (the default time for `wait`) between each number.  Let's say we're impatient.  Change line 3 to read
+
+{number-from: 3}
+```miniscript
+wait 0.25
+```
+
+so that it waits only a quarter second between each number.  Now click the "X" (Close) button at the left end of the toolbar.  The program editor closes.  Now `run` the program again.  You should see it count down much faster.
+
+But our changes at this point are only in memory; they have not been saved to disk.  So if you quit Mini Micro at this point, your changes would be gone.  Normally you could just enter `save` (or use the save button in the code editor) to save a file to wherever it came from, but this file came from the `/sys` disk, which is read-only (i.e. you can't write to it).  So you will need to supply a path to somewhere on the user disk.
+
+```terminal
+]save "/usr/fastCountdown"
+6 lines saved to /usr/fastCountdown.ms
+```
+
+Now that you know how to load, run, edit, and save the demos, explore!  There are are over two dozen demos in `/sys/demo`, all of them different.  Most of them will be fairly obvious how to use; for anything that looks like a graphical game, try the arrow keys and spacebar, or in some cases the mouse.  If you see a blinking cursor, type something.  A few programs have no input, but just do something interesting on their own.
+
+If you have trouble figuring out how to use a demo, `edit` it and read the comments at the top of the file.  In fact, even if you *don't* have trouble using a program, look over the script anyway!  There may be much you don't understand yet, but don't get discouraged.  A few weeks ago you didn't know how to read MiniScript at all, and now you can!  And by the end of this book, you'll know how to understand pretty much everything you see in these programs, and be well on your way to writing your own.
+
+For now, just skim them over, read the comments at the top, and see if you can find the main loop (usually at the bottom).  This will prepare your brain for all the fun new stuff we're going to pour into it over the next two weeks.
+
+## Getting Help
+
+Mini Micro has a lot of new functions and classes for you to use.  Fortunately you don't have to remember them; there are several good resources to teach or remind you about them.
+
+This book is one, of course.  Here you find more in-depth explanation of the key features and step-by-step examples, all presented in a thoughtful order where each day builds on what you did the days before.
+
+Another resource is the `help` command built into Mini Micro.  Just type `help` at the prompt and it will print some introductory help, with a prompt to get to more by using `help "topics"`.  That leads you to things like `help "files"` or `help "graphics"`.  The help you find this way is brief, but may be a good enough reminder if for some reason you don't have any of the other resources on hand.
+
+{i:"Mini Micro, Cheat Sheet;documentation, Mini Micro Cheat Sheet"}
+Next, keep in mind the Mini Micro Cheat Sheet, a very short (currently 4-page) expansion of the MiniScript Quick Reference you used in the first half of the book.  The additional pages cover almost everything there is to know about Mini Micro: all the built-in classes and functions.  They are organized by topic, so you can quickly find what you need.  If you don't have this yet, put the book down and go get it!  I recommend you keep it handy at all times.  I've included a copy of the current version here in the book just to whet your appetite, but go get your own copy that will be both more current, and big enough to read.
+
+{width:"95%"}
+![Mini Micro Cheat Sheet.](MiniMicro-docs.png)
+
+When you need more detail than the built-in help or the cheat sheet can provide, a good place to turn is the MiniScript Wiki.  This is a community-edited reference for everything having to do with MiniScript and Mini Micro.  You can find it via the MiniScript home page, or go to it directly at `https://miniscript.org/wiki/`.  Once there, follow the link to the Mini Micro page, which contains links to all the special Mini Micro classes and functions, as well as some very handy "How To" articles covering topics like how to make a sprite translucent, how to do simple physics, and so on.
+
+Finally, of course, you are encouraged to join the MiniScript community.  There is an active Discord server as well as web forums, and users there — including me — will be happy as a clam to help you with your MiniScript and Mini Micro questions.  It's also a great place to show off what you have created!
+
+{pageBreak}
+## Language vs. Environment
+
+I'd like to close this first chapter about Mini Micro with a reminder about the difference between a programming *language* and a programming *environment*.
+
+{i:"programming language"}
+MiniScript is a programming *language*.  It has a certain syntax: a way of typing in numbers, strings, loops, branches, and so on so that the computer can understand them.  It has a system of data types (strings, numbers, lists, maps, and functions), rules about how it looks up identifiers, and so on.
+
+{i:"programming environment"}
+Mini Micro is a programming *environment*.  The environment provides a context for using the language.  You've used MiniScript in at least two other environments already: the Try-It! page on the web, and command-line MiniScript.  It's possible you've encountered (or will someday encounter) MiniScript in other contexts too, such as in a game.  The language is the same in all these cases, but what you can *do* with it may vary quite a bit with the environment.
+
+You already saw all this when you moved from the Try-It! page to command-line MiniScript; only the latter, for example, can access files.  But Mini Micro takes this much further.  As you explored the demos, you saw all sorts of fancy things going on: animated graphics and text, sound, music, etc.  But, all of that is done with the MiniScript language you already know.  I'm not going to teach you any new parts of the language, because there aren't any!  From here on out, it's just a matter of familiarizing yourself with the extra functions and classes provided by the environment.
+
+{pageBreak}
+A> **Chapter Review**
+A> - You installed Mini Micro on your own computer.
+A> - You used Mini Micro commands to load, run, edit, and save programs.
+A> - You explored the nifty demos that come with Mini Micro, to get a good idea of what it can do.
+A> - You learned about the various places you can find helpful information about Mini Micro.
+A> - You reviewed the difference between programming language and programming environment.
+
+
+{gap:100}
+{width:"25%"}
+![](chinchilla-03.svg)
+
+
+ 

data/day16.txt

@@ -0,0 +1,311 @@
+{chapterHead: "Day 16: Key Module; MiniScript Files", startingPageNum:187}
+
+{width: "50%"}
+![](Chapter16.svg)
+
+Q> Experience is the name everyone gives to their mistakes.
+Q>— Oscar Wilde (poet and playwright, 1854-1900)
+
+A> **Chapter Objectives**
+A> - Practice editing, saving, and managing your Mini Micro programs.
+A> - Learn how to use the `key` module to interact more directly with the keyboard.
+A> - Discover different ways to access files on the host computer from Mini Micro, and vice versa.
+
+Fire up Mini Micro.  Today's going to be a fun day!
+
+## The `key` module
+
+Before today, the only way of getting input from the user has been with the `input` function.  That displays a prompt, then waits for the user to type as much as they like, until they press the Return/Enter key; then it returns what they typed as a string.  That's fine for many kinds of input, but it has limitations:
+
+- No way to enter special keys like Shift, Control, Escape, or F1.
+- No way for the computer to react to a single keypress (other than Return).
+- No way to tell if the user is currently pressing a key.
+
+Those limitations are difficult to avoid in general-purpose enviroments like the Try-It! page and command-line MiniScript.  But Mini Micro, being a virtual computer, can do much more!  With that preamble we introduce `key`, a module of methods for reading the keyboard.
+
+{i:"Mini Micro, `key` module;`key` module;keyboard"}
+{caption:"Methods in Mini Micro's `key` module."}
+| `key.available` | returns 1 if a key is in the buffer, 0 if not |
+| `key.get` | return a key from the key buffer, or the next key pressed |
+| `key.clear` | clear the key buffer |
+| `key.pressed(k)` | return 1 if key *k* is currently down |
+| `key.keyNames` | return all names usable with `key.pressed` |
+| `key.axis(h)` | return value of analog axis *h* |
+
+Remember that by "module" we really just mean a map containing some functions and other values.  Don't take my word for it — check for yourself!
+
+```terminal
+]key
+{"available": FUNCTION(), "clear": FUNCTION(), "get": FUNCTION(), "p
+ressed": FUNCTION(keyName="space"), "axis": FUNCTION(axisName="Horiz
+ontal"), "keyNames": FUNCTION()}
+```
+
+This just dumps the contents of the `key` module to the screen; it's not pretty, but it's good enough for you to verify what there.  So let's try it!  Enter:
+
+```terminal
+]foo = key.get
+```
+
+After entering this method call, Mini Micro doesn't show the usual "]" prompt with blinking cursor... instead it looks like it's frozen.  It's actually just waiting for you to press a key!  Go ahead and press your favorite letter.  (I'm pressing "m" here.)  As soon as you do, the prompt and cursor return.  Now if you enter `foo`, you can see that it has been assigned whatever key you pressed.
+
+That brings up the first good use of `key.get`: waiting for the user to be ready.  But now our examples are going to get long enough to be worth using the code editor rather than the REPL (Read-Eval-Print Loop).  So enter `edit` at the prompt to launch the Mini Micro code editor.  Then type in the following.
+
+{caption:"Press any key!"}
+```miniscript
+print "Press any key to begin!"
+key.get
+print "OK, here we go..."
+wait
+print "And we're done!"
+```
+
+After typing that in, click the close button in the top-left corner, or press Control-W, which does the same thing.  The editor disappears and you're back to the REPL, at a fresh prompt right after `edit`.  Now enter `run`, and you should see the program wait for you to indicate you're ready by pressing any key, and then run the rest of the program.
+
+```terminal
+]run
+Press any key to begin!
+OK, here we go...
+And we're done!
+```
+
+Of course you can't really press *any* key here; `key.get` does not return modifier keys like Shift and Control, nor function keys like F1.  It does, however, return values for the Escape key, Return, Delete, Backspace, and arrow keys.  Here's a fun way to test exactly what `key.get` returns.  Use `edit` again, delete the old code, and enter this.
+
+{caption:"`key.get` explorer"}
+```miniscript
+// What exactly does key.get return?
+while true  // press Control-C to exit
+	k = key.get
+	print "char(" + k.code + "): " + k
+end while
+```
+
+{pageBreak}
+D> You probably noticed that the Mini Micro code editor indents lines for you.  You don't need to press the Tab key within the `while` loop, and you don't need to press the Delete key before typing `end while` — in fact if you do, it deletes the line break and puts you back on the previous line.  Just type `end while` in line with the previous line, and the editor will fix it as soon as you're done typing it.
+
+D> Pro tip: you can also close any open `while`, `for`, or `if` block automatically by holding the Shift key when you press Return or Enter at the end of a line!  This inserts a blank line and the block closer, then positions the cursor on the blank line, ready to add code to the body of the loop.
+
+Again press the Close button (or hit Control-W) to exit the editor, and `run` the program.  Now try various keys on the keyboard.  It should print out the character code, as well as the printable character, if any.  You may notice that when you press the Return key, it reports as `char(13)`, and when we print that we get an extra line break.  The arrow keys display as `char(17)` through `char(20)`, and print as little arrow symbols.  We made an infinite loop here, so just press Control-C to break out of the program when done.
+
+This little program is something you might want to run again later, when you're trying to remember exactly what `key.get` returns for some special key.  So you'll want to save it, so you can reload it later.  Time to get organized!
+
+## Organizing Your Files
+
+If you enter `pwd` right now, you'll probably find that your current working directory is `/usr/`, the root directory of the user disk.  You certainly could just save your program here, but as I hope you will be creating lots and lots of programs in the future, that could get pretty cluttered.  It's generally a good idea to sort your stuff into folders.  Let's make a folder to contain any examples you enter from this book.
+
+{i:"`makedir`;`save`"}
+```terminal
+]cd
+]file.makedir "learnToCode"
+]cd "learnToCode"
+]save "keyGet"
+7 lines saved to /usr/learnToCode/keyGet.ms
+```
+
+That `cd` command on line 1 isn't really necessary if you're already in the `/usr/` directory, but it doesn't hurt; without any parameter, `cd` always returns you there.  Then the `file.makedir` command creates a new directory, and the next `cd` on line 3 changes your current directory to that one.  Finally, the `save` command saves your file.
+
+Let's just verify that it really is there.
+
+```terminal
+]dir
+/usr/learnToCode :
+  keyGet.ms                            152  2020-07-18 14:07:18
+]view "keyGet.ms"
+// What exactly does key.get return?
+print "Press any key, or Control-C to exit."
+while true
+    k = key.get
+    print "char(" + k.code + "): " + k
+end while
+```
+
+{i:"`view`"}
+Pretty neat, right?  The `dir` command, without any parameters, lists the contents of the current directory, along with the size and date/time of each file.  The `view` command can list a program, to verify what's there.  (It can also preview images and sounds, but we'll get to those later!)
+
+Notice that a program on disk and a program in memory are not the same thing.  You saw this yesterday; to run the demos you had to first `load` the program into memory, and then `run` it.  To create a new program on disk is basically the same thing in reverse: first you `edit` to create the program, and then `save` it.
+
+So we used the `view` command to list a program on disk.  How do you list the program in memory?  Of course you can `edit` it and see it that way, but you can also use the `source` command.
+
+```terminal
+]source
+// What exactly does key.get return?
+print "Press any key, or Control-C to exit."
+while true
+    k = key.get
+    print "char(" + k.code + "): " + k
+end while
+```
+
+There's our program, still in memory!
+
+D> The `source` and `edit` commands both operate on the program in memory.  The `view` command always displays a file on disk.
+
+But we're done with the keyGet program for now.  Let's clear it out of memory using the `reset` command.
+
+{i:"`reset`"}
+```terminal
+]reset
+Program source cleared and reset
+```
+
+If you try `source` now, it doesn't print anything; our current program is empty.  Likewise, when you `edit`, you'll be in a blank editor.  Do that, and type in this new program:
+
+{caption:"Keyboard Dash"}
+```miniscript
+print "Keyboard Dash!"
+print "Press the , and . keys as fast as you can"
+print "to race to the finish line."
+print
+print "Ready..."; wait
+print "Set..."; wait
+print "GO!"
+
+lastKey = ""
+count = 0
+startTime = time
+while count < 25
+	k = key.get
+	if k == lastKey then continue
+	if k != "." and k != "," then continue
+	count = count + 1
+	print count
+end while
+elapsed = time - startTime
+print "DONE!"
+print "You finished in " + elapsed + " seconds.  Great job!"
+```
+
+This time, before you exit the editor, try hitting the Save button (second button from the left), or pressing Control-S.  Because this program has not been saved before, the editor will pop up a little box asking you where to save it.
+
+{width:"50%"}
+![Code editor Save dialog.](SaveDialog.png)
+
+Type `keyboardDash` (with or without a `.ms` suffix), and hit Return/Enter or click Save.  The program will be saved, and the program path appears in the toolbar at the top of the screen.  Now exit with Control-W (or click the Close button).
+
+First, if you like, use the `dir` and `view` commands to verify that your program really was saved to disk.  So now you know *two* ways of saving a program: using the `save` command in the REPL, or using the Save button in the editor.  Both do the same thing.
+
+Finally, run your program, and alternately press the comma and period keys as fast as you can to race to the finish line.  How fast can you do it?  (My record is about 2.25 seconds.)  Find some other people and challenge them to a race!
+
+## More Key Methods
+
+Sometimes you want to get a key from the user, only if they've pressed one; if they haven't, then you want to continue on with the program.  There are two ways to do that.  The first is to call `key.get` only if `key.available` is true.  Or if you don't care what the key is, you can call `key.clear` to clear it out.
+
+{caption:"Reaction test."}
+```miniscript
+print "Press any key to stop the count."
+print "See if you can stop on exactly 50! Get ready..."
+wait
+print "GO!"
+for i in range(1, 100)
+	if key.available then break
+	print i
+	wait 0.05
+end for
+key.clear
+diff = abs(i - 50)
+print "You stopped " + diff + " away from 50."
+if diff < 5 then print "Amazing!"
+```
+
+Save this program as "reactionTest", then try it a few times.  Notice how we're checking `key.available` within the loop, and when one is available (i.e. the user has pressed a key), we `break` out of the loop.  Then we use `key.clear` to clear out the keyboard buffer.  In fact, try taking that out, and see what happens!
+
+{i:"keyboard buffer"}
+The second way to detect key presses without waiting for them is to use `key.pressed`.  This function is quite different from the other key functions we've looked at so far.  The `key.available`, `key.get`, and `key.clear` functions all deal with the keyboard *buffer*, the set of printable characters (plus a few editing characters as discovered before) that the user has typed.  These can include modified keys like capital letters, $, or π, but they don't include the modifier keys themselves.  Also, when you hold a printable key down, it will be entered into the keyboard buffer multiple times, following the same key-repeat behavior you see when typing.  Basically, despite being in the "key" module, what these functions actually report is keyboard *input*, one character at a time.
+
+The `key.pressed` function is different.  It reports on the status (pressed or not pressed) of individual, physical keys on the keyboard.  That includes the left and right shift keys, the alt keys, the function keys, and so on.  It also includes the printable keys like letters and numbers, but not the shifted version of those; to `key.pressed`, shift-2 is just two keys being pressed, not the at-sign that `key.get` would report.
+
+To illustrate, here's a program that counts up only while the left Shift key is held.
+
+{caption:"Demonstration of key.pressed."}
+```miniscript
+print "Hold left shift to count up.  Press Esc to quit."
+x = 0
+while not key.pressed("escape")
+	if key.pressed("left shift") then
+		x = x + 1
+		print x
+	end if
+end while
+key.clear
+```
+
+We're actually using `key.pressed` twice in this program: once to break out of the infinite loop with the Escape key, and once to increment the count whenever the left shift key is held.  Notice how fast that count goes up!
+
+If you're interested in making games, or even interactive simulations, you'll probably be using `key.pressed` a lot.  It lets you detect the keys as soon as they're pressed, for as long as they're pressed.  It can even detect multiple keys at once, which is handy if you're using them to control a character running and jumping at the same time.
+
+What are these magic strings that you use with `key.pressed` to specify the key?  Well, you'll find them on the Mini Micro Cheat Sheet, as well as in the `key.keyNames` list (although that list is so long, it won't fit on one screen!).  But you should also be aware of the `inputCheck` demo in the `/sys/demo` directory.
+
+{i:"`/sys/demo`,`inputCheck`"}
+```terminal
+]cd "/sys/demo"
+]load "inputCheck"
+]run
+```
+
+When you run this, mash any keys or combinations of keys on your keyboard or game controller, and the corresponding key or axis names will appear on the screen.
+
+We haven't covered axes yet, but it's not too hard: `key.axis` returns a value from -1 to 1 for analog axes, like joystick inputs.  Mini Micro also gives you a Horizontal and a Vertical axis usable with the arrow keys and the WASD keys.  You can tell axis names from key names because axis names are capitalized, while key names are all lower case.
+
+## More on Files
+
+You just changed to the `/sys/demo` directory.  How do you get back to your files?  The same question would apply after you quit Mini Micro and relaunch it again later.  You'll soon get comfortable navigating your files, but for now just do:
+
+```terminal
+]cd
+]cd "learnToCode"
+```
+
+and then follow this with a `dir` to make sure you see your saved files.  Remember that the first `cd` above takes you to `/usr/`, your home directory on the user disk.  But you could have done it instead in a one-liner:
+
+```terminal
+]cd "/usr/learnToCode"
+```
+
+Because the path in this case starts with a slash, it is an *absolute* path, and will work no matter where you are.  Without an initial slash, it's a *relative* path, and starts in your current directory.
+
+## Minidisk Files and Folders
+
+For the last topic of this chapter, we're going to dig a little more into how your files are actually stored in the host operating system.  This section applies to desktop computers — Windows, Mac, and Linux.  If you're running Mini Micro on a tablet or phone, you can safely skip to the end.
+
+{i:"disk slot;minidisk file;disk file"}
+Mini Micro has two ways of storing its files.  First is a "minidisk file", or just a "disk file" within the context of Mini Micro.  Click on the top disk slot below the screen.  A menu should pop up that looks like this:
+
+{width:"70%"}
+![Disk slot menu.](DiskSlotMenu.png)
+
+{i:"`/usr`"}
+Try selecting the top option, "Unmount /usr".  Now use the `dir` command in the REPL.  Mini Micro will reply "Invalid path".  The "/usr" path references a disk file or folder mounted in the top disk slot, but we just unmounted (removed) that, so there are no files there to view.
+
+{i:"mount folder"}
+Click the top slot again, and this time pick "Mount Folder..."  A folder selection dialog appears, this time showing real files on your host (Windows, Mac, or Linux) computer.  Choose some folder in your home directory, perhaps something with some text or picture files in it.  Now use the `cd` command to make sure your working directory is set to `/usr/`, and use the `dir` command again.  You should see the contents of the folder you selected, presented in Mini Micro as a file listing.  You can use the `view` command to view any files with a suffix like `.txt`, `.png`, `.jpg`, or `.wav`.
+
+Moreover, if you used the `file` module (from Chapter 13) to create, delete, or alter files here in Mini Micro, you would see those changes reflected in File Explorer or Finder on your host operating system.  (So please be careful!)
+
+{i:"mount disk file"}
+Assuming that your previous user disk was a minidisk file, you can click the slot again and choose "Mount Disk File..." to remount it.  (If you have trouble finding it, just search your system for a file called `user.minidisk`, which is what Mini Micro calls it by default.)  Or you can use the "New Disk File..." command to create a new minidisk file with any name and location you choose.
+
+A minidisk file is, in fact, nothing more than a zip file — a standard way of bundling a bunch of files and folders up into a single file, usually smaller than the original files thanks to compression.  If you have a .minidisk file and want to convert it to into regular files, you can do so with this procedure:
+
+1. Rename the file so that it ends in .zip rather than .minidisk.
+2. Unzip it.  Exactly how you do this depends on your system; in Windows you would use the "Extract All" button, on Mac you would just double-click it, etc.
+
+Now you have an ordinary folder, which you could use with Mini Micro via that "Mount Folder..." command.  What if you want to go the other way — take a folder and turn it into a minidisk file?  That's easy too:
+
+1. Zip the folder.  On Mac, you right-click it and choose "Archive..."; on Windows you might need a third-party zip program.
+2. Rename the zip file so that it ends in .minidisk rather than .zip.
+
+And that's it.  Now you can mount this as a disk in Mini Micro using the "Mount Disk File..." command.
+
+Each way of representing files has its pros and cons.  A minidisk file is a nice way of keeping all the MiniScript files for a particular program or task together.  If you want to send somebody a copy of your program, along with all the images and sounds and other data it might need, a minidisk file is the most convenient way to do that.  You'll also use this format when you package your game or program for distribution on sites like itch.io.
+
+But mounting a folder is nice if you frequently want to access files both from Mini Micro and from the host OS.  For example, you might want to use a paint program like PhotoShop to edit the artwork for a game, or use powerful audio software for editing the sound files for a music program.  That's easier to do when Mini Micro simply mounts a folder on the host disk.
+
+Now that you know about these two formats, you can choose how you prefer to store your files.  Not sure?  Don't worry about it — you can always convert from one to the other later.
+
+{i:"`/usr2`"}
+Finally, it's worth pointing out that Mini Micro has *two* disk slots.  Any folder or disk file you mount in the second slot becomes available in Mini Micro as             `/usr2/`.  You probably won't need this at first, but someday you may have the need to load a second disk (or folder) of programs and data so that you can copy or compare to your main disk.
+
+A> **Chapter Review**
+A> - You experimented with the `key` module for reading the keyboard.
+A> - You practiced editing and saving programs in Mini Micro.
+A> - You learned about the two ways Mini Micro stores files on the host disk: as a disk file, and as a folder hierarchy, and how to convert between them.

data/day17.txt

@@ -0,0 +1,258 @@
+{chapterHead: "Day 17: Colors and Text", startingPageNum:201}
+
+{width: "50%"}
+![](Chapter17.svg)
+
+Q> Life is a series of building, testing, changing and iterating.
+Q>— Lauren Mosenthal (designer, researcher, & entrepreneur)
+
+A> **Chapter Objectives**
+A> - Learn how to specify and work with colors in Mini Micro.
+A> - Explore the `text` module and various ways of placing text on the screen.
+
+When you boot up Mini Micro, it looks a lot like a terminal window at first.  There is monospaced text and a blinking cursor.  Yesterday you learned some ways to go beyond standard terminal input/output, on the input side: ways to get a single character input or detect the state of all keys and buttons.  Today we're going to go beyond standard terminal output: ways to move the cursor, change the text and background colors, and manipulate individual cells of the text display.  All this will lead to more interactive, engaging programs that are as fun to use as they are to create.
+
+## Color in Mini Micro
+
+{i:"color;Mini Micro,colors in"}
+Colors in Mini Micro are represented as standard HTML (that is, web page) color strings, which look like this:
+
+{width:"50%"}
+![](ColorString.svg)
+
+The first character must be a hash (`#`), followed by two characters each for red, green, and blue.  The last two characters represent alpha (transparency), and are optional.  If not specified, the alpha will be assumed to be FF, which is fully opaque.
+
+Each pair of characters is a *hexadecimal* value from 00 to FF.
+
+{i:"hexadecimal"}
+D> The ordinary numbers everybody knows about are *decimal* numbers, with digits that go from 0 to 9.  The second digit from the right is the "tens place" and digits there are multiplied by 10, so that 42 really means 4 \* 10 + 2.  *Hexadecimal* numbers are similar, but instead of ten different digits, there are 16: 0 through 9 plus A through F.  A in hexadecimal is the same value as 10 in decimal; B is 11, and so on.  F (hex) is worth 15 (decimal).  So the largest possible 2-digit value, FF, is 15 \* 16 + 15 = 255 in decimal.
+
+PRINT>If all that about hexadecimal numbers seems confusing, don't worry about it; you don't really need to understand them to work with colors.  Mini Micro comes with a `color` module that has 20 standard colors defined, so you can just refer to them by name.  The table at the top of the next page lists them all.
+EBOOK>If all that about hexadecimal numbers seems confusing, don't worry about it; you don't really need to understand them to work with colors.  Mini Micro comes with a `color` module that has 20 standard colors defined, so you can just refer to them by name.  The table below lists them all.
+
+{colWidths:"50,100,50,100", caption:"Colors defined in the `color` module."}
+|Name|Value|Name|Value|
+|----|-----|----|-----|
+|aqua|#00FFFF|navy|#000080|
+|black|#000000|olive|#808000|
+|blue|#0000FF|orange|#FF8000|
+|brown|#996633|pink|#FF8080|
+|clear|#00000000|purple|#800080|
+|fuchsia|#FF00FF|red|#FF0000|
+|gray|#808080|silver|#C0C0C0|
+|green|#008000|teal|#008080|
+|lime|#00FF00|white|#FFFFFF|
+|maroon|#800000|yellow|#FFFF00|
+
+{gap:30}
+D> Want to see those colors in color?  Check the *Mini Micro Cheat Sheet*!  They are shown at the bottom of page 2.
+
+There are many uses for colors in Mini Micro, but for today, we're just going to use them to color text.  When you launch Mini Micro, it comes up with the color set to orange text on a black background, though you probably noticed that the welcome message used several other colors.  Time for you to learn how to do such tricks yourself!  Try this:
+
+```terminal
+]text.color = color.lime
+```
+
+As soon as you hit return, the `]` prompt and the blinking cursor appear a bright green.  Enter `dir` just to get a bit more text to display in your current color settings.
+
+Now perhaps that bright green is a bit too garish.  Let's tone it down:
+
+```terminal
+]text.color = color.green
+]dir
+```
+
+If you consult the color chart, you'll note that `color.lime` is `"#00FF00"`, while `color.green` is `"#008000"`.  Both of these have red and blue equal to zero, but different amounts of green; lime uses FF, while green uses 80.  Because FF is a bigger (hexadecimal) number than 80, it's a lot more green, and so a brighter color.
+
+Green on black is nice, but what if we reduced the contrast a bit more by coloring the background?
+
+```terminal
+]text.backColor = color.navy
+]dir
+```
+
+Notice that we assigned to `text.backColor` here rather than `text.color`.  You might have also noticed that changing this only changes the background color of subsequent printing, not text already printed, or areas that are not printed over in some way.  To clear the whole screen to your new text colors, just enter `clear`.
+
+PRINT>Take a few moments now to explore other color schemes.  Are there any you particularly like?  The figure below shows what my screen looked like after messing around for a while (at least, as well as we can show it in a black and white book).
+EBOOK>Take a few moments now to explore other color schemes.  Are there any you particularly like?  The figure below shows what my screen looked like after messing around for a while (though if you're reading this on a monochrome ebook reader, you will have to use some imagination).
+
+{width:"80%"}
+![Fun with text colors.](TextColors.png)
+
+
+In addition to the 20 standard colors, the `color` module contains a couple of helper functions.  One is the `color.rgb` function, which constructs a color given numeric values for red, green, and blue in the range 0 to 255.
+
+```terminal
+]text.color = rgb(255, 200, 100)
+```
+
+There's also a `color.rgba` function that does the same, but takes an alpha value, also in the range 0-255.  An alpha of 0 makes a color that is invisible because it is completely transparent; an alpha of 255 is fully opaque (non-transparent).  Intermediate values make colors that are translucent, i.e., you can see through them to some degree.  That's not terribly useful now because there is nothing in the background to see, but you'll have use for it later on, when you've learned to make use of Mini Micro's multiple display layers.
+
+{i:"`lerp`;linear interpolation;`color.lerp`"}
+The last color function we're going to talk about is `color.lerp`.   "Lerp" is a computer term that comes from "linear interpolate," which is just a fancy way to describe the mixing of two values.  `color.lerp` takes three parameters: *colorA*, *colorB*, and *t*, which is the interpolation value from 0 to 1.  The result will be a color that is fraction *t* of the way between *colorA* and *colorB*.
+
+A couple of examples will clear it up.  Suppose that `a` and `b` are colors.  Then `color.lerp(a, b, 0)` returns exactly the same thing as `a`.  We've gone 0% of the way from color `a` to color `b`.  If we did `color.lerp(a, b, 0.5)`, then we'd get a color exactly halfway between `a` and `b`.  And of course `color.lerp(a, b, 1)` would return color `b`.
+
+We can use this to generate a bunch of colors in between two others in a loop.  Try this:
+
+```terminal
+]for t in range(0, 1, 0.05)
+...]text.backColor = color.lerp(color.red, color.blue, t)
+...]print "     "
+...]end for
+```
+
+PRINT>Here we've made a simple `for` loop that goes from 0 to 1 in increments of 0.05, and then use that value to lerp between red and blue.  For each one, we set the text background color and print and handful of spaces so we can see it.  (I can't effectively show the result in a black and white book, so please try it yourself!)
+EBOOK>Here we've made a simple `for` loop that goes from 0 to 1 in increments of 0.05, and then use that value to lerp between red and blue.  For each one, we set the text background color and print and handful of spaces so we can see it.  (Words can't do this justice; please try it!)
+
+
+There's one more trick you should know about colors, and that is the color picker in the Mini Micro code editor.  Enter `edit` to launch the editor, type `text.color =`, and then pause.  Use the mouse to click on the code wizard button, which looks like a magic wand glowing above a little document icon.  A menu should drop down from the button; select "Insert Color..." and the color picker will appear.
+
+![Color picker in the Mini Micro code editor.](ColorPicker.png)
+
+Here you can adjust the red, green, blue, and alpha values by using the sliders or by typing in values.  You can also select one of the standard colors by clicking on the little color boxes below.  A large color preview is shown against a checkered background, so you can see what effect the alpha channel has.  Once you've found a color you like, click the Insert button to insert the color value into your code.
+
+## The Text Display
+
+So far we've just been using `print` and `input` to manipulate the text on the display, just like a terminal or even the Try-It! web page.  You may have also caught `clear` for clearing the screen.   Now we're going to learn some more advanced ways to put text on the Mini Micro screen.
+
+The Mini Micro text display uses a friendly, monospaced font arranged in a grid of 26 rows by 68 columns.  Columns are numbered starting on the left, and like many things in computers, they begin at 0 with the leftmost column.  The rightmost column is column 67.  Rows start at the bottom of the screen with 0, and proceed up to row 25 at the top of the screen.
+
+![Mini Micro text display: 26 rows of 68 columns each.](TextDisplay.png)
+
+In terms of pixels, each cell is 16 pixels wide and 24 pixels tall, but they overlap horizontally by 2 pixels.  So effectively, you can think of the text cells as 14 by 24 pixels in size.  (You don't really need to worry about pixel coordinates yet, but we will start thinking about such things soon when we get into pixel graphics.)
+
+The text display has the concept of a cursor, which is where any printing goes.  You've seen this already: it's the blinking block that shows you where you can type.  But the cursor is only visible when it's waiting for input.  At other times, it's invisible, but it's still there — and the output of any `print` statement goes wherever that cursor is.  You can control where the cursor is by setting the `text.row` and `text.column` properties.  Try this (either via `edit`, or just typed into the REPL):
+
+```miniscript
+for row in range(20, 5)
+	text.row = row
+	text.column = 10 + row*2
+	print "Hello world!"
+end for
+```
+
+You already used `text.color` and `text.backColor` in the previous section, and now you've done something similar with `row` and `column`.  As you've surely noticed, there is a `text` module much like the `key` module.  It's actually *slightly* different, because Mini Micro can have not just one, but up to eight different text display layers, as you'll see in a couple of days.  But one of these is always the "default" text display, which handles `print` and `input`, and `text` is a reference to that.  So it's perfectly fine to think of `text` as just a module of text-related functionality.
+
+{i:"Mini Micro, `text` module;`text` module;text properties"
+{caption:"Properties that can be read or assigned to in the `text` module."}
+| `text.color` | foreground (text) color of subsequent printing |
+| `text.backColor` | background color of subsequent printing |
+| `text.column` | cursor column (0-67) |
+| `text.row` |  cursor row (0-25) |
+| `text.inverse` | boolean: when true, foreground and background colors are swapped |
+| `text.delimiter` | string to follow the text of every `print`; by default, `char(13)` |
+
+PRINT>Some of that functionality is in the form of properties you can both read, and assign new values to, like we did with `text.row` and `text.column` above.  The full set of these text properties is shown in the table on the previous page.
+EBOOK>Some of that functionality is in the form of properties you can both read, and assign new values to, like we did with `text.row` and `text.column` above.  The full set of these text properties is shown in the table above.
+
+But the `text` module also contains functions, like the `key` module did yesterday.  You never assign new values to these; you just call them and pass in any parameters they need.  Here is the list of those functions.
+
+{caption:"Functions in the `text` module.", colWidths:"150,*"}
+| `text.clear` | clear the display using the current foreground and background colors |
+| `text.cell(x, y)` | get the character displayed at column *x*, row *y* |
+| `text.setCell x, y, s` | set the character displayed at column *x*, row *y* to *s* |
+| `text.cellColor(x, y)` | get the foreground character at column *x*, row *y* |
+| `text.setCellColor x, y, c` | set the foreground color at column *x*, row *y* to *c* |
+| `text.cellBackColor(x, y)` | get the background character at column *x*, row *y* |
+| `text.setCellBackColor x, y, c` | set the background color at column *x*, row *y* to *c* |
+| `text.print s` | print *s* to this display starting at `text.column`, `text.row` |
+
+As usual, you should not try to memorize these!  Just skim them so you have some idea of what's available, and then look them up (here, or on the Mini Micro Cheat Sheet) when you need them.
+
+{i:"`text.inverse`"}
+The `text.inverse` property is a switch that causes the foreground and background colors to be swapped on subsequent output.  Try it: just enter `text.inverse = true` at the Mini Micro prompt.  Maybe follow it with `dir`, or `print` something, so you can really see the effect.  Do `text.inverse = false` to turn it back off.
+
+{i:"`text.delimeter`;`print`"}
+The last text property to consider is `text.delimiter`.  This is a special string that is added to the console after every `print` statement.  Try this:
+
+```terminal
+]print 1; print 2; print 3
+1
+2
+3
+```
+
+We're just putting three `print` statements on one line, joining them with semicolons.  You can see that each number appears on its own line.  But now enter `text.delimiter="*"`, and then repeat the previous command.  (Remember to user the up-arrow key to save yourself some typing!)
+
+```terminal
+]text.delimiter="*"
+]print 1; print 2; print 3
+1*2*3*
+```
+
+The difference this time is that all the output appears on one line, but after each number is an asterisk (the value you assigned to `text.delimiter`).  To restore the standard behavior, do `text.delimiter=char(13)`.  To understand that, first recall that the `char` intrinsic function returns a character (string) defined by its numeric Unicode value.  For example, `char(65)` is capital letter "A".  Unicode values less than 32 are called *control characters*, and are generally not printable, but instead cause special things to happen.
+
+{i:"line break"}
+`char(13)`, in particular, is a line break.  It causes the text cursor to go to the column 0 of the next line.  If the cursor was already on row 0, then it scrolls the whole text display up (i.e. moves everything up by one line), and then puts the cursor at the start of row 0.
+
+D> There are a couple other useful control characters, and a whole host of character codes that produce special glyphs in Mini Micro.  To learn these, run `/sys/demo/specialChars.ms`.
+
+
+Changing `text.delimiter` to the empty string (that is, `""`) is handy when you need to print something, do some extended calculations, and then print something else, all on the same line.  It's even more handy when you want to print something on row 0 without scrolling the screen.
+
+That covers all the `text` properties.  As for the functions, `text.clear` does almost the same thing as the `clear` method you already know, though it applies only to the text display (and not to the graphical displays you'll learn about soon).  The other text functions all have to do with getting or setting the data in a particular cell on the display.  Each cell contains three pieces of data:
+
+
+|Data|How to get it|How to change it|
+|----|-------------|----------------|
+|the text character displayed|`text.cell`|`text.setCell`|
+|the text color|`text.cellColor`|`text.setCellColor`|
+|the background color|`text.cellBackColor`|`text.setCellBackColor`|
+
+You use all these methods with parameters that specify the column and row of interest.  For example, try this:
+
+```terminal
+]clear
+]print "Neat?"
+Neat!
+]print text.cell(4, 24)
+?
+]text.setCell 4, 24, "!"
+```
+
+In this way, you can read or set the contents (or colors) of any cell on the screen.  Many classic games, like *Rogue* and *Dwarf Fortress*, use exactly this sort of technique to draw 2D games using only a text display.  In Mini Micro, the need for this is reduced, since it has powerful graphics capabilities you'll learn by the end of this book.  But the ability to do advanced text-based user interfaces is there if you need it.
+
+
+## ASCII Bear
+
+{i:"ASCII art"}
+To celebrate your new understanding of the text displays and color, here's a program that creates an adorable little bear using "ASCII art" (artwork made only with standard letters, numbers, and punctuation).  Type carefully!
+
+```miniscript
+text.color = color.black
+text.backColor = color.white
+clear
+print "    _     _"
+print "   (c).-.(c)"
+print "    / ._. \"
+print "  __\( Y )/__"
+print " (_.-/'-'\-._)"
+print "    || x ||"
+print "  _.' `-' '._"
+print " (.-./`-~\.-.)"
+print "  `-'     `-'"
+text.setCellColor 7, 20, color.gray // belly button
+text.setCellColor 6, 23, color.blue // left eye
+text.setCellColor 8, 23, color.blue // right eye
+```
+Feel free to tweak this and improve it if you can!
+
+
+## Exploring the Demos
+
+{i:"`/sys/demo`,`theMatrix`;`/sys/demo`,`forestFire`"}
+There are several demos in `/sys/demo/` that you are better equipped to understand now.  `theMatrix.ms` demonstrates direct manipulation of the text display.  The logic for managing all those dropping columns of characters is a little complex, but see if you can find where the characters and colors are poked onto the screen with text.setCell and text.setCellColor.  Slightly simpler is the `forestFire.ms` program, which simulates a forest fire entirely on the text display.
+
+{i:"`/sys/demo`,`typing`"}
+There's a typing game called `typing.ms` that also uses the text display.  Right near the top of the program, you'll find a `printAt` function that uses the things you learned today to print things exactly where they should appear on screen.
+
+{i:"`/sys/demo`,`therapist`;`/sys/demo`,`textAdventure`;`/sys/demo`,`acey-deucey`"}
+Finally, several of the other demos are primarily text-based, but don't do anything too fancy with the display.  The `therapist`, `textAdventure`, and `acey-deucey` programs all fall into this category.
+
+
+A> **Chapter Review**
+A> - You learned how to represent colors in Mini Micro using HTML color syntax.
+A> - You found the `color` module with 20 built-in colors, plus several handy functions.
+A> - You explored the `text` module, and its several properties and methods that let you display (or read) text anywhere on the screen, in any colors you like.
+

data/day18.txt

@@ -0,0 +1,282 @@
+{chapterHead: "Day 18: Pixel Graphics", startingPageNum:213}
+
+{width: "50%"}
+![](Chapter18.svg)
+
+Q> The future belongs to those who believe in the beauty of their dreams.
+Q>— Eleanor Roosevelt (First Lady and activist, 1884-1962)
+
+A> **Chapter Objectives**
+A> - Learn about the graphics display and the `gfx` module.
+A> - Read and write individual pixels on the display.
+A> - Learn to draw lines, rectangles, polygons, strings, and images.
+
+Today is a very special day.  For the first 17 chapters of this book — and perhaps your entire programming career up till now — your programs have been built around strings of text.  Strings come in, strings go out.  In the last chapter we got a little fancy about how and where the strings go out, but still, it was all just text on the screen.
+
+Today that changes forever.
+
+As of today, you are no longer limited to creating text.  Today you learn to create *graphics*: pictures composed of tiny pixels!  Of course if you ran the demos in     `/sys/demo`, or have played any Mini Micro games on the web, then you already know what that looks like.  So let's jump right in with a short program.  Type this in and see what it does:
+
+{caption:"Our first graphics program."}
+```miniscript
+clear
+gfx.clear color.white
+gfx.color = color.gray
+for x in range(0, 960, 64)
+	gfx.line x, 0, x, 640
+	gfx.print x, x,0
+end for
+for y in range(0, 640, 64)
+	gfx.line 0, y, 960, y
+	gfx.print y, 0,y
+end for
+key.get  // wait for a keypress
+```
+
+The first line clears the screen, and the last line waits for a keypress; you already know about these.  The rest of the program uses the built-in `gfx` global, which is new.  This is pronounced "graphics," and it is a reference to Mini Micro's pixel display, in the same way that `text` is a reference to the text display.  For brevity, we'll just refer to "the `gfx` module" in this chapter.
+
+{width:"75%"}
+![Mini Micro pixel display: 960 pixels wide, 640 pixels high.](PixelDisplay.svg)
+
+When you run that program, it should draw a grid with the X (horizontal) and Y (vertical) values listed every 64 pixels.
+
+As you can see, the graphics display is 960 pixels across horizontally, and 640 pixels vertically.  Just as with the text display, 0,0 is the lower-left corner of the screen; X values increase to the right, and Y values increase towards the top.
+
+In this program you used one graphics property, `gfx.color`, as well as three methods: `gfx.clear`, `gfx.line`, and `gfx.print`.  There are a few more graphics properties:
+
+{i:"Mini Micro, `gfx` module;`gfx` module;graphics properties"}
+{caption:"Properties in the `gfx` module.  `width` and `height` are read-only; the others can be assigned new values."}
+| `gfx.color` | default color for subsequent drawing |
+| `gfx.width` | width of the graphics display, in pixels |
+| `gfx.height` | height of the graphics display, in pixels |
+| `gfx.scrollX` | horizontal scroll position, in pixels |
+| `gfx.scrollY` | vertical scroll position, in pixels |
+| `gfx.scale` | scale factor, or [hScale, vScale] factors |
+
+EBOOK>Functions in the `gfx` module are listed below.  You've already used `gfx.clear`, which has three optional parameters: color, width, and height.  The color parameter (listed as `c` in the table) defaults in this case to `color.black`, while `width` and `height` default to 960 and 640, respectively.  We'll get into why you might use different values for these later.
+
+{caption:"Functions in the `gfx` module.  Parameters: `points` is a list; `c` is a color; `s` and `font` are strings; `img` is an Image; all other parameters are numbers measured in pixels.  All parameters have default values; in particular, color, pen size, and font parameters are usually omitted.", colWidths:"200,*"}
+| `gfx.clear c, width, height` | clear and resize the graphics display |
+| `gfx.pixel(x, y)` | get the color of pixel at *x*, row *y* |
+| `gfx.setPixel x, y, c` | set the color of pixel at *x*, row *y* to *c* |
+| `gfx.line x1, y1, x2, y2, c, penSize` | draw a line |
+| `gfx.drawRect left, bottom, width, height, c, penSize` | outline a rectangle |
+| `gfx.fillRect left, bottom, width, height, c` | fill a rectangle |
+| `gfx.drawEllipse left, bottom, width, height, c, penSize` | outline an ellipse |
+| `gfx.fillEllipse left, bottom, width, height, c` | fill an ellipse |
+| `gfx.drawPoly points, c, penSize` | outline a polygon |
+| `gfx.fillPoly points, c` | fill a polygon |
+| `gfx.print s, x, y, c, font` | draw string `s` in the given font |
+| `gfx.drawImage img, left, bottom, width, height, srcLeft, srcBottom, srcWidth, srcHeight` | draw an Image (or a rectangular portion of an image) |
+| `gfx.getImage(left, bottom, width, height)` | get a portion of the display as an Image |
+
+PRINT>Functions in the `gfx` module are listed on the next page.  You've already used `gfx.clear`, which has three optional parameters: color, width, and height.  The color parameter (listed as `c` in the table) defaults in this case to `color.black`, while `width` and `height` default to 960 and 640, respectively.  We'll get into why you might use different values for these later.
+
+## Getting and Setting Pixels
+
+Just as you can read or change individual cells of the text display with methods like `text.cell`, you can get and set individual pixels of the graphics display with the `gfx.pixel` and `gfx.setPixel` methods.  The program listed on the next page is a quick demo that randomly changes pixels from black to gray, and from gray to aqua.  As always, I recommend you type it and and try it out.
+
+There is one important trick to note on line 5 of this program.  Recall that colors are represented as a string containing a hash symbol, plus two digits each for red, green, blue, and *optionally* alpha.  The predefined color strings like `color.black` and `color.aqua` do not include the alpha characters (with the exception of `color.clear`, which needs them).  But whenever you get the color of a pixel with `gfx.pixel`, it includes the alpha, even if the pixel is fully opaque.
+
+{caption:"Pixel fog."}
+```miniscript
+gfx.clear
+while true
+	x = 960 * rnd
+	y = 640 * rnd
+	c = gfx.pixel(x, y)[:7]  // (ignore alpha)
+	if c == color.black then
+		gfx.setPixel x, y, color.gray
+	else
+		gfx.setPixel x, y, color.aqua
+	end if
+end while
+```
+
+Let's poke at this with the REPL to make sure it's clear.  If the program above is still running, hit control-C to stop it, then try the following.
+
+```terminal
+]color.red
+#FF0000
+]gfx.setPixel 200,200, color.red
+]gfx.pixel(200,200)
+#FF0000FF
+```
+
+So `color.red` is defined as "#FF0000": full red, and zero green and blue.  Alpha is not included in this string, because alpha is optional when it would be equal to FF (fully opaque).  But when we store this color as a pixel and then read it back out, we get the full color string including alpha, "#FF0000FF".  This is equivalent to the color we put in, but simple string comparison would say they are different.
+
+The solution is as shown in the example above: when you don't care about alpha, just truncate the color you get back to 7 characters.
+
+```terminal
+]gfx.pixel(200,200)[:7]
+#FF0000
+```
+
+Now you can compare this to other 7-character color strings with no problem.
+
+## Drawing Lines, Rectangles, and Ellipses
+
+Next up, let's look at some of the figure drawing routines.  All of these have an optional `color` parameter, which defaults to whatever color you set on `gfx.color`; and `penSize`, which defaults to one.  Try this at the prompt:
+
+```terminal
+]gfx.color = color.green
+]gfx.line 200,100, 500,540
+```
+
+This sets the default drawing color to green, then draws a line from X=200, Y=0 (i.e. a point at the bottom of the screen, 200 pixels from the left edge) to X=500, Y=640 (a point at the top of the screen, 500 pixels from the left).  Now use the up-arrow to recall that last command, but specify a different color:
+
+```terminal
+]gfx.line 200,100, 500,540, color.yellow
+```
+
+The line turns yellow.  Now let's try one more variation, specifying a pen size of 20:
+
+```terminal
+]gfx.line 200,100, 500,540, color.yellow, 20
+```
+
+The first two commands produced a very thin line, but this produces a fat, chunky line with square ends.  Let's use this to make a "screen saver" that endlessly fills the screen with random lines!
+
+{caption:"Random-lines screen saver."}
+```miniscript
+while true
+	c = color.rgb(255*rnd, 255*rnd, 255*rnd)
+	pen = 1 + rnd*20
+	gfx.line 960*rnd,640*rnd, 960*rnd,640*rnd, c, pen
+end while
+```
+
+Drawing the outline of a rectangle or ellipse is very similar, but the third and fourth parameters are the width and height of the figure, rather than the other end of a line.  The first two parameters are the position of the bottom-left corner (since Mini Micro always measures things from the bottom left).  Just keep saying "left, bottom, width, height" to yourself as you type these!  Try it:
+
+```terminal
+]gfx.drawRect 200,100, 300,80
+]gfx.drawRect 200,100, 300,80, color.lime
+]gfx.drawEllipse 200,100, 300,80, color.orange, 20
+```
+
+{width:"75%"}
+![Noodling around with `gfx.drawRect` and `gfx.drawEllipse`.](drawRectEllipse.png)
+
+But a rectangle or ellipse can also be filled rather than outlined.  In this case there is no `penSize` parameter.  Type the next one in on the REPL, line by line, to see a surprise.
+
+{caption:"Sometimes, when you stare at the computer long enough... the computer stares back."}
+```terminal
+]gfx.clear
+]gfx.fillRect 200,100, 400,500, color.brown
+]gfx.fillEllipse 250,400, 150,50, color.white
+]gfx.fillEllipse 400,400, 150,50, color.white
+]gfx.fillEllipse 455,410, 40,40, color.blue
+]gfx.fillEllipse 305,410, 40,40, color.blue
+]gfx.fillRect 300,250, 200,20, color.red
+]text.clear
+```
+
+
+If your eyes glaze over when you see so many numbers, don't worry.  It's actually not very common to write code like this; usually if you need a picture, you would just load a picture from disk (as we'll see later in this chapter).  More often when you're using drawing commands like these, the coordinates are computed from other values, for example when drawing a bar chart.  But you already know how to do math; and now you know how to draw too, so when that need arises, you'll be all set.
+
+## Drawing Polygons
+
+{i:"polygons"}
+Mini Micro can also draw polygons of three or more sides, and by "draw" we mean either outline or fill, just like rectangles and ellipses.  But polygons are a little trickier to specify, since they can include any number of points.  Mini Micro solves this by using a list of points.  Each element of the list can be itself an [x,y] list specifying the location of one point.
+
+```terminal
+]gfx.clear
+]gfx.drawPoly [[100,100], [200,300], [300,100]]
+]gfx.drawPoly [[100,100], [200,300], [300,100]], color.red
+]gfx.drawPoly [[100,100], [200,300], [300,100]], color.red, 10
+]gfx.fillPoly [[100,100], [200,300], [300,100]], color.blue
+```
+
+As an alternative, each point can be a little map containing "x" and "y" values.  This is mostly useful when working with other things that already have coordinates in this form, like the mouse pointer or sprites (all things we'll get to later).  For now, let's just prove that it works:
+
+```terminal
+]clear
+]gfx.drawPoly [{"x":100,"y":100}, {"x":200,"y":300}, {"x":300,"y":100}]
+```
+
+D> Note that this line of code does not quite fit on one line on the screen.  That's OK; just keep typing, and don't let it worry you when it wraps to the next line!
+
+## Drawing Text
+
+Sure, you already know how to print text to the text display.  But it turns out you can also draw text to the graphics display, and it's more flexible in two ways.  First, you can draw the text anywhere you like, rather than only in predefined rows and columns.  Second, you can draw it in a smaller or larger font, in addition to the standard font size.  All this is done with the `gfx.print` method.  Explore:
+
+```terminal
+]@gfx.print
+FUNCTION(self, str, x=0, y=0, color, fontName="normal")
+]gfx.print "Hello world!", 600, 400
+]gfx.print "Hello world!", 600, 350, color.aqua
+]gfx.print "Hello world!", 600, 300, color.aqua, "small"
+]gfx.print "Hello world!", 600, 250, color.aqua, "large"
+```
+
+That first line above displays the parameter list of the `gfx.print` function.  This is a handy trick that works with any function.
+
+D> If you remember the name of a function but need to review its parameters, enter an at sign (@) followed by the function name.  The REPL will display the parameter names and default values.
+
+The rest of the above example draws our classic greeting in various colors and sizes.
+
+{width:"75%"}
+![Hello, world!  (Now in a graphics display).](gfxPrint.png)
+
+Of course there are costs to the increased flexibility of drawing text with `gfx`: it is substantially slower than using `text`, you can't easily change the text once it's drawn, and you certainly can't read the text back from the display, as it's just a bunch of pixels.
+
+## Working with Images
+
+There are only a couple more methods left on the `gfx` module: `gfx.drawImage` and `gfx.getImage`.  But to understand them, we first need to cover the Image class.
+
+{i:"`Image`;Mini Micro, `Image` class;pictures, in Mini Micro"}
+`Image` is a class built into Mini Micro for representing pictures.  Images are usually loaded from disk, but they can also be built pixel by pixel from scratch, or plucked right out of a graphics display.  Once you have an image, you can either draw it directly to a graphics display, or (as we'll see in Chapter 22) turn it into a sprite that can be moved around very efficiently.
+
+Let's jump in with an example first, and then we'll go over the details.
+
+```terminal
+]img = file.loadImage("/sys/pics/Mochi.png")
+]gfx.drawImage img, 0, 0
+]gfx.drawImage img, 120, 0, img.width*6, img.height*6
+```
+
+{gap:20}
+{width:"50%"}
+![Small mochi, big mochi.](drawImage.png)
+
+
+All the `file` methods you learned in Chapter 13 still apply in Mini Micro.  But in Mini Micro there are a couple of additional functions, including `file.loadImage`, which simply returns an image from the given file path.
+
+The following table shows the properties and methods of the `Image` class.
+
+{caption:"Image properties (all read-only) and methods.", colWidths:"150,*"}
+| `img.width` | get the image width, in pixels |
+| `img.height` | get the image height, in pixels |
+| `img.pixel(x, y)` | get the color of pixel at *x*, row *y* |
+| `img.setPixel x, y, c` | set the color of pixel at *x*, row *y* to *c* |
+| `img.getImage(left, bottom, width, height)` | get a portion of the image as a new Image |
+| `Image.create(width, height, c)` | create a new image filled with color c |
+
+
+
+The identifier `Image` is capitalized because, unlike `color`, `text`, and `graphics`, you are expected to be working with an *instance* of this class, rather than calling methods on `Image` itself.  The one exception is `Image.create`, which is the method for creating an image from scratch.  So in the table above, we use `img` to stand in for any `Image` instance, like the one we got from `file.loadImage` in the example above.
+
+Now you know all the methods available on the Image class, but honestly, you will almost never use any of them.  The typical pattern is to load an image from disk, and then draw it to the screen, just as we did above.  Rarely do you need to modify the content of an image, but it's nice to know that you can.
+
+Getting back to the `gfx` module, `gfx.drawImage` takes more parameters than anything else in the Mini Micro API — a total of nine!  But you can think of it as: the image to draw, the area to draw it in, and the area of the image to use.  These let you basically take any rectangular portion of the source image, and stretch or squash it into ane rectangular area of the graphics display.  All the parameters except the image are optional.  If you leave off the last four, the source area, then the entire image will be used.  And if you leave off the *width* and *height* parameters, it will be drawn without any stretching or squashing.
+
+To illustrate, follow the example above with one more try that uses all nine parameters to draw just the mochi's smile, super-sized:
+
+```terminal
+]gfx.drawImage img, 0,0,500,100, 52,14,20,10
+```
+This grabs the rectangular area of the image with a bottom-left corner of 52,14, a width of 20, and a height of 10; and draws it onto the screen with its bottom-left corner at 0,0, and a stretched-out size of 500 wide by 100 tall.
+
+## Exploring the Demos
+
+{i:"`/sys/demo`,`sunset`"}
+Of the demos in `/sys/demo`, the `sunset.ms` program is the best one to review at this point.  It uses only the functions you've seen here to make a lovely picture, with details that are slightly different every time.  The `stars.ms` demo is also good, although it's so simple, you may find it too easy!
+
+{i:"turtle graphics;`/sys/demo`,`turtleDemo`"}
+The other drawing demo is `turtleDemo.ms`.  This uses a trick you'll learn more about tomorrow: `import`.  The `import` function lets you load some code from another file — in this case, a "turtle" module that provides for a very different approach to drawing called *turtle graphics*.  The basic idea here is that there is a little turtle on the screen that can be told to move and turn while drawing a line.  Go ahead and play with this demo;  just keep in mind that those turtle methods are not built into Mini Micro, but instead are only available after importing the turtle module.  (We'll explain more about `import` in the next chapter.)
+
+A> **Chapter Review**
+A> - You explored the Mini Micro pixel display, accessed via `gfx`.
+A> - You learned how to get and set individual pixels, as well as how to draw lines, rectangles, ellipses, and polygons.
+A> - You drew text in three different sizes and in various colors.
+A> - You learned about the Image class, including how to load an image from disk and draw it (in whole or in part) to the screen.

data/day19.txt

@@ -0,0 +1,346 @@
+{chapterHead: "Day 19: Display Layers, Mouse, and Import", startingPageNum:225}
+
+{width: "50%"}
+![](Chapter19.svg)
+
+
+Q> In some ways, programming is like painting. You start with a blank canvas and certain basic raw materials. You use a combination of science, art, and craft to determine what to do with them.
+Q>— Andrew Hunt (software developer and author)
+
+A> **Chapter Objectives**
+A> - Learn about the 8-layer display system in Mini Micro.
+A> - Discover how to get the position of the mouse cursor and the state of its buttons.
+A> - Learn how to use `import` to load extra functionality into your program.
+
+PRINT>You've learned how to draw to the default graphics display with `gfx`, and how to print text to the screen with `text`.  But it turns out that the Mini Micro display system is more sophisticated than this.  It actually consists of eight layers, any of which can be set to any display mode.  The available display modes are shown in the table on the next page.
+EBOOK>You've learned how to draw to the default graphics display with `gfx`, and how to print text to the screen with `text`.  But it turns out that the Mini Micro display system is more sophisticated than this.  It actually consists of eight layers, any of which can be set to any display mode.  The available display modes are shown in the table below.
+
+{i:"display modes", "Mini Micro, display modes"}
+| 0 | off | no display |
+| 1 | solid color | displays one color over the whole screen |
+| 2 | text | 26 row, 68 column text display |
+| 3 | pixel | 960 by 640 (by default) pixel display |
+| 4 | tile | displays a rectangular grid of small images |
+| 5 | sprite | displays a set of scaleable, rotatable, resizable images |
+
+{pageBreak}
+The layers are numbered from 0 to 7, and stacked up with 0 in the front, and 7 in the back.  Display layers that are off, or have any transparent areas, let you see through to the next layer behind it, and so on all the way to the back.  (If all layers are off or see-through, the screen appears black.)
+
+When you start up Mini Micro, or use the `clear` command, the display layers are set up like this:
+
+{width:"75%"}
+![Default display modes.  (Displays without a label are off).](DisplayDiagram.png)
+
+So in the standard configuration, displays 0, 1, and 2 are off; 3 is text; 4 is sprites (which we'll learn about in a few days); 5 is pixel graphics; 6 is off; and 7 is a solid color (black).  You might have noticed yesterday that when you have overlapping pixel graphics and text on the screen, the text appears on top of the pixel graphics.  Now you can see why: the text is in display 3, which is layered in front of the graphics layer in display 5.
+
+But this is only the default configuration; as a programmer, you can change this however you like!  The eight display layers can be set to any configuration, including multiple displays of the same type if desired.  Let's prove it!  Try this:
+
+{caption:"Filling all 8 displays with random text."}
+```miniscript
+for layer in range(7, 0)
+	// set the layer to text mode, with a random text color
+	display(layer).mode = displayMode.text
+	display(layer).color = rgb(255*rnd, 255*rnd, 255*rnd)
+	display(layer).clear
+	// fill it with random characters
+	for row in range(0,25)
+		for col in range(0,67)
+			c = char(32 + rnd*64)
+			display(layer).setCell col, row, c
+		end for
+	end for
+	wait
+end for
+```
+
+Run this, and it should make an absolute mess of your Mini Micro screen.  Don't worry; entering `clear` will of course clean it up!  Each of the eight layers is set to text mode, and then filled with random text.  By the end, every text position on the screen contains eight overlapping characters.
+
+This program introduces several new things you can use in your own programs:
+
+- `displayMode`, which is a built-in map that lets you refer to the different display modes by name, for example `displayMode.text`, `displayMode.pixel`, and `displayMode.solidColor`.  These simply map to the mode numbers (0-5) shown in the table on the previous page.
+- `display(num)`, a function that returns a reference to the display object for the given layer number (0-7).
+- `mode`, a property on every display class that controls what mode that layer is.
+
+So in the listing above, line 3 uses the `display` function to get a reference to one of the layers (using the `layer` variable from the `for` loop); and then it changes it to text mode by assigning `displayMode.text` to its `.mode` property.
+
+Let's use the REPL to do this step by step.  Start by resetting your displays:
+
+```terminal
+]clear
+]text.color = color.orange
+```
+
+After the `clear` call, display 3 is text and display 2 is off.  Let's change display 2 so that it is *also* text, and print some overlapping text.
+
+```terminal
+]display(2).mode = displayMode.text
+```
+
+As soon as you enter this line, all that random text that was created from the program before suddenly appears!  The `clear` command turns display 2 off, but it does not actually clear the underlying text display.  So we'll do that next, and then set the color, and print some dashes on line 10.
+
+```terminal
+]display(2).clear
+]display(2).color = color.green
+]display(2).row = 10; display(2).print "-----"
+```
+
+Those dashes appear in display 2, which is in front of the default `text` display (3).  So now let's print some text behind the dashes:
+
+```terminal
+]text.row = 10; text.print "DONE!"
+```
+
+Below is a handy function to list what the current display types are.
+
+{caption:"Function to list the current mode of all eight display layers."}
+```miniscript
+dispDump = function()
+	for layer in range(0,7)
+		d = display(layer)
+		print layer + ". " + displayMode.str(d.mode)
+	end for
+end function
+
+dispDump
+```
+
+This uses the `displayMode.str` function to convert a mode number back into a string (basically doing the same thing as `displayMode.indexOf` in this case).  The `for` loop here has been wrapped in a function so that, once you've run this code, you can just call `dispDump` at any time to see how your displays are arranged.
+
+Before we move on, let's create a couple of functions to do a fade-out or fade-in effect.  This will work by setting the frontmost display (layer 0) to solid color, and then using a loop to gradually change that from clear to black or vice versa.  This acts like a sort of stage curtain, covering or revealing the other seven layers.
+
+{caption:"Display fade-out and fade-in functions."}
+{i:"fade out"}
+```miniscript
+// fade a black curtain from alpha0 to alpha1
+// (where 0 means clear and 1 means solid black)
+// over `duration` seconds.
+fade = function(alpha0, alpha1, duration=1)
+	// set the frontmost display to solid color
+	display(0).mode = displayMode.solidColor
+	t0 = time   // note the time
+	while true  // loop until done
+		t = (time - t0) / duration  // fraction done
+		if t > 1 then break  // done when t > 1
+		a = alpha0 + (alpha1 - alpha0) * t
+		display(0).color = color.rgba(0,0,0,a)
+		yield  // wait till next display frame
+	end while
+	display(0).color = color.rgba(0,0,0,alpha1)
+end function
+
+// fade to black over `duration` seconds
+fadeOut = function(duration=1)
+	fade 0, 255, duration
+end function
+
+// fade from black to clear over `duration` seconds
+fadeIn = function(duration=1)
+	fade 255, 0, duration
+	display(0).mode = displayMode.off
+end function
+```
+
+Notice how the `fadeOut` and `fadeIn` functions do very little work themselves, instead calling a `fade` function that does all the heavy lifting.  This follows the DRY (Don't Repeat Yourself) principle from Chapter 11; without this helper function, `fadeIn` and `fadeOut` would be almost identical.
+
+After running the above code to define the functions, try them out with:
+
+```terminal
+]fadeOut; key.get; fadeIn
+```
+
+Neat, huh?  You can use these functions any time you need a dramatic fade to black in your own programs.
+
+## Reading the Mouse
+
+Let's turn now to a different topic: detecting where the mouse cursor is, and the state of the buttons.  This is a very useful thing to do, since it lets us go beyond keyboard input and make programs that can be controlled with a mouse (or track pad or touch screen!).
+
+{i:"`mouse` module;Mini Micro, `mouse` module"}
+This is done in Mini Micro with a very simple built-in module called `mouse`.  It has two read-only properties, one read/write property, and one function:
+
+{i:"Mini Micro, `gfx` module;`gfx` module;graphics properties"}
+{caption:"Properties and function in the `mouse` module.  `x` and `y` are read-only; `visible` can be assigned true or false."}
+| `mouse.x` | horizontal position of the mouse pointer (0-959) |
+| `mouse.y` | vertical position of the mouse pointer (0-639) |
+| `mouse.visible` | true if mouse cursor can be seen; false if hidden |
+| `mouse.button(which=0)` | true when the given button is pressed |
+
+To start exploring the `mouse` module, position the mouse somewhere over the Mini Micro screen, and simply enter `mouse` at the prompt.  You'll see something like this:
+
+```terminal
+]mouse
+{"x": 417, "y": 166, "button": FUNCTION(which=0), "visible": FUNCTIO
+N()}
+```
+
+Note the `x` and `y` values shown — these vary with the mouse position.  Try moving the mouse, and then entering `mouse` again.  In fact, on some systems, you can even read the mouse position beyond the bounds of the screen; for example, if you move the mouse to the left of the Mini Micro window, you'll see a negative `x` value.
+
+Next, try setting `mouse.visible = false` at the prompt, and observe that the mouse pointer disappears.  This is useful for some kinds of games, where you might want to use a sprite (coming up in Chapter 22) in place of the standard mouse cursor.  Set `mouse.visible = true` to bring it back.
+
+Finally, let's look at the `button` method.  A gaming mouse can have up to seven buttons, numbered 0 through 6.  A more typical mouse has two buttons, with the main button as number 0 and the secondary or right-click button as number 1.  Often the scroll wheel can be pushed, which reads as button 3.
+
+When you don't supply the `which` parameter to `mouse.button`, it reports the state of button 0.  So try it: enter `mouse.button` at the prompt, without touching the mouse, and it should report 0, meaning that the button is not pressed.  Then enter it again (remember the up-arrow trick!), but this time,  hold down the primary mouse button while you press Enter or Return.  This time it reports 1.
+
+Now that you can get the mouse position and button state, you can do all sorts of neat things.  Try this simple drawing program:
+
+{caption:"A simple drawing program in Mini Micro."}
+```miniscript
+clear
+gfx.color = color.white
+prev = {}
+while not key.pressed("escape")
+	// The mouse might move within this loop, so let's grab a copy
+	// of it right away as "m", and use only that.
+	m = {"x": mouse.x, "y": mouse.y}
+	
+	// If the button is down, draw a line from 
+	// our previous mouse position.
+	if mouse.button then gfx.line prev.x, prev.y, m.x, m.y
+	// ...and then remember that as the previous position next time.
+	prev = m
+	
+	yield    // wait for next frame
+end while
+key.clear
+```
+
+Run that code, and then try drawing with the mouse.  Can you draw a house?  Can you use the mouse to draw a mouse?  (Fortunately this is not a *Learn to Draw* book, so random scribbles are also perfectly fine.)
+
+## Importing prewritten code
+
+{i:"`import`;Mini Micro, `import`"}
+As the last topic for this chapter, we're going to learn about the `import` command.  This very useful function loads a file of MiniScript code stored somewhere else on disk.  For example:
+
+{i:"`/sys/lib`,`chars`"}
+```terminal
+]import "chars"
+]print chars.heart
+♥
+```
+
+{i:"`/sys/lib`;`/usr/lib`"}
+The first line above tells Mini Micro to search for a MiniScript source file called `chars.ms` in the current directory, `/sys/lib`, or `/usr/lib`.  In computers, "lib" stands for "library," and refers to a place to find reusable code that may be useful to a variety of programs.  (You can also define other folders to check by assigning them to `env.importPaths`.)  All the standard, built-in import modules are in `/sys/lib`, so let's go there and check them out.
+
+```terminal
+]cd "/sys/lib"
+]dir
+```
+
+You'll find `chars.ms` in this directory.  Use `load "chars"` and `edit` to view this file.  You'll see that it looks like an ordinary MiniScript program, with some helpful comments and (in this case) a bunch of assignments to things like `left`, `upArrow`, `mu`, `emptyBox`, and `heart`.  That last one is the value you used above when you printed `chars.heart`.
+
+So here's how `import` works: the name file is found, and then run in a special way, such that any global variables created by that file become entries in a map with the name of the module.  That assignment to `heart` in `chars.ms` becomes accessible as `chars.heart`, and so on for all the other values assigned.  Explore the file and note a few others that you want to try, then exit the editor and try them.  For example:
+
+```terminal
+]chars.dieFace[3]
+⚂
+]chars.bullet
+•
+```
+
+D>Always read an import file to learn how to use it!  Unlike the MiniScript language or the built-in Mini Micro classes, which are documented in places like the MiniScript wiki, most import modules are documented only within their own source.
+
+{i:"`listUtil` module;Mini Micro, `listUtil` module"}
+Let's try another one.  There's a library module called `listUtil` ("util" here is short for "utilities").  As always with import modules, begin by reading the source:
+
+{i:"`/sys/lib`,`listUtil`"}
+```terminal
+]load "listUtil"
+356 lines loaded from /sys/lib/listUtil.ms
+]edit
+```
+
+This one looks a little different, because most of the assignments in this file are adding to the built-in `list` type.  For example, near the top of the file you should find something like this:
+
+```miniscript
+// contains: return true if this list contains the given element.
+list.contains = function(item)
+	return self.indexOf(item) != null
+end function
+```
+
+This assigns a function to `list.contains`.  The built-in list type does not have a `contains` method, but after importing this module, it does!  Try it out:
+
+```terminal
+]import "listUtil"
+]a = [2, 4, 6, 8]
+]a.contains 2
+1
+]a.contains 3
+0
+```
+
+Edit `listUtils` again to see what other goodies have been added.  Some of them are a bit complex, and it's OK if you don't understand everything in here just yet.  But many of them are easy to understand, and could be quite useful:
+
+```terminal
+]a.min
+2
+]a.max
+8
+]a.any
+6
+```
+
+Of course when you try it, you may get a different value for `a.any`, since the whole point of the new `list.any` method is to return a random element!
+
+One particularly useful function added by `listUtil` is `list.removeVal`.  You will of course find this in the `listUtil` source code, and it begins like this:
+
+```miniscript
+// removeVal: remove the first (or all) occurrences of a 
+// given value.
+list.removeVal = function(val, removeAll=false)
+```
+
+This is handy because the standard `list.remove` method takes an element *index* to remove, not a value.  You would pass `list.remove` an argument of 0 to remove the first element, 1 to remove the second element, and so on.  But in many cases, what you have is a particular *value* you want to remove, and you don't know its index.  You just want to take that value out of the list, wherever it is (if it's there at all).  After doing `import "listUtil"`, you can do exactly that:
+
+```terminal
+]a.removeVal 6
+]a
+[2, 4, 8]
+```
+
+Of course all this works not only on the REPL command line, but also in your own programs.  Now that you know about it, you'll notice `import` statements near the top of many of the demo programs.  You should take some time to explore what these `/sys/lib` modules have to offer.  Here's a quick summary of the most important ones.
+
+{i:"import modules;`/sys/lib`"}
+{caption:"Import modules found in `/sys/lib`."}
+|chars|defines names for various special characters|
+|grfon|functions to save and load data in GRFON format|
+|json|functions to save and load data in JSON format|
+|listUtil|adds additional methods to the `list` type|
+|mapUtil|adds additional methods to the `map` type|
+|mathUtil|additional math & geometry functions|
+|pathUtil|functions for working with 2D paths|
+|sounds|some predefined synthesized sounds|
+|spriteControllers|extra functionality for sprites|
+|stringUtil|handy string constants, and adds methods to the `string` type|
+|textUtil|functions related to drawing text|
+|tileUtil|functions related to tile displays|
+|tsv|functions to read tab-separated data|
+|turtle|defines a `Turtle` class, for doing turtle graphics|
+
+Finally, it should be noted that an import module is also a perfectly valid MiniScript program in its own right.  You can `load` an import module, and then `run` it like any other program.  When you do, it will often run some testing code or otherwise demonstrate its functionality.  This works via a special trick.  When a MiniScript file is being executed via `import`, assignments at the "global" scope do not actually go into `globals` (they go into an in-between scope we might call *module scope*).  You can tell when this is the case because `globals != locals`.  Conversely, when a program is being run normally (not via `import`), then `globals == locals`.  That's why you'll often see something at the bottom of an import module like
+
+```miniscript
+if globals == locals then runUnitTests
+```
+
+This says, if we're being run as a regular program (rather than imported), then call `runUnitTests`.
+
+At some point, you'll want to create your own modules of handy code that you like to use in multiple programs.  You can simply create your library directory with `file.makedir "/usr/lib"`, and put your own scripts there.  These will be found by `import` just like the ones in `/sys/lib`.
+
+## Exploring the Demos
+
+{i:"`/sys/demo`,`scribble`"}
+Going back to `/sys/demo`, you'll find one called `scribble.ms` that is just a slightly expanded version of the mouse-drawing program you made above.  That one is worth studying a bit to see how the mouse is used.
+
+{i:"`/sys/demo`,`forestFire`"}
+For an example of display layers, you might look at the `forestFire` demo.  This sets up layers 1 and 2 both in text mode, and then switches back and forth between them on each step of the simulation.  You could also look at the `wumpusTrap` game, which uses several display layers, though two of these are tile and sprite, which we haven't covered yet.
+
+{i:"`/sys/demo`,`theMatrix`;`/sys/demo`,`turtleDemo`"}
+If it's `import` you're looking for, you can find that in many of the demos.  The `balloons` demo imports both `mathUtil` and `pathUtil` to help move the balloons around the track.  The `chars` module we introduced first in this chapter is used in `theMatrix` demo.  And of course `turtleDemo`, which you first saw in the previous chapter, imports the `turtle` module to provide all that turtle graphics goodness.
+
+
+A> **Chapter Review**
+A> - You gained insight into Mini Micro's 8 display layers, and how to control them.
+A> - You learned how to use the `mouse` module to read the mouse position and buttons.
+A> - You came to grips with `import`, and explored the library of modules available to you in `/sys/lib/`.
+A> - You have begun to think about what sort of code you might want to put into your own import modules, to make your future programs shorter and simpler.
+

data/day2.txt

@@ -0,0 +1,301 @@
+{chapterHead: "Day 2: Simple Math and Functions", startingPageNum:15}
+
+{width: "50%"}
+![](Chapter2.svg)
+
+Q> There’s so many exciting things going on in the computer industry, that if you have an idea, a dream, something that you want to do, then just go for it.
+Q>— Stephanie Shirley (IT entrepreneur and philanthropist)
+
+A> **Chapter Objectives**
+A> - Learn how to add, subtract, multiply, and divide numbers and strings.
+A> - Learn what *functions* are and how to use them.
+A> - Explore a few of MiniScript's most common built-in functions.
+A> - Appreciate that coding is an open-book exercise; you don't need to remember everything!
+
+## Doing Math
+
+In Day 1, you learned how to use `print` to make MiniScript display a number or string to the output area.  Except for some minor changes in formatting, what you put in was exactly what you got out -- MiniScript wasn't really doing any work for you.
+
+Today we'll learn how to put that computer to work!  Some people are good at doing math in their heads, but nobody is as good at arithmetic as a computer.  How many minutes are in a year?  Let's use MiniScript to find out!
+
+{caption: "Minutes in a year"}
+```miniscript
+print 365 * 24 * 60
+```
+
+The `*` character in MiniScript (and most other programming languages) means multiplication.  So the program above multiplies 365 days in a year, times 24 hours in a day, times 60 minutes in an hour.  The answer is printed to the output box.
+
+The multiplication symbol `*` is just one of several *operators* that can be applied to numbers in MiniScript.
+
+operator
+: a symbol or word used to indicate an operation (such as addition, division, etc.)
+
+Everyone learns the four basic arithmetic operators in school.  MiniScript numbers support the same four, plus two more: power (raise the first number to the second), and modulo (remainder after division).  We'll expand on these in a moment.  For now, focus on how to write addition, subtraction, multiplication, and division, since these are by far the most common operators you are likely to use.
+
+{i:"numbers, operators;operators, numeric"}
+| `+` | addition |
+| `-` | subtraction |
+| `*` | multiplication |
+| `/` | division |
+| `%` | modulo |
+| `^` | power |
+
+These operators go between the numbers they operate on, just like you always did in school.  So, `39 + 3` adds three to 39, just as you would expect.  The order of operation is the same as standard arithmetic, too; power is always done first, then multiplication and division (and modulo), and finally addition and subtraction is done last.  You can always control the order explicitly by putting in parentheses, again, just like standard math.
+
+{caption: "Order of operations"}
+```miniscript
+print 2 + 3 * 4
+print (2 + 3) * 4
+```
+
+Line 1 in the above example first multiplies 3 and 4 to get 12, then adds 2 to get 14.  This is because multiplication is always done before addition, unless you force it otherwise with parentheses.  The second line above does exactly that: first it adds 2 and 3 to get 5, and then multiplies that by 4 to get 20.
+
+D> Hang in there!  We'll be making creating beautiful art and engrossing games before you know it.
+
+## String Operators
+
+Yesterday you learned about two types of data: numbers and strings.  The mathy stuff above was all about numbers.  What about strings?
+
+It turns out that you can use most of the same operators on strings, too, but they have different effects.  This is a type of math you probably did *not* learn in school, but fortunately it's very simple.  When you add two strings together, it simply joins them in order into one big string.  This operation is technically called *concatenation*.
+
+{i: "string, concatenation"}
+concatenation
+: forming one larger string by joining two smaller strings together
+
+For example:
+
+{caption: "String concatenation"}
+```miniscript
+print "How" + "dy"
+```
+
+Can you guess what output this produces? Try it and see if you were right!
+
+You can also subtract two strings.  This lops the second string off the end of the first one, if indeed it is found at the end; otherwise it returns the first string as-is.  Some examples will help:
+
+{caption: "String subtraction"}
+```miniscript
+print "Howdy" - "dy"
+print "Alien.png" - ".png"
+print "No Such Thing" - "Item"
+```
+
+Line 1 prints out "How", which is what's left after you subtract "dy" from "Howdy".  The second line similarly lops ".png" off the end of "Alien.png", and leaves you with just "Alien" (hey, that example's actually useful!).  And the third example prints "No Such Thing" -- the subtraction has no effect in this case, since the string we're trying to subtract ("Item") does not occur at the end of "No Such Thing".
+
+Multiplication with numbers can be thought of as a shortcut for repeated addition.  For example, `5 * 3` is the same as `5 + 5 + 5`.  With strings, it's same idea: you can multiply a string by a number, and this is the same as adding the string that many times.  So `"Foo" * 3` is the same as `"Foo" + "Foo" + "Foo".`  When you mix multiple operators, the order of operations is the same as with numbers, too.  Try this one:
+
+{i:"string, replication"}
+{caption: "Spam and beans"}
+```miniscript
+print "Spam, " * 4 + "Baked Beans, and Spam!"
+```
+
+Multiplying a string by a number this way is known as *string replication*.  And it works not only for whole numbers.  You can multiply a string by 0.5 to cut it in half, or by 2.5 to add it to itself two whole times and half of once more.  Moreover, you can also use the division operator, `/`, to divide a string down to a fraction of its former self.
+
+{pageBreak}
+D> A common application of string replication is to print out some number of characters in a row.  For example, `print "=" * 60` is much easier way to print a row of 60 equal signs than counting them as you type them in.  And sometimes you'll need to print out some number of spaces that is calculated based on the length of *other* stuff you've printed out... string replication really comes in handy then!
+
+Here are the operators you can use with strings:
+
+{i:"string, operators;operators, string"}
+| `+` | concatenation |
+| `-` | subtraction |
+| `*` | replication (by a number) |
+| `/` | division (by a number) |
+
+All of these operators begin with a string on the left side of the operator.  With `*` and `/`, the right-hand side must be a number.  But with `+` and `-`, the right-hand side can be anything... but if it's not a string, it gets automatically converted to a string, before being added to or subtracted from the left-hand string.
+
+This is frequently used with `print`, to output some combination of strings and numeric values.
+
+{caption: "The number 3.5E6 is automatically converted to a string"}
+```miniscript
+print "Your projected net worth is $" + 3.5E6 + "!"
+```
+
+## Functions
+
+MiniScript has a variety of built-in *functions*, which are like commands or operations that you invoke by name.  You've used one a bunch of times already: `print`. 
+
+function
+: a block of code that can be called upon from other code
+
+When you write
+
+```miniscript
+print 6 * 7
+```
+You are really saying, "Invoke the function called *print* and give it the value of 6 \* 7." (The values you give a function are called its *arguments* in computer jargon.)
+
+argument
+: a value given as input to a function
+
+You probably saw this concept in middle-school math.  Whenever you wrote an equation of like *y = f(x)*, this meant there was some function *f* that took *x* as its argument, and returned a value equal to *y*.
+
+(You may also hear the term *parameter* -- for the sake of Day 2, consider this a synonym for *argument*.  We'll elaborate on this in Chapter 11.)
+
+Functions in MiniScript can cause things to happen -- for example, `print` causes output to appear on the screen -- or they can return a result (or both).  Many of the built-in functions in MiniScript are the sort that return a result, usually based on the argument (or several arguments) that you give it.  For example, the `sign(x)` function returns the sign of its argument: 1 if the argument is positive, -1 if the argument is negative, and 0 if the argument is exactly zero.  Experiment a bit with this:
+
+```miniscript
+print sign(-0.1)
+```
+
+Try some other values, too.
+
+D> Experimenting with code is an extremely powerful way to learn.  Don't give up your power -- experiment!
+
+Notice that when we're supplying arguments to a function, and doing something with the result, then we need to put parentheses around the arguments, just like you did with *f(x)* in school.  Math functions are usually like this; try the `sqrt(x)` function (which returns the square root of its argument) for another example.
+
+What if you need to supply more than one argument?  In this case you just list all your arguments, separated by commas, within the parentheses.  For example, there is a `round(x,d)` function that rounds a number *x* to *d* decimal places.  You invoke it like this:
+
+{caption:"Rounding numbers"}
+```miniscript
+print round(1.23468, 0)
+print round(1.23468, 1)
+print round(1.23468, 2)
+print round(1.23468, 3)
+print round(1.23468, 4)
+```
+
+In the first line above, the first argument is `1.23468`, and the second argument is `0`.  Order matters -- that's the only way MiniScript can know which argument is which.  So when you use an unfamiliar function, you'll look up exactly what the arguments are so you can supply them in the correct order.
+
+Some functions have *optional* arguments.  These can be left out, and MiniScript will assume some value for them.  Because order matters, you can only omit arguments at the *end* of the argument list; you can't omit something in the middle and then provide more arguments after that, because the computer would have no way to know which ones you meant.
+
+optional argument
+: an argument that may be omitted when calling a function; a default value is used in this case.  Also called an *optional parameter*.
+
+As an example, let's revisit that `round` function above.  The second argument -- the number of decimal places to round to -- is actually optional, with a default value of 0.  So if you write just `round(1.23468)`, with a single argument, this is exactly the same as writing `round(1.23468, 0)`.  But don't take my word for it -- try it!
+
+However, sometimes a function doesn't need *any* arguments.  Two good examples are `pi` and `rnd`.  The `pi` function always returns the value of pi, `3.141593`.  Conversely, `rnd` (which is short for "random") returns a different random number between 0 and 1 every time you call it.  Try it:
+
+{caption:"Using `pi` and `rnd`"}
+```miniscript
+print pi
+print rnd
+print rnd
+print rnd
+```
+
+You should run this script multiple times, until you're satisfied that `rnd` really does return a different result every time you use it.
+
+Now notice that when invoking a call without any arguments, you don't need any parentheses.  (Technically you can put empty parentheses after the function name, but this is considered bad MiniScript style.)
+
+You also don't need parentheses when the function you're calling is the first (main) word on the statement, as with `print`.  This won't come as a surprise to you, since you've been using `print` without any parentheses since Day 1!
+
+There's one more trick when it comes to invoking functions.  Many functions that operate on a particular type of data can be invoked in a different way, using a dot (i.e. period) after the data, and before the function name. The value before the dot then gets passed in as the first argument. This seems a little pointless now, but will become more useful once we have variables (which are coming next). Here's an example:
+
+```miniscript
+print "Hello world".len
+```
+
+This uses the `len` function, which returns the length of the string (that is, a count of how many characters it contains).  The above could also be written as:
+
+```miniscript
+print len("Hello world")
+```
+
+...but the dot syntax is more convenient in many cases we'll get to in the future.
+
+{i:"functions, numeric;numeric functions"}
+## Built-In Numeric Functions
+
+In the table below is a list of built-in (or *intrinsic*) MiniScript functions that work with numbers.  In this table, x and y are any number, i is an integer, and r is a number of radians.
+
+intrinsic
+: built into MiniScript, rather than added by your own code
+
+{i:"intrinsic functions, numeric;numeric functions"}
+{caption:"Intrinsic numeric functions"}
+| `abs(x)` | absolute value of `x` |
+| `acos(x)` | arccosine of `x`, in radians |
+| `asin(x)` | arcsine of `x`, in radians |
+| `atan(y, x=1)` | arctangent of `y/x`, in radians |
+| `ceil(x)` | next whole number equal to or greater than `x` |
+| `char(i)` | returns Unicode character with code point `i` |
+| `cos(r)` | cosine of `r` radians |
+| `floor(x)` | next whole number less than or equal to `x` |
+| `pi` | 3.14159265358979 |
+| `round(x, d=0)` | `x` rounded to `d` decimal places |
+| `rnd(seed=null)` | returns random number which is at least 0 but less than 1 |
+| `sign(x)` | sign of `x`: -1 if `x` < 0; 0 if `x` == 0; 1 if `x` > 0 |
+| `sin(r)` | sine of `r` radians |
+| `sqrt(x)` | square root of `x` |
+| `str(x)` | converts `x` to a string |
+| `tan(r)` | tangent of `r` radians |
+
+
+It looks like a lot, but that's OK!  You don't need to remember or even understand all of this table yet.  It's included here just so you'll have a complete table to refer to later.  For now, let's just touch on a few of the highlights.
+
+Some of these functions you have seen already; we covered `sign`, `sqrt`, `pi`, and `round` above.  Many of the others -- `sin`, `cos`, `tan`, `asin`, `acos`, and `atan` -- relate to trigonometry.  Unless you are a mathematician or engineer, you may not have much use for these yet, but you may need them someday.
+
+Two of these functions convert a number to a string, but in different ways.  The `char` function gets a character from its Unicode code point; for example char(65) is "A", char(66) is "B", and so on.
+
+Unicode
+: a standard assignment of a unique number to every character in every human language
+
+On the other hand, `str` converts a number to a string in the same way that `print` does.  So `str(65)` returns the string "65".  (If you print this out, this will look the same as printing 65 directly; for now you'll just have to trust that you really did convert it to a string yourself.)
+
+Here's an example that uses the numeric function `sqrt`.
+```miniscript
+print "The square root of 100 is " + sqrt(100)
+```
+
+{i:"functions, string;string functions"}
+## Built-In String Functions
+
+All the string functions except `slice` are designed to be invoked on strings using dot syntax.  But as noted above, they can also be invoked by putting the function name first, and then passing the string in as the first argument.  The table on the next page shows them with dot syntax.  In this table, `self` refers to the string you called it on, `s` is another string argument, and `i` is an integer (whole) number.
+
+Again, don't worry about understanding all of this.  You'll only need a few of these for quite a while.  `len`, which you've already seen, is handy to get the length of a string.  You may use `upper` and `lower` to convert a string to uppercase or lowercase.
+
+To find the Unicode code point of the first character in a string, you can call the `code` function.  This is the inverse of the `char` function you saw in the *numeric functions* table.  To do the inverse of `str`, that is convert a string into a number, you'll use `val`, but that's covered in detail on Day 4.
+
+{pageBreak}
+{i:"intrinsic functions, string;string functions"}
+{caption:"Intrinsic string functions", colWidths:"150,*"}
+| `.code` | Unicode code point of first character of `self` |
+| `.hasIndex(i)` | 1 if `i` is >= 0 and \< self.len; otherwise 0 |
+| `.indexes` | a list of all valid indexes of the string |
+| `.indexOf(s, after=null)` | 0-based position of first substring `s` within `self`, or `null` if not found; optionally begins the search after the given position |
+| `.len` | length (number of characters) of `self` |
+| `.lower` | lowercase version of `self` |
+| `.remove(s)` | `self`, but with first occurrence of substring s removed (if any) |
+| `.replace(oldVal, newVal, maxCount=null)` | returns a string with the first `maxCount` elements matching `oldVal` replaced with `newVal`; if `maxCount` not specified, replaces all |
+| `.split(delimiter=" ", maxCount=null)` | splits `self` into a list of at most `maxCount` elements |
+| `.upper` | uppercase version of `self` |
+| `.val` | converts `self` to a number (if `self` is not a valid number, returns 0) |
+| `.values` | list of individual characters in `self` (e.g. "spam".values = ["s", "p", "a", "m"] |
+| `slice(s, from, to)` | a substring of `s` starting at index `from` and going up to index `to` |
+
+Example usage:
+
+```miniscript
+print "Hello World!".upper
+```
+
+
+## Coding is an Open-Book Process
+
+Some readers will feel a strong urge to study and memorize all the details thrown at you in this chapter.  Don't bother!  There is no final exam at the end of this book.  The only test is how well you can apply your new coding skills to solve your own problems, and when you do that, you are allowed -- nay, encouraged! -- to use the book, the Internet, the MiniScript Cheat Sheet, the person sitting next to you, and any other resources at your disposal.
+
+So, far more valuable than memorizing all those functions is just remembering that you saw them.  When you need to do something with a number or a string, say to yourself, "hmm, there's probably a function for that," and then either come back to this chapter, or use one of the other resources you know about to find the details.  You will naturally come to remember any functions you use a lot; for everything else, look them up as needed.
+
+To help stretch those new coding muscles, here's one more sample program to try.
+
+{caption: "String and number functions review"}
+```miniscript
+print "The next whole number after pi is " + ceil(pi)
+print "...which is " + "Huge!".upper
+print "Rounded to 2 decimal places, pi is " + round(pi, 2)
+print "...which is " + "NOT So Huge".lower
+print """Hello World"" has " + "Hello World".len + " characters"
+print "...and the code point of the first one is " + "H".code
+print "Your lucky number is: " + floor(rnd * 100)
+```
+
+As always, be sure to type carefully.  Especially be careful with the embedded (and so doubled) quotation marks in line 5.  (Review Day 1 if you've forgotten what that's about.)
+
+A> **Chapter Review**
+A> - You discovered how to do math with numbers and strings.
+A> - You can invoke functions, including providing arguments, and using dot syntax.
+A> - You browsed a list of built-in numeric and string functions.
+A> - You learned that you don't need to memorize all the details, because it's OK to look them up when you need them.
+

data/day20.txt

@@ -0,0 +1,303 @@
+{chapterHead: "Day 20: Sounds & Music", startingPageNum:237}
+
+{width: "50%"}
+![](Chapter20.svg)
+
+Q> There is no recipe, there is no one way to do things — there is only your way. And if you can recognize that in yourself and accept and appreciate that in others, you can make magic.
+Q>— Ara Katz (co-founder of Seed Health, Spring, and BeachMint)
+
+A> **Chapter Objectives**
+A> - Load and play digitized sounds from files on disk.
+A> - Learn how to synthesize sounds from scratch.
+A> - Use your new audio skills to create music from code.
+
+So far, working with Mini Micro has been like watching a silent movie.  Unless you happen to have printed `char(7)` at some point, your programs have not made a peep.  Grab your earbuds or apologize to your neighbor, because that's going to change today!
+
+## Playing Sound Files
+
+There are two ways to make sounds in Mini Micro.  The first one involves loading a digitized sound from disk, and simply playing it.
+
+Mini Micro comes with a bunch of sound files in `/sys/sounds`.  `cd` to that directory, then use `dir` to list them.  Use the `view` command to hear what they sound like (remember to put quotes around the file name!).  Many of the sounds are musical instruments, and we'll cover how to use these to make music in the last part of this chapter.  Others are sound effects, like *bonus.wav*, *pickup.wav*, and *pop.wav*.
+
+To play these sounds from code is easy: load the sound, and then play it.
+
+```terminal
+]snd = file.loadSound("/sys/sounds/bonus.wav")
+]snd.play
+```
+
+{i:"`Sound` class"}
+The result of `file.loadSound` is a `Sound` object, another built-in class in Mini Micro.  This class has some properties that don't apply to file-based sounds, so for now let's just consider the following:
+
+{caption:"Properties and methods for digitized sounds.  *snd* is any `Sound` object.", colWidths:"150,*"}
+|`snd.duration`|length of the sound, in seconds|
+|`snd.loop`|if true, repeat the sound indefinitely until stopped|
+|`snd.play` *volume=1*, *pan=0*, *speed=1*|play this sound|
+|`snd.stop`|stop playing this sound|
+|`snd.isPlaying`|returns 1 (true) if sound is playing, 0 (false) if not|
+|`Sound.stopAll`|stop all currently playing sounds|
+
+The `play` method is the only one with any parameters, though they are all optional.  The parameters are:
+
+- *volume*: how loud to play, from 0 (silent) to 1 (full volume).
+- *pan*: adjusts the left/right stereo balance, from -1 (left speaker only) to 1 (right speaker only).  0 means to play in both speakers equally.
+- *speed*: a factor that controls payback speed and pitch.  1 is normal speed, 0.5 is half speed, 2 is double speed, and so on.  Faster speeds produce a higher pitch.
+
+As an example, try this `for` loop:
+
+{caption:"How to play the guitar."}
+```miniscript
+snd = file.loadSound("/sys/sounds/elecGuitarC4.wav")
+for x in range(1, 2, 0.25)
+	snd.play 1, 0, x
+	wait snd.duration
+end for
+```
+
+This plays the sound five times, at a different speed each time.  Notice that when you play a sound at double speed, it sounds exactly one octave higher.
+
+Of course you are not limited to the sounds that ship with Mini Micro.  You can import your own sounds, in WAV or OGG format.  The easiest way to do this is to click on the lower disk slot, use "Mount Folder..." to mount a folder in the host OS containing your sound files, and then access these in Mini Micro under the       `/usr2` directory.  When you find a sound file you want to use in your own programs, copy it onto your *user.minidisk* file for easy access.
+
+
+## Synthesizing Sounds
+
+Loading a sound file is one way of making sounds.  The other way is to create sounds from scratch, using Mini Micro's sophisticated synthesizer.
+
+To understand how synthesized sounds work, we first have to talk a bit about how sound works in general.  Sound is repeated, tiny changes in air pressure over time.  These air pressure variations cause little receptors in your ear to vibrate.  Each receptor is tuned to a different *frequency*, which is how many times the air pressure goes up and down per second.  Humans can typically hear frequencies between 20 and 20,000 cycles per second or so.  (The shorthand for "cycles per second" is a unit called Hertz, and abbreviated Hz.)  
+
+Low frequencies, like 20 Hz, sound like very deep, low sounds, while high frequencies are high-pitched sounds.  The relationship between frequency and pitch is not linear; to go up one octave in pitch, you must double the frequency.  Conversely, to go down one octave in pitch, you would cut the frequency in half.
+
+Speakers are simply hardware that produce these changes in air presure, by moving the speaker cone back and forth according to an electronic signal.  Microphones do the reverse, responding to changes in air pressure by producing a signal that a computer can read.  This is known as *digitizing* the sound, and is how most of those sound files in `/sys/sounds/` were created.
+
+If you were to take the signal from a microphone and graph it, to represent the air pressure changes visually, you would often see some pattern that repeats over and over, hundreds or thousands of times per second.  That pattern is called the *waveform*.
+
+waveform
+: one cycle of a sound wave, representing the air pressure changes that are repeated *frequency* times per second
+
+frequency
+: how many times per second the waveform is repeated to produce a sound
+
+Note that in the context of Mini Micro, *waveform* refers to just *one* cycle of the air pressure changes, which is repeated many times per second.  In other contexts, people may use "waveform" to refer to a graph of the entire sound, from beginning to end.
+
+So to define a simple sound, we need to know:
+
+1. What the waveform looks like.
+2. How many times per second that waveform should be repeated (i.e. the frequency).
+3. How long the sound should last.
+4. How the volume should change over the course of the sound.
+
+That third one, how long the sound should last, is called the *duration* of the sound; and that last one is called the *envelope*.
+
+envelope
+: how the amplitude (volume) of a sound varies from the beginning to the end of the sound
+
+And now you have all the background you need to understand sound synthesis in Mini Micro.  The `Sound` class has some additional properties that correspond to the concepts above.
+
+{caption:"Properties and methods related to synthesizing sounds from scratch.", colWidths:"120,*"}
+|`snd.duration`|length of the sound, in seconds|
+|`snd.freq`|frequency (repeats of `waveform` per second)|
+|`snd.envelope`|how the sound amplitude varies over the course of the sound|
+|`snd.fadeIn`|length of fade-in period when sound begins, in seconds|
+|`snd.fadeOut`|length of fade-out period when sound begins, in seconds|
+|`snd.init` *duration, freq, envelope, waveform*|shortcut for setting the four key properties|
+|`snd.mix` *sound2, level|add another synthesized sound into this one|
+
+Let's begin, as usual, by experimenting on the REPL command line.
+
+```terminal
+]s = new Sound
+]s.duration = 1
+]s.freq = 440
+]s.envelope = 1
+]s.waveform = Sound.sineWave
+]s.play
+```
+
+You should hear a clean, pure note (for the musically inclined, this is A above middle C) that lasts for 1 second.  Let's go over each of these properties in turn.
+
+First, `duration`.  This one is easy enough: it's how long the sound lasts, in seconds.  Try changing it and hear the difference.
+
+```terminal
+]s.duration = 1.5
+]s.play
+]s.duration = 0.5
+]s.play
+```
+
+Next, frequency.  You probably have a good idea of this by now, but go ahead and play with it a bit to be sure.
+
+```terminal
+]s.freq = 220
+]s.play
+]s.freq = 880
+]s.play
+```
+
+However, you aren't limited to a single, constant frequency for the whole sound.  If you give Mini Micro a list of frequencies, it will smoothly interpolate between them.  Try these:
+
+```terminal
+]s.duration = 2
+]s.freq = [220, 880]
+]s.play
+]s.freq = [880, 220]
+]s.play
+]s.freq = [220,300] * 8
+]s.play
+```
+
+That last one is using list replication; go ahead and print out `s.freq` to make sure you understood that correctly.  And you can hear what it does to the sound: the pitch varies between 220 and 300 Hz, 8 times over the 2-second duration of the sound.
+
+Envelope is a little trickier.  Here, Mini Micro is expecting either 1, which indicates a constant amplitude for the sound; or a list of values between 0 and 1, which indicate how the amplitude should vary over the course of the sound.  For example, if you use an envelope of `[0,1]`, then the sound will start at an amplitude of 0 (silent) and ramp up te full volume by the end of the sound.  An envelope of `[1,0]` would do the opposite.  Try it!
+
+```terminal
+]s.freq = 440
+]s.envelope = [0,1]
+]s.play
+]s.envelope = [1,0]
+]s.play
+]s.envelope = [0,1,0]
+]s.play
+]s.envelope = [1,0,1]
+]s.play
+```
+
+You can use as many values in your `envelope` list as you like; the synthesizer will evenly space these amplitude changes over the length of the sound.  And of course you don't have to stick to only values of 0 and 1; you can use any values in between.  For example, using list replication again:
+
+```terminal
+]s.envelope = [1, 0.25] * 8
+]s.play
+```
+
+It should be noted that the envelope isn't the *only* factor that affects the amplitude of the sound over time; there are also `fadeIn` and `fadeOut` properties.  These are a simple way to make the sound fade in (go from zero to full amplitude) at the start of the sound, and fade out (go from full amplitude down to zero) at the end of the sound.  This is an important feature in digital sounds, because without some fade-in and fade-out, you may hear an unpleasant click when the sound begins or ends.  If you don't specify a value for one of these, a value of 0.01 seconds is used by default.
+
+Finally, let's consider the waveform.  In the examples so far we've been using a sine wave, which is a pure, smooth variation in air pressure over time.  Such a smooth waveform strongly excites only one of the frequency detectors in your ear, producing a sound that is clean and pure (and so rather boring).
+
+You can specify a waveform as a list of values from -1 to 1, and Mini Micro will interpolate over that list for each cycle of the sound.  But the `Sound` class also has five common waveforms built right in, as shown below.
+
+{width:"97%"}
+![Waveforms available on the `Sound` class.](SoundWaves.svg)
+
+We've been using `Sound.sineWave`.  Try `Sound.triangleWave` next, which is pretty close to a sine wave, but not quite so pure.
+
+```terminal
+]s.waveform = Sound.triangleWave
+]s.play
+```
+
+It's the same pitch as before, but now a little richer, less pure.  (If you need to compare again, switch back to `Sound.sineWave` and play that again.)  Next try `Sound.sawtoothWave`.  (I'm not showing the commands for that — you know what you're doing by now — but please try it, since you can't really know what it sounds like until you try!)  A sawtooth wave is substantially buzzier than the triangle wave.  Finally, try `Sound.squareWave`, which has a nice retro "8-bit" sound to it.
+
+There is one more waveform which we haven't tried yet: `Sound.noiseWave`.  This one is different from all the others; while the others have a fairly simple shape, this one looks like complex, random gibberish.  And that's pretty much what it is.  Random, chaotic air pressure changes like that don't sound like tones to us at all; they sound like noise.  But if you repeat this noisy waveform hundreds or thousands of times per second, our ears will *still* detect the repeating pattern and hear a tone.  So when you want to make pure noise, use it with a very low frequency, like so:
+
+```terminal
+]s.waveform = Sound.noiseWave
+]s.freq = 5
+]s.play
+```
+
+Of course you may want to try other frequencies too, and there's certainly no harm in using high frequencies with noise if you like the sound.  It's totally up to you.  With the right choice of parameters, you can approximate the sound of footsteps, impacts, wind, waves, and so on.
+
+The `init` method is a shorthand for setting `duration`, `freq`, `envelope`, and `waveform` all at once, in that order.  For just playing around on the REPL, assigning (or changing) these properties one at a time is probably nicer.  But in code, you might want to do more of it at once, something like:
+
+```terminal
+]s = new Sound
+]s.init 0.5, [2000,50], [1,0.25]
+{"__isa": Sound, "duration": 0.5, "freq": [2000, 50], "waveform": [1
+, -1], "envelope": [1, 0.25], "fadeOut": 0.01, "fadeIn": 0.01, "_han
+dle": null}
+]s.play
+```
+
+Note that each of the parameters to `Sound.init` has a default value; in the example above, we omitted the last one (waveform), and it used `Sound.sawtoothWave` by default.
+
+The last topic to cover in synthesizing sounds is the `mix` method.  This lets you take a second synthesized sound, and add it to the first, so that when you play them you essentially get both at once.  For example:
+
+```terminal
+]pew = new Sound
+]pew.init 0.5, [2000,10], [1,0]
+]pew.play
+]psh = new Sound
+]psh.init 0.2, 5, [1,0], Sound.noiseWave
+]psh.play
+]pew.mix psh
+]pew.play
+```
+
+In lines 1-3 above, we synthesize and test a "pew" sound (a rapid falling tone).  Then in lines 4-6, we synthesize and test a noisy burst sound.  Line 7 mixes the noisy burst into the pew sound.  Now when we play that sound, we hear the noisy burst at the beginning.
+
+I think you can see by now that Mini Micro's sound synthesizer is very versatile.  With only a few lines of code, you can make a wide variety of sounds.  You could make the audio for a game entirely with synthesized sounds, especially if you're going for a retro feel; or you could use synthesized sounds as stand-ins until you find the digitized sounds you need.  Synthesized sounds also have a lot of flexibility to respond to what's going on in the program, changing any of their parameters according to user input or other data.  In this way, they have the potential to provide endless variation, and avoid that repetitive feeling that often results from digitized sounds.
+
+## Making Music
+
+One use for both digitized and sythesized sounds is making music.  Of course if you just want a background score, you could load a sound file in OGG format and simply play it.  But if you want to use synthesized sounds, or make music on the fly from code, then you will need to know what frequency to use for each note.
+
+{i:"`noteFreq`"}
+Mini Micro has an intrinsic global function just for that, called `noteFreq`.  It takes a *note number*, and returns the proper frequency for that note.
+
+note number
+: a standard way of identifying notes over a 9-octave range, with each note assigned a unique number
+
+Middle C (also known as C4, i.e. note C in octave 4) is note number 60, and the next highest note, C sharp, is note 61.  After that is 62 (D), 63 (D sharp or E flat), and so on.  When you include all the sharps and flats, there are 12 notes per octave, so high C (also known as C5) is note 72, and low C (i.e. C3) is note 48.
+
+![Note names and numbers for octaves 3 through 5 of the musical scale.](NoteNumbers.svg)
+
+By passing these note numbers to the `noteFreq` function, you can get the right frequency to make any note.
+
+```terminal
+]snd = new Sound
+]snd.init 1, noteFreq(60)
+{"__isa": Sound, "duration": 1, "freq": 261.625549, "waveform": [1,
+-1], "envelope": 1, "fadeOut": 0.01, "fadeIn": 0.01, "_handle": null
+}
+]snd.play
+]snd.freq = noteFreq(67)
+]snd.play
+```
+
+The above plays a sawtooth wave middle C (note 60) followed by middle G (note 67).
+
+With digitized sounds, the procedure is a little different.  You first need to know what pitch the sound was recorded as.  All of the digitized instruments in         `/sys/sounds` were recorded at note 60 (C4).  Then, divide the desired frequency by the original note frequency, and use this ratio as the `speed` parameter to `Sound.play`.
+
+```terminal
+]snd = file.loadSound("/sys/sounds/celloLongC4.wav")
+]snd.play  // plays as note 60 (C4)
+]snd.play 1, 0, noteFreq(67)/noteFreq(60)  // plays as note 67 (G4)
+```
+
+Here's a little program from the Mini Micro Cheat Sheet that illustrates how to make a little song.  The notes are defined by a list, where each element is a note number and duration.
+
+{caption:"Playing a song with code. Charge!"}
+```miniscript
+// notes defined as: [note, duration]
+notes = [[60, 0.1], [64, 0.1], [67, 0.1],
+         [72, 0.2], [67, 0.1], [72, 0.4]]
+snd = new Sound
+for n in notes
+	snd.init n[1], noteFreq(n[0])
+	snd.play
+	wait snd.duration
+end for
+```
+
+**Challenge:** modify the above program to use a digitized horn sound (`/sys/sounds/hornC4.wav`).  You will need to remove the `snd.init` call, and change the `snd.play` line to calculate the correct pitch for each note as shown above.  Finally, the `wait` command will need changing to use `n[0]` as the wait time.
+
+It's worth noting that computers and music have a long and beautiful history together.  In recent years the practice of "live coding" has become an increasingly popular form of performance art, where a composer/programmer/performer writes code to create music in real-time, in front of an audience.  Who knows, perhaps your own practice creating music in Mini Micro will lead to performing on stage one day!
+
+## Exploring the Demos
+
+{i:"`/sys/demo`,`drumMachine`"}
+The poster child for sound and music is certainly `drumMachine.ms` (in the          `/sys/demo` folder).  It uses a display type (tile) that you haven't learned about yet, but you should be able to understand how it is loading and playing sounds.  It's also a fun program to play with.  Feel free to load a different set of sounds, and get your jam on!
+
+{i:"`sounds` module;Mini Micro, `sounds` module;`/sys/lib`,`listUtil`"}
+Most of the other game demos use sounds of either sort, but for synthesized sounds, the best place to look might actually be the import module `/sys/lib/sounds.ms`.  This defines a handful of generally useful sounds.  To use these in your own program, you can `import "sounds"` and then simply call (for example) `sounds.ding.play`.  But today you should actually `load` this as a program, `run` it (it goes into a demo mode when run this way), and then study the source code.
+
+A> **Chapter Review**
+A> - You learned how to load and play digitized sounds from WAV and OGG files.
+A> - You synthesized sounds from scratch, using nothing but code and ingenuity.
+A> - You created music with the help of the `noteFreq` function.
+
+
+{gap:50}
+{width:"28%"}
+![](chinchilla-06-note.svg)
+
+

data/day21.txt

@@ -0,0 +1,333 @@
+{chapterHead: "Day 21: Fireworks Demo", startingPageNum:249}
+
+{width: "50%"}
+![](Chapter21.svg)
+
+Q> After a long time of practicing, our work will become natural, skillful, swift, and steady.
+Q>— Bruce Lee (martial artist, actor, instructor, and philosopher)
+
+A> **Chapter Objectives**
+A> - Rest and recouperate.
+A> - Enter and play with a fun Mini Micro demo that includes display layers, sound, and mouse input.
+A> - Review & synthesize what you've learned so far.
+
+
+Congratulations!  You have come a long way since Day 1.  You've learned all about the  MiniScript language, and how to use it in three different environments: the Try-It! page, command-line MiniScript, and Mini Micro.  You've also learned many of the custom classes and functions available in MiniScript to work with the display, mouse, and keyboard.  If you've been doing one chapter a day, then it's been three weeks since you started your journey, and you have just a bit over one week left in this course.
+
+It's time to take a break, and instead of trying to pile on any new knowledge, let your existing knowledge settle a bit.  You deserve a rest!  In fact, your achievements so far are worthy of celebration!  And what better way to celebrate than... fireworks?
+
+![Fireworks!](Fireworks.png)
+
+This program will generate pretty, physics-based fireworks, launched from wherever you click the mouse, complete with sounds on launch and burst.  To create all the visual effects, we will use several display layers:
+
+- Display 7 will be the background, but we'll switch it to pixel mode so we can draw a nice deep gradient.
+- Display 5, the standard `gfx` layer, is where most of the drawing will take place.
+- Display 2 will be used to draw a brief "flash" (white circle) when a rocket bursts.
+
+We will leave the standard `text` layer (display 3) alone, so you can see your typing when the program is not running.  The graphics displays will be set to a scale of 3, making the pixels three times bigger than normal, so that the firework particles are easier to see.  
+
+Also, to help us with some list operations like removing an element by value, or selecting a random value, we will import the *listUtil* module.  So, as you might expect, our program begins with the `import` statement, followed by setting up the displays.  Use `reset` (or freshly launch Mini Micro) to clear any program you might have in memory, then `edit` to enter the code in Listing 1.
+
+{caption:"Listing 1 (Fireworks set-up code)."}
+```miniscript
+// set up
+import "listUtil"
+clear
+gfx.clear color.clear, 960/3, 640/3
+gfx.scale = 3
+
+display(2).mode = displayMode.pixel
+flashGfx = display(2)
+flashGfx.clear color.clear, gfx.width, gfx.height
+flashGfx.scale = gfx.scale
+flashGfx.color = color.white
+
+display(7).mode = displayMode.pixel
+bkgnd = display(7)
+bkgnd.clear color.black, gfx.width, gfx.height
+bkgnd.scale = gfx.scale
+for y in range(0, bkgnd.height-1)
+	c = color.lerp("#550055", "#000022", y/bkgnd.height)
+	bkgnd.line 0, y, bkgnd.width, y, c
+end for
+```
+
+Save this program as `fireworks.ms`.  Then run, and you should see a purple gradient representing the evening sky.  (This also makes a nice background; someday you may want to put something like this into `/usr/startup.ms` to make it your standard work background!)
+
+Here's the next portion of the fireworks program:
+
+{caption: "Listing 2 (more Fireworks set-up).", number-from: 22}
+```miniscript
+burstColors = [color.yellow, color.red, color.blue, 
+   color.aqua, color.pink, color.lime, color.fuchsia]
+
+launchSnd = new Sound
+launchSnd.init 0.3, 5, [0,1,0], Sound.noiseWave
+
+burstSnd = new Sound
+burstSnd.init 1, 2, [1,0.1,0.01,0], Sound.noiseWave
+
+panForX = function(x)
+	return 2 * (x / gfx.width - 0.5)
+end function
+
+for x in range(0, gfx.width, 100)
+	launchSnd.play
+	wait
+	burstSnd.play
+	wait
+end for
+```
+
+Lines 22-23 set up a list of colors to use for the firework bursts.  This is a long list, so we simply hit return after a comma, and continue it on the next line.  (Note that this might slightly confuse the code editor, and cause it to mark the closing square bracket in red — don't let that alarm you.)
+
+Next, we define a couple of synthesized sounds for the rocket launch and burst.  Remember that the parameters to `Sound.init` are *duration*, *frequency*, *envelope*, and *waveform*.
+
+We want to use the stereo pan (i.e. left-right balance) to make these sounds appear in the left speaker when they occur on the left side of the screen, and in the right speaker when they occur on the right (and smoothly interpolate in between).  The `panForX` function does that calculation, converting the *x* coordinate (which goes from 0 to `gfx.width`, the width of the graphics display) into a pan value (-1 to 1).  Finally, the `for` loop on lines 35-40 tests all that out, playing sounds that should pan from left to right.  (You might need to put on some headphones or ear buds to hear the effect.)
+
+D> Code a little, test a little!
+
+Once that's working, delete that `for` loop starting on line 35, and add this code instead.
+
+{caption: "Listing 3 (Fireworks `Particle` class).", number-from: 35}
+```miniscript
+// make a Particle class
+Particle = {}
+Particle.x = 0
+Particle.y = 0
+Particle.vx = 0
+Particle.vy = 0
+Particle.color = color.yellow
+Particle.trail = null
+Particle.maxTrails = 5
+Particle.gravity = -15
+Particle.dragFactor = 0.99
+Particle.update = function(dt=0.1)
+	// apply gravity and drag to velocity
+	self.vy = (self.vy + self.gravity*dt) * self.dragFactor
+	self.vx = self.vx * self.dragFactor
+	
+	// apply velocity to position
+	self.x = self.x + self.vx * dt
+	self.y = self.y + self.vy * dt
+	
+	// draw, appending to the trail
+	gfx.setPixel self.x, self.y, self.color
+	if self.trail == null then self.trail = []
+	self.trail.push [self.x, self.y]
+	
+	// erase when the trail is too long
+	if self.trail.len > self.maxTrails then
+		pos = self.trail.pull
+		gfx.setPixel pos[0], pos[1], color.clear
+	end if
+end function
+Particle.die = function()
+	// erase trail
+	for pos in self.trail
+		gfx.setPixel pos[0], pos[1], color.clear			
+	end for
+	// remove from global list
+	particles.removeVal self  // (removeVal is from listUtil)
+end function
+
+// keep a list of all Particle instances
+particles = []
+
+p = new Particle
+p.vx = 30
+p.vy = 90
+for i in range(90)
+	p.update
+	yield
+end for
+p.die
+```
+
+In Listing 3, we define a class called Particle.  This represent things that move according to simply physics, like the rockets and the embers (i.e. burst particles).  The physics is quite simple: in addition to the position (*x* and *y*), we also keep track of velocity (*vx* and *vy*).  On every step, the vertical velocity *vy* is updated by gravity, and then the position is updated by the velocity.
+
+To draw a particle, we're just using `gfx.setPixel`.  But we also keep track of the last several positions it was drawn, in the `trail` list.  So when we draw the particle at a new position, we add that position to the trail; and when the trail is too long, we pull off the oldest point and erase it (by setting the pixel to `color.clear`).
+
+The `Particle.die` function is called when we want to remove a particle completely.  It erases all the pixels in the trail, and then removes the particle from the global `particles` list.  Note that this `removeVal` method we're using here is not standard MiniScript; it is something added by the `listUtil` module imported on line 1.
+
+Finally, all that code at the end (lines 78-85) is, again, test code just to make sure that things are working so far.  When you run this, you should see a particle leap up from the 0, 0 corner of the screen, arc across the screen, and then disappear.
+
+When that's working, delete lines 78-85, and then continue on with Listing 4.  Here we make a *subclass* of Particle, to handle the special case of a particle that is actually a Rocket (i.e. launched from the ground, and not yet burst).
+
+subclass
+: a class created from another class using `new`, so that it inherits all of the values and methods of that other class
+
+superclass
+: the more general class that a subclass is created from
+
+Subclasses can be a very handy OOP (object-oriented programming) technique.  They allow us to make a more specialized version of a class, one that is like the superclass in most ways, but also specialized in certain ways.  In this case, the superclass is our general-purpose `Particle` class, and the subclass is `Rocket`.  A rocket behaves like other particles in most ways, except that at some point in its flight, it bursts, creating a shower of other particles.
+
+{caption: "Listing 4 (Fireworks `Rocket` class).", number-from: 78}
+```miniscript
+// make a subclass of Particle that represents a rocket
+Rocket = new Particle
+Rocket.timeTillBurst = 3
+Rocket.update = function(dt=0.1)
+	// do standard particle update...
+	super.update dt
+	
+	// then, update time till burst, and burst when it's time
+	self.timeTillBurst = self.timeTillBurst - dt
+	if self.timeTillBurst <= 0 then
+		// remove the rocket particle and its trail
+		self.die
+		
+		// create the burst particles
+		c = burstColors.any  // (.any provided by listUtil)
+		for i in range(1,40)
+			p = new Ember
+			p.startColor = c
+			p.x = self.x
+			p.y = self.y
+			angle = 2 * pi * rnd
+			speed = 10 + 50*rnd
+			p.vx = speed * cos(angle)
+			p.vy = speed * sin(angle)
+			particles.push p
+		end for
+		
+		// flash and bang
+		flashGfx.fillEllipse self.x-10, self.y-10, 20, 20
+		globals.haveFlash = true
+		burstSnd.play 1, panForX(self.x), 0.9 + 0.2*rnd
+	end if
+end function
+
+Ember = new Particle
+p = new Rocket
+p.vx = 30
+p.vy = 90
+particles.push p
+for i in range(100)
+	for p in particles
+		p.update
+	end for
+	yield
+end for
+```
+
+{i:"`super`"}
+Notice the `Rocket.update` function, which overrides the `Particle.update` function in the superclass.  But the first thing that this function does is call `super.update`, which means that it runs the standard `Particle.update` code.  
+
+D> `super` is a special MiniScript keyword that finds the identifier after the dot somewhere higher in the chain of classes related by `new`.  It's commonly used in a subclass method to call the same method in the superclass.
+
+It then goes on to figure out if it's time to burst.  When it is, it calls its own `die` method, then creates a bunch of burst particles (using the `Ember` class we trivially defined in the test code on line 112), as well as drawing a flash (white circle).
+
+The test code here defines `Ember` as a `new Particle`, but does not override any properties or methods.  That's a pointless thing to do, *except* in a case like this, where we know we're going to need an ember class later, but for now are content with standard particle behavior.  The test code then creates and launches a `Rocket`, with a little update loop to make it go.
+
+Note that there is nothing here yet to erase the flash on the `flashGfx` display.  So once the rocket bursts, it leaves a yellow circle behind.  That's OK — we'll fix that later.
+
+Moving on, clear out that test code starting on line 112, and let's create that Ember class for real.
+
+{caption: "Listing 5 (Fireworks `Ember` class).", number-from: 112}
+```miniscript
+// make another Particle subclass that represents the
+// embers that float down after the rocket bursts
+Ember = new Particle
+Ember.age = 0
+Ember.gravity = -5
+Ember.dragFactor = 0.90
+Ember.startColor = color.pink
+Ember.endColor = "#88000088"  // translucent red
+Ember.update = function(dt=0.1)
+	// age, adjust our color, and when it's time, die
+	self.age = self.age + dt
+	if self.age > 3 then
+		self.die
+	else
+		// update our color
+		self.color = color.lerp(self.startColor, self.endColor, self.age/3)
+		// and then do standard particle update
+		super.update dt	
+	end if
+end function
+
+p = new Ember
+p.x = 120
+p.y = 200
+p.vx = 30
+for i in range(50)
+	p.update
+	yield
+end for
+```
+
+As usual, we include a bit of test code at the bottom so you can make sure it's working.  When you run this, a little pink ember should appear near the top of the screen, fly off to the right, and fade out.  That's what makes embers different from other particles: they change colors over time.  Notice that the call to `super.update` here doesn't happen until later in `Ember.update`, *after* updating the color; otherwise the very first appearance of the ember would be in the wrong color.
+
+Now we're almost done!  We need a function to launch a rocket, and a main loop.  Since any test code for the launch function would be practically the full main loop anyway, let's just press on and finish the program.  Delete the test code starting on line 134, and wrap it up with Listing 6.
+
+{caption: "Listing 6 (Fireworks launch method and main loop).", number-from: 134}
+```miniscript
+// function to create and launch a new firework
+launchAt = function(x)
+	p = new Rocket
+	p.x = x / gfx.scale
+	p.y = 0
+	p.vx = 30 * rnd - 15
+	p.vy = 10 * rnd + 80
+	p.timeTillBurst = 3 + 3 * rnd
+	particles.push p
+	launchSnd.play 0.3, panForX(p.x), 0.9 + 0.2*rnd
+end function
+
+// main loop
+mouseWasDown = false
+haveFlash = false
+while true
+	// clear the flashes, if we have any
+	if haveFlash then
+		flashGfx.fillRect 0, 0, flashGfx.width, 
+		   flashGfx.height, color.clear
+		globals.haveFlash = false
+	end if
+	// launch whenever the mouse is clicked
+	mouseIsDown = mouse.button
+	if mouseIsDown and not mouseWasDown then
+		launchAt mouse.x
+	end if
+	mouseWasDown = mouseIsDown
+	// update all particles
+	for p in particles
+		p.update
+	end for
+	yield
+end while
+```
+
+The `launchAt` function takes an *x* position in unscaled screen coordinates, like the mouse position (and unlike the `gfx` display in this program, which is scaled by a factor of 3).  It creates a new `Rocket` instance, just like our test code from Listing 4.  Many of the rocket properties — its initial velocity, and the time until it bursts — are randomized, which makes the fireworks more interesting and fun.  The function also plays the launch sound, with stereo pan adjusted for the particle position, and the speed (pitch) randomized a bit so the launches don't sound too monotonous.
+
+The main loop has several jobs.  First, it clears the flash display, if indeed any flashes were drawn the last time through the loop.  We do this with `flashGfx.fillRect`, filling with `color.clear`, because if we used `flashGfx.clear`, it would reset the display scale and then we'd just have to set it back.
+
+Second, it watches `mouse.button` and compares it to the previous value, to determine when the mouse has just been clicked.  When that happens, it calls our `launchAt` method to launch a rocket at the mouse position.
+
+{i:"`yield`"}
+Finally, it loops over all particles and calls `update` on them.  And then it calls the `yield` intrinsic, which tells Mini Micro to wait until the start of the next frame (frames are when the screen is updated, roughly 60 times per second).
+
+Run the program, and click around the screen.  A rocket should launch from below the mouse each time you click.  Go ahead and spam the mouse button!  These fireworks are for *you*; you deserve it!  (Just press control-C to break out of the main loop when done.)
+
+## Going Farther
+
+This has turned out to be a pretty short program — considerably shorter than the Sea Battle game you did in Chapter 14.  Mini Micro allows you to make a lot of fun with not that much code!  But since it was so short, perhaps you have time to try a bit more on your own?
+
+One simple hack would be to make it launch *two* rockets each time the mouse is clicked, instead of just one.  This is literally just one extra line in the main loop.  Why not give it a try?
+
+Another tweak is to change how long the embers last before they die.  Right now they disappear after 3 seconds.  Can you change that to 6 seconds?  You will need to change the code in two places, because this time is used both to make the color fade out, and to actually remove the particles.  Change it in both places, and make sure that works.
+
+{i:"magic number"}
+Then, realize that this is a rather poor design, having that magic number in two different places.  (This is similar to the concept of *magic strings* discussed in Chapter 14.)  Add a `maxAge` property to the Ember class, and use that instead of the number in both places.
+
+Finally, we still have all the embers from a particular burst fading out and disappearing at the same time.  Wouldn't it be more interesting if that time were randomized a bit too, so some embers last longer than others?  Find where the embers are created, and we assign a random velocity.  Assign a random `maxAge` there as well.  Run your program and confirm that the embers in a burst now disappear at different times rather than all at once.
+
+If you have difficulty with any of this, don't be discouraged!  I encourage you to make use of the community resources you can find via the MiniScript web site (`https://miniscript.org`).  There is a Discord server, forums, and more.  Don't be afraid to ask for help — it is a very supportive and welcoming community, and asking for help is something even professional programmers do on a regular basis.
+
+{pageBreak}
+A> **Chapter Review**
+A> - You built the *Fireworks* demo, celebrating all your hard work and progress up to this point.
+A> - You reviewed and practiced using display layers, mouse input, pixel graphics, and sound.
+A> - You learned about subclasses, superclasses, and the `super` keyword.
+A> - You went "beyond the book" and made some significant changes to the program on your own.  Day by day, your coding skills are growing!

data/day22.txt

@@ -0,0 +1,365 @@
+{chapterHead: "Day 22: Sprites", startingPageNum:263}
+
+{width: "50%"}
+![](Chapter22.svg)
+
+Q> With too many bells and whistles, it gets complicated. With too few, there are inefficiencies. Designing something just powerful enough is an art.
+Q>— Barbara Liskov (2008 A. M. Turing award winner)
+
+A> **Chapter Objectives**
+A> - Learn about *sprites* and how they are used in games and utilities.
+A> - Explore the SpriteDisplay, Sprite, and Bounds classes in Mini Micro.
+A> - Write code to make sprites move, rotate, scale, and respond to mouse clicks.
+
+If you look carefully at any two-dimensional (2D) video game, you will see the screen full of little images that move around.  This is easiest to see in older games (though still true today).  Consider one of the greatest arcade games of all time, *Ms. Pac-Man*.  Our heroine, Ms. Pac-Man, travels around the maze eating dots; and if you look closely she often overlaps the walls of the maze slightly.  The four ghosts also travel around the maze, passing right over the dots and power-up pills, as well as each other.
+
+Now consider how you would create such an effect using the tools you have so far, such as the `drawImage` and `fillRect` methods on `PixelDisplay`.  You could certainly keep track of where the ghosts are, and draw them in their correct positions for each frame.  But to make them move, you would need to erase them, perhaps by filling the space they previously occupied with black.  But this would clobber any dots that had been there, as well as any parts of the maze they happened to overlap.  So to fix this, you would have to redraw the dots *and* the maze on every frame, too.
+
+All this drawing would be difficult and inefficient, resulting in a slow, flickery display.  Yet these machines from the 1980s drew things like this — and much more complicated scenes, with lots of moving objects overlapping a complex background — at video rates, without breaking a sweat.  How did they do it?  And more importantly, how can *you* do it?
+
+The answer is... sprites.
+
+sprite
+: an image, often with transparent areas and usually much smaller than the screen, which can be made to appear on screen and efficiently moved, rotated, and scaled, all without disrupting the background or other sprites
+
+D> OK, fine, some readers will realize that in Mini Micro there is another answer, which is to take advantage of display layers.  By drawing your ghost and player images in a different display layer than the maze and dots, you could clear the moving images on each frame without clobbering the background, and thereby make such an animation work.  But sprites are both easier and far more efficient than this approach.
+
+PRINT>The image on the next page is from a Mini Micro game called *Dr. Yond's Zombie Experiment*.  The characters (both human and zombie), the giant floating brain, and the balls of energy are all sprites, as indicated with the white boxes in the figure.  These are drawn and animated very efficiently over the pavement and buildings in the background.
+EBOOK>The following image is from a Mini Micro game called *Dr. Yond's Zombie Experiment*.  The characters (both human and zombie), the giant floating brain, and the balls of energy are all sprites, as indicated with the yellow boxes in the figure.  These are drawn and animated very efficiently over the pavement and buildings in the background.
+
+![Screen shot from *Dr. Yond's Zombie Experiment*, with boxes added to outline the sprites.  There are 13 sprites on screen.  Can you spot them all?](DYZE-sprites.png)
+
+## Creating and Drawing Sprites
+
+To make a program like this with your own code, you first have to create a sprite object.  You may recall from Chapter 12 (or yesterday's fireworks program) that you create an object in MiniScript using `new` with the desired class.  In this case what we desire is the built-in Sprite class.  Try it right on the command line:
+
+```miniscript
+spr = new Sprite
+spr.image = file.loadImage("/sys/pics/Wumpus.png")
+```
+
+This creates a new Sprite object, and assigns an image (a fuzzy purple wumpus image from `/sys/pics`) to its `image` property.
+
+It does not, however, cause the wumpus to appear on screen.  Right now our sprite object is just hanging out in memory, not attached to any display.  To make it appear, we need to add it to a sprite display.  In the default configuration, display 4 is a sprite display, so we can do:
+
+```miniscript
+display(4).sprites.push spr
+```
+
+You should see a wumpus peeking out from the lower-left corner of the screen.  To bring it more into view, assign to its `x` and `y` properties:
+
+```miniscript
+spr.x = 480
+spr.y = 320
+```
+
+That will move the sprite into the center of the screen.
+
+If you don't see the sprite, then the most likely cause is that you made a typo in the file path.  You could print out `spr.image` and if it is null, repeat the `file.loadImage` line above, checking your typing and capitalization very carefully.
+
+{i:"`Sprite` class"}
+PRINT>So far, you've seen the `image`, `x`, and `y` properties of the `Sprite` class.  The full set is presented in the table at the top of the next page.  We'll cover the rest before the chapter is done.
+EBOOK>So far, you've seen the `image`, `x`, and `y` properties of the `Sprite` class.  The full set is presented in the table below.  We'll cover the rest before the chapter is done.
+
+{gap:20}
+
+{caption:"Properties and methods for the Sprite class (where `spr` is any Sprite object).  The last three rows are functions; all the others are properties which may be read or assigned."}
+|`spr.image`|image to use for the sprite's appearance|
+|`spr.x`|horizontal position of the center of the sprite in the display|
+|`spr.y`|vertical position of the center of the sprite in the display|
+|`spr.scale`|scale factor: 1 is normal size, 0.5 is half size, etc.|
+|`spr.rotation`|sprite rotation angle in degrees|
+|`spr.tint`|tint color (white for no tint)|
+|`spr.localBounds`|defines rectangular bounds relative to the sprite itself|
+|`spr.worldBounds`|get the bounds of the sprite on screen|
+|`contains`(*pt*)|return true if the sprite bounds contains the given x/y point|
+|`overlaps`(*other*)|return true if the sprite is touching other sprite or Bounds|
+
+## Animating Sprites
+
+Sprites excel at animation!  And to do it is simple: you only need to change one or more of the sprite's properties (like position, scale, and rotation) from frame to frame.  Let's first try a simple animation of our sprite's `rotation` property.
+
+```miniscript
+for ang in range(0,360)
+	spr.rotation = ang
+	yield
+end for
+```
+
+{i:"`yield`"}
+You should see the wumpus slowly spin counter-clockwise.  The `yield` call here makes the script wait until the next frame; frames happen 60 times per second.  Since we're changing our angle by 1 degree on each frame, it takes 6 seconds to complete the loop.  If we wanted to spin faster, we could simply change the angle more on each step.  Try replacing the `range` call above with `range(0, 360, 6)` for example, which should complete six times faster.
+
+What about position?  That's just as easy:
+
+```miniscript
+for x in range(100, 900, 10)
+	spr.x = x
+	yield
+end for
+```
+
+Type that in, and watch the wumpus zoom across the screen from left (x=100) to right (x=900).  Now you try: make a loop that moves the Wumpus vertically instead of horizontally.  (Remember that `y` values in Mini Micro range from 0 at the bottom of the screen, to 640 at the top.)
+
+Finally, let's look at the `scale` property.  This is a factor that's multiplied by the sprite's natural size.  When `scale` is 1, then one pixel in the image appears as one pixel on screen.  If you set `scale` to 2, then each image pixel covers two pixels on screen.  You're not limited to whole numbers, either; you can set the scale to 0.1 or 1.25 or anything else, and the sprite will be scaled accordingly.
+
+But this section is about animation, so let's animate!  This time, how about a `while` loop:
+
+```miniscript
+while true
+	spr.scale = 1 + sin(time)/2
+	yield
+end while
+```
+
+{i:"`time`;`sin`"}
+The scale here is set using the built-in `time` function, which returns the time in seconds since the start of the program.  This is passed through `sin` to produce a scale factor that slowly changes between 0.5 and 1.5.  Just press Control-C when you've had enough of this animation.
+
+Our furry Wumpus is a single image, so loading it was very easy.  But most animated characters have many different versions of the image, in different poses or with different expressions.  Sometimes these are stored on disk as separate little image files, but other times, multiple sprite images are arranged into one big image file called a "sprite sheet."
+
+sprite sheet
+: a single image file that contains multiple smaller images meant for use as sprites
+
+Mini Micro has examples of both styles in the `/sys/pics/` directory.  For example, `cd` down into "/sys/pics/KP" and do a `dir`.  You will see eight images of K.P., a cute little character who looks like a handheld video game with arms and legs.  (Remember that you can use the `view` command to preview an image in Mini Micro.)
+
+But now go back up to the `/sys/pics` directory (perhaps by using `cd ".."`), and view the file "Enemies.png".
+
+![The result of doing `view "Enemies.png"` in the `/sys/pics` directory.  (The background color was changed to white before doing this command, to make the dark colors in the image easier to see.)](ViewEnemies.png)
+
+Here you can see one image file that includes quite a lot of little pictures: four versions of four different enemies, plus eight facial expressions, and a box of instructions on the right.  (That's a feature most sprite sheets don't have, but this one does.)
+
+To make a sprite from a sprite-sheet is a two-step process: (1) load the sprite sheet itself; (2) extract the smaller image you need using `Image.getImage`.  For example:
+
+```miniscript
+sheet = file.loadImage("Enemies.png")
+spr = new Sprite
+spr.image = sheet.getImage(0, 128*3, 128, 128)
+display(4).sprites.push spr
+spr.x = 480; spr.y = 320
+```
+
+The only real difference between this and the Wumpus example you did before is the `getImage` call on line 3, which plucks out a square area that starts at 0 on the left, 128\*3 pixels up from the bottom, and is 128 pixels wide by 128 pixels tall.
+
+This leads to the final common trick for animating sprites: changing the image over time.  You probably noticed in the Enemies sprite sheet that there were two versions of the colored enemies, differing only in which foot is down.  By alternating between these two images, we can give the appearance of the enemy marching in place.  Continuing from the previous example...
+
+```miniscript
+img1 = sheet.getImage(0, 128*3, 128, 128)
+img2 = sheet.getImage(0, 128*2, 128, 128)
+while true
+	spr.image = img1
+	wait 0.2
+	spr.image = img2
+	wait 0.2
+end while
+```
+
+You should see the yellow enemy grumpily stamping his feet.
+
+At this point we've just done very simple, quick animation demos at the REPL prompt.  In real games, things get a little more complicated: you probably have multiple sprites all doing different things.  How do you keep track of what to change on every frame?  ...Object-oriented programming to the rescue!
+
+The solution is to create a subclass of `Sprite` for each kind of sprite you need in your game, all with an `update` method to be called on each frame.  Each such object is responsible for keeping track of its own state, so it knows what it needs to change and when.  Then the main loop has nothing to do but call `update` on all the sprites.  Here's an example that illustrates that, using the same enemy sprite as above.  But this is getting too long to type in on the command line, so you will probably want to use `edit` to invoke the code editor.
+
+{i:"`/sys/lib`,`mathUtil`"}
+{caption:"Stampy demo."}
+```miniscript
+import "mathUtil"
+clear
+sheet = file.loadImage("/sys/pics/Enemies.png")
+// Make a subclass of Sprite called Stamper
+Stamper = new Sprite
+Stamper.frames = []  // (image for each frame of animation)
+Stamper.frames.push sheet.getImage(0, 128*3, 128, 128)
+Stamper.frames.push sheet.getImage(0, 128*2, 128, 128)
+Stamper.target = {"x":480, "y":320}
+Stamper.lastStepTime = 0
+Stamper.curFrame = 0
+Stamper.update = function()
+	if time > self.lastStepTime + 0.2 then
+		// Change to the other image (stamp stamp!)
+		self.curFrame = 1 - self.curFrame
+		self.image = self.frames[self.curFrame]
+		self.lastStepTime = time
+	end if
+	// Move towards the target
+	mathUtil.moveTowardsXY self, self.target, 5
+end function
+
+// Create a Stamper instance, and add to the sprite display.
+stampy = new Stamper // yes, it's stampy the Stamper!
+display(4).sprites.push stampy
+stampy2 = new Stamper // and he has a friend
+display(4).sprites.push stampy2
+stampy2.target = {"x":800, "y":100}
+
+// Main loop: update sprites, and set target on mouse click
+while true
+	for spr in display(4).sprites
+		spr.update // (assumes all sprites have an update function)
+	end for
+	if mouse.button then stampy.target = mouse + {}
+	yield
+end while
+```
+
+When you run this, you should see two enemy sprites appear.  One slinks off into the corner and stays there, while the other moves to any point on the screen that you click with the mouse.  And both enemies stamp their feet the whole time.
+
+Let's quickly go over how this works.  The first line imports the "mathUtil" module, so we can use the handy `mathUtil.moveTowardsXY` function to move our sprite towards a target.  On lines 5-21 we define a Sprite subclass called Stampy, with properties to keep track of both sprite frames (images plucked from the sprite sheet), as well as a target position, what time we last took a step, and the current frame.  The class also includes an `update` method, that assigns a new `image` when it is time to take a step, and moves the whole sprite 5 pixels closer to the target.
+
+Lines 24-25 create a new `Stamper` instance named `stampy`, and add it to the sprite display.  Lines 26-28 create *another* `Stamper` instance, and give it a different initial target.
+
+Finally, the main loop updates all the sprites (assuming that all sprites have an `update` method, which is true in this demo because they are all derived from `Stampy`).  Also, when the mouse button is pressed, it sets the target of our `stampy` sprite to the mouse position (plus an empty dictionary; see note below).  Finally, we remember to call `yield` in the main loop, so that it the loop will run only once per screen update.
+
+D> What's going on with `mouse + {}` in line 35?  Adding two maps together always results in a *new* map, even if one of the maps you're adding is empty.  So this is a way of creating a fresh copy of the `mouse` map.  Without this trick, we would be telling `stampy` to use the built-in `mouse` map as its target, and when the values in that map get updated (as they automatically do whenever you move the mouse), the sprite would automatically follow it.  Try it: remove `+ {}` from that line, and see what happens!
+
+
+## Controlling Draw Order
+
+The last example had two sprites on screen.  If you directed the the first one to the lower-right corner, so that it overlapped the second sprite, then you may have noticed that at always appeared behind the second one.
+
+That's controlled by the order in which sprites appear in the `sprite` list of the display.  In that last example, we first pushed `stampy` onto the list at position 0, and then we pushed `stampy2`, which would put it at position 1.  You can think of the sprite display as simply walking through its sprite list, drawing the sprites in order, so in this case `stampy2` appears on top.
+
+Run that example again, and position the moving sprite so that it's partially overlapping the stationary one.  Then break the program (Control-C), and type in this:
+
+```miniscript
+while true
+	display(4).sprites.push display(4).sprites.pull
+	wait 1
+end while
+```
+
+Every second, this simply loop pulls element 0 off the sprites list, and pushes it onto the end of the list.  Changing the order of sprites in a list changes the order in which they are drawn on screen.
+
+Some games like to sort the sprites to produce a pseudo-3D effect, where sprites higher up on the screen are meant to be further away from the viewer, and so should be drawn behind sprites that are lower on the screen.  We can make the Stampy demo do that with two small changes.  First, insert this line at the bottom of the `Stamper.update` function:
+
+{number-from: 21}
+```miniscript
+	self.sortOrder = -self.y
+```
+
+This adds a new `sortOrder` property to the sprites that decreases as Y increases, that is, the sortOrder gets smaller as sprites move up the screen.  Then add these lines in the main loop, after `end for` but before the `if mouse.button` line:
+
+{number-from: 36}
+```miniscript
+	// sort sprites by their sortOrder property
+	display(4).sprites.sort "sortOrder"
+```
+
+Now run again, and move our moving Stampy around near the stationary one.  You should observe that whichever sprite is higher on the screen is now drawn behind, and whichever one is lower on the screen is drawn in front.  This creates the illusion that the sprites are moving in 3D space.
+
+{width:"50%"}
+![Back off, dude!  If I had a neck, you'd be breathing down it.](StampyClose.png)
+
+Before we move on, save this program if you haven't already — I called it "StampyDemo", but you can call it whatever you like.  We will use it again later.
+
+## Hit Detection
+
+The last topic of this chapter is about detecting when something is touching a sprite.  When that something is the mouse, this is called *hit detection*; when it's another sprite, it's more commonly called *collision detection*.
+
+hit detection
+: determining whether a point on the screen (usually, the mouse) is touching a sprite
+collision detection
+: determining whether two sprites are touching
+
+{i:"`Bounds` class"}
+PRINT>Both of these tasks are done in Mini Micro with the help of another built-in class called `Bounds`.  `Bounds` has the properties listed below, and the methods at the top of the next page.
+EBOOK>Both of these tasks are done in Mini Micro with the help of another built-in class called `Bounds`.  `Bounds` has the properties listed below.
+
+{caption:"Properties of the Bounds class (where `b` is any Bounds object).  All of these may be written (i.e. assigned to) as well as read."}
+|`b.x`|horizontal position of the center of the bounding box|
+|`b.y`|vertical position of the center of the bounding box|
+|`b.width`|bounding box width|
+|`b.height`|bounding box height
+|`b.rotation`|rotation angle of the bounding box, in degrees|
+
+EBOOK>`Bounds` also has the following three methods.
+
+{caption:"Methods of the Bounds class (where `b` is any Bounds object)."}
+|`b.corners`|returns box corners as a list of [x,y] coordinates|
+|`b.overlaps(`*b2*`)`|returns whether `b` is touching box *b2*|
+|`b.contains(`*x*`, `*y*`)`|return true if point *x, y* is within box `b`|
+
+You can use `Bounds` by itself, just to define a rectangular (possibly rotated) area and see whether any point is inside or outside that area.  But the more usual way to use it is via the `Sprite` class.  `Sprite` has special support for a Bounds object called `localBounds`.  Once you assign and configure the `localBounds` of a sprite, you can then do hit testing and collision testing on that sprite.
+
+Some examples will make this clearer.  Let's create a fresh sprite, using our old friend the Wumpus.
+
+```miniscript
+clear
+spr = new Sprite
+spr.image = file.loadImage("/sys/pics/Wumpus.png")
+display(4).sprites.push spr
+```
+
+You should see the Wumpus once again peeking out from the lower-left corner.  If you look at `spr.localBounds`, you will see it is null.  Sprites do not automatically get any bounding box defined.  But let's define one:
+
+```miniscript
+spr.localBounds = new Bounds
+spr.localBounds.width = spr.image.width
+spr.localBounds.height = spr.image.height
+```
+
+Now we've created a `Bounds` object, assigned it to the special `localBounds` property of our Sprite, and then set its width and height to match the image.  We didn't assign to the `x` or `y` properties of the bounds, so they are implicitly `0,0`, which is the center of the sprite.
+
+That's all the setup you need to do to enable the `contains` and `overlaps` methods of Sprite to work.  For example, try this code to make the Wumpus bashful and jump away from the mouse.
+
+{caption:Bashful Wumpus doesn't want to be clicked on!}
+```miniscript
+while true
+	if spr.contains(mouse) then
+		spr.x = 960*rnd
+		spr.y = 640*rnd
+	end if
+end while
+```
+
+Type that in and then see if you can click on the Wumpus.  Slippery little monster, isn't he?
+
+Because this is such a common and useful task, let's summarize.
+
+D> **Hit-Testing Summary**
+D> 1. Set the sprite's `localBounds` to define the bounding box relative to the sprite itself.
+D> 2. Call `contains` on the sprite with a point of interest.
+
+Note that the `contains` method actually allows several different parameter styles for defining the point of interest:
+
+- give it the *x* and *y* coordinates as two separate numeric parameters; or
+- give it a list containing [*x*, *y*]; or 
+- give it a map containing "x" and "y" keys.
+
+In the example above, we gave it `mouse`, which happens to be a map containing *x* and *y*, so we were using the third style.
+
+Finally, let's consider collision-testing.  This is what we use to tell if two sprites are touching each other.  You set this up exactly the same way, except that there are two sprites involved instead of one; and then you use the `overlaps` method to test whether they are touching.
+
+To illustrate, please load up that Stampy demo you made in the previous section.  We're going to modify it to tint the moving sprite whenever it touches the stationary one.  First, where we are defining the `Stamper` class, we need to add a `localBounds`.
+
+{number-from: 9}
+```miniscript
+Stamper.localBounds = new Bounds
+Stamper.localBounds.width = 128
+Stamper.localBounds.height = 128
+```
+
+Then, let's add a special version of the `update` method just for `stampy`, our moving Stamper.  It will begin by calling the superclass version of `update`, so that it does whatever all Stampers do; but it will then do the `overlaps` test against `stampy2`, and blush accordingly.
+
+{number-from: 34}
+```miniscript
+stampy.update = function()
+	super.update  // do regular update first
+	if self.overlaps(stampy2) then
+		self.tint = color.red
+	else
+		self.tint = color.white		
+	end if
+end function
+```
+
+With those changes, run the program again, and guide your stamper around the screen.  You should see that whenever it touches the second stamper, it turns red.  Note that the argument to `overlaps` can be either a `Bounds` object, or a `Sprite` object; either will work (but passing a `Sprite` is more common).
+
+## Sprites in the Wild
+
+Now that you know how to create, animate, hit-test, and collision-check sprites in Mini Micro, be on the lookout for sprites in the apps you use every day.  Any little image that moves, rotates, reacts to clicks or taps, and animates by switching among some series of predefined frames is likely a sprite.  You'll see them in any 2D game, but sometimes in serious productivity software too, where they may be serving as custom widgets in the user interface.  Sprites also appear in 3D games, as an efficient way to draw things that are far away from the camera, or as status bars, icons, and other such elements that appear in the user interface, or float over units in the game.
+
+Sprites are one of the most powerful, general, and widely useful concepts in real-time computer graphics.  Now that you have this tool in your toolbelt, you will be using it a lot.  Keep it sharp!
+
+A> **Chapter Review**
+A> - You learned about sprites, and how to create them in Mini Micro.
+A> - You animated sprites by changing their position, rotation, or image.
+A> - You discovered the `Bounds` class, and used it to test whether a sprite is touching a point or another sprite.

data/day23.txt

@@ -0,0 +1,364 @@
+{chapterHead: "Day 23: Fun with Words", startingPageNum:279}
+
+{width: "50%"}
+![](Chapter23.svg)
+
+
+Q> Sometimes it's better to leave something alone, to pause, and that's very true of programming.
+Q>— Joyce Wheeler (Executive Director of Technology, LinkedIn)
+
+A> **Chapter Objectives**
+A> - Discover Mini Micro's built-in English word list.
+A> - Write some code to analyze data and generate random strings of letters.
+A> - Lay the foundation for a word game (to be completed tomorrow).
+
+
+{i:"`/sys/data`"}
+Today we're going to do something a bit different.  Mini Micro comes with a list of over 64,000 common English words, found in the file `/sys/data/englishWords.txt`.  We'll use this to explore how code can be used to answer questions about data that would be very hard to answer in any other way.  Then, we'll make a solid start on a fun word game, where the player tries to find words in a grid of random letters.  We'll get about halfway through that game today, then take a break and finish it tomorrow.
+
+## Exploring the Words File
+
+Let's begin by using the `view` command in Mini Micro to peek at the file:
+
+```terminal
+]view "/sys/data/englishWords.txt"
+```
+
+You should see a pageful of words in alphabetical order: *a*, *aah*, *aardvark*, and so on, followed by something like "64637 more".  You can press Return a few times to see more pages, but chances are good you'll lose interest before even getting out of the A's.  When that happens, press Q or the Escape key to exit `view`.
+
+You can see that the structure of this file is quite simple: one word per line.  So we can read all the words into a list by doing:
+
+```miniscript
+words = file.readLines("/sys/data/englishWords.txt")
+```
+
+I wouldn't suggest trying to print `words` at this point (but hey, go ahead and try if you want — it's not going to hurt anything, though it may take a while).  But print `words.len` to see how many words there are.
+
+This list of words is a data set, so put on your "data scientist" hat and let's ask some questions about it.  We've already seen the first few items, alphabetically.  What are the *last* few words?  Print out `words[-10:]` to see.
+
+We've also already seen one of the shortest words in the English language, "a".  Are there any other 1-letter words?  Let's use a simple `for` loop to find out.  It's a loop so short that, if you like, you can do it as a one-liner:
+
+```miniscript
+for w in words; if w.len==1 then print w; end for
+```
+
+In addition to "a", this also prints out "I" (the pronoun) and "O" (as in "O say can you see?").  It also prints out "x", which surprised me when I did this.  But finding surprises in data is part of the fun!  (And yes, if you look up "x" in many dictionaries, you will find it defined as a word meaning to cross out or indicate choice.)
+
+Now let's find the longest word in the set.  This is slightly bigger `for` loop.
+
+```miniscript
+biggest = ""
+for w in words
+	if w.len > biggest.len then biggest = w
+end for
+biggest
+```
+
+This loops over all words, comparing each one to the biggest word found so far.  Whenever it finds a new biggest word, it stores that in `biggest`, which we print out at the end.  What word did you find?  And, how many letters does it have?  (No fair counting them by hand — make MiniScript do that for you!)
+
+Next up is a question I actually needed an answer to.  I was pondering making a word-search game, where the user would try to make words out of randomly selected letters in a grid, and I wondered what to do with "Q".  Usually "Q" in English is followed by a "u", but is that always the case?  Maybe there are a bunch of exceptions we're not thinking of.  Let's find out!
+
+{i:"`/sys/lib`,`stringUtil`"}
+```miniscript
+import "stringUtil"
+for w in words
+	if w.contains("q") and not w.contains("qu") then print w
+end for
+```
+
+Notice that we had to import "stringUtil" before doing this `for` loop.  That's because `contains` is not a standard MiniScript intrinsic function; it is something added by the `stringUtil` module.  (The standard MiniScript solution would be to check whether `w.indexOf("q") != null`, but `contains` is a lot clearer.)
+
+So this loop prints out every word that contains a "q", but does not contain "qu".  Exactly three words popped out: "burqa", "burqas", and "qwerty".  Out of more than 64 thousand words, that's not too many!
+
+If we also import the "listUtil" module, we'll get some additional handy functions, like the `any` method that returns a random element of a list.
+
+```miniscript
+import "listUtil"
+for i in range(1,10); print words.any; end for
+```
+
+But enough playing!  Keep your data-scientist hat on a bit longer, but now balance your game-developer hat on top (programmers often have to wear many hats).  We're going to be making a game that involves a grid of random letters.  But we don't want to pick all letters with equal likelihood; that would result in a lot of Z's and X's that aren't terribly useful.  We want to pick more common letters more often, and less common letters less often.  But which letters are the most common, and by how much?
+
+## Letter Frequency Analysis
+
+That's another data analysis question we can answer with code.  This one requires a little more code than you probably want to do on the REPL command line, though.  So fire up the editor, and enter the following.
+
+{caption: "Letter frequency analysis program."}
+```miniscript
+import "mapUtil"
+import "listUtil"
+
+// load the word list
+words = file.readLines("/sys/data/englishWords.txt")
+
+// convert all words to uppercase
+for i in words.indexes
+	words[i] = words[i].upper
+end for
+
+// count the frequency of each letter
+print "Analyzing words..."
+counts = {}  // key: letter; value: count
+for word in words
+	for letter in word
+		counts[letter] = counts.get(letter, 0) + 1
+	end for
+end for
+print counts
+```
+
+This one takes a little longer to run, as it's iterating not only over the words, but the letters within the words.  But before too long, out pops the answer: the total number of times each letter occurs in the word list.  Save this program as `freqCount.ms` in case you need it later.
+
+Now we're going to do a trick.  Select that output by clicking and dragging over it with the mouse.  Now copy with Control-C (or on a Mac, you can use Command-C).  Use `reset` to clear the frequency-counting program, then `edit` to start a new one.  Finally, type "freq =", and then paste the output you copied before (using the Paste button or Control+V).  Adjust the line breaks, and voila!  The result should look something like this (though the order of the letters may be different — remember that when you print or iterate over a map, the order of the entries is undefined).
+
+{caption: "The start of our word game, with frequencies copied from the output of the previous program."}
+```miniscript
+freq = {"A": 40116, "H": 12329, "R": 38506, "D": 21334, 
+"V": 5427, "K": 5275, "S": 49034, "B": 10303, "C": 21554, 
+"I": 47047, "U": 17692, "E": 62155, "L": 27954, "O": 33150, 
+"N": 37001, "G": 16930, "M": 14495, "T": 36982, "Y": 8191, 
+"J": 941, "Z": 2090, "P": 15815, "F": 7635, "W": 5081, 
+"Q": 990, "X": 1487}
+```
+
+Save this as "wordGame.ms" and run it.  It doesn't generate any output, but once run you should be able to enter `freq` and see your frequency map.
+
+D> You just used code to write code.  Programs making programs.  Scary, or cool?  Maybe both!
+
+## Starting the Word Game
+
+Let's start building the rest of the game.  Edit your program, and insert some lines above your frequency table, so that it looks like this.
+
+{i:"`/sys/lib`,`mapUtil`;`/sys/lib`,`listUtil`;`/sys/lib`,`mathUtil`;`/sys/lib`,`sounds`"}
+{caption: "Listing 1 (Start of the actual game)."}
+```miniscript
+import "mapUtil"
+import "listUtil"
+import "mathUtil"
+import "sounds"
+
+clear
+text.color = color.silver
+
+display(2).mode = displayMode.pixel
+overlay = display(2)
+overlay.clear
+
+kRows = 5
+kCols = 5
+
+words = file.readLines("/sys/data/englishWords.txt")
+for i in range(0, words.len-1)
+	words[i] = words[i].upper
+end for
+
+freq = {"A": 40116, "H": 12329, "R": 38506, "D": 21334, 
+"V": 5427, "K": 5275, "S": 49034, "B": 10303, "C": 21554, 
+"I": 47047, "U": 17692, "E": 62155, "L": 27954, "O": 33150, 
+"N": 37001, "G": 16930, "M": 14495, "T": 36982, "Y": 8191, 
+"J": 941, "Z": 2090, "P": 15815, "F": 7635, "W": 5081, 
+"Qu": 990, "X": 1487}
+```
+
+{i:"`/sys/lib`"}
+The first four lines simply import some modules from `/sys/lib` that we will make use of elsewhere.  (When writing your own programs from scratch, you can add these as you need them, or just put your favorites at the top of any program you begin.  There's no harm in importing them even if you don't actually use them.)
+
+Lines 6-11 clear the screen and set up the displays.  That includes changing the text color to silver, so don't be surprised to see that happen when you run this code.
+
+Lines 13 and 14 define how many rows and columns we will use in our grid of random letters.  The "k" prefix is commonly used to identify a "constant" value, that is, a value that should not change throughout the life of the program.  (Yes, I know that "constant" does not start with a "k" in English.  Nonetheless this is a common convention.)
+
+Then lines 16-19 load the words file, and convert all the words to upper case.  That saves us from having to worry about mixed upper/lower case later on.
+
+Finally, after all that comes the frequency table you developed in the last section, with one little change: find the "Q" entry, and change it to "Qu".  Because we determined earlier that words that use a "q" without a "u" are extremely rare, our game will never use a "q" by itself; instead we'll always pick that as the "qu" combo.
+
+## Random Letters
+
+Now we need some code to generate a random letter, or a whole grid of random letters.  And we want to do this in a way that mirrors the normal frequency of letters in our word set, so that "E" is the most common letter picked, "J" is the least, and so on.  Add the listing below to your growing program.
+
+{caption: "Listing 2 (Selecting random letters).", number-from: 28}
+```miniscript
+totalFreq = freq.values.sum
+
+randomLetter = function()
+	i = floor(rnd * totalFreq)
+	for kv in freq
+		if i < kv.value then return kv.key
+		i = i - kv.value
+	end for
+end function
+```
+
+Run that, and again nothing happens.  But let's test the code out as we consider how it works.  Line 28 calculates the total of all the frequency values in our table, i.e., the total number of letters in our word set.  `freq.values` would give you a list of all the frequencies, and appending `.sum` adds them up.  Enter `totalFreq` to make sure it gives you a nice big number like 539514.  (Feel free to proudly tell your neighbor that your code processes over half a million letters without breaking a sweat.)
+
+The `randomLetter` function picks a random number `i` from 0 to this total frequency count.  Then it iterates over the frequency table (using `kv` to remind us that these are key/value pairs), checking whether `i` is less than the frequency value of each letter.  This will of course be more likely for numbers with big values (like E and S) than for numbers with small values (like X and J).  If our random `i` is in fact less than the value of the letter, we return that letter.  Otherwise, we subtract that letter's value from `i`, and go on to check the next letter.  This makes `i` smaller and smaller, and guarantees that by the time we reach the end of the frequency table, we *will* find some letter that fits — and the probability of each letter being chosen is exactly equal to their relative frequencies.
+
+D> This is an algorithm known as a *weighted random selection*, and it can be used any time you want to pick from a set of things, but with a different probability or "weight" for each thing.
+
+Enter `randomLetter` at the REPL prompt, and it should print out a letter (or in the case of "Qu", two letters).  Repeat it a few times (or maybe even use a `for` loop!), and convince yourself that the more common English letters are appearing more often.
+
+## Creating Letter Tiles
+
+Our game is going to involve a grid of letter tiles, much like the playing pieces in Scrabble.  These little tiles need to move around, detect mouse clicks, etc., so we'll make a Sprite subclass to represent them.
+
+D> Careful: we're using "tile" here just to describe the shape and usage of the sprites in this game.  Don't confuse it with "tile" as in `TileDisplay`, which we'll be learning about in Chapter 25.  In this chapter and the next, remember that our "tiles" are just ordinary sprites that happen to look like letter tiles.
+
+In most games, you load sprite images from picture files on disk.  But in this case, we're going to draw the tile images in a PixelDisplay, and then pull out that part of the display as an image to use for the sprite.  It's a neat trick to consider any time you can work out a way to draw your sprite images with code.
+
+{caption: "Listing 3 (Tile-drawing code, and Tile class).", number-from: 38}
+```miniscript
+blockPic = file.loadImage("/sys/pics/Block.png")
+drawBlock = function(letter, x=100, y=100)
+	gfx.drawImage blockPic, x, y, 40, 40
+	if letter.len < 2 then
+		gfx.print letter, x+8, y+4, color.black, "large"
+	else
+		gfx.print letter, x+6, y+8, color.black
+	end if
+end function
+
+Tile = new Sprite
+Tile.letter = ""
+Tile.scale = 2
+Tile.tint = color.yellow
+Tile.target = {"x":0, "y":0}
+Tile.speed = 100
+Tile.localBounds = new Bounds
+Tile.localBounds.width = 36
+Tile.localBounds.height = 36
+
+Tile.goTo = function(x,y, speed)
+	self.target.x = x
+	self.target.y = y
+	if speed != null then self.speed = speed	
+end function
+
+Tile.goToGridPos = function(col, row)
+	self.goTo 300 + col * 90, 135 + row * 90
+end function
+
+Tile.update = function(dt = 0.1)
+	mathUtil.moveTowardsXY(self, self.target, self.speed * dt)
+end function
+
+Tile.updateAll = function(dt = 0.1)
+	updatedAny = false
+	for s in spriteDisp.sprites
+		if not s isa Tile then continue
+		if s.x == s.target.x and s.y == s.target.y then continue
+		s.update
+		updatedAny = true
+	end for
+	return updatedAny
+end function
+
+Tile.selected = function()
+	return self.tint != Tile.tint
+end function
+```
+
+Add that to your program, then run it, and let's test it out on the command line.
+
+```terminal
+]drawBlock "E"
+]drawBlock "Qu", 140, 100
+```
+
+This should produce two tiles near the bottom of the screen: one "E", and one with a smaller "Qu".  
+
+{width:"50%"}
+![](WordGameEQu.png)
+
+Now let's try grabbing the first of these as the image for a Tile instance.
+
+```terminal
+]t = new Tile
+]t.image = gfx.getImage(100,100,40,40)
+]display(4).sprites.push t
+[t]
+]t.x = 200; t.y = 300
+```
+
+This should create a large (due to `Tile.scale`), yellowish (due to `Tile.tint`) letter "E" tile.  The `Tile` class includes some simple animation code, too.  Let's test it:
+
+```terminal
+]t.goTo 800, 600
+]while true; t.update; yield; end while
+```
+
+If you see your "E" tile slide up towards the upper-right corner of the screen, then you're ready to press Control-C and move on to the next code listing.  If not, go back and check your typing carefully.
+
+{caption: "Listing 4 (Letter grid storage and set-up).", number-from: 86)
+```miniscript
+// 2D array to keep track of the tiles that belong in each
+// row and column of the grid.  Indexed first by column,
+// and within a column indexed bottom-up, so within a column
+// we can easily remove something and the rest shift down.
+grid = list.init2d(kCols, kRows)
+
+makeSprite = function(letter)
+	gfx.fillRect 0, 0, 40, 40, color.clear
+	drawBlock letter, 0, 0
+	spr = new Tile
+	spr.image = gfx.getImage(0, 0, 40, 40)
+	spr.letter = letter
+	return spr
+end function
+
+letterSprites = {}  // key: letter; value: Tile
+for code in range("A".code, "Z".code)
+	gfx.clear
+	c = char(code)
+	if c == "Q" then c = "Qu"
+	letterSprites[c] = makeSprite(c)
+end for
+gfx.clear
+
+display(4).mode = displayMode.sprite
+spriteDisp = display(4)
+spriteDisp.clear
+
+newTile = function(col, row)
+	tile = new letterSprites[randomLetter]
+	tile.target = {"x":0, "y":0} // make sure tile has its own target map
+	spriteDisp.sprites.push tile
+	tile.goToGridPos col, row
+	tile.x = tile.target.x
+	tile.y = tile.target.y + 500 + 50 * rnd + 100*row
+	grid[col][row] = tile
+	return tile
+end function
+
+for col in range(0, kCols-1)
+	for row in range(0, kRows-1)
+		newTile col, row
+	end for
+end for
+```
+
+This code uses the `list.init2d` method from the `listUtil` module to initialize a two-dimensional array, that is, a list of lists.  It's stored in global variable `grid`, and to get to any particular Tile, you index into this twice: `grid[c][r]` gets you the Tile in column `c` and row `r`.  Columns start at 0 on the left and go up to 4 on the right; rows start at 0 on the bottom, and go up to 4 on top.  So the layout of these accessors is just like X and Y pixel positions, or column and row in a text display.
+
+The `makeSprite` function does what we did by hand earlier: it draws the given letter into the `gfx` PixelDisplay, then grabs that image and assigns it to a freshly created Tile.  To save time later on, we do this once for each letter in the loop on lines 102-107.  Also notice the special trick we do on line 105, where instead of making a "Q" tile, we make it "Qu".  All these sprites are stored in a map called `letterSprites`, so we can easily look up a sprite for any letter.
+
+Lines 110-112 just set up the sprite display, and the `newTile` function starting on line 114 creates a new tile, with a random letter (using the `randomLetter` function we made earlier), and stores it in `grid`.  It also tells the tile to go to its grid position, but then on lines 119-120, sets its *current* position to some spot much higher on the screen.  That's so that we can have all the tiles fall pleasingly into place when the game begins.
+
+Finally, the nested `for` loops at the end of Listing 4 call `newTile` for every row and column, creating our initial grid of tiles.  Our program does not yet have a main loop to make them animate, so after you enter all that and run it, let's test it out by manually entering, on the REPL command line:
+
+```terminal
+]while true; Tile.updateAll; yield; end while
+```
+
+PRINT>This should cause all the tiles to slide neatly down from the top of the screen.  The final result should look something like the image on the next page.
+EBOOK>This should cause all the tiles to slide neatly down from the top of the screen.  The final result should look something like the image below.
+
+{width: "80%"}
+![Things have fallen into place.](WordGameGridTest.png)
+
+{pageBreak}
+And we're going to stop there for today.  You've worked hard and made a great start on your most complex program yet — you deserve a break!
+
+A> **Chapter Review**
+A> - You explored the `englishWords.txt` file included with Mini Micro.
+A> - You learned how to use your coding powers to get answers about large datasets.
+A> - You wrote code to load the word set, draw tiles, turn those into sprites, and animate them into place.
+
+

data/day24.txt

@@ -0,0 +1,270 @@
+{chapterHead: "Day 24: Word-Find Game", startingPageNum:293}
+
+{width: "50%"}
+![](Chapter24.svg)
+
+Q> When to use iterative development? You should use iterative development only on projects that you want to succeed.
+Q>— Martin Fowler (software developer and author)
+
+A> **Chapter Objectives**
+A> - Finish the word game we started yesterday.
+A> - Get practice at making sprites interact with the mouse.
+A> - Learn techniques for debugging with a Read, Eval, Print Loop.
+
+Yesterday we made a solid start on our word-finding game: we prepared the word list, wrote code to randomly select letters in the same proportions as real words, made a `Sprite` subclass named `Tile`, and animated a grid of tiles sliding into place.  Today we're going to finish the game, with selection of letters to make a word, checking these against the word list, calculating a score, and a timer to make it exciting.
+
+## Tile selection
+
+Start by adding the code in Listing 1 to the program you began yesterday.
+
+{caption:"Listing 1 (tile selection with the mouse).", number-from: 131}
+```miniscript
+tileUnderMouse = function()
+	for s in spriteDisp.sprites
+		if not s isa Tile then continue
+		if s.contains(mouse) then return s
+	end for
+end function
+
+wordInProgress = ""
+addToWord = function(tile)
+	globals.wordInProgress = wordInProgress + tile.letter
+	if lastTile != null then
+		overlay.line lastTile.x, lastTile.y, tile.x, tile.y, "#88FF8888", 5
+	end if
+	globals.lastTile = tile
+	tile.tint = color.aqua
+	tile.selected = true
+end function
+
+trackMouseOnTiles = function()
+	while mouse.button
+		updateTime
+		yield
+		tile = tileUnderMouse
+		if tile == null or tile.selected then continue
+		if mathUtil.distance(tile, lastTile) > 150 then continue
+		addToWord tile
+	end while
+end function
+```
+
+{i:"`isa` operator;operator, `isa`"}
+We've added several new functions here.  The `tileUnderMouse` function is responsible for figuring out which `Tile` instance, if any, is under the mouse.  It does this by iterating over all sprites in the display, skipping any that is not actually a `Tile`.  It checks whether each sprite `s` is a `Tile` by using MiniScript's `isa` (pronounced "is a") operator.
+
+D> `isa` is the operator used to check data types in MiniScript; it returns 1 (true) if the operand on the left matches the type on the right, and 0 (false) otherwise.  Built-in types can be identified as `number`, `string`, `list`, `map`, and `funcRef`.  In the case of a class, `isa` returns true if the object on the left is the class on the right, or any subclass of it.
+
+The `tileUnderMouse` function then uses the `Sprite.contains` method to check whether each tile contains the mouse.  (Recall that this works because we assigned the `localBounds` of the `Tile` class.)
+
+The next function, `addToWord`, adds a given tile to the growing word, stored in the `wordInProgress` global variable.  Then it draws a line in the overlay display (a `PixelDisplay` we prepared at the top of the program), and highlights the given tile by tinting it aqua.
+
+Finally, the `trackMouseOnTiles` function is a loop that continues as long as the mouse is down.  It's meant to be called after the first tile has been clicked, and it handles dragging of the mouse over subsequent tiles.  Lines 154 avoids any problems when the mouse is between tiles.  Line 155 prevents users from cheating by snaking the mouse in between tiles to reach some farther-away tile.  Neighboring tiles are always less than 150 pixels away, so if we find the mouse is over some tile farther away than that, we just ignore it.
+
+To test this code requires a little bit of work: we need to first initialize our grid, and then wait for the user to click the mouse.  Then we need to update `lastTile` and call `addToWord` before we can finally call that `trackMouseOnTiles` function.  Add the following test code to your program so you can try it out and make sure it works.
+
+{caption:"Test code for Listing 1.", number-from: 160}
+```miniscript
+// test code:
+updateTime = null // (we'll fill this in later)
+for i in range(1000); Tile.updateAll; end for
+while not mouse.button; yield; end while
+lastTile = tileUnderMouse
+addToWord lastTile
+trackMouseOnTiles
+print wordInProgress
+```
+
+It's worth pointing out the trick on line 161: if you assign `null` to a variable, you can use that like a do-nothing function with no parameters.  That's needed in this case because  `trackMouseOnTiles` calls `updateTime` to update a timer, but we haven't gotten to that code yet.
+
+With this test code in place, run your program.  Tiles should settle very quickly into place, and then if you click any tile and drag, you can construct a word (or a string of random gibberish).  Run it a few times.  What's the longest word you can find?  (Mine was "FILET"... but I bet you can do better!)
+
+## Clearing tiles
+
+To turn this word-selection functionality into a game, we'll need at least two more things.  First, if the word is valid, then we need to clear out the tiles used, move any higher-up tiles down, and add new tiles to fill the columns.  Second, in the case where the letters traced do not make a valid word, we need to just deselect those tiles so the player can try again.
+
+The code in Listing 2 below provides these functions.  Insert this code *before* your existing test code, as you'll still need that to test.
+
+{caption:"Listing 2 (Tile clearing and deselection).", number-from: 160}
+```miniscript
+clearUsedTiles = function()
+	for col in range(0, kCols-1)
+		// first iterate top-down, deleting any selected tiles
+		for row in range(kRows-1, 0)
+			tile = grid[col][row]
+			if tile == null or not tile.selected then continue
+			spriteDisp.sprites.removeVal tile	// remove sprite
+			grid[col].remove row		// remove used tile
+			grid[col].push null		// add empty spot to column
+		end for
+		// then iterate again bottom-up, adding new tiles
+		for row in range(0, kRows-1)
+			if grid[col][row] == null then
+				newTile col, row
+			else
+				grid[col][row].goToGridPos col, row
+			end if
+		end for
+	end for
+	overlay.clear
+	globals.lastTile = null
+end function
+
+deselectTiles = function()
+	for col in range(0, kCols-1)
+		for row in range(0, kRows-1)
+			tile = grid[col][row]
+			tile.selected = false
+			tile.tint = Tile.tint
+		end for
+	end for
+	overlay.clear
+	globals.lastTile = null
+end function
+```
+
+Let's discuss how these functions work.  The `clearUsedTiles` function iterates over the columns of the grid.  For each column, it iterates over the rows twice.  First it goes top-down, deleting any selected tiles from the list of tiles in that column, and pushing an empty entry (`null`) onto the end of the list.  Then it goes bottom-up, telling each tile to go to (i.e. set its target position to) the proper place on screen, and creating new tiles for any `null` entries it finds.  The net effect of all this is to take out the selected tiles, shift the ones above it down, and create new tiles as needed.
+
+The `deselectTiles` function is simpler.  It just iterates over all rows and columns, turning off the `selected` flag, and setting the tint back to the standard `Tile` tint.  Then it clears the `overlay` display where the tracing line is drawn, and while we're at it, also clears the global `lastTile` variable that keeps track of the last tile clicked.
+
+After inserting that code, run the program again, and then use the mouse to trace out some letters.  Then enter `deselectTiles` at the command prompt.  The selected tiles should go back to normal, and the tracing overlay should disappear.
+
+Then run the program again, and again select a sequence of tiles.  This time call `clearUsedTiles`, and you should see the selected tiles disappear.  The surrounding tiles (and new tiles, currently off the top of the screen) have had their targets set, but they need an animation loop in order to reach those targets.  Let's give them one:
+
+```terminal
+]while true; Tile.updateAll; yield; end while
+```
+
+This should cause the tiles to slide down into place.  Press Control-C to break the loop once that is done.
+
+## Adding a score and history
+
+Now let's add some more functions to handle when a word has been entered.  We want to draw the word near the top of the screen, above the tile grid; and then score it based on whether it's in the dictionary, and how long it is.  Long words are much harder to find than short ones, so we want to really reward the player for finding these.  So we'll define the score for a word with `n` letters as `2 ^ n`, that is, 2 to the `n`th power.  That gives us 2 points for a 1-letter word, 4 points for 2-letter words, 8 points for 3-letter words, and so on.
+
+In addition to the total score, we'll also keep a history of all the words found in the course of the game.  This will be displayed on the left side of the screen, so when you find some really amazing word like EVACUATE, you can show people even if it's not the last word in the game.
+
+Again insert the new code (in Listing 3 this time) above your existing test code.
+
+{caption:"Listing 3 (Word drawing and scoring functions).", number-from: 195}
+```miniscript
+drawWord = function(word, valid)
+	if valid then c = color.aqua else c = color.teal
+	gfx.clear
+	gfx.print word, 480 - word.len/2*20.5, 550, c, "large"
+end function
+
+score = 0
+wordsFound = []  // each element will be [word, points]
+scoreWord = function(word)
+	valid = words.contains(word)
+	drawWord word, valid
+	if not valid then return false
+	points = 2 ^ word.len
+	wordsFound.insert 0, [word, points]
+	text.row = 21
+	for w in wordsFound
+		print (w[0] + " "*11)[:11] + (" "*5 + w[1])[-5:]
+		if text.row < 2 then break
+	end for
+	globals.score = score + points
+	text.row = 25
+	print "SCORE: " + score
+	return true
+end function
+```
+
+There are two functions in this chunk as well.  The `drawWord` function simply sets a color based on whether the word is valid, then clears the `gfx` PixelDisplay, and uses `gfx.print` to print the word in a large font.
+
+The `scoreWord` function is responsible for determining whether the word is valid, by checking whether our `words` list contains it.  (Recall that `contains` is a method added to the list type by the `listUtil` module.)  It calls that `drawWord` function, and then if the word is not valid, bails out on line 206.  Otherwise (that is, if the word is valid), it calculates the points, inserts the word and score at the front a `wordsFound` list, and then updates the text display.  Notice also that `scoreWord` returns `true` if the word was valid, and `false` if not; this lets the calling code do other things based on whether the word was good.
+
+To test this, go down to the last line of your test code.  If we've stuck together on all the blank lines and whatnot, it'll be line 227.  In any case, replace the `print` statement at the end of your test code with:
+
+{number-from: 227}
+```miniscript
+scoreWord wordInProgress
+```
+
+Now run the program.  First select a bunch of gibberish characters that do not make a valid word.  You should see the word drawn above the tiles, but no score appear.  Now run it again, but this time find some valid word.  You should see the word drawn in a brighter color, a score appear in the top-left corner of the screen, and the word plus its score appear to the left of the grid — a fairly redundant display when there's only one word, but nice once we start entering multiple words.
+
+## Wrapping up
+
+Almost done!  To finish the game, we're going to finally add that `updateTime` function, which puts a timer in the upper-right corner of the screen.  And finally, as in most games, we'll have a main loop.  Delete that test code at the end of your program, and enter the following.
+
+{caption:"Listing 4 (Timer and main loop).", number-from: 220}
+```miniscript
+endTime = time + 120
+updateTime = function()
+	timeLeft = ceil(endTime - time)
+	text.row = 25
+	text.column = 58
+	if timeLeft <= 0 then
+		print "TIME'S UP!"
+	else
+		mins = floor(timeLeft/60)
+		secs = ("00" + (timeLeft % 60))[-2:]
+		print "TIME: " + mins + ":" + secs
+	end if
+end function
+
+lastTile = null
+while true
+	while Tile.updateAll; updateTime; yield; end while
+	if time > endTime then break
+	while not mouse.button; updateTime; yield; end while
+	tileHit = tileUnderMouse
+	if tileHit == null or tileHit.selected then continue
+	addToWord tileHit
+	trackMouseOnTiles		
+	
+	if scoreWord(wordInProgress) then
+		sounds.daDing.play
+		clearUsedTiles
+	else
+		sounds.land.play
+		deselectTiles
+	end if
+	wordInProgress = ""
+end while
+
+s = "Final Score: " + score
+text.row = 2
+text.column = 34 - s.len/2
+print s
+sounds.wow.play
+```
+
+This code uses the `time` intrinsic method, which is the number of seconds that have passed since the start of the session, to calculate an `endTime` once, when the program first runs.  Then every time the `updateTime` method is called, we can calculate how much time is left, and print that at the top of the screen.  All that math on lines 228 and 229 is just a way to convert a number of seconds (`timeLeft`) into minutes and seconds, and ensure that the seconds always display as two digits so you get "1:08" instead of "1:8".
+
+The main loop, lines 235-252, is mostly just calling all the other functions you defined and tested yesterday and today.  It has a couple of smaller loops inside it.  The one on line 236 updates all the tiles, until they have all slid into place.  Line 237 checks for the timer running out, and breaks out of the main loop.  Then the little loop on line 238 waits for the user to click the mouse.  Both of those little loops update the timer while they wait.
+
+Once we know the user has clicked the mouse, we find the tile hit by calling `tileUnderMouse`, just like our old test code.  But now there's a check for the case where the user failed to hit any tile (line 240), which is something we ignored before.  Remember that `continue` jumps to the next iteration of the loop, skipping the rest of the loop body.
+
+If the user hit a valid tile, then we add it to the word (line 241), and track the mouse until it's released (line 242).  Then we call that `scoreWord` function, which both updates the display, and tells us whether the word was valid.  Depending on whether it was valid, we either clear the tiles used, or just deselect them (while also playing a sound).
+
+Finally, we reset our `wordInProgress` variable, end our main loop, repeating all of the above until the timer runs out.
+
+When that happens, the `break` on line 237 will jump down past the `end while`, where we print the final score, and play a "wow" sound to signal the end of the game.
+
+This is a pretty long program — great job hanging in there!  You should pause at this point and just play with it a bit.  Grab some friends or family and challenge them.  I got a score of 170 just now.  Can you beat that?
+
+## Taking it further
+
+This is a complete, fun game as it is.  But there are certainly ways you could extend it or modify it to make it your own, and I encourage you to try!
+
+You could very easily change the number of rows and columns, since these magic numbers were stored in constants at the top of the program.  I just changed mine from 5 columns to 6, and immediately found the word ANIME.  What can you find?
+
+One obvious change would be to the scoring formula.  Replace `2 ^ word.len` with something else.  It could be another formula based on the word length, or you could iterate over the letters of the word, and add a certain score for each letter, like in Scrabble.  How does this affect your strategy when you play?
+
+As written, the history (the words and scores previously obtained) always has the newest words at the top.  That made sense to me, but maybe you'd like it better if the newest words were at the bottom.  Can you figure out how to make that change?  (Hint: look for where a new entry is beeing added to the `wordsFound` list.)
+
+A somewhat more substantial change would be to add a feature that lets the player destroy letters without making them part of a word.  For example, maybe if the user right-clicks a letter, you clear that letter (select it and call `clearUsedTiles`), but subtract 50 points from the score.  This really enhances the strategy, since it makes it possible to connect much longer words, but there's a penalty for doing it.
+
+Or, consider giving the user some way to clear all the letters at once and get a fresh set, for those times when you feel like you've just gotten rotten luck on the draw.  Perhaps detect when a certain key has been pressed (with `key.available` and `key.get`), and in that case, select all tiles and call `clearUsedTiles`.
+
+A> **Chapter Review**
+A> - You finished a word game, your longest and most sophisticated program yet.
+A> - You probably got some practice debugging and tracking down typos.  This is an important skill and well worth practicing!
+A> - You considered ways to go beyond the code in the book, changing things and adding features to make it your own.
+
+
+
+

data/day25.txt

@@ -0,0 +1,307 @@
+{chapterHead: "Day 25: Tile Display", startingPageNum:305}
+
+{width: "50%"}
+![](Chapter25.svg)
+
+Q> Testing leads to failure, and failure leads to understanding.
+Q>— Burt Rutan (aerospace engineer and entrepreneur)
+
+A> **Chapter Objectives**
+A> - Learn the last type of Mini Micro graphics display, `TileDisplay`.
+A> - Get familiar with presenting grid-based data or images.
+A> - Learn to draw hexagonal grids as well as rectangular ones.
+
+You've learned a lot about Mini Micro's sophisticated display system by now.  To review, it has eight display layers, each of which can be configured to any of the following modes:
+
+| 0 | off | no display |
+| 1 | solid color | displays one color over the whole screen |
+| 2 | text | 26 row, 68 column text display |
+| 3 | pixel | 960 by 640 (by default) pixel display |
+| 4 | tile | displays a rectangular grid of small images |
+| 5 | sprite | displays a set of scaleable, rotatable, resizable images |
+
+Most of these were covered on Day 19, though pixel displays were covered on Day 18, and sprite displays on Day 22.  The only display mode we haven't explored yet is `tile` mode.
+
+So today, let's do that!  After today, your training in Mini Micro graphics will be complete.
+
+## TileDisplay
+
+The big idea with a `TileDisplay` is that it takes little rectangular sub-images from a source image called a "tile set," and places them into a grid of locations on the screen.
+
+![Overview of how TileDisplay works. Rectangular portions of a tile set (SimplePlatformTiles.png, *left*) are mapped to rectangular portions of the display (*right*).  That happy character standing on the bridge is a Sprite, but everything else on screen is a TileDisplay. Grid lines have been added for reference.](TileDisplayOverview.png)
+
+{i:"`/sys/demo`,`platformer`"}
+The figure above shows one of the built-in images (`/sys/pics/SimplePlatformTiles.png`) on the left, with grid lines added so you can see where the tiles are.  Such an image is called a *tile set*.  On the right is a screen shot of the platform demo (`/sys/demo/platformer.ms`), also with reference lines added.  Each of those little squares in the `TileDisplay` is called a *cell*, and each cell shows some *tile* from the tile set.  Let's get that terminology straight to avoid confusion later.
+
+tile set
+: an image composed of a rectangular grid of smaller images intended to be used with a tile display
+tile
+: one of those little images in a tile set
+tile display
+: a display composed of rectangular cells, each displaying zero or one tiles from a tile set; in Mini Micro, represented by the `TileDisplay` class
+cell
+: one of those little rectangular areas of the display
+
+## Sprites vs. Tiles
+
+Remember those letter tiles in the word game of Chapters 23 and 24?  Those were *sprites*, drawn in a `SpriteDisplay`, and for good reason: we wanted them to fall smoothly into position, and we might even want to add a little bit of rotation to each one to make them look more natural.  That sort of fine control is not possible with a `TileDisplay`; every cell in a `TileDisplay` is positioned precisely next to its neighbors like every other cell, and no rotation is possible.
+
+Why would you ever use a `TileDisplay`, then?  There are two chief advantages.  First, a `TileDisplay` is somewhat easier to manage, since you need only assign a tile number to any cell of the display, and the graphics on screen automatically update.  You'll see how easy that is by the end of the chapter.  Second, while `SpriteDisplay` is the most efficient way to draw a bunch of moving/rotating pictures, it can't compete with a `TileDisplay` when it comes to drawing a large grid of same-sized little images.  So if you're making something like a map or game board, in most cases `TileDisplay` is both easier and faster.
+
+## The `TileDisplay` class
+
+When you set a display's `mode` to `displayMode.tile`, it changes the type of that display to `TileDisplay`, which means it gets the following assignable properties:
+
+{caption:"Properties of the `TileDisplay` class (where `td` is any `TileDisplay` reference).  All these may be both read and assigned to.  The `extent`, `tileSetTileSize`, `cellSize`, and `overlap` properties may be either a single number applied to both X and Y, or an `[x,y]` list."}
+|`td.extent`|[columns, rows] display size|
+|`td.tileSet`|`Image` containing tiles to draw from|
+|`td.tileSetTileSize`|size of tiles in `tileSet`|
+|`td.cellSize`|size of tiles (cells) on screen|
+|`td.overlap`|cell overlap on screen, in pixels|
+|`td.oddRowOffset`|amount to shift odd rows horizontally; use 0.5 for hex rows|
+|`td.oddColOffset`|amount to shift odd columns vertically; use 0.5 for hex columns|
+|`td.scrollX`|horizontal scroll amount, in pixels|
+|`td.scrollY`|vertical scroll amount, in pixels|
+
+{pageBreak}
+And it gets the following methods (you can only call these, not assign to them):
+
+{caption:"Methods of the `TileDisplay` class."}
+|`td.clear` *toIndex*|set all tiles to null (the default) or the given index|
+|`td.cell(x,y)|get the tile index of cell `x`,`y`|
+|`td.setCell x, y, idx|set the tile index of cell `x`,`y` to `idx`|
+|`td.cellTint(x,y)|get the tint color of cell `x`,`y`|
+|`td.setCellTint x, y, c|set the tint of cell `x`,`y` to color `c`|
+
+That seems like a lot, but as we'll see shortly, they fall into just a couple of groups: things for configuring the TileDisplay at setup time, and things for controlling the content (the tiles shown and their tint color) as your program runs.
+
+## Basic Configuration
+
+EBOOK>It's time to put hands to keyboard and start using this thing!  You may recall from Day 19 the default display types that Mini Micro gets at startup (or when you use the `clear` command).  These include a PixelDisplay (display 5), a SpriteDisplay (4), and of course a TextDisplay (3).  They do not, however, include a TileDisplay.
+
+EBOOK>So the first thing to do is create such a display!  You can put it in any layer you want, but for this chapter, let's repurpose layer 5, as we won't be doing any pixel drawing anyway.  Fire up Mini Micro, and let's get started.
+
+{width: "50%", position:"top"}
+![The tile set image `/sys/pics/TileShapes.png`, with tile index numbers added.](SimpleTileShapes.png)
+
+PRINT>It's time to put hands to keyboard and start using this thing!  You may recall from Day 19 the default display types that Mini Micro gets at startup (or when you use the `clear` command).  These include a PixelDisplay (display 5), a SpriteDisplay (4), and of course a TextDisplay (3).  They do not, however, include a TileDisplay.
+
+PRINT>So the first thing to do is create such a display!  You can put it in any layer you want, but for this chapter, let's repurpose layer 5, as we won't be doing any pixel drawing anyway.  Fire up Mini Micro, and let's get started.
+
+```terminal
+]display(5).mode = displayMode.tile
+]td = display(5)
+```
+
+Nothing much appears to happen at this point, but invisibly, display 5 has transmogrified from a pixel display into a tile display.  We've also assigned it to a variable called `td` so we can refer to it more easily.  Now let's load a tile set (and also use the `view` command so you can get a glimpse of what it looks like).
+
+```terminal
+]td.tileSet = file.loadImage("/sys/pics/TileShapes.png")
+]view td.tileSet
+```
+
+The tile set we've loaded here is a selection of eight different simple shapes, in eight different colors.  The image is 512 by 512 pixels, and since there are 8 rows and columns, this means the tile size (in the tile set) is 64 pixels wide and tall.  This is the next thing we have to do: tell the tile display how big the tiles are.
+
+```terminal
+]td.tileSetTileSize = 64
+```
+
+We used just a simple number here (64) because the tiles are square.  That's usually the case, but if you ever find or make a tile set with non-square tiles, you can specify the width and height in a list like `[48,32]`.
+
+Finally we're ready to get some tiles onto the display!  The easiest way to do that is with the `.clear` method, which takes a *tile index* to know which tile it should clear everything to.
+
+tile index
+: a number which identifies a tile in a tile set, starting with 0 at the top-left, and counting left-to-right, then top-to-bottom
+
+The figure above shows the tile indexes for this tile set.  Let's clear the tile display to the dark blue circle, which is tile index 20.
+
+```terminal
+]td.clear 20
+```
+
+The result should look something like this:
+
+{width:"75%"}
+![Initial setup of a TileDisplay.](TileDisplay1.png)
+
+
+Now we can see the tile display: it's that grid of blue circles!  Check your understanding of tile index by trying a few other values.  Can you fill the display with red diamonds?  How about purple hexagons?
+
+You probably noticed that the tile display does not fill the whole screen.  There 12 columns and 7 rows of cells, which is called the *extent* of the display.
+
+extent
+: how many columns and rows a tile display has
+
+In fact if you type `td.extent` at the prompt, it will tell you `[12, 7]`.  You can change it by simply assigning a new pair of numbers.  Note that if you make the tile set *smaller*, you see the change right away; but if you make it bigger, it's not so obvious, because the new rows and columns are filled in with empty cells.  You need to use the `.clear` method (or otherwise fill in the new cells) to see the new extent.  Try this, carefully observing the result at each step:
+
+```terminal
+]td.extent = [8,6]
+]td.extent = [15,10]
+]td.clear 20
+```
+
+Now the screen should be full of blue circles.  But that's a function of the extent of the tile display, and also the cell size.  The default cell size is 64, which happens to be the same as our tile size in this case.  But you can easily change it.  Explore:
+
+```terminal
+]td.cellSize = 32
+]td.cellSize = 320
+]td.cellSize = [128,32]
+]td.cellSize = 64
+```
+
+Note that just like the `tileSetTileSize` property, you can specify `cellSize` as either a simple number for square cells, or as a `[width, height]` list for non-square cells.
+
+Changing the tile size is how you can scale a tile display.  What about scrolling?  That uses the same `scrollX` and `scrollY` properties you already saw on `PixelDisplay` and `SpriteDisplay`.
+
+```terminal
+]for x in range(0,100); td.scrollX = x; wait 0.1; end for
+]td.scrollX = 0
+```
+
+A tile display could be configured to be many times bigger than the actual screen, with different areas being scrolled into view as needed during a run.
+
+## Using Cells
+
+You've already been using tile indexes with the `.clear` method, to clear the whole tile display to the same cell.  Now let's learn to set, read, and tint specific cells.
+
+The methods for doing this are very similar to those you would use on a `TextDisplay` (Day 17): `cell(column, row)` to read the tile index at a given column and row, or `setCell column, row, index` to set it.  And just like a `TextDisplay`, rows count up from the bottom, and columns count from the left side of the display.  So to change the lower-left cell to index 8 — a round-cornered square in our tile set — just do:
+
+```terminal
+]td.setCell 0, 0, 8
+```
+
+Now try using the `cell` method to read back the tile index at several positions.
+
+```terminal
+]td.cell 0,0
+8
+]td.cell 1,0
+20
+```
+
+Simple, right?  Cover up the code below, and see if you can solve the following challenge without looking: change the cell that's 6th from the left, and 3rd from the bottom, into a white diamond.  (Remember that rows and columns begin at 0, not at 1.)
+
+```terminal
+]td.setCell 5, 2, 40
+```
+
+Did you get it right?
+
+D> Make up some more challenges for yourself if you need more practice; the computer is a calm and infinitely patient teacher.
+
+Instead of assigning a tile index to a cell, you can also set it to `null`, which means "don't draw any tile here at all."  In fact this is what the `.clear` method does to all cells if you don't specify an index value.  Go ahead and try it now:
+
+```terminal
+]td.setCell 3, 3, null
+```
+
+The other thing you can do with tile display cells is tint them, just like sprites.  If you tint a pixel that's white in the source image, it comes out exactly the tint color; but if the source image is darker, then you get a darker version of the tint color.  That's why white images are so useful.  In fact, this `SimpleTiles.png` is really eight times bigger than it needs to be; it could have been *only* white shapes, as all the other colors could be made by tinting.  (But sometimes it's convenient to use the prebaked colors, too.)  Anyway, try this:
+
+```terminal
+]td.setCellTint 5, 2, color.orange
+]td.setCellTint 5, 1, color.gray
+```
+
+The first line above tints that white diamond a nice strong orange.  The second line tints a blue circle gray, which really just makes it a darker blue.
+
+Hopefully you see how by assigning different tile indexes and/or tints to different cells, you can build a complex display that looks like a map, or a platformer game level, or anything else that has a basically grid-like structure.
+
+## Overlap and Offset
+
+So far we have only seen cells arranged into a neat square or rectangular grid.  Tile displays in Mini Micro are more versatile than that, however.
+
+First, it is possible to set the cells in the display to overlap horizontally, vertically, or both.  To do this you assign to the `overlap` property a list that contains the desired horizontal and vertical overlap.  For example:
+
+```terminal
+]td.overlap = [0, 8]
+```
+
+This scrunches the cells so that they overlap in Y.  This can be useful for certain art styles, where each tile contains bits at the top that overlap, for example, grass or flowers that stick up from the ground on a grass tile.  When tiles are overlapped, they're always layered so that lower rows on the screen are drawn on top of higher rows, producing the correct result in this case.  In other cases, `overlap` is simply used to spread the cells apart, or squeeze them together, as needed.
+
+The second trick you can do with the cell arrangement is to offset odd-numbered rows or columns by some fraction of the cell width.  This is useful in making isometric or hexagonal maps.  Let's start with an isometric map.  That's one where the map is made of little diamonds that fit together neatly, as if you were looking at graph paper from an angle.
+
+{width: "50%"}
+![Isometric map made using the `overlap` and `oddRowOffset` properties of a `TileDisplay`.](IsometricTiles.png)
+
+To do set this up, we'll use a diamond-shaped tile with a rectangular cell size.  Then we'll use `overlap` to make it so that each row overlaps the one above it, and the `oddRowOffset` property to shift the odd-number rows over by one half the cell width.  Try it:
+
+```terminal
+]td.overlap = 0
+]td.clear 40
+]td.cellSize = [64, 48]
+]td.overlap = [0, 24]
+]td.oddRowOffset = 0.5
+```
+
+Line 1 above just clears out the `overlap` values from our previous experiment.  Line 2 clears the display to a white diamond tile, and line 3 squashes that vertically so that each cell on screen is wider than it is tall.  Line 4 makes the rows overlap, and then — here's the real trick — line 5 shifts the odd rows (i.e. row 1, 3, 5, etc.) over by one half (0.5) of the cell width.  The result is a nice neat isometric display, as shown in the figure above.
+
+The other use for shifting odd rows or columns is to make a hexagonal display.  The basic idea here is the same: make your tiles overlap, and then add a row or column offset, depending on which way your hexagons are rotated.  We'll walk through each case, using circle tiles at first (which make it slightly easier to see what's going on) and then switching to hexagons.
+
+First, let's get back to an ordinary square grid of circles.
+
+```terminal
+]td.oddRowOffset = 0
+]td.cellSize = 64
+]td.overlap = 0
+]td.clear 16
+```
+
+Remember that the 16 used on line 4 is just the tile index for a white circle in our tile set.  If you look back at the tile set, you'll see that right below that, at index 24, is a hexagon with a flat top and points on its left/right sides.  That means when we're all done, the cells are going to overlap a bit horizontally, and we'll be offsetting the odd columns to make them all fit.  Try it step by step:
+
+```terminal
+]td.overlap = [11, 0]
+]td.oddColOffset = 0.5
+]td.clear 24
+```
+
+{gap:20}
+{width: "50%"}
+![Hexagonal grid with offset columns.](Hex24.png)
+
+The next row in our tile set, at index 32, is the opposite kind of hexagon: it's flat on the sides, and pointy on top and bottom.  To fit together neatly, it needs to overlap in Y, and have the odd rows shifted over by half a cell.
+
+```terminal
+]td.clear 16
+]td.oddColOffset = 0
+]td.overlap = [0, 11]
+]td.oddRowOffset = 0.5
+]td.clear 32
+```
+
+The first two lines above are just undoing our previous demo; lines 3-5 do the actual setup for this kind of hexagonal display.
+
+{width: "50%"}
+![Hexagonal grid with offset rows.](Hex32.png)
+
+
+## Exploring the Demos
+
+`TileDisplay` is used by quite a few of the demos in `/sys/demo/`.  Here's a quick run-down of how each of them use it, and what you might be able to learn.
+
+{i:"`/sys/demo`,`drumMachine`"}
+**drumMachine**: this demo uses two overlaid tile displays, in display layers 5 and 6.  Both use the same `TileShapes.png` tile set you've been working with in this chapter.  The frontmost layer uses the square with rounded corners, and uses a *negative* `overlap` value to spread them apart so there's a nice gap between the cells.  The background layer uses no gap, and a solid square tile; this is used to highlight the column of cells that represents the current point in the music loop.  The result of all this is an interactive grid where each row represents a different instrument, and each column represents a point in time; by clicking those cells on and off, you can lay down a beat.
+
+{i:"`/sys/demo`,`levelEditor`"}
+**levelEditor**: this is an interesting one, because it's not just a demo, but also a useful tool.  It sets up `display(6)` as the tile display, with `display(5)` used in pixel mode to draw on top of the tiles.  It then provides functions to define the pattern of tiles in a tile display, save these out to disk as a data file, and load them back in for further editing next time.
+
+{i:"`/sys/demo`,`platformer`"}
+**platformer**: this game demo uses a layout defined by `levelEditor`, and also adds a sprite character who can run, jump, and climb.  The very first figure in this chapter was a screen shot of this demo and its tile set.  The code illustrates how to check the tile display where the character is trying to walk or climb, and use that information to react appropriately.  It's one of the more sophisticated demos in Mini Micro, but if you're interested in making platformer games, it's definitely the place to start.
+
+{i:"`/sys/demo`,`speedConquest`"}
+**speedConquest**: this turn-based strategy game also uses the `TileShapes.png` tile set, with a hexagonal layout (using `oddColOffset`).  In this case it uses only the white tile, and then tints them to each player's color to make their territories clear.  There's also a sprite layer, used to draw the units and flags on top of the tile display.  In the code you'll find some handy functions for converting between tile coordinates and pixel coordinates, which is a bit trickier in a hex layout than in a rectangular one.  These functions are useful for handling mouse clicks and figuring out where to position the sprites.  (It's also a really fun game — if you haven't given it a serious try yet, I recommend it!  It's a much deeper game than it first appears.)
+
+{i:"`/sys/demo`,`wumpusTrap`"}
+**wumpusTrap**: this puzzle game also uses a hex grid, but this time using `oddRowOffset` because the hexagons are in the other orientation.  Also, it uses different color tiles from the tile set rather than using tint.  Like `speedConquest`, it has some handy functions for converting between pixels and tile coordinates, so between the two, you should have a starting point for any sort of hex map you might want to make.  Naturally the wumpus in this game is in a separate sprite layer on top of the tile display.  (And yes, it is always possible to trap the wumpus — but not always easy!)
+
+A> **Chapter Review**
+A> - You explored the `TileDisplay` class, the last type of Mini Micro display.
+A> - You learned how to load a tile set, and configure the tile display.
+A> - You discovered how to control what a tile display shows by assigning a tile index or tint color to each cell.
+A> - You learned about the overlap and offset properties that enable you to make an isometric or hexagonal display.
+A> - You toured the built-in demos that illustrate some of the many ways a tile display can be put to use.
+
+
+{gap:250}
+{width:"25%"}
+![](chinchilla-05.svg)
+

data/day26.txt

@@ -0,0 +1,429 @@
+{chapterHead: "Day 26: Treasure Hunt", startingPageNum:319}
+
+{width: "50%"}
+![](Chapter26.svg)
+
+Q> No more training do you require.  
+Q> Already know you that which you need.
+Q>— Yoda (Star Wars: Episode VI - Return of the Jedi)
+
+A> **Chapter Objectives**
+A> - Build and enjoy the *Treasure Hunt* game.
+A> - See how `TileDisplay` is used in a real program.
+A> - Practice installing resources onto your user disk, so you're not limited to only the stuff on the `/sys` disk.
+
+Your introduction to MiniScript and Mini Micro are essentially complete at this point.  You learned the basics of coding, and flexed your skills via the Try-It! page, in the first week.  The second week you learned to use command-line MiniScript, while also learning about lists, maps, and classes.  Since then you've been exploring Mini Micro, and have learned about displaying text, pixel graphics, sprites, and tiles, not to mention playing sounds and music and interacting with the mouse and keyboard.  As Yoda said: already know you that which you need.
+
+However, just as with Luke's journey to master the Force, your journey is not yet over.  Your head is full of knowledge, but can you actually *use* that knowledge to create your own software?  For most readers, the answer at this point will be "not yet," and that's OK.  Learning to apply what you have learned takes practice.
+
+So the next few chapters of the book will be practice and review, in the form of programs for you to type in.  I urge you not to skip this exercise!  It will make your programming skills stronger.
+
+(And to any eager readers who skipped the first half of the book to get to the "good stuff," I say welcome!  But please remember to go back and go through the rest of the book at some point.  It will give you a strong foundation in the basics, and ultimately save you a lot of time learning things the hard way.)
+
+## *Treasure Hunt*
+
+The program for this chapter is a game based on the classic *Minesweeper*.  The basic idea behind *Minesweeper* dates all the way back to the era of mainframe computers in the 1960s.  For many years a version of *Minesweeper* was included with the Microsoft Windows operating system, leading to a great surge in popularity, and probably causing a noticeable drain on the office economy.
+
+The core game play for all *Minesweeper* variants is the same: you click squares on a map to discover what they contain.  If they contain a mine, it's game-over.  Otherwise, the square reveals how many mines there are in the neighboring squares.  Using these numbers, you can usually find a safe place to try next.
+
+Our version of the game is called *Treasure Hunt*, and adds a little twist: hidden along with the bombs are half a dozen treasures, and uncovering these treasures scores you points.  The faster you discover them, the more points you earn!
+
+{width: "80%"}
+![Screen shot of *Treasure Hunt*.](TreasureHuntGame.png)
+
+Incidentally, this game is so much fun, and the code so straightforward, that it almost didn't make it into this book.  I was very tempted to add it to the built-in demos in `/sys/demo/` in the final version of Mini Micro.  But in the end I decided to instead include it here, as a reward for those of you who took the time to work through this book.  Enjoy!
+
+## Getting the Tile Set
+
+This is the first program in this book that does not rely entirely on resources included on Mini Micro's `/sys` disk.  Instead, you'll need to download a tile set from the internet, and install it on your `/usr` disk.  This will become a very common task as you start building more of your own programs, so it's a good skill to learn.
+
+The tiles for this game are available on OpenGameArt.org, a web site dedicated to sharing artwork for making games.  You can find it by searching for "treasure hunt" on the main page there, or by pointing your web browser directly to `https://opengameart.org/content/treasure-hunt-tiles`.  When you find the right page, there will be a download link for `TreasureHunt.png`, an image that looks like the picture on the next page.
+
+{width: "50%"}
+![`TreasureHunt.png`, the tile set for the game.](TreasureHuntTiles.png)
+
+Now you need to get this onto your `/usr` disk.  You have several options for this:
+
+{pageBreak}
+- If you are using a *folder* for your user disk rather than a "minidisk" file, you can simply download the image with your web browser, and save it to that folder.
+- If not, you can download the image somewhere else, then use the `file.import` command in Mini Micro to copy it into your `usr` disk.
+- Or you can use `http.get` to download the file directly within Mini Micro, by right-clicking on the file link at OpenGameArt, then pasting it into a command like so:
+
+```terminal
+]img = http.get("https://opengameart.org/sites/default/files/treasurehunt_0.png")
+]file.saveImage "TreasureHunt.png", img
+```
+
+No matter which method you use, at the end you should have a `TreasureHunt.png` file on your user disk, in the folder where you plan to save the program.  If needed, review Chapter 14, which discusses how to convert your `/usr` disk between the minidisk (zip file) format and a folder of real files.  When you've got that sorted out, move on to the next step.
+
+## Starting the Program
+
+Now it's time to start on the code!  As in past chapters, we'll break this into sections, with a bit of explanation after each one.  But we won't lead you explicitly through testing code anymore.  You should still test as you go, though — *at least* run the program to make sure it doesn't generate any errors right away.  We'll point out further tests you can do at each point, but it will be up to you to write them.  Your programming skills are growing!
+
+{caption:"Listing 1 (Program set-up).", number-from: 1}
+```miniscript
+// Treasure Hunt!
+// A Minesweeper-type game with treasures.
+
+import "listUtil"
+
+// Constants
+kCols = 20
+kRows = 15
+kCellGrass = 16
+kCellFlag = 17
+kCellBomb = 18
+kCellTreasure = 10      // (first treasure on sand background)
+kCellTransTreasure = 26 // (first one on transparent background)
+
+// Set up the displays
+clear
+display(4).mode = displayMode.tile
+td = display(4)
+td.tileSet = file.loadImage("TreasureHunt.png")
+td.tileSetTileSize = 32
+td.cellSize = 32
+td.extent = [kCols, kRows]
+td.clear kCellGrass
+td.scrollX = -80; td.scrollY = -80
+
+gold = "#FFDD52FF"
+gfx.color = gold
+gfx.print "Treasures Found", 780, 540, gold, "small"
+gfx.line 780-4, 540-4, 780+"Treasures Found".len * 9 + 4, 540-4
+treasureListY = 540 - 48
+treasureListX = 780
+
+text.color = gold
+text.row = 25; print "TREASURE HUNT!"
+score = 0
+treasuresLeft = 0
+
+// Load sounds
+treasureSnd = file.loadSound("/sys/sounds/cha-ching.wav")
+bombSnd = file.loadSound("/sys/sounds/airburst.wav")
+```
+
+Here's a pretty typical first page of a Mini Micro game.  After a header comment, we import the `listUtil` module on line 4.  We'll be using the `list.init2d` method this module adds to conveniently create a 2D array to keep track of the hidden treasures and bombs.
+
+Then we define a bunch of constants on lines 7-13.  `kCols` and `kRows` define the size of the play area, and the other constants define the indexes of various tiles in the tile map, so we're not stuck looking at mysterious numbers like `17` for the rest of the program.
+
+The next block of lines, from 16 through 24, set up a `TileDisplay` and name it `td`, just as we saw in the previous chapter.  Then we set up the graphics display, with a nice gold color for the treasure list, and use the same color on the text display.  So this game is using three of Mini Micro's eight displays:
+
+- a `PixelDisplay` called `gfx` in layer 5, for the treasure list;
+- a `TileDisplay` called `td` in layer 4, for the game board; and
+- a `TextDisplay` called `text` in layer 3, for the time and score.
+
+Note that `gfx` and `text` are the standard layers set up by the `clear` command, but there is no standard `TileDisplay`, which is why we have to explicitly create one on lines 17-18.
+
+Finally, on lines 39-40, we load a couple of sounds we'll need later.
+
+You should run at this point, and make sure you don't see any errors.  You should also see a field of green tiles, a blank "Treasures Found" list on the right, and the "TREASURE HUNT!" title at the top.
+
+D> Also remember to save your work often!
+
+## The `GridPos` Class
+
+In this program we are going to be dealing with grid positions a lot.  We'll have code that figures out what grid position the mouse is over, what secrets are buried at that grid position, which grid positions are neighboring this one, and so on.  We could represent such grid positions as an `[x, y]` list, but a little more effort up front to define a `GridPos` class will pay off in simpler, clearer code later.
+
+{caption:"Listing 2 (The `GridPos` class.)", number-from: 42}
+```miniscript
+// Define a "GridPos" class to represent a grid
+// position (i.e. column, row).
+GridPos = {"col":0, "row":0}
+
+// Function to make a GridPos at a given column and row
+GridPos.make = function(c,r)
+	gp = new GridPos
+	gp.col = c
+	gp.row = r
+	return gp
+end function
+
+// Function to make a random (but in-bounds) GridPos.
+GridPos.random = function()
+	return GridPos.make(floor(kCols * rnd), floor(kRows * rnd))
+end function
+
+// Function to find the GridPos at a screen position;
+// returns null if out of bounds.
+GridPos.atXY = function(screenPos)
+	col = floor((screenPos.x + td.scrollX) / td.cellSize)
+	row = floor((screenPos.y + td.scrollY) / td.cellSize)
+	if col < 0 or col >= kCols then return null
+	if row < 0 or row >= kRows then return null
+	return GridPos.make(col, row)
+end function
+
+// Method to get all in-bounds neighbors of this GridPos
+GridPos.neighbors = function()
+	result = []
+	for i in range(-1, 1)
+		for j in range(-1, 1)
+			if i == 0 and j == 0 then continue
+			p = GridPos.make(self.col + i, self.row + j)
+			if p.col < 0 or p.col >= kCols then continue
+			if p.row < 0 or p.row >= kRows then continue
+			result.push p
+		end for
+	end for
+	return result
+end function
+
+// Method to get the tile cell through this GridPos
+GridPos.cell = function()
+	return td.cell(self.col, self.row)
+end function
+```
+
+Line 44 declares the `GridPos` class by simply assigning a map with default `col` and `row` properties.  To make it easier to create an instance of this class, we have the `GridPos.make` function on line 47.  Getting a *random* grid position is also a useful thing to do, especially when burying bombs and treasures, so we have a function for that starting line 55.  Notice how `GridPos.random` uses `GridPos.make` to make its job easier.
+
+Next, the `GridPos.atXY` function at line 61 works out what grid position is at a certain screen position (such as that given by `mouse`).  The code here is fairly general; it would work for any tile display `td`, provided that its `cellSize` is a simple number (rather than a `[width, height]` list), and no column or row offset is used.  Note that this function also does bounds checking, and returns `null` for any location outside the bounds of the grid.
+
+Lines 70-82 define the `GridPos.neighbors` method.  This is the first one intended to be called on a `GridPos` instance, i.e. some particular grid position, rather than on the `GridPos` class itself.  Its job is to return a list of all the neighboring in-bounds grid positions.  We need that in the game mainly to count how many bombs are hidden in neighboring cells, so we know what number to display.
+
+Finally, the `GridPos.cell` method at line 85 is just a shortcut for looking up the cell index from the tile display.  This turned out to be a sufficiently common thing in the rest of the code, that it was worth making this little helper method.
+
+At this point you should not only make sure the code runs, but also try out these `GridPos` functions.  You can do this right on the command line: call each one, passing in some reasonable parameter value, and make sure you get a sensible result.
+
+## Handling mouse clicks
+
+The next part of the program is a function to handle mouse clicks.  We want to treat each tile cell kind of like a button: darken it while the mouse is pressed and inside the cell, but return it to normal appearance fi the mouse is dragged outside the cell.  If the mouse is released outside the cell, it should have no effect.
+
+If it's released *inside* the cell, then the effect depends on which mouse button was used.  A normal (button 0) click reveals the hidden content of that cell, but a right-click (button 1) toggles a flag.
+
+{caption:"Listing 3 (`handleClick` function.)", number-from: 89}
+```miniscript
+handleClick = function(btn=0)
+	hitPos = GridPos.atXY(mouse)
+	if hitPos == null or hitPos.cell < kCellGrass then
+		// invalid click; just wait for mouse-up and return
+		while mouse.button(btn); yield; end while
+		return		
+	end if
+	// Valid click: highlight until mouse-up
+	while mouse.button(btn)
+		inCell = (GridPos.atXY(mouse) == hitPos)
+		if inCell then
+			td.setCellTint hitPos.col, hitPos.row, "#DDDDDD"
+		else
+			td.setCellTint hitPos.col, hitPos.row, color.white			
+		end if
+		yield
+	end while
+	// If mouse was not released in the hit cell, bail out
+	if not inCell then return
+	td.setCellTint hitPos.col, hitPos.row, color.white			
+	// Otherwise, process the click.
+	// Left click (btn 0), reveal the cell.
+	// Right click (btn 1), toggle flag.
+	if btn == 0 then
+		reveal hitPos
+	else
+		if hitPos.cell == kCellFlag then
+			td.setCell hitPos.col, hitPos.row, kCellGrass
+		else
+			td.setCell hitPos.col, hitPos.row, kCellFlag
+		end if
+	end if
+end function
+```
+
+The function begins by making sure we have clicked a valid cell.  The click is ignored if it is out of bounds, or if the cell index at the clicked point is less than the grass cell; all the tiles in the tile set before that represent already-revealed locations, and clicking those should have no effect.
+
+The loop from line 97 to 105 handles the "button" behavior, darkening the cell while the mouse is pressed within its bounds.  It also sets a local variable `inCell` to note whether the mouse is actually within the cell originally clicked.  So, once the mouse is finally released, line 107 can bail out if it was released outside the cell.
+
+D> If you're confused by all this, open up any ordinary program or web page that has a clickable button.  Mouse-down on the button, then drag the mouse away before you release.  The button should pop back up as soon as you're outside the button, and the button's effect is not triggered.  That's all we're doing here.
+
+Finally, if we make it to line 109, then it's a valid click.  Here we do different things depending on the mouse button used: either reveal the contents of the cell hit, or toggle between grass and flag.
+
+To test this, you will need to make a mock `reveal` method that takes one parameter.  It doesn't need to do anything, but you might have it just print the value of the parameter for testing purposes.  (We'll get to the real `reveal` method later.)  Then, call `handleClick 0` while you hold the left mouse button down on some cell of the grid; or call `handleClick 1` while holding the right mouse button.
+
+## Time, Score, and Burying Stuff
+
+Here are a handful of little functions we'll need.  Dividing your program into small functions like this is almost always a good idea.  Within the function, you can focus on a problem small enough to understand completely; and elsewhere, where you *use* the function, you can forget about the details and just trust that it does what it says it does.
+
+{caption:"Listing 4 (Drawing time and score, and tracking hidden items.)", number-from: 123}
+```miniscript
+// Function to draw the score and time.
+drawTimeAndScore = function()
+	minutes = floor(time/60)
+	seconds = ("00" + (floor(time) % 60))[-2:]
+	s = "Time: " + minutes + ":" + seconds
+	s = s + " " * 6 + "Score: " + ("000000" + score)[-6:]
+	text.row = 25; text.column = 38
+	print s	
+end function
+drawTimeAndScore
+
+// Our map of where stuff is hidden. This is stored as a 2D
+// list, indexed by column, row, with values of 0, 
+// kCellBomb, or kCellTreasure through kCellTreasure+5.
+hidden = list.init2d(kCols, kRows, 0)
+
+// Find an empty (grass) spot in the hidden map.
+findEmptyPos = function()
+	while true
+		p = GridPos.random
+		if hidden[p.col][p.row] == 0 then return p
+	end while
+end function
+
+// Populate the hidden map with bombs and treasures.
+buryStuff = function(qtyBombs=40, qtyTreasures=6)
+	for i in range(1, qtyBombs)
+		p = findEmptyPos
+		hidden[p.col][p.row] = kCellBomb
+	end for
+	for i in range(1, qtyTreasures)
+		p = findEmptyPos
+		hidden[p.col][p.row] = kCellTreasure + (i % 6)
+	end for
+	globals.treasuresLeft = qtyTreasures
+end function
+```
+
+Most of the `drawTimeAndScore` function is just composing the string we want to draw.  Notice the trick being used to add leading zeros to the numbers: add a string of zeros to the front, and then use `[-2:]` to grab just the last two characters of the result (or in the case of score, `[-6:]` to grab the last six).
+
+The global variable called `hidden`, defined on line 137, is important.  It is a two-dimensional list (i.e. list of lists) that keeps track of where all the treasures and bombs are buried.  Each entry is either `0`, indicating nothing of interest, `kCellBomb`, indicating a bomb (of course), or the index of one of the treasure tiles.  We use the `list.init2d` method, which was added by the `listUtil` module imported on line 4, to prepare this data structure.
+
+The next two functions work with that `hidden` list.  The `findEmptyPos` function uses an infinite loop to just keep trying random locations, until it finds one that is empty.  The `buryStuff` function makes use of that to store a number of bombs and treasures.
+
+To test these functions is pretty easy.  When you run the code at this point, you'll now see a time and score (both zero, of course) in the upper-right corner of the screen.  You can print out `hidden` and see that it's all zeros, then print it again after calling `buryStuff`, and see that it now contains some nonzeros (mostly 18, which are the bombs, but also some values between 10 and 16, which represent treasures).
+
+## Game Over!
+
+Next we'll need a couple of functions to handle winning or losing the game.  You lose the game when you click on a bomb, at which point it explodes, we reveal the positions of all the bombs, and then offer to play again.  Winning is simpler, as we just display a happy message, and also offer to replay.
+
+{caption:"Listing 5 (Functions to handle losing or winning the game.)", number-from: 160}
+```miniscript
+// Show an explosion at the given grid position; end the game.
+doBoom = function(p)
+	bombSnd.play
+	for i in range(0,3)
+		td.setCell p.col, p.row, kCellBomb + i
+		wait 0.1
+	end for
+	for c in range(0, kCols-1)
+		for r in range(0, kRows-1)
+			if hidden[c][r] == kCellBomb then
+				td.setCell c, r, kCellBomb
+			end if
+		end for
+	end for
+	td.setCell p.col, p.row, kCellBomb + 2
+	text.row = 1
+	print "Play again (Y/N)?"
+	if key.get.upper == "N" then exit
+	run
+end function
+
+gameWon = function()
+	text.row = 2; text.column = 30
+	print "YOU WIN!"
+	print "Play again (Y/N)?"
+	if key.get.upper == "N" then exit
+	run
+end function
+```
+
+To test the `gameWon` method is trivial (just call it on the command line).  To test `doBoom`, you'll need to pass in a grid position.  Remember that you can use `GridPos.make` to construct one of these very easily — for example, `GridPos.make(5,5)`.
+
+## Final Functions
+
+Only two more functions are needed in the Treasure Hunt game.  The first one is called when you discover a treasure; it updates the display and your score, and checks for successful completion of the game.  The other one reveals the contents of any cell, and takes appropriate action.
+
+{caption:"Listing 6 (`getTreasure` and `reveal` functions.)", number-from: 189}
+```miniscript
+// Show the treasure found; add it to our list and score
+getTreasure = function(p, found)
+	td.setCell p.col, p.row, found
+	treasureSnd.play
+	img = td.tileSet.getImage(32*(found-kCellTreasure+2), 0, 32, 32)
+	gfx.drawImage img, treasureListX + 20, treasureListY
+	points = 100 + ceil(1E6/(10+time))
+	gfx.print points, treasureListX+60, treasureListY+6, gold, "small"
+	globals.treasureListY = treasureListY - 40
+	globals.score = score + points
+	drawTimeAndScore
+	wait 0.5
+	globals.treasuresLeft = treasuresLeft - 1
+	if not treasuresLeft then gameWon
+end function
+
+// Reveal the given grid position.  If it's a bomb,
+// game over!  Otherwise show how many neighboring cells
+// contain bombs.  If that is 0, reveal all neighbors.
+reveal = function(p)
+	if td.cell(p.col, p.row) < kCellGrass then return
+	found = hidden[p.col][p.row]
+	// If we found a bomb, then it's game-over
+	if found == kCellBomb then
+		doBoom p
+		return
+	end if
+	// If we found treasure, reveal it
+	if found >= kCellTreasure and found < kCellTreasure+6 then
+		getTreasure p, found
+		return
+	end if
+	// Otherwise, count bombs and show the number
+	bombCount = 0
+	for n in p.neighbors
+		if hidden[n.col][n.row] == kCellBomb then
+			bombCount = bombCount + 1
+		end if
+	end for
+	td.setCell p.col, p.row, bombCount
+	// ...and if the bomb count was 0, then reveal neighbors too
+	if bombCount == 0 then
+		for n in p.neighbors; reveal n; end for
+	end if
+end function
+```
+
+The `getTreasure` function is fairly straightforward, but it contains a handy trick: it's calling `getImage` on the tile set image itself, to pluck out an image of the treasure for drawing on the pixel display.  You probably noticed that this tile set actually contains two versions of each treasure: one on the sandy background, and one on a transparent background.  This function grabs the transparent one, so we can draw it neatly into our list of collected treasures.
+
+The `reveal` method contains a technique you may find surprising.  If you've ever played Minesweeper, you know that when you click on a cell with *no* bombs next to it, then the game reveals not only that square, but all adjacent squares too.  And if ane of *those* squares have no neighboring bombs, the process repeats, potentially revealing a large hunk of the map at once.  How does this work?
+
+{i:"recursion"}
+It's actually quite simple: line 230 checks for the case where the bomb count is zero, and then that little loop on line 231 does the rest.  We simply loop over the neighbors of this grid position, and call `reveal` on each one.  The `reveal` method is calling itself, which is a technique called *recursion*.  This was first introduced in Chapter 13, in the "find a file" program.  You might go back and compare that program to the listing above, and see if recursion "clicks" for you yet.  (If not, don't worry — it will eventually!)
+
+Testing these functions is pretty straightforward.  You'll need to pass `getTreasure` a grid position (use `GridPos.make` again) as well as a treasure tile index, from 10 to 15.  You should see the treasure appear both on the map and on the "Treasures Found" list on the right side of the screen.
+
+To test `reveal`, just pass it a grid position.  But you might want to call `buryStuff` first, otherwise the map will be empty, and a single `reveal` will simply turn the whole map from grass to sand.
+
+## Main Loop
+
+Finally, as with most programs, the main loop comes at the end.  The main loop in this program is very simple, because we have so neatly divided all the real work out into functions.
+
+{caption:"Listing 7 (setup and main loop.)", number-from: 235}
+```miniscript
+// Setup and main loop
+buryStuff
+while true
+	drawTimeAndScore
+	if mouse.button(0) then handleClick(0)
+	if mouse.button(1) then handleClick(1)
+	yield
+end while
+```
+
+And that's it!  After you've put this in, go and play a while!  It's not an easy game to win, but not impossible either.  My high score is about 250,000 points.  Can you beat that?
+
+## Taking it Further
+
+This is a pretty polished game, but you could make it even better!
+
+You might start with some simple tweaks to optimize the fun.  You can easily change the board size by tweaking those constants on lines 7-8.  You could also change the number of bombs and treasures, by changing the default values on the `buryStuff` function on line 148, or by overriding those defaults where the function is called on line 236.  These tweaks can make the game longer or shorter, easier or harder.  It's up to you!
+
+Beyond that, you might want to do something more exciting when the game ends.  If you lose, there's a fairly satisfying boom and a small animation, but you might want to do something more spectacular... maybe draw a *giant* explosion sprite that covers the whole screen?  Or use a `SolidColorDisplay` to make the whole screen flash?  In the case of the user winning, you should at least play a triumphant fanfare, and maybe some sort of big "YOU WIN" graphic, rather than the easy-to-miss text under the map.  Maybe you'll even want to incorporate the fireworks animation from Day 21, and give the user a *real* treat!
+
+A> **Chapter Review**
+A> - You entered and debugged the *Treasure Hunt* game.
+A> - You practiced working with tile displays.
+A> - You also reviewed use of sounds, pixel displays, and text.
+A> - Most importantly, you practiced the "code a little, test a little" habit, this time with your *own* tests at each step.
+
+
+

data/day27.txt

@@ -0,0 +1,316 @@
+{chapterHead: "Day 27: Algorithms, Step by Step", startingPageNum:335}
+
+{width: "50%"}
+![](Chapter27.svg)
+
+Q> First, solve the problem. Then, write the code.
+Q>— John Johnson
+
+A> **Chapter Objectives**
+A> - Learn about algorithms and pseudocode.
+A> - Translate several pseudocode algorithms into MiniScript.
+A> - See how to fix an incomplete algorithm.
+
+Today we're going to address head-on a topic we've only hinted before now: *algorithms*.
+
+algorithm
+: a process to be followed in order to solve a problem
+
+Algorithms are wonderful things.  They are clear, step-by-step instructions for accomplishing something.  In mathematics, you learned algorithms for multiplying or dividing big numbers.  In the kitchen, you might have an entire book of algorithms for making various foods (those algorithms are usually called "recipes").  But it's in computing that algorithms are most famous, and most useful.  A computer is very good at following instructions quickly and accurately — but it has to be told exactly what to do.
+
+Of course programming is also telling a computer specifically what to do.  We've been doing that this whole book.  But programming is giving instructions to a computer in a specific programming language, like MiniScript.  Algorithms are at a slightly more generic level; they are instructions on how to solve a problem regardless of the specific programming language used.  They are usually written in either natural language (for example, English), or else in pseudocode.
+
+pseudocode
+: a made-up, natural-ish programming language used to convey an algorithm to human readers
+
+You can find algorithms for all sorts of things.  Need to efficiently combine two sorted lists into one bigger list that's still sorted?  There's an algorithm for that.  Need to divide a bunch of data points into clusters?  There's one for that too.  Want to find the first 1000 prime numbers?  You can find several different algorithms for that!  In many cases, when you face some common problem like this, you can save yourself some time by digging up a known algorithm for it, and then just converting the pseudocode into whatever real programming language you're using.  And *that's* the cool thing about algorithms: they represent things humanity has figured out how to do, regardless of the particulars of a programming language.
+
+D> Programming languages come and go, but algorithms are eternal.
+
+So in the end, an algorithm is just a fancy word for a simple concept: step-by-step instructions on how to do something.  Let's make all this concrete by looking at a few simple, well-known algorithms.
+
+## Greatest Common Divisor
+
+The greatest common divisor (or "GCD" for short) of two numbers is the largest whole number that will divide evenly into them both.  For example, the GCD of 8 and 12 is 4, because 4 divides both 8 and 12 without any fractions or remainder.  The GCD has all sorts of uses.  For example, if you want to simplify a fraction, you just divide the top and bottom by their GCD: so 8/12 simplifies to 2/3 (dividing them both by 4).
+
+A pretty neat algorithm for finding the GCD was developed by Euclid, a Greek mathematician who lived around 300 BC.  This is one of the oldest algorithms still in common use.  If you search for "Euclidean algorithm for greatest common divisor," you will find a whole lot of material about it, including a Wikipedia page that gives several variations of the algorithm in pseudocode.  The first one is given as:
+
+```pseudo
+function gcd(a, b)
+    while b != 0
+        t := b
+        b := a mod b
+        a := t
+    return a
+```
+
+I bet you can read that!  It looks *almost* like MiniScript, but not quite.  It uses `:=` to indicate assignment, while we use a simple `=` sign.  It's written `mod` as a word, while in MiniScript we use the `%` operator.  And finally, you may notice that the `while` loop does not have an `end while`, and the `function` does not have an `end function`, but you can easily guess where these should go.  So, in MiniScript this would be:
+
+```miniscript
+gcd = function(a, b)
+    while b != 0
+        t = b
+        b = a % b
+        a = t
+    end while
+    return a
+end function
+```
+
+Pretty direct conversion, isn't it?  Type that in and try it out.  What is the GCD of 294 and 546?
+
+Skipping ahead to the third version of the algorithm, the pseudocode is given as:
+
+```pseudo
+function gcd(a, b)
+    if b = 0
+        return a
+    else
+        return gcd(b, a mod b)
+```
+
+This is a fun  one because it's recursive — it is defined in terms of itself.  But as MiniScript supports recursion too, this too is a straightforward translation:
+
+```miniscript
+gcd = function(a, b)
+    if b == 0 then
+        return a
+    else
+        return gcd(b, a % b)
+    end if
+end function
+```
+
+D> Remember that MiniScript uses `==` for comparing two numbers.  Pseudocode often uses a single `=` (especially pseudocode that uses `:=` for assignment).
+
+And finally, the second version in the Wikipedia page is actually Euclid's original version, as he hadn't thought of *mod*.  This is given in pseudocode as:
+
+```pseudo
+function gcd(a, b)
+    while a != b 
+        if a > b
+            a := a - b
+        else
+            b := b - a
+    return a
+```
+
+Can you translate this to MiniScript code yourself?  Try it!
+
+## Binary Search
+
+Another useful algorithm is finding the position of an element in a sorted list.  Of course you could just search every element with this algorithm:
+
+```pseudo
+function find(x, list)
+	i := 0
+	while i < length of list
+		if list[i] = x then return i
+		i := i + 1
+	return -1
+```
+
+This is actually an algorithm called *sequential search*, and is in fact what MiniScript does when you use the `indexOf` intrinsic method.  It's the best possible algorithm for an *unsorted* list of items, where the thing you're looking for could be anywhere; you simply have to check each one.  But if we know the list is sorted, then we can do much better.  The first thing we might do is simply bail out as soon as we find an item bigger than what you're looking for, since in a sorted list, there's no way it could be found after that.
+
+```pseudo
+function find(x, list)
+	i := 0
+	while i < length of list
+		if list[i] = x then return i
+		if list[i] > x then return -1
+		i := i + 1
+	return -1
+```
+
+But it turns out we can do even better, by using the *binary search* algorithm.  Instead of keeping track of just one position in the list (like `i` in the pseudocode above), binary search keeps track of two positions, called `min` and `max`.  And on each step, it moves one of those by quite a lot, quickly zeroing in on the target value.
+
+Googling "binary search" quickly led me to a nice lesson about at Kahn Academy, which gives the pesudocode as:
+
+D>The inputs are the array, which we call array; the number n of elements in array; and target, the number being searched for. The output is the index in array of target:
+D>1. Let min = 0 and max = n-1.
+D>2. Compute guess as the average of max and min, rounded down (so that it is an integer).
+D>3. If array[guess] equals target, then stop. You found it! Return guess.
+D>4. If the guess was too low, that is, array[guess] \< target, then set min = guess + 1.
+D>5. Otherwise, the guess was too high. Set max = guess - 1.
+D>6. Go back to step 2.
+
+
+Here's a very different style of pseudocode!  In case it wasn't clear already, everybody's pseudocode is a little different.  That's OK, because it only needs to be clear to humans, not to computers.  We can work with this.  Just convert it into MiniScript, step by step.
+
+```miniscript
+find = function(array, target)
+	n = array.len  // (no need to pass this as a parameter!)
+	// step 1:
+	min = 0
+	max = n-1
+	while true  // (loop from step 2 to step 6)
+		// step 2:
+		guess = floor((max + min)/2)
+		// step 3:
+		if array[guess] == target then return guess
+		// steps 4 and 5:
+		if array[guess] < target then
+			min = guess + 1
+		else
+			max = guess - 1
+		end if
+	end while // step 6
+end function
+```
+
+Note that while the pseudocode said that the number `n` of elements in the array was to be one of the inputs (i.e. parameters to the function), there is no need for that in MiniScript; a list already knows its own length.  So our implementation takes only the list, and the target value.  Also, while the pseudocode uses "go to" to make a loop, MiniScript (like most other modern languages) uses `for` or `while` to loop instead.  So we just threw a `while true` loop around the steps in the algorithm that should loop.
+
+Type that in and give it a try on this data:
+
+```terminal
+]find [3,6,10,14,19,27], 10
+2
+```
+
+It works!  We asked for the index of value 10, and it returned 2, which is correct since element 2 of our list is indeed 10.  But now try this one:
+
+```terminal
+]find [3,6,10,14,19,27], 11
+```
+
+Uh-oh!  This call never returns; it is stuck in an infinite loop.  Looking at the pseudocode (or our MiniScript implementation), it is easy to see why: the only `return` statement in it is when the target element is found.  If the target is not found, it will never return.  So the pseudocode algorithm we found here is slightly flawed.
+
+When you run into something like this, first, give a cheer for testing!  It's so much better to discover things like this right away, rather than later when this code has become some small part of a much larger program.  And next, you have two options.  Either search for a different variation of the algorithm, and implement that, or just fix the problem with this one.  We're going to do the latter.
+
+When a program is stuck in an infinite loop, the first step is usually to get a better understanding of what state it's in when it's stuck.  Press Control-C if your program is still stuck, and then insert a `print` statement right after we calculate the guess, on line 9:
+
+{number-from: 9}
+```miniscript
+		print "min:" + min + " max:" + max + " guess:" + guess
+```
+
+Now run that same test that failed before.  It will very quickly start repeating this line over and over:
+
+```terminal
+min:3 max:2 guess:2
+```
+
+Now notice something odd about this — the "min" is actually greater than the "max" value!  As we move the `min` value up and the `max` value down, we will always either find the target value, or end up in this situation where `min > max`.  So, the solution is to just check for that.  Change the `while` statement so that instead of `while true`, it reads `while min < max`.  And finally, add a `return -1` down after the `end while` (but before `end function`).
+
+Now try both tests again (remember that in Mini Micro or command-line MiniScript, you can press the up arrow to recall a previous command).  It should work now.
+
+If you have a very large list of items, and know that this list is always sorted, this algorithm will often be faster than the built-in `indexOf` method.  So now you have a handy new tool in your toolbox, *and* you've learned how to fix a flawed algorithm you find on the internet!
+
+## k-Means Clustering
+
+For our last example, we're going to look at a machine learning algorithm called "k-means clustering."  Suppose you have a bunch of data points, characterized by X and Y values, and you want to divide those points into groups ("clusters") so that each point is mostly surrounded by other points in the same group.  How do you do that?
+
+D> This problem actually came up in my day job quite recently.  We were building a large multiplayer game.  To keep network traffic down, we wanted to divide all the players into groups of nearby players, so we can send frequent updates only to other players in the same group.  k-means clustering is one way to do that!
+
+The k-means clustering algorithm is a fancy name for a simple idea.  Each group (or "cluster") is defined by the centroid (average position) of all the data points assigned to it.  We simply alternate between assigning each point to the nearest cluster, and moving each cluster to the centroid of its assigned points.  In pseudocode:
+
+```pseudo
+initialize k clusters at random positions
+repeat until done:
+	assign each data point to the nearest cluster
+	move each cluster to the centroid of data assigned to it
+```
+
+Using Mini Micro, we can implement this algorithm in a very visual way, using sprites for the data points and cluster centroids.  It comes out a bit longer, but it's totally worth it.
+
+{caption:"k-means clustering program."}
+```miniscript
+import "mathUtil"
+import "listUtil"
+
+clear
+
+Datum = new Sprite
+Datum.image = file.loadImage("/sys/pics/shapes/Circle.png")
+Datum.scale = 0.2
+
+Cluster = new Sprite
+Cluster.image = file.loadImage("/sys/pics/XO/X-white.png")
+Cluster.scale = 0.2
+
+// Define the number of data points (n) and centroids (k).
+n = 40
+k = 4
+
+// Create some random data points.
+data = []
+for i in range(1, n)
+	d = new Datum
+	d.x = round(960 * rnd)     // (960 is the screen width)
+	d.y = round(640 * rnd)     // (640 is screen height)
+	display(4).sprites.push d  // (display 4 is the sprite display)
+	data.push d
+end for
+
+// Create the centroids, also in random starting positions.
+centroids = []
+colors = [color.orange, color.aqua, color.fuchsia, color.lime]
+for i in range(1, k)
+	c = new Cluster
+	c.tint = colors[i-1]
+	c.x = round(960) * rnd
+	c.y = round(640 * rnd)
+	display(4).sprites.push c
+	centroids.push c
+end for
+
+// update all data points by assigning them to the nearest centroid
+// also update dataX and dataY lists within each centroid
+updateData = function()
+	for c in centroids
+		c.dataX = []
+		c.dataY = []
+	end for
+	for d in data
+		bestCluster = null
+		for c in centroids
+			dist = mathUtil.distance(d, c)
+			if bestCluster == null or dist < bestDist then
+				bestCluster = c
+				bestDist = dist
+			end if
+		end for
+		d.tint = bestCluster.tint
+		bestCluster.dataX.push d.x
+		bestCluster.dataY.push d.y
+	end for
+end function
+
+// update the centroids by moving them to the average position
+// of the data points assigned to them
+updateClusters = function()
+	for c in centroids
+		if not c.dataX then continue
+		c.x = c.dataX.mean
+		c.y = c.dataY.mean
+	end for
+end function
+
+// Repeat those steps until done!
+for i in range(10)
+	updateData
+	updateClusters
+	wait	// slow things down enough that you can see!
+end for
+```
+
+
+Notice that even though the pseudocode didn't show any functions, I chose to put each of the major update steps into its own function in the MiniScript implementation.  That just helps keep things neat and organized.  Also note that we're defining "done" as simply completing 10 updates.  You might need more in some cases, or you might keep track of whether any of the points are actually changing their color, and stop when they are no longer changing.  (This is guaranteed to happen eventually.)
+
+{width:"75%"}
+![Sample run of the k-Means Clustering algorithm.  Circles are data points; X symbols are cluster centers.](kMeansClustering.png)
+
+Run this a few times; since the data and initial cluster positions are random, you'll get a different result every time.
+
+
+## Next Steps
+
+The three algorithms in this chapter are pretty typical of most small, well-defined problems that you might need to solve.  Now you've learned the secret every expert programmer knows: you don't have to think up a solution to every problem yourself.  In many cases, a good solution (algorithm) is already known, and all you need to do is translate it into your favorite language (which is surely MiniScript in our case!).
+
+Of course, not *every* problem has already been solved by someone else.  The number of things a computer can do is infinite, and you have so much creative freedom, you will certainly run into things that no one has done before, or if they have, they failed to publish a nice neat algorithm explaining how they did it.  In such cases you'll need to develop your *own* algorithm.  And that's the topic of the next chapter!
+
+A> **Chapter Review**
+A> - You learned about algorithms, and how they relate to programming.
+A> - You implemented algorithms for Greatest Common Divisor, Binary Search, and k-Means Clustering.
+A> - You learned how to fix an algorithm that is incomplete or contains an error.
+

data/day28.txt

@@ -0,0 +1,348 @@
+{chapterHead: "Day 28: Snowflakes Evolution", startingPageNum:347}
+
+{width: "50%"}
+![](Chapter28.svg)
+
+Q> Programming isn't about what you know; it's about what you can figure out.
+Q>— Chris Pine (programmer and author)
+
+A> **Chapter Objectives**
+A> - Build the *Snowflakes Evolution* app, which lets you guide the development of an endless variety of beautiful snowflakes.
+A> - Learn how to design a custom algorithm to tackle a complex computing problem.
+A> - Brush up on turtle graphics.
+
+In the previous chapter, you learned about algorithms, and how to convert a pseudocode description of an algorithm into working MiniScript code.  Today we're going to learn how to design your own algorithm from scratch!
+
+The context of this task will be a fun little program called *Snowflake Evolution*.  The program begins by generating six random snowflakes, as shown in the screen shot on the next page.  Then, when the user clicks one of them, it generates several variations of the selected snowflake.  This process can be repeated as many times as desired, allowing you to guide snowflakes through a process of directed evolution.
+
+![Four screen shots from the *Snowflake Evolution* app.](Snowflakes.png)
+
+But how do you write code to generate such complex shapes?  And not only that, but do it in a way that lets us generate variations of a particular shape?  That's not something for which you can easily find an off-the-shelf algorithm.  So let's roll up our sleeves and figure it out!
+
+
+## First Observations
+
+Looking at the snowflakes in the figure, the first thing we should notice is the sixfold symmetry.  Thinking in the step-by-step terms of algorithms, we should think of drawing the branches one at a time.  But all six branches are the same, so we can just use a loop.  In pseudocode, that would look something like this.
+
+```pseudo
+repeat 6 times
+	draw a branch
+	rotate 60°
+```
+
+This assumes that the *draw a branch* step does the same thing every time we do it, except pointed in a different direction.
+
+Of the many ways Mini Micro has to put graphics on the screen, this assumption — that we can draw the same thing, but rotated differently — leads us directly to turtle graphics, first introduced in Chapter 18.  To draw the same branch but rotated some number of degrees with only `gfx.line` and friends would take a *lot* of math!  But with turtle graphics, it is easy: just rotate the turtle, and then use turtle drawing commands that work with whatever direction it is facing.
+
+So we're already making progress on two levels: we have a very rough sketch of the algorithm, and we have made an important decision about the implementation.
+
+## Anatomy of a Snowflake Branch
+
+We still don't know how quite to do that *draw a branch* step.  So let's look more closely.  Consider the following snowflake.
+
+{width: "50%"}
+![](FlakeFull.png)
+
+We've already dealt with the fact that there are six identical branches, so let's focus now on just one branch.
+
+{width: "25%"}
+![](FlakeBranch1.png)
+
+{gap:30}
+How can we simplify this?  The first thing to notice is that there is some self-similarity going on.  Each of the two side branches coming off the main trunk, when viewed in isolation, look a lot like the whole branch.  And in fact if you were to break the main branch right where those two side branches come off, the smaller part of that looks a lot like the whole branch, too.
+
+{width: "25%"}
+![](FlakeBranch2.png)
+
+And then if you were to focus on any one of those branches, you could break it down into smaller bits the exact same way: a trunk, two smaller side branches, and one smaller forward branch.
+
+{width: "25%"}
+![](FlakeBranch3.png)
+
+## Our Custom Branch Algorithm
+
+So we've uncovered a recursive structure here: a branch is composed of a straight line, followed by three smaller branches.  In pseudocode, we might represent this as something like:
+
+```pseudo
+draw a branch = function(scale)
+	if scale is too small, return
+	draw a straight line proportional to scale
+	turn to the left
+	draw a branch (scale * 0.5)
+	turn to the right
+	draw a branch (scale * 0.5)
+	turn forward
+	draw a branch (scale * 0.6)
+```
+
+And now we have a detailed enough algorithm to convert this into MiniScript.
+
+{i:"`/sys/lib`,`turtle`"}
+{caption: "First stab at a program for drawing one branch of a snowflake."}
+```miniscript
+import "turtle"
+clear
+
+drawBranch = function(turtle, scale = 1)
+	if scale < 0.02 then return
+	// create a new turtle, so we don't move the one passed in
+	t = new turtle
+	// draw main branch
+	t.penSize = 20 * scale
+	t.forward 100 * scale
+	// draw sub-branches
+	t.left 70
+	drawBranch t, scale * 0.4
+	t.right 70 * 2
+	drawBranch t, scale * 0.4
+	t.left 70
+	drawBranch t, scale * 0.6
+end function
+
+drawBranch new Turtle
+```
+
+This is a pretty direct translation of the pseudocode.  The only "trick" here is on line 7, where we take the Turtle object that was passed in to our `drawBranch` function and create a `new` turtle derived from it.  That allows us to do whatever we like with this new turtle — move it, rotate it, change its pen size or color — without affecting the turtle that was passed in.  That's very handy since the turtle that was passed in has other work to do (i.e. drawing more branches), and our job is easier if we can assume that its state has not changed after drawing a branch.
+
+So type that in, if you haven't already, and give it a try.  The result should look like this:
+
+{width: "25%"}
+![](FlakeBranchMS.png)
+
+{gap:30}
+Looks pretty good!  And now we can make an entire snowflake by just drawing it six times, turning 60 degrees each time.  Just replace line 20 of the program above with:
+
+{number-from: 20}
+```miniscript
+t = new Turtle
+for i in range(1, 6)
+	drawBranch t
+	t.left 60
+end for
+```
+
+And now you have a beautiful snowflake!
+
+## Introducing Variation
+
+This code, of course, will draw the same snowflake every time you run it.  But there are lots of magic numbers in it, which could be varied to produce different results: the length and width of the main branch, the angle of the side branches, and the scale of the side and forward branches.  We could also tweak the color.  Go ahead and experiment with those numbers a while to see what you can create!
+
+For our *Snowflake Evolution* program, we're going to wrap up all those adjustable bits into a little class called `Step`.  And we'll go a little further: instead of strictly drawing the exact same branch at every level of the recursion, we'll keep a list of four different step variations, and switch to one of those when we recurse.
+
+This will all likely be clearer in MiniScript than in English, so `reset` your program, and dive right in.
+
+{i:"`/sys/lib`,`turtle`;`/sys/lib`,`mathUtil`"}
+{caption: "Listing 1 (Start of Snowflake Evolution program)."}
+```miniscript
+import "turtle"
+import "mathUtil"
+clamp = @mathUtil.clamp // (we'll be using this a lot)
+clear
+
+// randColor: return a random (bright) color, 155-255 in RGB.
+randColor = function()
+	return color.fromList([155+99*rnd, 155+99*rnd, 155+99*rnd])
+end function
+
+// Step class.  Draws one branch of a snowflake
+// (using recursion to draw sub-branches).
+Step = {}
+
+Step.newRandom = function()
+	result = new Step
+	result.penSize = round(5 + 10*rnd)
+	result.penColor = randColor
+	result.fwd = 25 + 50*rnd
+	result.sideAngle = 20 + 60*rnd
+	result.sideScale = 0.25 + 0.5*rnd
+	result.sideStepNum = floor(rnd * 4)
+	result.fwdScale = 0.25 + 0.5*rnd
+	result.fwdStepNum = floor(rnd * 4)
+	return result
+end function
+
+Step.draw = function(turtle, steps, scale=1)
+	if scale < 0.1 then return
+	t = new turtle
+	t.penSize = self.penSize * scale
+	t.color = self.penColor
+	t.forward self.fwd * scale
+	newScale = scale * self.sideScale
+	if self.sideAngle > 0 and steps.hasIndex(self.sideStepNum) then
+		t.left self.sideAngle
+		steps[self.sideStepNum].draw t, steps, newScale
+		t.right self.sideAngle * 2
+		steps[self.sideStepNum].draw t, steps, newScale
+		t.left self.sideAngle
+	end if
+	newScale = scale * self.fwdScale
+	if newScale > 0 and steps.hasIndex(self.fwdStepNum) then
+		steps[self.fwdStepNum].draw t, steps, newScale		
+	end if
+end function
+
+// Snowflake class: keeps four Steps, and uses them to
+// draw a complete snowflake.
+Snowflake = {}
+
+Snowflake.newRandom = function()
+	result = new Snowflake
+	result.steps = []
+	for i in range(1, 4)
+		result.steps.push Step.newRandom
+	end for
+	return result
+end function
+
+Snowflake.draw = function(x=480, y=320)
+	t = new Turtle
+	t.penDown = false
+	t.goTo x, y
+	t.penDown = true
+	for i in range(0,5)
+		self.steps[0].draw t, self.steps
+		t.left 60
+	end for
+end function
+
+flake = Snowflake.newRandom
+flake.draw
+```
+
+The recursive drawing algorithm from the previous section is now implemented in the `Step.draw` method.  It looks a little more complicated because the function takes a list of `Step` objects, each specifying a different set of properties for the branch.  So when it is time to draw one of the angled side branches, or the forward branch, it calls `draw` on some item from that list instead of on `self`.
+
+A `Snowflake` is just a collection of four different `Step`s.  It also has the `draw` method that kicks off the branch-drawing process six times in six different directions, making a complete snowflake.
+
+{pageBreak}
+D> Why four different `Step` objects?  I knew I wanted more than one, and ten seemed excessive, given the recursion rarely goes more than a few levels deep anyway.  Four seemed to work nicely, but you should feel free to try other numbers!  Be sure to change the `4`s in both `Step.newRandom`, and in `Snowflake.newRandom`.  Or better yet, store this value in a well-named global variable, and get rid of the magic value!
+
+Once you've entered the listing above, run it several times.  You should get a different snowflake each time!
+
+## Mutant Clones
+
+Our *Snowflake Evolution* app requires creating several variations of one snowflake.  So we will need some code to both *clone* a snowflake, and to *mutate* it.
+
+clone
+: to create a copy of an object
+mutate
+: to introduce (usually small) changes to an object
+
+Clear out the last couple of lines (test code) from your program, and continue with the code below.
+
+{caption: "Listing 2 (Cloning and mutation).", number-from: 72}
+```miniscript
+Step.mutate = function()
+	i = floor(rnd * 8)
+	if i == 0 then 
+		self.penSize = clamp(self.penSize + rnd*2-1, 1, 15)
+	else if i == 1 then 
+		self.fwd = clamp(self.fwd + rnd*20-10, 10, 100)
+	else if i == 2 then 
+		self.sideAngle = clamp(self.sideAngle + rnd*20-10, 0, 170)
+	else if i == 3 then
+		self.sideScale = clamp(self.sideScale + rnd/2-0.25, 0, 0.8)
+	else if i == 4 then
+		self.sideStepNum = floor(rnd * 4)
+	else if i == 5 then
+		self.fwdScale = clamp(self.fwdScale + rnd/2-0.25, 0, 0.9)
+	else if i == 6 then
+		self.penColor = randColor
+	else
+		self.fwdStepNum = floor(rnd * 4)		
+	end if
+end function
+
+Step.clone = function()
+	return {} + self
+end function
+
+Snowflake.cloneAndMutate = function()
+	result = new Snowflake
+	result.steps = []
+	for step in self.steps
+		result.steps.push step.clone
+		result.steps[-1].mutate
+	end for
+	return result
+end function
+
+flake = Snowflake.newRandom
+while true
+	clear
+	flake.draw
+	if key.get == char(27) then break
+	flake = flake.cloneAndMutate
+end while
+```
+
+This listing includes somewhat longer test code, which generates a single mutated clone every time you press a key (until you press Escape, which is `char(27)`; then it breaks the loop).
+
+Most of the work here is being done by the `Step.mutate` method, which picks a random attribute (`i`), and then randomly changes the corresponding property.  The `clamp` method being used here (imported from the `mathUtil` module) simply limits a value to a valid range.  This is especially important for the `sideScale` and `fwdScale` properties, which must always be less than 1.
+
+D> What if, say, `fwdScale` were *not* less than 1?  Remember that this controls how big the next section of the branch is, relative to the last section.  And also remember that the recursion stops when the branches get too small.  So if the next part of the branch were actually *bigger* than the previous part, what would happen?  If you're not sure, try it and see!
+
+## Main Program
+
+We're just about done now.  The rest of the program draws six flakes at a time, waits for the user to pick one with the mouse, and then generates five new ones — mostly mutant clones of the one selected.
+
+Delete the test code starting on line 107, and then type in the following to finish the program.
+
+{caption: "Listing 3 (Wrapping up *Snowflake Evolution*).", number-from: 107}
+```miniscript
+// Helper function to wait for a click.  Also watches
+// for the Escape key, and if pressed, exits the program.
+waitForClick = function()
+	// wait for mouse down, or escape key
+	while not mouse.button
+		if key.pressed("escape") then exit
+		yield
+	end while
+	// wait for mouse up
+	while mouse.button; yield; end while
+end function
+
+// Prepare six snowflakes.
+flakes = []
+for i in range(0,5)
+	flakes.push Snowflake.newRandom	
+end for	
+
+// Main loop.
+while true
+	// Draw our current six snowflakes.
+	clear
+	for i in range(0,5)
+		col = i % 3
+		row = floor(i/3)
+		flakes[i].draw 160 + col * 320, 160 + row*320
+	end for
+	
+	// Wait for a click, and figure out which flake was hit.
+	waitForClick
+	col = floor(mouse.x / 320)
+	row = floor(mouse.y / 320)
+	choice = row * 3 + col
+	
+	// Replace all the other flakes with new ones.
+	for i in range(0, 5)
+		if i != choice then 
+			// create either a mutant of the chosen one,
+			// or occasionally, a completely new one
+			if rnd < 0.8 then
+				flakes[i] = flakes[choice].cloneAndMutate
+			else
+				flakes[i] = Snowflake.newRandom				
+			end if
+		end if
+	end for
+end while
+```
+
+Before you call it a day, take some time to play with this program!  It's really fun trying to "breed" the perfect snowflake, guiding their evolution with judicious clicks of the mouse.  But don't be shy about hitting Escape and running again to get a fresh new batch of snowflakes to start from.
+
+A> **Chapter Review**
+A> - You developed an algorithm for drawing a snowflake, by recursively drawing the same (or similar) things at progressively smaller scales.
+A> - You implemented that algorithm first in a small program that draws a snowflake.
+A> - You elaborated that into a more sophisticated program that demonstrates cloning and mutation.
+
+

data/day29.txt

@@ -0,0 +1,109 @@
+{chapterHead: "Day 29: Finding Help", startingPageNum:359}
+
+{width: "50%"}
+![](Chapter29.svg)
+
+Q> Don’t be afraid to say "I don’t know" or "I don’t understand" – no question is a dumb question.
+Q>— Margaret Hamilton (software engineering pioneer)
+
+
+A> **Chapter Objectives**
+A> - Learn where to look for programming help on the Internet.
+A> - Explore some places where you can join a community and share your work.
+A> - Learn some common ways programmers find solutions to problems.
+
+I hope you've found this book fun and easy to follow.  If you're like many readers, you began with little or no programming experience, and now you've completed an entire book, entered and debugged a large number of programs, and learned MiniScript syntax as well as most of the Mini Micro classes and functions.
+
+Despite the considerable increase in your programming prowess, you may still find it difficult when you sit down to write a program from scratch.  You may experience a form of "writer's block" where you don't even know how to begin.  Or you may get partway through a project, and then run into some bug you don't know how to solve.  You can certainly search this book for helpful advice, and I hope you find some!  But if that doesn't work, then what do you do?
+
+In this chapter we'll go over some places to get help at times like those.  We'll also cover some communities you can join and participate in even when you don't need help — for example, when you've just coded something cool and want to share it with people who will appreciate it.  The MiniScript community is friendly and supportive.  Here's where you can find them.
+
+Q> The Internet?  Is that thing still around?
+Q>— Homer Simpson
+
+## Official MiniScript Sites
+
+From the very beginning of the book, I've encouraged you to make use of the resources linked from the MiniScript home page.  But it's worth suggesting these again.
+
+MiniScript home page
+: <https://miniscript.org>
+
+This web site is the first step for all things related to MiniScript and Mini Micro.  Other sites may come and go, or change their web address, but this one should always be valid and up to date.
+
+From here you can find links to most of the other places mentioned in this chapter.  You'll also find very helpful resources like the MiniScript Quick Reference.
+
+One of these resources is the **MiniScript User's Manual**, a downloadable reference book that explains the MiniScript language and its intrinsic functions in good detail.  I wouldn't recommend this book to someone who is entirely new to programming.  But you're not new to programming any more!  You will be able to understand pretty much everything in this book at this point.  While much of it is the same material that was covered here, it's presented in a different way, and this might make you say "aha!" if you were confused on some detail of the language.
+
+You'll also find an invitation link for the **MiniScript Discord server** here.  Discord is a popular real-time chat program.  People here communicate mostly by text, though you can also post pictures of your projects, and a voice channel is available when needed.  Text channels are divided into topics, including `#mini-micro`, `#show-and-tell`, and `#game-ideas`, so you can focus on the areas that interest you.  Many MiniScript users hang out here and are always eager to share the excitement of coding.  (If you are underage, please check with a parent or caregiver before joining any online chat.)
+
+MiniScript wiki
+: <https://miniscript.org/wiki/>
+
+The MiniScript wiki is a very useful reference site.  Continually updated and extended by volunteers (including myself), this wiki has a page for just about every language feature and function in MiniScript and Mini Micro.  Let's say you are wondering if there is some way to hide the mouse cursor in Mini Micro.  Just go to the wiki, type "mouse" into the search field, and press Return.  This will take you to the documentation on the `mouse` module, which includes a link to every method and property therein, including `mouse.visible`.  Clicking that takes you to details on `mouse.visible`, including a simple code example you can type in (or copy and paste) to try it yourself.
+
+The wiki is cross-referenced using tags that appear on the bottom of most pages, making it easy to explore and find related topics.  It also features a large number of "how to" articles demonstrating how to solve specific problems, for example, how to move a sprite towards a target.  Just type "how to" into the Search field to find the whole set of these.
+
+MiniScript forums
+: <https://forums.miniscript.org/>
+
+The MiniScript forums are an online discussion board for the MiniScript community.  Posts to the board are divided into topics, similar to Discord, but while Discord messages are real-time and tend to disappear quickly, posts to the forums stick around for a long time and end up indexed by search engines such as Google.  So the forums are a better place for longer, more detailed discussions, or for anyone who just prefers web forums to Discord.
+
+## Third-Party Sites
+
+These are sites that are not directly associated with the MiniScript maintainers, but nonetheless include some useful MiniScript-related content.
+
+YouTube
+: <https://youtube.com>
+
+I doubt I have to explain YouTube to anyone!  The 900-pound-gorilla of video-sharing sites, YouTube includes videos about just about everything, including MiniScript.  Unfortunately it can be a little hard to find, especially since a recent (and completely unrelated) scripting language related to Bitcoin has also started calling itself MiniScript (and there is apparently a children's scooter called the Mini Micro).  So be careful!
+
+There is a MiniScript channel which contains official MiniScript videos; you can find that via <http://bit.ly/miniscript-channel>.  If you're a visual learner, you may find this a helpful resource.
+
+Reddit
+: <https://www.reddit.com/r/MiniScript/>
+
+Reddit is a discussion site that bills itself as "the front page of the internet."  It's divided into topic areas called "subreddits," and the URL above takes you directly to the subreddit for MiniScript.  At the moment, this area gets less traffic than the Discord server or forums, but if you like Reddit's format or are already a user there, you should join this subreddit so you don't miss out on anything.  It's also a fine place to ask questions when you need help; the community tends to be a little less formal and more forgiving than StackOverflow (below).
+
+StackOverflow
+: <https://stackoverflow.com/>
+
+StackOverflow is a question/answer site for programmers.  No, it's *the* question/answer site for programmers!  Professionals and serious hobbyists frequently make use of this site when they have a problem.  The first step is always to search for an existing question; very often if you're stuck on something, someone else was stuck on it before you, and an existing question may have a good answer.
+
+When that fails, then you can post a new question here, and very often get a good answer within days.  Other users will vote on which answers are the best, and the original questioner can mark one answer as "accepted," all of which helps later searchers find an answer likely to work.
+
+StackOverflow can be a little intimidating to new users; it has pretty strict guidelines about what constitutes a programming question, not duplicating a previous question, etc.  Don't let it scare you!  Everyone there is there either to get help, or give help (or both).  And everyone was a first-time user at some point.  If you have a technical question about programming, this is a valid place to find or ask for expert advice.  And if this book turns out to be the start of a long and productive programming career, you will definitely be making use of StackOverflow on a regular basis.
+
+## Other places to find MiniScript code
+
+The last two sites we'll consider in this chapter are not really discussion sites, though they do have some limited commenting features.  They're really *project* sites, where people who have put a lot of work into a MiniScript or Mini Micro project have decided to share it with the world.  These can be really helpful for a beginner.  It's like a new architect not only driving around and looking at buildings, but getting to peek at the blueprints too!
+
+GitHub
+: <https://github.com>
+
+GitHub is a very popular source code hosting site, based on the *git* version control system.  Using git, you can push a copy of your project (source code, images, and other files) up to GitHub, where other people can clone your project to make their own variation, or even suggest fixes or enhancements to yours.  Use of git is beyond the scope of this book, and is a bit involved, but it's something you may want to learn eventually.
+
+In the meantime, though, you can browse other people's projects on GitHub.  On the wiki under "open-source projects" you will find a list of games/apps/programs written in MiniScript; those are mostly or entirely links to GitHub.  Click on any of those to go to the GitHub project, and then start clicking on file or folder names you see to drill down to the MiniScript code files.  Who knows what cool coding tricks you may learn this way?
+
+Itch.io
+: <https://itch.io/games/tag-minimicro>
+
+Itch.io is a project hosting site that is mostly about serving compiled, ready-to-run games and other software projects.  However, in the case of Mini Micro games (which you will find using the URL above), you can usually get to the source code just by pressing Control-C during the game, and then poking around.
+
+D> You can *usually* but not *always* do this because it is possible to package your Mini Micro game in such a way that breaking with Control-C is disabled.  To learn how, go to the MiniScript Wiki and search for "bootOpts.grfon".
+
+The itch.io community is generally very friendly and supportive.  If you like any of the Mini Micro games you find here, post a comment to let the author know!  And someday, when you've created something fun or interesting, consider posting it as a project here for others to enjoy.  You can package your app as a web build, upload it here, and send the URL to everyone you know; they will be able to run your program right in their web browser, without having to download anything.
+
+## The tip of the iceberg
+
+The internet is vast, and of course we've only scratched the surface with this survey.  It's also always in motion, so by the time you read this, there may be other good places to get help or find other MiniScript users.  Don't be afraid to poke around, and ask the folks you meet in one place if there is anywhere else you should check out.
+
+This has been a short chapter, if you only read it — but as always in this book, you learn more from *doing* than from merely reading!  So if you haven't already, I highly recommend you go check out these sites.  All of them are free to use and welcoming to newcomers.
+
+
+A> **Chapter Review**
+A> - You reviewed the official MiniScript sites and resources.
+A> - You learned about some third-party sites that also have some MiniScript content.
+A> - You discovered project-hosting sites where you may find sophisticated MiniScript programs to learn from.
+
+
+

data/day3.txt

@@ -0,0 +1,158 @@
+{chapterHead: "Day 3: Variables and Comments", startingPageNum:27}
+
+{width: "50%"}
+![](Chapter3.svg)
+
+Q> Any fool can write code that a computer can understand. Good programmers write code that humans can understand.
+Q>— Martin Fowler (software developer and author)
+
+A> **Chapter Objectives**
+A> - Learn how *variables* are used to hold values in memory.
+A> - Use *comments* to leave notes for your future self (or others).
+A> - Start thinking about how to write code that is clear and easy to read.
+
+## Keeping values for later
+
+So far, every program you've written has created values right where they are used -- mainly on a `print` statement.
+
+```miniscript
+print "Hey " * 3
+```
+
+The example above multiplies `"Hey "` by three, resulting in `"Hey Hey Hey "`, and then immediately passes it to the `print` function.  This is like assembling a sandwich in the kitchen, and then immediately eating it.
+
+There's nothing wrong with that; in fact it's a perfectly fine way to eat a sandwich.  But sometimes your recipe is too complex to do all at once; some steps need to be done ahead of time.  Or sometimes you want to make your sandwich in the morning, and eat it at lunch.
+
+In such cases, you need to store your intermediate results somewhere.  Let's imagine you're more organized in the kitchen than most people (including me!).  You have a large number of tupperware containers, and a dry-erase marker you use to label each one whenever you put something in it.  So you might build a sandwich, put it in a tupperware, and write "hamOnRye" on it.  Then later, when you're hungry for a ham on rye, you can easily grab the right tupperware and retrieve the sandwich you stored earlier.
+
+In computer programming, we have a similar concept, but the tupperware containers are called *variables*.  A variable has a name (the label) and stores a value, so you can easily retrieve it later.  You store something in a variable by using the equals sign, called the *assignment operator* in this case.
+
+variable
+: a name associated with a storage location that can hold a value
+
+assignment
+: storing a value in a variable by use of the `=` operator
+
+It looks like this:
+
+```miniscript
+greeting = "Hey " * 3
+print greeting
+```
+
+Line 1 in this example also computes `"Hey Hey Hey "`, but then stores this result in a variable called `greeting`.  Line 2 then retrieves that value, passing the value of `greeting` to the `print` function.
+
+![Variables are like storage bins for data.](variableBins.svg)
+
+And that's all there is to it.  Variable names can be pretty much anything, as long as they start with a letter or underscore character, and contain only letters, numbers, and underscores.  In particular, this means that a variable name can't contain spaces.  So `hamOnRye` would be a perfectly fine variable name, but `ham on rye` would not.
+
+D> MiniScript uses spaces and punctuation to divide your program code into words, and expects each word to have some meaning.  That's why you can't use spaces, commas, or other punctuation in a variable name; it would look like multiple words.  A variable is a single thing, so it needs to be a single word as far as the computer's concerned.
+
+E> Does "hamOnRye" look strange to you?  This style of internal capital letters, known as "camel case," is common in computer programming, but not in normal English.  It's a way to let us humans see it as multiple words, while still appearing to the computer as a single word.
+
+The example above was admittedly a bit pointless.  Our greeting expression was very simple and used immediately, so we didn't really need a variable there -- it was like making a simple sandwich and eating it right away.  So let's look at a more realistic example.
+
+{caption: "Always-8 number trick"}
+```miniscript
+num = 42
+print "starting with: " + num
+x = num - 1
+print "- 1: " + x
+x = x * 3
+print "* 3: " + x
+x = x + 12
+print "+ 12: " + x
+x = x / 3
+print "/ 3: " + x
+x = x + 5
+print "+ 5: " + x
+result = x - num
+print "- " + num + ": " + result
+print "...it's always 8!"
+```
+
+This program encodes a little arithmatic trick I found somewhere.  You start with any number -- the listing above uses `42` -- and then do a series of simple math operations to it.  At the end, no matter what you started with, you end up with 8.
+
+Variables are handy in this program for several reasons.  First, it lets us take a complex series of steps and do them one at a time, which makes the code easier to write and understand.  Second, it lets us print out the result of each of those steps as we go.  Without variables, we could either print the result of a calculation, or use it as part of a larger calculation, but not both.  Finally, you'll notice that the last step is to subtract off the number we started with -- that would be impossible if we didn't store that original number away in `num`, keeping it intact while we did all our calculations in a different variable `x`.
+
+{pageBreak}
+D> Try it!  Enter the program on the previous page carefully, and run it several times, changing the value assigned to `num` in the first line each time.  Neat, huh?
+
+## Assignment Is Not Math
+
+Some mathematically-minded people may be disturbed by lines like
+
+```miniscript
+x = x + 12
+```
+
+from the above example.  If you think of this as algebra, it makes no sense at all!  In high-school math, this would be a statement that says, "there is a number x such that x is equal to x plus 12."  There can be no such number; this is an equation with no solution.
+
+But this isn't algebra, and the above line is not a declaration of equality.  It's computer programming, and this is an assignment.  The computer does this in two steps: first, it computes the value of whatever's on the right-hand side of the `=` sign.  And second, it stores that value under the label on the left-hand side.
+
+Going back to the kitchen analogy, this would be like having a container labeled "lunch".  In the morning, you store some bread in this container.  At your mid-morning break, you retrieve your "lunch" container, take out the bread, insert some ham, and then put it back into that same "lunch" container.  You've simply reused the same container.
+
+The same thing is going on with `x = x + 12`.  We first take out the value of `x`, whatever it is at this point, and add 12 to it.  Then we store this new value back into `x`, replacing the previous value.
+
+## Leaving Notes For Yourself
+
+The second (and last) concept for today is simple but important: leaving little messages in your programs, so that readers of the code (including your future self) will better understand what it's all about.  These messages are called *comments*.
+
+comment
+: a message left in a program, ignored by the computer, meant for human readers of the code
+
+A comment in MiniScript starts with two forward slashes, `//`, and continues until the end of the line.  So anywhere you see `//` in a MiniScript program, except of course inside a string, you are looking at a note left for you by whoever wrote the code.
+
+Here's an example program containing some comments:
+
+{caption: "Simple dice program"}
+```miniscript
+// Dice program
+// Rolls two 6-sided dice and prints the sum.
+
+// Note: rnd returns a number between 0 and 1.
+// So if we multiply by 6, we get a number between 0 and 6.
+// The ceil function then "rounds" this to a whole number 1-6.
+d1 = ceil(rnd * 6)  // get the first die
+d2 = ceil(rnd * 6)  // get the second die
+print "Rolled: " + d1 + " and " + d2
+print "Total: " + (d1 + d2) // parens needed here!
+```
+
+The comments at the top of the listing are sometimes called *header comments*, and are generally there to provide an overview of what the program does.  Those are lines 1-2 in the listing above.  Lines 4-6 are providing some implementation notes, explaining the calculation that follows.
+
+Those were all longer comments that got entire lines to themselves, but you can also put a shorter comment at the end of a line of code, as shown on lines 7, 8, and 10.  In this case the computer will execute the MiniScript up until `//`, and then ignore the rest of the line.  As a human, you may often do the opposite, especially when skimming the code; you'll look for the comments, and mostly ignore the code itself.  (Not that this is always advisable; remember that comments are written by humans, and not checked by the computer... and humans often make mistakes!)
+
+As a beginner, you will be tempted to skip writing comments.  You are juggling a lot of things in your head, and comments feel like just one more.  But this is a mistake.  On the contrary, as a beginner you should write *more* comments, and you should write most of them first, before you write the actual code.  Use the comments as a way to organize your thoughts and construct an outline of your program, before you get into the nitty-gritty details.  In most cases, this will produce a working solution faster, and result in a better program.
+
+## Writing Clear Code
+
+That brings us to possibly the most important lesson in this book, and it's well put by the quote at the start of this chapter.
+
+The computer programs you've written so far have been simple, no more than a dozen lines, and often much less.  It's simple enough to read through them and understand what they're doing.
+
+But that won't be the case much longer.  Even in a high-level language like MiniScript, nontrivial programs routinely take hundreds or thousands of lines of code.  Commercial games and other apps are often millions of lines of code.  No human can grasp all those details at once.
+
+Managing this complexity is the central business of programming.  There are many strategies for doing so, and they work great together.  But as a beginner, there are just two you should keep in mind:
+
+1. Pick good, descriptive names for your variables and functions.
+
+2. Write good comments.
+
+Both of these stem from the recognition that the person reading the code in the future -- quite likely yourself -- will not be able to know everything about it at once.  When reading a line of code that uses a variable, they may not see where it was assigned a value.  So it's important that the name itself provide a useful clue to what it contains.  And of course comments help explain what is going on when the variables and operations themselves are not obvious.  They're also important for relaying the *intent* of the code, that is, the big picture of what the programmer was trying to do.  This provides the context in which the details can make sense.
+
+The importance of all this can't be overstated.  Most big software projects that fail, fail not because the computer hardware or programming environment wasn't up to the task.  They fail because the code got harder and harder to understand, and it reached a point where any attempt to change anything -- even just fixing a bug -- caused more problems than it fixed.
+
+But this is not a cause for despair.  We have learned a lot in the last half-century about how to write code that is clear, easy to understand, and a pleasure to maintain.  Well-written code has a beauty to it that is very real, even though most people can't see it.  By the end of this book, you'll be well on your way to seeing that beauty yourself.
+
+{pageBreak}
+Now that we've introduced variables and comments, the rest of the example programs will make use of these in ways that hopefully make the code clear.  And when you write your own code from scratch (which, if you haven't already done, you will soon!), please try to do the same thing.
+
+
+A> **Chapter Review**
+A> - You learned how to store values in variables for future use.
+A> - You discovered how to leave comments in the code for human readers.
+A> - You've begun to think about how to write code that is not only correct, but clear and easy to understand.
+
+
+

data/day30.txt

@@ -0,0 +1,106 @@
+{chapterHead: "Day 30: Where to Go From Here", startingPageNum:367}
+
+{width: "50%"}
+![](Chapter30.svg)
+
+Q> Software engineering is the closest I could come to fulfilling my lifelong dream of becoming a wizard.
+Q>— Mel Klimushyn (software engineer)
+
+A> **Chapter Objectives**
+A> - Learn some fun ways to apply your programming skills.
+A> - Find resources that will enable you to keep learning and growing as a coder.
+A> - Get some final words of wisdom that you may find useful.
+
+This is it.  The final chapter!  If you've done one chapter per day, then you set out on your programming journey a month ago.  Look how far you've come!
+
+This guide book is coming to an end, but the road to programming mastery does not.  So let's finish by looking forward a bit, so you can choose your own path as you continue from here.
+
+## Contributing to the Community
+
+Q> When one teaches, two learn.
+Q> — Robert Heinlein (science fiction author)
+
+A great way to continue growing as a programmer is to help the MiniScript community, and there are several easy ways to do that.  First, you can look for tasks to implement at Rosetta Code.
+
+Rosetta Code
+: <http://www.rosettacode.org/>
+
+This site is a specialized wiki that has a large number of relatively simple, well-defined tasks, and for each task, implementations in a wide variety of languages.  If you search for "MiniScript" you can find a page that lists all the tasks that have been already implemented in MiniScript.  There are over 150 of those, and studying these is a great way to get nice, bite-sized examples of MiniScript code.
+
+But there are literally thousands of tasks not yet implemented in MiniScript (and you can get a list of those from the MiniScript category page, too).  Some of the tasks are complex, but most of them are quite simple.  Most of them have dozens of implementations in other languages, too, which you can use as pseudocode if you're not sure about the algorithm.
+
+So, my suggestion is this: create an account on Rosetta Code, browse the tasks not implemented in MiniScript, find some nice easy ones, and implement them!  You will be exercising your skills, and helping visitors to Rosetta Code see how we do things in MiniScript.  Then head on over to BadgeList — described in the next section — to collect your Rosetta Coder badge!
+
+Another way to help out the community is to contribute to the MiniScript wiki.  That was also mentioned in the last chapter, but it's so important that it's worth pointing out again.
+
+MiniScript wiki
+: <https://miniscript.org/wiki/>
+
+Beginners often think of wikis as something they only read.  But it doesn't need to be that way; you can and should *write* wiki content, too!  Find some article that is short or lacking in examples, and improve it by adding your own example, or clarifying some unclear part of the text.  If you poke around enough, you might even find a link to some page that does not yet exist.  In that case, create it!
+
+Here's a great way to get started when making a new page: find some similar page, click Edit, and then copy the wiki source code that appears in the editing box.  Then cancel that edit, go to the page you want to create, click "create this page," and then paste in the copied text.  Now you have the basic format already done, and you can just change the text and sample code to reflect the new topic.  Be sure to use the Preview button to check that it all looks good before you save it.  But don't worry about making mistakes — a wiki can always restore a previous version of a page if needed, and believe me, your efforts will be greatly appreciated.
+
+Rosetta Code and the wiki are important but indirect ways of helping others: you're depositing your knowledge in a resource that future knowledge-seekers may find.  But also try to help others more directly, through the forums or Discord server.  Check in with these when you can, and if you see somebody posting a question you happen to know the answer to, help them out!  Also, if you see someone sharing something they're working on, give them some positive feedback.  Helping each other in this way makes us all stronger.
+
+## Coding Challenges
+
+If you're facing the "writer's block" problem where you just don't know what program to write next, then there are some fun programming challenges that might be of use.  Your first stop could be Badge List:
+
+Badge List
+: <https://www.badgelist.com/MiniScript>
+
+Badge List is a fun little site that awards "badges" for your accomplishments, something like merit badges in Girl Scouts and Boy Scouts.  You can group the badges by tags or just browse them all, and many of them are organized into different difficulty levels.  Start with the *MiniScript Neophyte* badge, which only requires you to use a `for` loop to print "Hello world!" ten times.  Like Rosetta Code, you will find some of the tasks are quite easy, while others are more difficult.  See how many badges you can collect!
+
+{i:"game jam"}
+When you're ready for a bigger challenge, you may want to dip your toes into the warm, chaotic waters of *game jams*.  A game jam is a contest in which developers get together, individually or in small teams, to create a game in a short amount of time — typically a few days, sometimes several weeks.  There are usually restrictions and/or a theme that is not known until the contest begins, which helps keep people from working ahead on a project before the official start date.
+
+Most game jams are informal affairs, just for fun, though some of them do offer prizes, awarded by a panel of judges.  Every game jam I've participated in has been a blast, and full of supportive, positive people all eager to share their love of coding.  Here's a good place to find upcoming game jams:
+
+Game jams on itch.io
+: <https://itch.io/jams>
+
+Here you'll find a "jam calendar" showing all the ongoing or upcoming jams.  You can also search and filter in various ways.  Note that you don't need to find a MiniScript-specific game jam; you can build your Mini Micro games for Windows, Mac, Linux, and the web, so you can enter almost any game jam that does not require a specific development tool.
+
+{width:"75%"}
+![There are always a ton of jams going on at itch.io.](JamCalendar.png)
+
+The game jam community is also a great place to connect with others in the hobby.  In particular, it's common for programmers like yourself to team up with artists and musicians to tackle a jam together.
+
+Note that there's a `#game-jam` channel in the MiniScript Discord server, too, so if you are thinking about participating in a jam and would like a coding partner, help with a bug, or just words of encouragement, be sure to post there.
+
+## More Guidance
+
+Since you've made it this far, it's clear you're a good reader and you enjoy learning this way.  So you may be wondering if there are any other books to learn from?
+
+At the time of this writing, the only other book is the *MiniScript User's Manual*, described in the last chapter.  *Learn to Code in 30 Days* is the first "real" book written for MiniScript, because its whole purpose is to help people who are new to coding get up to speed.
+
+However, there are plans for follow-on books that will be focused on different topics: games with various themes, simulations, and more.  They will include program listings, and lots of explanation about how to tackle various problems that come up when writing that sort of code.  As those books come out, they will be announced via the forums, Discord, and of course the MiniScript home page.  Maybe by the time you're reading this, some are out already!  Go have a look, and be sure to let me know what you most want to see.
+
+## Parting Advice
+
+You are fortunate to have begun your coding journey with MiniScript, a language that is especially simple and easy to learn, while still being powerful enough to create real programs.  MiniScript is still a pretty new language, and you will find that many people have not heard of it.  Those people are likely to tell you that if you want to become a programmer, you have to learn JavaScript, or C#, or C++, or whatever else their preferred language might be.
+
+*This is not true.*
+
+You already *are* a programmer, and there is no one language that you have to learn.  Eventually you will be comfortable in many languages, but there is no rush to get there.  The best tool for the job is whichever one lets you accomplish your goals in the simplest, most efficient manner.  In many cases, that will be MiniScript and Mini Micro, even if the guru you're speaking to has never seriously looked at these.  Just smile and nod, thank them for their advice, and then go and do it your way anyway.
+
+At the same time, don't be afraid of learning another language when a genuine need arises.  Beginners often mistake *syntax* for *programming.*  Syntax is the detailed rules about how to declare variables, write loops, create classes, and so on in a particular language.  That stuff is relatively easy to pick up in a new language, because the concepts are all more or less the same as any other language.  The real difficulty in programming is at the conceptual level: how to break a complex problem down into smaller problems, how to design an algorithm when you need one, how to manage the complexity of your code so that you don't have to keep too many things in your head at once.  These skills are universal.  So you can certainly stick with MiniScript while you build these skills, and rest assured that when someday you need to pick up another language, those same skills will still apply.
+
+Be patient with yourself as you build these skills.  This book is called *Learn to Code in 30 Days*, and you've done that — but it's in the same sense that you could learn to play the piano in 30 days.  You know all the basics and you can understand what the experts are doing, but that doesn't mean you can do it yourself at an expert level yet.  That's OK!  Like any skill, programming takes practice.  Keep mind that there is no such thing as raw talent:
+
+Q> A lot of people believe that... people have their gifts and that they should go out and look for what that gift is. That’s what you are spending your teenage and college years sifting through and sampling things and then finding your gift, but what I find with most college students is that they never find their gift... We argue that there is no gift to be found, basically that [they] are much better off picking something that they want to be good at and then use all of that [known about how] you can effectively achieve a high level of performance.
+Q>— Anders Ericsson, Ph.D.
+
+Talent is what you have *after* you've put in hours and hours of productive practice.  In the case of programming, that means writing code.  This chapter was full of suggestions on where to find programming tasks, from tiny to large, as well as where to share your own unique creations.  Use them!  And if you find them challenging, that is OK.  That feeling of struggling, of not quite being able to see the answer, is just the feeling of your mind getting stronger.  It's no different from sore muscles, which indicate your body growing stronger.  It's a sign of time well spent.
+
+You will find that this talent you build in programming spills over to other mental activities, too.  Computers, as you know by now, are patient, but require precision.  You have to say exactly what you mean; fuzzy thinking doesn't work.  So over time you learn to think clearly and precisely, and this will serve you well in everything from schoolwork, to the workplace, to understanding the world.
+
+So have fun!  Remember "code a little, test a little."  Don't try to do too much at once.  And when you do get stuck — as we all do from time to time — don't be shy about asking for help.  Every expert was a beginner at some point, and someday *you* will be the expert helping someone who is new.
+
+You are now part of a web of experience passed from person to person, which stretches back to our prehistoric ancestors, and forward to who-knows-where — the stars, perhaps.  With diligence, a good attitude, and a supportive community, there is nothing you can't accomplish.
+
+Happy coding!
+
+{gap:100}
+{width:"25%"}
+![](chinchilla-04.svg)

data/day4.txt

@@ -0,0 +1,137 @@
+{chapterHead: "Day 4: Input and Val", startingPageNum:37}
+
+{width: "50%"}
+![](Chapter4.svg)
+
+Q> I view computer science as a liberal art. It should be something that everybody learns.
+Q>— Steve Jobs (co-founder, Apple Computer)
+
+A> **Chapter Objectives**
+A> - Learn to use `input` to get a string from the user.
+A> - Use the `val` function to convert a string to a number.
+
+## Getting input from the user
+
+In the first three days of this course, you've already learned how to store values in variables, do math with them, and print them out.  But those values are always set right in the program code, so your program does the same thing every time.  The only exception to that is code that uses the `rnd` function, but that only gets a random value.  What can a program do when it needs a little input from the user?
+
+The answer is the `input` function.  This is a built-in function in most MiniScript implementations.
+
+{i:"`input`"}
+{caption:"`input` intrinsic function"}
+| `input(s="")` | displays prompt s, then returns string entered by the user |
+
+
+{i:"prompt"}
+prompt
+: a string displayed to the user when the computer is waiting for input, giving them some idea of what sort of input is needed
+
+Here's a simple example.
+
+```miniscript
+name = input("What is your name?")
+print "Hello, " + name + "!"
+```
+
+Go ahead and try this on the MiniScript *Try-It!* page.  When you run it, you'll see the prompt — "What is your name?" — displayed in the output area, followed by a rectangular blinking cursor.  That blinking cursor is your invitation to type something!  Go ahead and type your name.  (Or the name of your favorite celebrity, or your favorite fruit — it's your program; you can troll it if you like.)
+
+{i:"Return key;Enter key"}
+When you've typed something, press the Return or Enter key, which is your signal to the computer that you're done with your answer.  The program then continues with line 2, printing out a personalized greeting.  Now run it again, and type something else.  You get a different output.
+
+D> Pause for a moment and think about how cool that is.  You can now make programs that can ask for information from the user, process that information, and produce a unique result.  Every run of the program can do something new and useful based on the information the user provides.  This is the power that got us to the Moon; it's the power that took the world by storm in the second half of the 20th century.  And now that power is yours.
+
+The ability to get input from the user lets you make considerably more chatty programs than you could before.  Let's illustrate that with a somewhat longer example.  (Remember, the fastest way to learn is to actually type these examples in and run them!)
+
+{caption:"Cookbook suggestion program"}
+```miniscript
+name = input("Enter your name: ")
+print "Hello, " + name + "."
+food = input("What's your favorite food? ")
+print "You like " + food + "?  I can't stand the stuff."
+print "So what region do you live in?"
+region = input("Northern, Eastern, etc.? ")
+print "Well, maybe you should make a cookbook:"
+print name + "'s " + region + " " + food + "!"
+```
+
+This program uses three variables: `name`, `food`, and `region`.  Each of them is assigned a value from a separate call to the `input` function.  You can see that the computer works through this program, step by step, but it pauses on each `input` call, waiting for the user to type something and press return.  Then it continues with the next line.
+
+{width: "75%"}
+![Cookbook suggestion sample output](CookbookSuggestion.png)
+
+## Getting a *number* from the user
+
+Recall the difference between strings and numbers, which we covered in Chapter 1.  A string is a sequence of characters, like `"Mary"`, while a number is a numeric value, like `42`.  Even if the sequence of characters in a string happens to look like a number to us, like `"007"`, it's still just a bunch of characters to the computer.
+
+The `input` function always returns a string.  This is important.
+
+A> The `input` function always returns a string!
+
+That's important to remember, because the math operators do different things with strings than they do with numbers.  With numbers, `*` is multiplication.  But with strings, it is string replication (i.e. repeating).  So if you try to do something like the following, it doesn't work as intended.
+
+{caption:"Incorrect dog-years program"}
+```miniscript
+age = input("Enter your age: ")
+print "That's " + age*7 + " in dog years!"
+```
+
+Try that out and see what happens.  The program above asks your age, so the user probably enters something like "42", which gets stored in the variable `age`.  But it's still a string, so when we do `age*7`, we get "42424242424242" — that is, the string "42" repeated seven times.
+
+The solution is the `val` function, which we briefly mentioned in Chapter 2.  This takes a string argument and returns its numeric value.  To fix the program above, we just need to use this to convert the user's input to a number.  That could be done in several ways; we could do it in the math expression where the number is needed...
+
+{caption:"Dog-years program, corrected version 1"}
+```miniscript
+age = input("Enter your age: ")
+print "That's " + val(age)*7 + " in dog years!"
+```
+
+Or we could do it around the `input`, so we get a number right away...
+
+{caption:"Dog-years program, corrected version 2"}
+```miniscript
+age = val(input("Enter your age: "))
+print "That's " + age*7 + " in dog years!"
+```
+
+Or we could even add a new line, between where we get `age` as a string and where we use `age` as a number, that reassigns the variable with the numeric value.
+
+{caption:"Dog-years program, corrected version 3"}
+```miniscript
+age = input("Enter your age: ")
+age = val(age)
+print "That's " + age*7 + " in dog years!"
+```
+
+All of these work just fine; you should use whichever makes the most sense to you.
+
+Also try entering a string that does *not* look like a number.  Enter "fish" for example.  What result to you get?
+
+A> If given a string that does not appear to be a number, `val` returns 0.
+
+However, it's smart enough to correctly convert negative numbers, numbers with a decimal point, etc.  Experiment with different values until you're comfortable with it.  `val` is one of the most common functions you will use in all your MiniScript programming, so it's well worth spending a little time on it.
+
+Try one more example to see how `input`, `val`, and math all work together to do handy calculations.  (Remember that the rest of the line after `//` is a comment for the human reader, and ignored by the computer.)
+
+{caption:"Yearly income calculator"}
+```miniscript
+// Yearly income calculator.
+// Enter your income per hour, and hours worked per week,
+// and this will calculate your income per month and year.
+amountPerHour = val(input("Hourly rate? "))
+hoursPerWeek = val(input("Hours per week? "))
+weeksPerYear = 50  // assume 2 weeks vacation
+amountPerYear = amountPerHour * hoursPerWeek * weeksPerYear
+print "That's " + amountPerYear + " per year,"
+print "or about " + round(amountPerYear/12) + " per month!"
+```
+
+{gap:40}
+A> **Chapter Review**
+A> - You learned how use `input` to get a string from the user.
+A> - You used the `val` function to convert a string to a numeric value.
+A> - You've entered programs that can be run again and again, calculating different results based on user inputs.
+
+
+
+
+
+

data/day5.txt

@@ -0,0 +1,235 @@
+{chapterHead: "Day 5: Comparisons and Looping", startingPageNum:43}
+
+{width: "50%"}
+![](Chapter5.svg)
+
+Q> You might not think that programmers are artists, but programming is an extremely creative profession.
+Q> It's logic-based creativity.
+Q>— John Romero (co-founder, id Software)
+
+A> **Chapter Objectives**
+A> - Learn how to compare two values to see if they are equal, or which one is greater.
+A> - Learn to use `while` and `for` to make blocks of code repeat.
+A> - Obtain and start relying on the *MiniScript Quick Reference*.
+
+{i:"hard-coded value;value, hard-coded"}
+By now, you know several ways to get values into your computer program.  You can put them right into the code (these are known as "hard-coded" values); you can ask the user for them with `input`; or you can calculate them from other values.  Doing calculations with them is great, but sometimes what you need is to make *decisions* with them.  That begins by comparing two values.  In a computer program, there are various *comparison operators* for just this purpose.
+
+{i:"comparison operator"}
+comparison operator
+: a type of operator that compares two values in some way
+
+For example: suppose you wonder whether your computer really understands math at all, so you decide to check whether it knows that 2 plus 2 equals 4.  Write:
+
+```miniscript
+print 2 + 2 == 4
+```
+
+The comparison operator here is `==`, pronounced "equals."  Notice that this operator is written with *two* equal signs.  A single equal sign is used for assignment, as you learned on Day 3.
+
+D> To test two values for equality, remember to use *two* equal signs: `==`
+
+So in the example above, we are comparing the result of `2 + 2`, on the left side of `==`, to the value `4`, on the right.  Run this code and you should see the value `1` in the output.  In MiniScript, `1` means "true" and `0` means "false."  So MiniScript here is saying that yes, indeed, two plus two is equal to four.
+
+D> MiniScript uses the value 1 to mean true, and 0 to mean false.
+
+But `==` is just one comparison operator.  There are half a dozen:
+
+{i:"operators, comparison;comparison operators"}
+{caption:"Comparison operators"}
+| `==` | equals |
+| `!=` | not equal |
+| `>` | greater than |
+| `>=` | greater than or equal to |
+| `<` | less than |
+| `<=` | less than or equal to |
+
+You can use any of these to compare values, wherever they might come from.  Here's an example that decides if you're old enough to see a scary movie.
+
+{caption:"Movie Decider 1"}
+```miniscript
+print "Now showing: Chainsaw Zombie Nightmare VII"
+age = val(input("How old are you? "))
+print "My decision: " + (age >= 18)
+```
+
+This program prints the name of the movie, asks for your age, and then compares your age to 17.  It prints a 1 if your age is 18 or older, otherwise it prints a 0.
+
+That works, but it's not a very elegant way of displaying the result, is it?  Let's make it a little better by making use of string replication from Day 2.  A string multiplied by 1 is just that string itself; but a string multiplied by 0 is nothing (an empty string).  We can use that to print a custom message:
+
+{caption:"Movie Decider 2"}
+```miniscript
+print "Now showing: Chainsaw Zombie Nightmare VII"
+age = val(input("How old are you? "))
+print "Hmm..."
+ok = age >= 18
+print "OK, you can go." * ok
+```
+
+Try that one a few times, entering different ages.  Notice how we are storing the result of the age comparison in a variable, `ok`, on line 4, and then multiplying that by the message on line 5.
+
+If you enter 18 or older, this program works fine.  But if you enter a smaller number, it doesn't print anything after "Hmm..."  Let's improve that with the help of the `not` operator.
+
+{i:"`not` operator;operator, `not`"}
+D> The `not` operator changes 1 to 0 (true to false), and vice versa.
+
+This is the first operator we've seen that operates on a single value, instead of appearing between two values.  You put `not` before the value you want to operate on.  We can use that to finish our movie decider.
+
+{caption:"Movie Decider 3"}
+```miniscript
+print "Now showing: Chainsaw Zombie Nightmare VII"
+age = val(input("How old are you? "))
+print "Hmm..."
+ok = age >= 18
+print "OK, you can go." * ok + "I'm sorry, you're too young." * (not ok)
+```
+
+D> When a line in a code listing is too long, the end of it is printed in this book on the next line, identified with "..." as shown in the last line above.  But when you type it in, just keep typing — it will wrap or scroll over as needed.
+
+This is not the only way to print out alternate messages; we'll learn a more natural way tomorrow.  But it works and is a nice way to review both string replication, and the fact that `true` and `false` are represented as `1` and `0` in MiniScript.
+
+## Looping with `while`
+
+{i:"`while` loop"}
+So far every program we've written has started with the first line, executed each line in order to the end, and quit.  A decent start, to be sure, but computers are so much more powerful when they can do the same operation multiple times.
+
+Now that you know how to compare values, you're ready to learn the first of two ways to make the computer repeat itself.  This is the `while` statement, which defines that a group of lines should repeat while some condition is true.  It looks like this:
+
+{caption:"Doublings"}
+```miniscript
+x = 1
+while x < 1000
+    print x
+    x = x * 2
+end while
+print "And that's high enough!"
+```
+
+Type this code into the Try-It! interface and see what it does.  In plain English, this starts by assigning 1 to x.  Then the loop begins.  Lines 3-4 are repeated as long as (or "while") x is less than 1000.  Those lines print x and then double its value.
+
+When the `while` condition (`x < 1000`) is no longer true, then the loop exits, continuing with the line right after `end while`.
+
+Of course this can work with any sort of condition.  Try this variation:
+
+{caption:"Doubling Spam"}
+```miniscript
+x = "spam "
+while x.len < 60
+    print x
+    x = x * 2
+end while
+print "...that's enough spam for me!"
+```
+
+This is almost the same as the previous program, except instead of numbers, we are doubling strings; and our `while` condition now relies on `x.len` (the length of x).
+
+Let's revisit our movie-decider program.  Suppose it's your job to tell not just one youth, but a whole busload of youths, whether each of them is allowed to see the movie.  Because you are becoming a programmer, you quickly think to automate this tedious process.
+
+{caption:"Multi Movie Decider"}
+```miniscript
+print "Now showing: Chainsaw Zombie Nightmare VII"
+age = val(input("How old are you? "))
+while age > 0
+	print "Hmm..."
+	ok = age >= 18
+	print "OK, you can go." * ok + "I'm sorry, you're too young." * (not ok)
+	age = val(input("Next! How old are YOU?  (0 to exit): "))
+end while
+```
+
+{i:"indentation"}
+I'm sure you've noticed by now that the lines inside the `while` loop are indented.  In MiniScript, indentation is like comments: it's there for the human readers of the code, and ignored by the computer.  But that doesn't mean it's not important!  Without indenting the body of the loop, it would be much harder to see what's going on; and it's generally important that you be able to understand your code when you look at it months later.  But it's not important exactly *how* you indent.  Generally you should just hit the Tab key to indent a line, and your text editor will either insert an actual tab character, or some number of spaces.  Either is fine, as long as the result is clear to your eyes.
+
+## Looping with `for`
+
+{i:"`for` loop"}
+MiniScript has exactly two ways to repeat code; one is the `while` loop.  The other is the `for` loop. It looks like this:
+
+{caption:"For Loop"}
+```miniscript
+for i in range(1, 10)
+    print i
+end for
+```
+
+Like a `while` loop, a `for` loop repeats everything in the loop body (which by convention we indent, though the computer is just looking for the line that says `end for`).  But rather than looping while some condition is true, a `for` loop assigns a sequence of values to a variable, and stops when that sequence is complete.
+
+{i:"`range` function"}
+The example above uses the `range` function, which we haven't covered before.  We'll delve into that more deeply in Chapter 8, but for now just think of it as a way to tell the `for` loop what range of numbers you want it to loop over.  In the example above, `for i in range(1, 10)` makes the variable `i` go from 1 to 10.  (Unlike some other languages, `range` in MiniScript includes both the start and end values specified.)  Try it!
+
+You can easily make a `for` statement count down instead of up.  Try this one:
+
+{caption:"Countdown"}
+```miniscript
+for i in range(10, 1)
+    print i + "..."
+    wait
+end for
+print "Lift-off!"
+```
+
+{i:"`wait` function"}
+Here I have snuck in another new function, `wait`, which just tells MiniScript to pause for 1 second (unless you specify some other number of seconds as an argument).  Together with `range` counting from 10 down to 1, we have a classic rocket count-down.
+
+The `for` loop can also iterate over the characters of a string.  For a trivial example:
+
+{caption:Hello World, Letter by Letter}
+```miniscript
+for i in "Hello world"
+    print i
+end for
+```
+
+This prints each character of the string on its own line.
+
+This is a good time to point out that `for` and `while` loops can be *nested*, that is, you can put one loop inside of another, as much as you like.  Here's a simple example that prints out all the squares on a Chess board.
+
+{caption:"Chess Coordinates"}
+```miniscript
+for col in "ABCDEFGH"
+    for row in "12345678"
+        print col + row
+    end for
+end for
+```
+
+{i:"loop, inner vs. outer;outer loop;inner loop"}
+We call the first loop (`col` in this case) the *outer* loop, and the one nested inside it (`row` in his example) the *inner* loop.  For every iteration of the outer loop, the inner loop starts over and does its whole sequence again.  Here we have eight iterations for columns A through H in the outer loop, and eight iterations for rows 1 through 8 in the inner loop.  How many lines will this print?  Try it and see if you were right!
+
+iteration
+: one time through the body of a loop
+
+Of course you don't have to stop with just two loops; you could nest these as deeply as you like, though the number of iterations adds up quickly.  For example, if the outermost loop iterates 10 times, the middle loop iterates 5 times, and the innermost loop iterates 8 times, the result would be (10 \* 5 \* 8) = 400 iterations in all.
+
+## The MiniScript Quick Reference
+
+{i:"MiniScript Quick Reference;Quick Reference;documentation, MiniScript Quick Reference"}
+In Chapter 2, we referred to coding as an "open-book process."  It's like a test where you're allowed to use your textbook.  Not only that, but you're allowed to search the web, too!  These are great ways to find answers, especially to questions you haven't seen before.
+
+However, they're not always the *fastest* way to find answers, particularly for things you've seen before but just need to double-check your spelling or punctuation.  For that, a concise cheat sheet works much better.  Fortunately, MiniScript comes with exactly that: the **MiniScript Quick Reference**.  This is a one-page document that contains everything you need to know about the MiniScript language.  That's right.  One page.  Everything!
+
+If you haven't already done so, you should go to <https://miniscript.org> *right now*, scroll down to the "MiniScript Quick Reference" link, and click it.  Save the file that appears to someplace handy like your desktop, and if you have a printer, print it out and tape it up next to your computer, or slip it into the cover of your notebook.  Or at least leave it lying around on your desk.  The point is, have it handy, so that you can quickly refer to it.
+
+Although you're only on Day 5, you will find that you already understand much of what this page contains:
+
+- The left column talks about general syntax, including comments; and also `while` and `for` loops, which you just learned.  It also mentions `if` blocks, and `break` and `continue`, both of which we'll cover tomorrow.
+- The middle column talks about numbers and strings, which you understand; plus lists and maps, which we'll get to on days 8 and 10.
+- The right column includes some more advanced stuff we haven't gotten to yet, plus a list of all the important intrinsic functions, for those moments when you know there's a function to do something, but you can't quite remember what it's called.
+
+D> There is only one important function that you won't find on this sheet, and that's `input`.  That's because `input` is not actually part of the official MiniScript standard; if you use MiniScript in the context of a game, for example, it might not have this.  But all the contexts we discuss in this book will have `input`.  So go ahead and write it in the margin next to `yield` if you like.
+
+So this MiniScript Quick Reference serves not only as a handy jog for your memory, but also as a map of what you've learned, and what still lies ahead.  In another week or so, you will understand pretty much everything on this sheet.
+
+In fact, you might consider making an extra printout of this sheet, and highlighting things on it as we go (starting by highlighting everything we've already covered).  That will give you a very visual indicator of your progress, as well as reinforce what you've learned.  If you don't have a printer, you can probably do the same thing using your PDF viewer software.
+
+{pageBreak}
+A> **Chapter Review**
+A> - You learned how to use comparison operators to compare two values.
+A> - You used `while` and `for` to repeat code multiple times.
+A> - You acquired the MiniScript Quick Reference, which will be your favorite one-page document in the coming weeks.
+
+
+{gap:100}
+{width:"25%"}
+![](chinchilla-01.svg)
+

data/day6.txt

@@ -0,0 +1,245 @@
+{chapterHead: "Day 6: If and Break", startingPageNum:53}
+
+{width: "50%"}
+![](Chapter6.svg)
+
+Q> In the end, there can be only one `else` block.  
+Q> Or none.  That's cool too.
+Q>— The Highlander
+
+A> **Chapter Objectives**
+A> - Learn how a computer program can do different things depending on what values it currently has.
+A> - Explore the various forms of the `if` statement.
+A> - Learn how to short-cut or exit a loop.
+
+In the last chapter, we learned how to compare values, and applied that new power to the `while` loop.  But, it turns out, that's a little bit like learning to cook and then only doing so for breakfast.  It's a perfectly valid use of your skill, but misses the most common application.  In programming, comparing values happens most often in the `if` statement.
+
+{i:"`if`"}
+An `if` statement does just what it sounds like: it tells the computer to do something only *if* some condition is true.  Let's look at a simple example:
+
+{caption:Our first `if` statement}
+```miniscript
+age = val(input("Enter your age: "))
+if age > 23 then
+	print "Wow, you're old!"
+end if
+print "OK, got it."
+```
+
+Line 1 of this example should be familiar to you; it displays a prompt, waits for the user to type something and press Return, converts this to a number using `val`, and stores it in a variable called `age`.
+
+The new bit is on line 2.  It says that *if* (and *only* if!) age is greater than 23, *then* the computer should actually do line 3.  If not, then the computer should just skip on down to the `end if` line.  
+
+Note how, just as with `while` and `for` loops, we indent the body of the `if` block (everything between `if` and `end if`) for clarity.  But again, that indentation is like a comment; it's for the human readers of the code, and ignored by the computer.  But that doesn't mean you shouldn't do it!
+
+Also notice that there are two new keywords on line 2: `if` and `then`.  An `if` statement always has both of these keywords, working together.  The actual condition lies in between.
+
+Type in the above code and run it several times, testing it with different ages.  (It's totally OK to lie about your age when testing a program.)
+
+## Doing Something Else
+
+The above example prints an extra message when an age over 23 is entered.  You may have wondered how to print a different extra message for younger users.  You could do it with another `if` block, like so:
+
+{caption:Life without `else`}
+```miniscript
+age = val(input("Enter your age: "))
+if age > 23 then
+	print "Wow, you're old!"
+end if
+if age <= 23 then
+	print "Not so old, are you?"
+end if
+print "OK, got it."
+```
+
+That works, but it's a pain; we have to think about what the opposite of the original comparison is (changing `> 23` to `<= 23` in this case).  Worse, if we ever change the initial `if` statement, we'll have to remember to change the second one accordingly.  That's just inviting mistakes.  Programming is all about making complex things easier so as to *reduce* the chance of mistakes, especially in the future.
+
+Fortunately, there's a much better way to express what we're trying to do here, and that is the `else` statement.  The word `else`, on a line all by itself, identifies code that the computer should run when the condition in the `if` statement is *not* true.
+
+{caption:`else` to the rescue}
+```miniscript
+age = val(input("Enter your age: "))
+if age > 23 then
+	print "Wow, you're old!"
+else
+	print "Not so old, are you?"
+end if
+print "OK, got it."
+```
+
+This is much better!  Now when the computer gets to line 2, it's going to check the age, and then print one message or the other, but never both.
+
+## Checking Multiple Possibilities
+
+Sometimes there are multiple possibilities you want to check for, and run code corresponding only to the one that is true.  You can do this using `else if` blocks.
+Extending the previous example, suppose we want the computer to comment on several different age ranges.
+
+{caption:Being snarky to all ages}
+```miniscript
+age = val(input("Enter your age: "))
+if age > 60 then
+	print "Distinguished indeed."
+else if age > 23 then
+	print "Older than dirt!  (Dirt's 23.)"
+else if age > 17 then
+	print "Be sure to vote!"
+else if age > 12 then
+	print "Ah, the teenage years."
+else if age < 1 then
+	print "I don't think that's right."
+else
+	print "Just a young'un!"
+end if
+print "Seriously though, thanks for telling me."
+```
+
+In this example there are actually four `else if` blocks, but you can have any number of these (including none at all).  Here's how it works: the computer first checks the condition on the `if` statement.  If that's true, then it runs the code in that very first block (line 3 in the example above), and then jumps on down to the `end if` statement, skipping the rest of the conditions.  Otherwise, it goes on to check the condition in the first `else if` block.  Again if the condition there is true, it runs *that* block of code and then skips to the end; otherwise it goes on checking the next `else if`, and the next, until it either finds one that applies, or reaches the `else` block (which always applies, since it doesn't have a condition).
+
+To review, a complete `if` statement consists of:
+
+- an `if` *condition* `then` block
+- zero or more `else if` *condition* `then` blocks
+- zero or one `else` block
+- an `end if` statement
+
+Notice that while you can have any number of `else if` blocks, you can have no more than one `else` block, and this must always come last.
+
+Finally, be aware that just like `while` and `for` loops, `if` blocks can be nested; you can put an `if` inside another `if`.  Or inside a loop.  Or put a loop inside an `if`.  Combine these however you like... just remember to be consistent about your indentation, so you don't get confused about what's going on.
+
+## Single-Line If
+{i:"single-line `if`;`if`, single-line"}
+
+A fairly common need is to do a simple check with just one simple effect.  This often comes up in input validation, that is, making maximum sense out of a human's input (humans are notoriously unreliable).  Suppose you've got code that asks users for a percentage, but you just know some eager user is going to try to give you 110%, which doesn't make any sense mathematically.  But you want to treat it the same as 100%.  You could write:
+
+{caption:Using three lines where one would do}
+```miniscript
+effort = val(input("Enter effort, in percent: "))
+if effort > 100 then
+	effort = 100
+end if
+print "OK, calculating with " + effort + "%..."
+```
+
+There's nothing wrong with this.  It works fine.  But it will eventually become a little annoying to have to write (or read) three lines for such a simple correction.  For this reason, MiniScript supports a special single-line form of the *if* statement.  It looks like this (see line 2):
+
+{caption:Single-line `if`}
+```miniscript
+effort = val(input("Enter effort, in percent: "))
+if effort > 100 then effort = 100
+print "OK, calculating with " + effort + "%..."
+```
+
+This does exactly the same thing as the previous example; it's just shorter, and easier to read and write.
+
+To make a single-line *if* statement, simply put the (single line) of code you want to happen if the condition is true on the same line right after `then`.  That's it.  If you have more than one line of code to do when the condition is true, you'll need to use the standard block form instead.
+
+You can, however, also include an `else` clause in the single-line *if*.  This is less commonly needed, but might come up for example when finding the right way to pluralize a word:
+
+{caption:Counting geese}
+```miniscript
+count = val(input("How many geese? "))
+if count == 1 then n = "goose" else n = "geese"
+print "Thanks for the " + count + " " + n + "!"
+```
+
+Type that in and try entering different numbers — in particular, be sure to try both 1 and any value other than 1.  You'll see that the print statement at the end always selects the right form of the word "goose."  You could certainly do the same thing with a block-form `if`/`else` statement, but it would take five lines of code instead of one.  That would require more brain power to process when reading the code, whereas the single-line form is much easier to scan and say "oh, we're just picking the right form of the noun here" and move on.  Minimizing the brain power needed to read the code is one of the keys of good programming.
+
+## Breaking a Loop
+
+Let's return now to the subject of loops, introduced yesterday.  Once a loop begins, must it carry through mindlessly to completion?  Is it a slave to its `for` sequence or `while` condition, condemned, like Bill Murray in *Groundhog Day*, to repeat itself over and over until the loop is fully satisfied?
+
+{i:"`break`"}
+Well, no.  There is a way out: the `break` statement.  This statement tells MiniScript to break out of the current loop, jumping to the next line past the closest `end for` or `end while` statement.
+
+{caption:"C'mon, 1!"}
+```miniscript
+while true
+   roll = 1 + floor(rnd * 6)
+   print "I rolled: " + roll
+   if roll == 1 then break
+end while
+print "Finally rolled a 1!"
+```
+
+Look at the funny condition on this `while` statement — `while true`.  That would be an infinite loop, because of course `true` can never be `false`.
+
+{i:"infinite loop"}
+{i:"loop, infinite"}
+infinite loop
+: a loop that repeats forever, or until something forcibly halts the program
+
+But this loop does not actually repeat forever, because we've provided an escape clause in line 4: `if roll == 1 then break`.  This is using the single-line `if` statement you just learned about to check whether the randomly selected value is a 1.  If it is, then we execute the `break` statement, which jumps past the nearest `end while` or `end for` statement, exiting the loop.
+
+{i:"`continue`"}
+There is another, related statement called `continue`.  Instead of skipping past the nearest `end while` or `end for` statement, it skips to the next iteration of the loop, as if that `end` line had been reached normally.  For example, suppose you're writing code for a user who's afraid of the number 13, and whatever processing you do with all the other numbers, you want to skip it entirely for that one.
+
+{caption:Triskaidekaphobia}
+```miniscript
+sum = 0
+for i in range(1,20)
+    if i == 13 then continue
+    print i + ". " + "*" * i
+    sum = sum + i
+end for
+print "That's a total of: " + sum
+```
+
+This is an ordinary `for` loop, but on line 13, we check for the special case of `i == 13`, and when that's true, we `continue` — that is, we skip the rest of the loop body and continue with the next iteration of the loop (when `i` is 14 in this case).
+
+This is a pretty silly example, but in real code the need for this sort of thing occurs fairly often.  You might have a long `while` loop that does a lot of processing, but starts by asking the user for an input.  You could check this input and if it's no good, skip the rest of the loop and continue with the next iteration.  You could also check for a special input that means "I'm done" and bail out.
+
+{caption:Common while-loop input handling}
+```miniscript
+while true
+	inp = input("Enter a value (0 to exit): ")
+	if inp == "0" then break
+	if val(inp) < 1 or val(inp) > 100 then
+		print "Please keep your values between 1 and 100."
+		continue
+	end if
+	print "...OK... doing big complex processing with " + inp + "..."
+end while
+```
+
+Just imagine that line 8 in the example above is actually a couple dozen lines long, and you may see why bailing out at the top of the loop is better than putting all that code inside a giant `if` block.  (Remember, the goal isn't to write code the computer can understand... it's to write code a *human* can understand, and with as little effort as possible!)
+
+As a final example, here's a program that may actually be useful.  It allows you to encode and decode messages in a cipher called "ROT-13."  In this cipher, every letter in the alphabet is rotated 13 places, so A maps to N, B maps to O, etc.  Because the alphabet is exactly 26 letters long, a 13-letter rotation also does the inverse mapping (N maps to A, O maps to B, and so on).  So, with this one program, you can either enter a plain-text message and get back the encoded version, or enter an encoded message to decode it.
+
+{width:"75%"}
+![](secretMessage.svg)
+
+{caption:ROT-13 secret message encoder/decoder}
+```miniscript
+while true
+    msg = input("Enter your message: ")
+    if msg == "" then break
+    result = ""
+    for i in range(0, msg.len - 1)
+        c = msg[i]   // gets the i'th letter of msg, starting at 0.
+        if c >= "A" and c <= "Z" then
+            letterNum = c.code - "A".code		// A=0, B=1, etc.
+            letterNum = (letterNum + 13) % 26	// 1->14, 2->15...
+            result = result + char("A".code + letterNum) // 0->A...
+        else if c >= "a" and c <= "z" then
+            letterNum = c.code - "a".code		// a=0, b=1, etc.
+            letterNum = (letterNum + 13) % 26	// 1->14, 2->15...
+            result = result + char("a".code + letterNum) // 0->a...
+        else
+            // not a letter; copy to the output as-is
+            result = result + c
+        end if
+    end for
+    print result
+end while
+```
+
+Notice how there is a main `while` loop that runs forever, but we break out of it (on line 3) if the user enters an empty string.  Then within the `for` loop that iterates over each character of the message, we have an `if`/`else if`/`else` block that checks for several possibilities: the character is an upper-case letter (lines 7-10), or a lower-case letter (lines 11-14), or anything else (lines 15-17).
+
+Enter this code carefully, and confirm that it works by entering a message, and then copying the encoded message and pasting it back as your next input, which should produce the original message.  Use this to send secret messages over email or social media!  And then when you're done, just press Return without typing in anything, and the program will neatly exit.
+
+{pageBreak}
+A> **Chapter Review**
+A> - You learned how to use `if`, with optional `else if` and `else` blocks, to make a program do different things depending on the data.
+A> - You can use a single-line `if` or `if`/`else` for very short checks.
+A> - You learned how to break out of a loop with `break`, or skip to the next iteration with `continue`.
+

data/day7.txt

@@ -0,0 +1,276 @@
+{chapterHead: "Day 7: Three Small Games", startingPageNum:63}
+
+{width: "50%"}
+![](Chapter7.svg)
+
+Q> The only way to learn a new programming language is by writing programs in it.
+Q>— Dennis Ritchie (creator of C programming language)
+
+A> **Chapter Objectives**
+A> - Rest and recouperate.
+A> - Enter and play with some simple-but-fun MiniScript games.
+A> - Review and synthesize what you've learned so far.
+
+If you've been doing one chapter a day, then it's been a week since you started on your journey to programming mastery.  If you've been doing the chapters faster or slower than that, that's fine too.  In any case, it's time to pause and let it sink in.
+
+A great way to help it sink in is to type in some short programs.  In our modern world of scrolling through social media posts and picking responses from suggestions made by AI, you will be tempted to skip this exercise.  Don't!  Typing in code is crucial to learning how to write your own code.  It's like having an expert trainer help you to move your body correctly as you learn dance or martial arts.  But in this case, the muscles being moved are in your brain.
+
+So in this chapter are three small games.  Why games?  First, games are fun.  But more importantly, games like these are *easy*; they represent a world of simplified, well-defined rules that can be converted into code.  With only six chapters behind us, our toolset is still a bit limited.  We haven't learned about lists, maps, or functions yet, so we have to keep things simple.  In a few more weeks, you'll be able to create simulations that provide deep insight into science or business, analysis programs that crunch numbers or graph data, programs that create music or art, and much more.  So if games aren't your cup of tea, be patient — the skills you practice here will be useful for other kinds of coding too.
+
+## The Matchstick Game
+
+First up is the matchstick game.  This is a classic numbers game for two players.  You start with a pile of matchsticks between you, and then take turns removing one, two, or three matchsticks from the pile.  Whoever takes the last matchstick loses.  The skill in this game is to think ahead and try to force your opponent to take the last matchstick.
+
+Our implementation here pits you, the human player, against the computer!  Here's the code — only 40 lines long.  Type it in and take it for a spin.  If you get any errors, compare your code carefully to the code below.  If you are still getting errors, check the troubleshooting section at the end of this chapter.
+
+{caption:Matchstick Game}
+```miniscript
+// Matchstick Game
+qty = 15
+while qty > 0
+    // Human player's turn.
+    // Print how many matchsticks there are.
+    if qty == 1 then
+        print "There is one matchstick left."
+    else
+        print "There are " + qty + " matchsticks."
+    end if
+    // Ask the player how many to take.
+    take = 0
+    while take < 1 or take > 3 or qty - take < 0
+        take = round(val(input("How many do you take? ")))
+    end while
+    // Update the quantity left, and check for game-over.
+    qty = qty - take
+    if qty == 0 then
+        print "You took the last matchstick.  I win! :)"
+        break
+    end if
+    
+    // Computer player's turn.
+    // Print how many matchsticks there are now.
+    if qty == 1 then
+        print "That leaves just one matchstick."
+        print "I guess I have to take it.  You win!"
+        break
+    else
+        print "That leaves " + qty + " matchsticks."
+    end if
+    // Calculate how many the computer should take.
+    take = (qty - 1) % 4
+    if take == 0 then take = 3
+    if rnd < 0.2 then take = ceil(rnd * 3) // occasional mistake
+    print "I'll take " + take + "."
+    // Update the quantity.
+    qty = qty - take
+    if qty == 0 then print "Oops.  You win!"
+end while
+```
+
+Most of this code should be pretty clear to you by now.  There's a main `while` loop, as in most interactive programs.  This begins by printing out the current state of the game on lines 6-10.  Then we ask (with `input`) how many matchsticks you want to take.  Notice how we use a little `while` loop around that to keep asking until we get a valid input (lines 12-15).
+
+The second half of the main loop does the computer's turn.  It begins by again printing the current state.  Then on lines 33-35, we do a bit of mathematical wizardry to figure out how many matchsticks the computer should take.  Let's pause and study how that works.
+
+The computer's goal is to leave only 1 matchstick, forcing the player to take it.  So if there are 2 sticks left, the computer should take 1; if there are 3 it should take 2, etc.  In general, if `qty` (the number of matchsticks left) is a small number, the computer should take `qty - 1`.  That explains the first part of line 33.
+
+This works up to 4, since 4 - 3 is 1, a valid number of matchsticks to take.  What if there's more than that?  Well, if there are 5 matchsticks left, then the computer is out of luck.  No matter how many it takes, the human can take all but one of the remainder.  But this works both ways; if the computer can stick the human with 5, then it can win no matter what the human does.  So the computer should take 1 when `qty = 6`, 2 when `qty = 7`, etc.  If you keep working this out, the correct number of matchsticks to take repeats every 4 numbers.
+
+Whenever you have a sequence that repeats every so-many numbers, it's a hint to use the mod (`%`) operator.  Mod is the remainder after division.  In this case, we want the remainder after dividing by 4.  Let's work through an example: if `qty = 6`, then `qty - 1` is 5, and `5 % 4`, the remainder after dividing 5 by 4, is 1.  So the computer takes 1 matchstick, leaving the player with 5, from which the player cannot win.  It works!
+
+The only hitch in this formula is that sometimes the remainder after dividing by 4 is 0.  This is true when `qty - 1` is 4, 8, 12, etc.  Taking 0 sticks is not a legal move.  These are the no-win situations for the computer; it doesn't really matter what we do in this case, but to keep the game moving along, we have the computer take 3 matchsticks in this case (line 34).
+
+If all this math is still unclear, don't worry about it.  It's not the programming that's tricky; it's the math!  And eventually, programming will make math easier.  For now it's OK to just take these formulas on authority and enjoy the game.
+
+Finally, note that the computer would play a perfect game if not for line 35.  That generates a random number between 0 and 1, and if this is less than 0.2 (i.e., 20% of the time), it makes a random move instead of the ideal move.  This causes the computer to make occasional mistakes, giving the poor human a chance to win.  Feel free to change that 0.2 to other values, to make the computer smarter or dumber.
+
+**Challenge:** Change line 34 so that when the computer is in a tight spot, instead of always taking 3 matchsticks, it randomly takes 1, 2, or 3.  This makes the game less predictable and more interesting for a good human player.
+
+
+## The Bit-Flip Game
+
+Next up is a fun little logic puzzle.  Nine bits are arranged in three rows and three columns.  You can think of these as coins, or Othello pieces that are black on one side and white on the other, or cards that are face up or down.  But since we're doing this on a computer, they're just bits, each with a value of 0 or 1.
+
+The bits start out all 0, and your goal is to change them all to 1.  On each move, you pick a row and column.  All the bits that match your row or column are flipped: 1 becomes 0, and 0 becomes 1.  Can you find a sequence of moves that gets all the bits to be 1?
+
+{caption:Bit-Flip Game}
+```miniscript
+b0A = 0    // bit in column 0, row A
+b0B = 0    // bit in column 0, row B
+b0C = 0    // (etc.)
+b1A = 0
+b1B = 0
+b1C = 0
+b2A = 0
+b2B = 0
+b2C = 0
+print "Can you flip the all bits to 1?"
+print
+while true
+    print "Bit: "
+    print "  A: " + b0A + " " + b1A + " " + b2A
+    print "  B: " + b0B + " " + b1B + " " + b2B
+    print "  C: " + b0C + " " + b1C + " " + b2C
+    print "     - - -"
+    print "     0 1 2"
+    print
+    if b0A + b0B + b0C + b1A + b1B + b1C + b2A + b2B + b2C == 9 then
+        print "You win!"
+        break
+    end if
+    cmd = input("Which row and column to flip (e.g. A0)? ").upper
+    if cmd.len != 2 then continue
+    row = cmd[0]
+    col = val(cmd[1])
+    if col == 0 then
+        b0A = 1 - b0A
+        b0B = 1 - b0B
+        b0C = 1 - b0C
+    else if col == 1 then
+        b1A = 1 - b1A
+        b1B = 1 - b1B
+        b1C = 1 - b1C
+    else if col == 2 then
+        b2A = 1 - b2A
+        b2B = 1 - b2B
+        b2C = 1 - b2C
+    end if
+    if row == "A" then
+        if col != 0 then b0A = 1 - b0A
+        if col != 1 then b1A = 1 - b1A
+        if col != 2 then b2A = 1 - b2A
+    else if row == "B" then
+        if col != 0 then b0B = 1 - b0B
+        if col != 1 then b1B = 1 - b1B
+        if col != 2 then b2B = 1 - b2B
+    else if row == "C" then
+        if col != 0 then b0C = 1 - b0C
+        if col != 1 then b1C = 1 - b1C
+        if col != 2 then b2C = 1 - b2C
+    end if
+end while
+```
+
+The logic in this game is straightforward.  Notice that our main loop in this program is using `while true`, with a `break` when the game is over (line 22).  We get the user's input on line 24, and if it's not 2 characters long, use `continue` to jump back to the top of the loop.
+
+The rest of the main loop flips the appropriate set of bits.  There is an `if`/`else if` structure for the column (lines 28-40), and another one for the row (lines 41-53).  Note that there is one bit that matches the column *and* the row — i.e., the one at the exact coordinates you enter.  We don't want to flip that one twice.  So as we're working on the row, we also check (using single-line `if` statements) to be sure we skip the entered column.
+
+**Challenge:** The code given above gets the job done and exercises some important variations on the `if` statement.  But there is another way to do it.  Lines 28-53 could be replaced with nine lines, each checking for a particular row and column, like this:
+
+```miniscript
+    if row == "A" or col == 0 then b0A = 1 - b0A
+```
+
+Delete lines 28-53, and replace them with the line above, which handles position A0, and eight similar lines to handle the other eight positions.  Verify that the game still works!
+
+
+## Pig Dice Game
+
+The last game for this chapter is another computer-versus-human game.  This one involves rolling dice.  On each player's turn, a six-sided die is rolled.  If the player rolls a 1, their turn is over and they get no points for that turn.  If they roll 2 to 6, they get that many points added to their total for the turn.  At this point they face a choice: end their turn and add their current total to their score; or roll again, potentially getting even more points, but risk getting a 1 and losing all their points for the turn.  This continues until the player either chooses to stop, or rolls a 1.
+
+In either case, play then passes to the other player.  The first player to reach the goal (32 points in this version) wins the game.
+
+{width:"50%"}
+![](pigDice.svg)
+
+{caption:Pig Dice Game}
+```miniscript
+// Pig Dice game
+human = 0
+computer = 0
+goal = 32
+print "Let's play Pig to " + goal + " points!"
+while human < goal and computer < goal
+    // Human player's turn
+    print
+    print "Your turn!  (You: " + human + "  Me: " + computer + ")"
+    rollTotal = 0
+    choice = "R"
+    while choice != "D"
+        if choice == "R" then  // roll!
+            wait
+            roll = ceil(rnd * 6)
+            if roll == 1 then
+                print "You roll a 1.  No points for you!"
+                rollTotal = 0
+                break
+            end if
+            rollTotal = rollTotal + roll
+            print "Your roll: " + roll + ", total: " + rollTotal
+        end if
+        choice = input("[R]oll again, or [D]one? ")
+        choice = choice.upper
+    end while
+    human = human + rollTotal
+    print "You gain " + rollTotal + " points, and now have: " + human
+    if human >= goal then break
+    
+    // Computer's turn
+    print
+    print "My turn!  (You: " + human + "  Me: " + computer + ")"
+    rollTotal = 0
+    while true
+        wait
+        roll = ceil(rnd * 6)
+        if roll == 1 then
+            print "I roll a 1.  Darn!"
+            rollTotal = 0
+            break
+        end if
+        rollTotal = rollTotal + roll
+        print "My roll: " + roll + ", total: " + rollTotal
+        if rnd * 20 < rollTotal then
+            print "That's enough for me."
+            break
+        end if
+        print "I'll roll again."
+    end while
+    computer = computer + rollTotal
+    print "I gain " + rollTotal + " points, and now have: " + computer
+   
+end while
+
+print
+print "Final scores:  You: " + human + "  Me: " + computer
+if human > computer then
+    print "You win.  Well played!"
+else
+    print "I win.  Good game!"
+end if
+```
+
+As usual, there's a main `while` loop here.  Within that, we have a section of code for the human player, using another `while` loop to let the player roll as many times as they like until they stop or get a 1.  Notice how the `break` statement on line 19 breaks out of this inner loop.
+
+Then we have a similar section of code for the computer player.  The AI (artificial intelligence) here is on line 45: the computer decides to stop when `rnd * 20 < rollTotal`.  The formula `rnd * 20` picks a random number between 0 and 20.  So when the computer's total roll is rather small, it's likely to roll again.  When the total for the turn is 10, it has a 50% chance of stopping.  And once the roll total is 20 or more, the computer is guaranteed to stop.
+
+Play the game a few times and see how often you can win.  It's not easy!
+
+**Challenge:** the rule used on line 45 is certainly not optimal; it always plays the same, regardless of whether it's ahead or behind.  A smarter player might play more aggressively when behind, and more conservatively when ahead.  Change the code so that it first picks a `target` value, equal to 10 if `computer > human`, or 25 otherwise.  Then use `rnd * target` instead of `rnd * 20` when deciding whether to roll again.
+        
+
+## Troubleshooting
+
+If you got errors or incorrect behavior in any of the programs above, start by comparing your code carefully to what's in the book.  Here are some common mistakes to watch out for:
+
+- Be sure you've used the correct capitalization.  Remember that MiniScript is case-sensitive.  So check for places you may have typed `RollTotal` or `rolltotal` rather than `rollTotal`, for example.
+
+- Check that every `if` statement has a `then`, and unless it's a single-line `if`, it should also have a matching `end if` statement.
+
+- Check that every `while` has a matching `end while`.
+
+- Be sure every open parenthesis `(` has a matching close parenthesis `)`.
+
+- Make sure your quotation marks are balanced.  Every string must have quotation marks at the beginning, and quotation marks at the end.
+
+- Some text editors may try to apply "smart quotes," that is, quotation marks that curl towards the text they enclose.  Those will not work with MiniScript (or any other programming language I've used).  You need to use the straight kind, like `"`.  If you're running into this problem, find the option to turn off smart quotes, or use a different text editor.
+
+- Make sure any tests for equality are using two equal signs, `==` instead of `=`.  If you get an error like "got OpAssign where Keyword(then) is required", you made this mistake (and now you know how to fix it).
+
+- The Bit-Flip Game uses some square brackets on lines 26 and 27, to get to the first and second characters of the player's input.  Double-check that you're using square brackets and parentheses exactly as shown.
+
+{pageBreak}
+A> **Chapter Review**
+A> - You entered and debugged several real programs that do interesting things.
+A> - You practiced using variables, assignment, `if` blocks, and `while` loops.
+A> - You exercised your coding muscles, laying down brain pathways through which magic will one day flow.  Savor this accomplishment.  You are well on your way!
+
+

data/day8.txt

@@ -0,0 +1,372 @@
+{chapterHead: "Day 8: Command-Line MiniScript", startingPageNum:75}
+
+{width: "50%"}
+![](Chapter8.svg)
+
+Q> Ah, the command line.  This is the interface of a Programmer.
+Q> Not as clumsy or random as a GUI... 
+Q> An elegant interface for a more civilized age.
+Q>— Obi-wan Codonly
+
+A> **Chapter Objectives**
+A> - Install command-line MiniScript on your computer.
+A> - Learn about a Read-Eval-Print Loop, and how it makes coding even more fun and interactive.
+A> - Learn how to represent and work with a list of data.
+A> - Realize that a programming language may be used in different environments, but your knowledge still applies.
+
+For many readers, all code written this point has been run in the MiniScript *Try-It!* web page.  However, that is only one way to run MiniScript code; there are many others.
+
+In the beginning it is very easy to confuse the *programming language* with the *development environment* you are using.
+
+programming language
+: A formal language used to specify a computer program, e.g., MiniScript
+
+development environment
+: A software application that provides a programming language and related tools, such as a code editor and libraries of extra intrinsic functions.  E.g., the Try-It! web page, command-line MiniScript, and Mini Micro
+
+The great thing is, your knowledge of the language from one environment applies equally well in other environments.  Yet each one provides unique new capabilities.  Today you're going to add a second MiniScript environment to your tool set.
+
+
+## Command-Line MiniScript
+
+{i: "MiniScript, command-line;command-line MiniScript"}
+Today's computers use a graphical user interface (GUI) of buttons, menus, and other widgets, manipulated more with a mouse or touch screen than by typing.  However, on desktop computers at least, there is still a command line available to power users such as yourself.
+
+command line
+: a user interface based around typing commands and getting interactive results
+
+To someone raised on a GUI, the command line might seem old-fashioned.  But there are many power users today who rely on it heavily.  With practice, complex operations can be carried out efficiently with a command line that would take much longer (or in some cases be impossible to do at all) with pointing and clicking.  The command line is especially important (and useful) to a programmer.  So this week, let's install and explore the command-line version of MiniScript.
+
+Unfortunately, the details of how to find and use the command line are a bit different depending on what kind of computer you use.  We'll cover here the three main varieties of desktop platforms: Windows, Mac OS, and Linux.
+
+{pageBreak}
+### Windows
+
+On a Windows computer, the standard command line is called `cmd` (short for "Command Prompt").  The easiest way to get to it is probably: (1) click on `Start` in the lower-left corner of your screen; (2) type `cmd` and press Enter.
+
+If you type "Windows command line" or "how to use Windows cmd" into your favorite web search engine, you will probably find some great introductory resources.  The main commands you should pay attention to are `dir` (directory, i.e. list files for the folder you are in) and `cd` (change directory, i.e. move to a different folder).
+
+Once you have mastered those, you are ready to download and use command-line MiniScript.  Point your web browser to <https://miniscript.org/cmdline/>, and click the link for "miniscript-win.zip".  This should download the zip archive, probably into your Downloads folder.  Find that file in Windows Explorer, select it, and press the "Extract All" button.  This should result in a file called `miniscript.exe` (though in Explorer, file extensions are normally hidden, so it may appear as simply "miniscript").
+
+Now go back to Command Prompt, navigate to that directory using the "cd" command, and run miniscript by typing `miniscript.exe` and pressing Enter.  If all goes well, you should see the word "MiniScript" followed by some version information, and a ">" prompt, as shown in the image below.
+
+{width:"75%"}
+![Command-Line MiniScript on Windows](cmdline-windows.png)
+
+Chances are good, however, that all will *not* go well, and Windows will instead decide that MiniScript is a "threat" (because it can execute commands), and quarantine the file, removing it from the folder where you had it and tucking it away in some hidden location.  The exact steps you follow to fix this may vary slightly depending on what version of Windows you're running, but here's the procedure for Windows 10:
+
+1. Open **Windows Security** (again from the Start menu).
+2. Click on **Virus & threat protection**, and then on **Protection history** (or **Threat history**).
+3. In the filter pop-up, select **Quarantined items**.
+4. Click miniscript.exe, and then click **Restore**.
+
+This should both restore the file, and tell Windows that this particular file is OK and not actually a threat.
+
+Once you've done all that, you should be able to run `miniscript.exe`, and get a result like the above.  Once you see that MiniScript header and version info, you're ready to go!
+
+Finally, it should be noted that there are alternatives to the built-in Command Line app for Windows.  Terminal is a popular one, as is the somewhat older PowerShell; both are from Microsoft and available in the Microsoft Store.  If you're already using one of these alternatives, feel free to continue using it with MiniScript.  Otherwise, Command Line is perfectly adequate for now, and you can always move to something else if you feel the need later.
+
+### MacOS
+
+The procedure on a Mac is similar to on Windows.  The app you'll want to use is called Terminal, and can be launched via Spotlight, or directly from Applications/Utilities.  If you're new to Terminal, do a search for "mac useful terminal commands," and read an article or two.  There are plenty of good resources on this very useful tool.
+
+Now you're ready to download and use command-line MiniScript.  Point your web browser to <https://miniscript.org/cmdline/>, and click the link for "miniscript-mac.zip".  This should download the zip archive, probably into your Downloads folder.  Find that file in Finder, and double-click it to unzip.  This should result in a file called `MiniScript`.  Finally, double-click that new MiniScript file to launch it in Terminal.
+
+At this point, chances are Finder is going to get cranky, with a message along the lines of "MiniScript can't be opened because it is from an unidentified developer."  If that happens, click OK to dismiss the alert, then right-click MiniScript and choose "Open" from the contextual menu.  You'll get a similar alert, but this time there will be an "Open" button.  Click that, and Finder will remember that it's OK to run this program.
+
+The result should look similar to the image below.
+
+{width:"75%"}
+![Command-Line MiniScript on macOS](cmdline-mac.png)
+
+Note that double-clicking the executable is not the only way to launch it; you can also open a Terminal window yourself, use `cd` to navigate to the folder containing MiniScript, and then enter `./MiniScript` to run it.  This does essentially the same thing.
+
+
+### Linux
+
+If you're a Linux user, chances are extremely high that you don't need me telling you how to use the command line — you probably know more about it than I do!  Just download the gzipped Linux binary from <https://miniscript.org/cmdline/>, unpack it, and put it somewhere in your search path.  Then invoke it by name, like any other command-line tool.
+
+Some Linux users prefer to build their software from the source code.  If that describes you, you can find a link on the MiniScript home page to the source code repository.  The build process is pretty straightforward, and explained in the README file in the MiniScript-cpp directory.
+
+### Trouble-Shooting
+
+For many readers, this will be the first time you have ever tried to install and run a command-line program.  With all the variations on operating systems out there, and these systems' (quite justified) concern for security, doing this can be tricky, and it's possible something has gone wrong.  But this is an important step, so if you've run into a roadblock, don't give up!
+
+You may have someone in your home or office who has more experience with this sort of thing; show them what you're trying to do, and they may be able to help.  Or, failing that, come to the MiniScript forums or Discord server (both reachable via <https://miniscript.org/>).  We'll work together to get you unstuck.  Command-line MiniScript, and for that matter the command line itself, are powerful tools you will want in your toolbox.
+
+
+## The Read-Eval-Print Loop
+
+{i:"prompt"}
+Once you've got MiniScript running, you should be looking at a blinky cursor next to a ">" prompt.  Now what?  ...Now the fun begins!
+
+{i:"REPL, defined"}
+That prompt and cursor represent something called a read-eval-print loop, or REPL for short.  That's a fancy way of saying that you can type and run code here interactively, as MiniScript itself will
+
+- **Read** input from the user,
+- **Evaluate** the expression or command entered,
+- **Print** the results, and
+- repeat (i.e. **Loop**) until told to quit.
+ 
+Try it!  At the prompt, type
+
+```terminal
+> 6*7
+```
+
+and press Return or Enter.  (Note that when examples are shown with a faint REPL prompt, like the `>` above, you don't type that; only type what comes after.) MiniScript immediately responds with
+
+```repl
+42
+```
+
+and then displays the ">" prompt again, waiting for your next command.  That `6*7` you typed in was MiniScript code.  You didn't need to use `print` here because that's a built-in function of the read-eval-print loop; it evaluated your MiniScript expression, `6*7`, and printed the result automatically.
+
+Prove that this is more than just a calculator by trying something a little more complex:
+
+```terminal
+> ceil(6*rnd) + ceil(6*rnd)
+```
+
+This simulates rolling two dice.  I can't say exactly what the output will be, except that it will be between 2 and 12, and most likely closer to 7!  Here's your first power-user trick on the command line: *press the up-arrow key*, and the previous command should reappear on the prompt, with the cursor at the end.  You can just press Enter or Return at this point to execute the same command again.  Do this up-arrow/return trick several times, rolling the dice multiple times to confirm that the result really is random (and more importantly, to learn how to repeat previous commands).
+
+The command-line environment supports all the same MiniScript powers you know from the Try-It page, and then some.  This includes variables, `print` and `input`, `wait`, loops, and so on.  Carefully type in the following:
+
+```miniscript
+for i in range(10, 1)
+  print i + "..."
+  wait   
+end for
+```
+
+But hold on — something different happened after the "for" line, didn't it?  The prompt changed from ">" to ">>>".  This is the REPL's way of acknowledging that your input is not yet finished (because you have started a `for` loop, but not yet ended it).  As you're typing this code, it actually looks like this:
+
+```terminal
+> for i in range(10, 1)
+>>> print i + "..."
+>>> wait   
+>>> end for
+```
+
+You may also notice that the statements inside the loop, `print` and `wait` in this example, don't do anything as soon as you type them.  Only after you finish with the `end for` does the whole loop run and do whatever it does.
+
+Now, let's see what happens if things get out of control.  Here's an infinite loop.  Don't panic!
+
+```miniscript
+i = 0
+while true
+  i = i + 1
+  print i
+end while
+```
+
+{i:"control-C"}
+Woo!  MiniScript starts printing numbers very fast, with no sign of stopping.  Fortunately *you* are the programmer; you are in charge!  Hold the Control key down and then press the C key (i.e., the key combination called control-C).  MiniScript stops and exits.  This leaves you either at the command prompt, or (if you launched MiniScript directly from Finder) back in Finder.  Just relaunch it the same way you did before, and you'll have a fresh clean REPL, ready to continue.
+
+It can sometimes happen that you make a mistake in entering some code in the REPL, and don't catch it until you've already pressed Return.  There's no going back to edit something already entered; but you can often just replace a previous result with a new one (i.e., assign a new value to a variable if you made a mistake on a previous assignment).  If you make a mistake inside a `for`, `while`, or `if` block, you can usually just enter the corresponding `end` statement to finish the block and get back to a ">" prompt where you can try again.  But if all else fails, Control-C will always bail out and let you start over.
+
+Obviously the REPL is not a great way to enter long programs.  We'll be learning tomorrow how to use command-line MiniScript with programs stored in text files, which is better for writing more than a few lines of code.  What's great about a REPL is that it is a very fast, very *interactive* way of experimenting with code.  When you put this book down, stretch your wings, and start to fly on your own, you will very often pause and say, "I *think* I know how to do that, but does that actually work?"  At those times, if you have the MiniScript REPL at hand, you can very quickly try out your idea and see if it works.  If it does not, you can try a slightly different variation, often using up-arrow to recall and modify a previous command.  This process is extremely fast, even more so than the Try-It! page... and it is also a lot of fun.
+
+So, for the rest of this chapter, let's work exclusively in the REPL, while we learn about lists.
+
+## Lists
+
+You know that there are several different types of data in MiniScript.  So far, we've talked about numbers (e.g. 42) and strings (e.g. "Hello World").  It's time to introduce a third data type: lists.
+
+{i:"data type, list"}
+list
+: a data type that is an ordered sequence of other data
+
+Lists in MiniScript appear in square brackets, with their elements separated with commas.  You can assign these to variables, pass them into functions, and generally handle them just like you would numbers and strings.
+
+{caption:"List Example 1"}
+```terminal
+> a = [1, 2, "x"]
+> b = ["foo", 42]
+> c = a + b
+> print c
+[1, 2, "x", "foo", 42]
+```
+
+In this example, line 1 creates a list with three elements — the numbers 1 and 2, and the string "x" — and assigns this to variable `a`.  Line 2 creates a similar list `b` with two elements.  Then line 3 adds these together and stores the result in `c`.  Lists support addition (`+`), replication (`*`), and division (`/`) in the same way as strings.  That is, `+` joins two lists together; `*` repeats a list some number of times; and `\\` cuts a list down to some fraction of its former length.
+
+At this point, you should put the book down for a moment and go play with this using the command-line REPL.  Experiment!  Can you put a list inside another list?  Does it matter whether you put a space after each comma?  Can you make a list with no elements at all?  Lists are a really important type of data that will come up again and again in your programming, so it's worth making sure you understand them.
+
+Of course just being able to create a list and print it isn't very useful.  You also need to be able to pull an element out of a list.  We can do this with *list indexing*.
+
+list index
+: a numeric value, starting at 0, that indicates a particular element of a list
+
+You use a list index by simply putting it in square brackets after a variable that contains a list.  The first element is index 0, so you can print just the first element of a list this way:
+
+{i:"list indexing;indexing, list"}
+{caption:"List Indexing"}
+```miniscript
+a = ["foo", 42, "XYZZY"]
+print a[0]
+```
+
+D> Counting in MiniScript, and most other modern languages, generally starts at 0.  Just think of the index as "how many elements come *before* the one I want" and you'll be fine.
+
+Experiment with that last example, too.  Make sure you can print out any element you want.  If you try to use an index that doesn't exist, such as 7 when there are only three elements, MiniScript will report the problem as a "MiniScript::IndexException".
+
+There's one more trick with list indexing that is super handy: by using negative numbers, you can count backwards from the end of the list.  The last element is -1, the second-to-last is -2, and so on.
+
+{caption:"List Indexing, Backwards!"}
+```miniscript
+a = ["foo", 42, "XYZZY"]
+print a[-1]
+```
+
+Again, experiment with this, and see that if you go too far, you get an `IndexException`.
+
+Just as there are a number of intrinsic (built-in) functions for working with numbers and strings, there are intrinsic functions for lists, too.  These are shown in the table on the next page.
+{gap:12}
+
+{i:"functions, list;list functions"}
+{caption:"Intrinsic list functions", colWidths:"170,*"}
+| `.hasIndex(i)` | 1 if i is a valid list index; otherwise 0 |
+| `.indexes` | a list with numbers from 0 to `self.len-1` |
+| `.indexOf(x, after=null)` | 0-based position of first element matching x in `self`, or null if not found; optionally begins the search after the given position |
+| `.insert index, value` | inserts value into `self` at the given index (in place) |
+| `.join(delimiter=" ")` | builds a string by joining elements by the given delimiter |
+| `.len` | length (number of elements) of `self` |
+| `.pop` | removes and returns the last element of `self` (like a stack) |
+| `.pull` | removes and returns the first element of `self` (like a queue) |
+| `.push x` | appends the given value to the end of `self`; often used with pop or pull |
+| `.shuffle` | randomly rearranges the elements of `self` (in place) |
+| `.sort key=null` | sorts list in place, optionally by value of the given key (e.g. in a list of maps) |
+| `.sum` | total of all numeric elements of `self` |
+| `.remove i` | removes element at index i from `self` (in place) |
+| `.replace oldval, newval, maxCount=null` | replaces (in place) up to maxCount occurrences of oldval in the list with newval (if maxCount not specified, then all occurrences are replaced) |
+| `slice(list, from, to)` | equivalent to list[from:to] |
+
+This is the complete set of list intrinsics, and it includes some stuff we haven't talked about yet.  So just as on Day 2, please don't worry about understanding everything in this table today.  Let's just highlight a few of the most important functions:
+
+- `a.len` gives you the length (number of elements) in list a.
+- `a.push "x"` adds a new element "x" to the end of the list.
+- `a.insert 2, "y"` inserts a new element "y" after the first 2 elements in the list.
+- `a.remove 1` removes element 1 (that is, the item with 1 element to its left).
+
+With these four functions, you have ways to find out how big a list is, and modify it in various ways: add a new item to the end, insert a new item at any position, and remove any item.  You're probably beginning to see why lists are so important in programming; they let you hold and work with any amount of data.
+
+{pageBreak}
+Let's exercise these important list functions with an example.
+
+{caption:"List Example 2"}
+```miniscript
+a = []
+while a.len < 5
+    a.push input("Next item?")
+end while
+print "You entered: " + a
+print "Element 2 is " + a[2]
+print "But I can change that..."
+a[2] = "HAHA!"
+print "Now we have: " + a
+print "But I feel bad.  Let's just get rid of it."
+a.remove 2
+print "Now it's just: " + a
+```
+
+That's one of the longer examples, but go ahead and type it in.  It's going to ask you to enter five strings; enter the names of the numbers in Spanish, or your favorite pizza toppings, or whatever.  The program then does some shenanigans with the middle element (which, in list of length 5, is element 2).  As always, play with the code to gain deep understanding.  See if you can make it change the first element instead, or the last one.
+
+{i:"string indexing;indexing, string;immutable"}
+D> You can index into strings, too!  The elements of a string are characters.  `s[2]` is a perfectly cromulent way to get character 2 (the one with 2 characters to its left) of a string.  The main difference is, strings are *immutable*, which means you can't assign a new value to an element of a string, nor can you insert or remove characters, the way you can with lists.  We'll explore this more in the next chapter.
+
+## `range` and `for` revisited
+
+A `for` loop assigns a variable — often called `i` in our examples — to each element of a list or string, in turn.  It stops looping after it has done this with all elements.  It's equivalent to:
+
+{caption:Life in a world without `for` loops}
+```miniscript
+myList = [1, 2, "hey", "you"]
+index = 0
+while index < myList.len
+    i = myList[index]
+    print i
+    index = index + 1
+end while
+```
+...but as you can see, the `for` loop is considerably shorter and easier:
+
+{i:"`for` loop"}
+{caption:"`for` loops make life easy"}
+```miniscript
+myList = [1, 2, "hey", "you"]
+for i in myList
+    print i
+end for
+```
+
+{i:"`range` function"}
+In previous chapters, we used `for` loops with the `range` function, which I glossed over without properly explaining.  But now it's time to revisit that.  `range` is an intrinsic function that takes three parameters: a starting value, an ending value (which defaults to zero), and a step size (which defaults to one).  It returns a list with elements that begin at the start value, and count towards the end value, in increments of the given step.
+
+{caption:"Examples of the `range` function", hpad:8}
+| `range(1, 10)` | `[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]` |
+| `range(10, 1)` | `[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]` |
+| `range(1,10,3)` | `[1, 4, 7, 10]` |
+| `range(1,10,4)` | `[1, 5, 9]` |
+| `range(10,1,4)` | `Runtime Exception: range() error` |
+| `range(10,1,-4)` | `[10, 6, 2]` |
+| `range(10)` | `[10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]` |
+
+It's quite possibly the most commonly used function in MiniScript, apart from print, and in some code it surpasses even that.  So take some time with the REPL to play with it.  Type in each of the examples in the left column on the previous page, and you should see the output shown on the right.
+
+Notice that `range` can count both ways: if the start value is less than the end, it counts up; otherwise it counts down.  Also notice that the start value is always included as the first element of the resulting list, but the end value might not be included at all, if it is not hit by the combination of start and step.  Finally, notice that the step size, if given, must be negative if counting down, or positive if counting up; otherwise you get an error.
+
+Experiment a bit more and make sure that `range` is a tool you are comfortable using.  Now that you understand this, you can really understand all those `for` loops we glossed over before.  When we write something like
+
+```miniscript
+for i in range(10, 1)
+  print i + "..."
+  wait   
+end for
+```
+
+...that `for` statement is really just iterating over the list returned by `range`.  We could have instead written
+
+```miniscript
+for i in [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
+  print i + "..."
+  wait   
+end for
+```
+
+and this would do the exact same thing.
+
+D> In programming, there are often many ways to do the same thing.  You should always pick whichever way seems clearest and easiest to read and understand.  This is usually (but not always) the way that is shortest.
+
+{i:`indexes`}
+We'll end the day with one more tip related to lists and `for` loops.  It sometimes happens that you need to iterate over not the elements of a list, but the indexes of those elements.  For example, suppose you want to write a loop that converts every element of a list of strings to upper case.  You might do it like this:
+
+{caption:"Uppercasing a list, the slightly less easy way"}
+```miniscript
+data = ["Billy", "and", "the", "boingers"]
+for i in range(0, data.len - 1)
+	data[i] = data[i].upper
+end for
+data
+```
+
+(We left out `print` on the last line because I assume you're typing this into a REPL, where simply naming a variable is enough to print its contents.)  So this isn't too bad; `i` here will go from 0 to the last index (which is one less than the length of the list), and then we use that to reassign `data[i]` with the uppercase version.
+
+But there is a better way to do it, and that is the `.indexes` method.  This returns a list of all the valid indexes for a list or string (or map, which you'll learn about in a couple days).  If you did the above in your REPL, then type `data.indexes` now to see what it returns in this case.  The `.indexes` method is commonly used with `for`, like this:
+
+{caption:"Uppercasing a list, the slightly easier way"}
+```miniscript
+data = ["Billy", "and", "the", "boingers"]
+for i in data.indexes
+	data[i] = data[i].upper
+end for
+data
+```
+
+Same loop, but slightly shorter and clearer code.
+
+{pageBreak}
+A> **Chapter Review**
+A> - You installed command-line MiniScript for your platform.
+A> - You learned how to do use a REPL to work with code interactively.
+A> - You discovered that your knowledge of the MiniScript language may apply in very different environments.
+A> - You explored the list datatype, and in the process, gained deeper understanding of `for` loops.

data/day9.txt

@@ -0,0 +1,249 @@
+{chapterHead: "Day 9: Slice and Scripts", startingPageNum:93}
+
+{width: "50%"}
+![](Chapter9.svg)
+
+Q> If you do not have courage, you may not have the opportunity to use any of your other virtues.
+Q>— Samuel L. Jackson (actor and producer)
+
+A> **Chapter Objectives**
+A> - Learn how to extract a section of a list or a string.
+A> - See the many ways in which this "slicing" can be useful.
+A> - Learn to write a longer script as a file, so you can run it again and again.
+
+
+We saw in the last chapter how you could access any element of a list or string by putting its 0-based index in square brackets.  We're going to build on that in some really cool ways, so let's start with a quick review.  Fire up command-line MiniScript, and try the following at the REPL:
+
+```
+s = "Howdy world!"
+s[0]
+```
+
+That should print "H", since the character in `s` with 0 letters to its left is "H".  What would `s[3]` print?  What about `s[-1]`, recalling that negative indexes count from the end of the string?  Check each of these in the REPL to make sure you're right.
+
+D> If you're not at a computer, following along with these examples in the REPL, they are unlikely to stick.  Don't waste your time!  No runner ever got fast by watching other people run.
+
+Now the coolness begins.
+
+## Slicing
+
+In MiniScript, as well as some other languages (e.g. Python), you can index into a string or list with *two* indexes instead of just one.  When you do, you get back the subset that starts at the first index, and goes up to (but not including) the second one.  This operation is known as *slicing*, and what you get back is called a *slice*.
+
+slice
+: a substring or sublist defined by start and end indexes in a larger string or list
+
+slicing
+: the operation of getting a slice: `seq[a:b]`, where `seq` is a string or list, and `a` and `b` are numbers
+
+You get a slice by putting the two indexes together within the square brackets, separated by a colon.  Try it:
+
+```
+s[0:3]
+```
+
+This should print "How", which is the substring starting at `s[0]`, and going up to but not including `s[3]`.  Now see if you can get the slice "world", starting with "w" and going up to but not including "!".  Go on.  I'll wait.
+
+D> At times like this, the REPL is your dearest friend.  Even when you are an experienced programmer with decades of skillful code-craft under your belt, when you need to quickly confirm your understanding of some language feature like slicing, there is no better way than launching a REPL and trying a few quick examples.
+
+Did you come up with `s[6:11]`?  That gets the job done!  But to get that you probably either had to try several times, or count carefully from the beginning of the string.  There is another way, using the trick that negative indices count from the end of the string.  `s[-1]` is the exclamation point of our string, so you could write:
+
+```
+s[6:-1]
+```
+
+This returns the substring starting at character 6, and going up to but not including the last character of the string.  You can use a negative number with either index, or both, as needed.
+
+In addition to a numeric index (whether negative or not), you can also *omit* either index.  If you leave out the first index, the slice starts at the beginning of the string; if you leave out the second index, the slice extends to the end of the string.  These are very commonly needed, so this is a convenient shortcut.  Suppose you want to get the first five letters of string `s`.  You could of course write:
+
+```
+s[0:5]
+```
+
+but you can also write:
+
+```
+s[:5]
+```
+
+which you might read out loud as "s (up to 5)".  These are equivalent, though the second form is slightly shorter, and makes your intent slightly more clear.  The benefit is a bit greater when you omit the second index.  Suppose we want to get the slice "world!" from our "Howdy world!" string... but we are too lazy to count how long the string is (or, in a more realistic setting, we can't know how long it is because it may be different on each run).  You could do:
+
+```
+s[6:s.len]
+```
+
+but it's shorter, easier, and faster to do
+
+```
+s[6:]
+```
+
+which you might read as "s (from 6 to the end)".
+
+These sorts of string operations come up in programming a lot more than you might think.  Suppose you had a filename with a three-letter extension, which is something like ".txt" or ".png" or ".jpg".  You might want to get the name without the extension, to display a nice name to the user; or you might want to get the extension itself, to figure out what sort of file it is.  Both of these are easy, thanks to slicing.
+
+{caption:"Getting the name and file extension from a file name"}
+```miniscript
+filename = "My Recipes.txt"
+name = filename[:-4]
+ext = filename[-3:]
+```
+
+Enter that in the REPL, and then enter `name` and `ext` by themselves to see what values they have.  `filename[:-4]` gets the original string up to (but not including) the 4th character from the end, or in other words, it strips off the last four characters.  Conversely, `filename[-3:]` gets the last three characters of the string.
+
+All our examples so far have been with strings, but slicing works with lists, too.  For this next batch of examples, let's work with a list of the first ten prime numbers.
+
+```
+p = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29] 
+```
+
+Now, because we know this list is already sorted, you can use `p[0]` to find the smallest number, and `p[-1]` to find the largest.  (Try it!)  That much you knew yesterday.  But now you can get, say, the *three* smallest prime numbers:
+
+```
+p[:3]
+```
+
+Similarly, suppose you wanted the list of all primes *except* for the first and last.  You only want the ones in the middle.  Again with slicing, this is easy:
+
+```
+p[1:-1]
+```
+
+This gets the slice starting at element 1 (i.e., the one with 1 to its left), and going up to but not including the last one.
+
+## Attack of the Mutant Lists
+
+One important difference between strings and lists is that strings are immutable, while lists are mutable.  "Mutable" means "able to be mutated," and "mutated" is just a fancy word for "changed."
+
+mutable
+: describes an object with data that can be changed: in MiniScript, lists and maps
+immutable
+: describes an object that can't be changed, but only replaced: strings and numbers
+
+You've been mutating lists since you first saw them (i.e. yesterday), with methods like `.push`.  Here's another way to mutate a list: replace any element with a new value.
+
+```
+p[3] = 42
+```
+
+Try that, and then examine `p` to see what it contains.  It looks the same as before, except element 3 (the one with 3 items to its left) has been replaced with 42.  However, it's important to note that you can *not* replace a slice this way.
+
+{caption:"This doesn't work."}
+```miniscript
+p[3:6] = [1,2,3]
+```
+
+Try it.  At the time of this writing, at least, it doesn't work.
+
+D> It's possible that this feature will be added to MiniScript someday.  It's a sensible thing to want, and wouldn't break any existing code.
+
+And you also can't mutate a string.
+
+{caption:"This also doesn't work (with strings)."}
+```miniscript
+s[2] = "x"
+```
+
+Of course you can always assign a *new* string to a string variable.  When you do something like `s = s.upper`, that is exactly what you're doing.  That's not mutating the string; it's just replacing it with a different one.  It's the same with numbers, for that matter; there is no way to *change* a number, but you can always assign a variable a new number, replacing its previous value, as in `x = x + 1`.
+
+Because lists are mutable, you have to be a little careful sometimes.  When you do something like `q = p`, it is not creating a new list; it is simply making `q` refer to the same list that `p` already referred to.  The list itself lives off in the computer's memory somewhere, and has variables like `p` and `q` that refer to it.  The list is actually deleted only when there are no more references to it.  So, of course, it doesn't matter what variable you use to mutate the list; all references point to the same thing.  Try this:
+
+```
+q = p
+q[0] = "hey"
+p
+p.push "ho!"
+q
+```
+
+{pageBreak}
+The results will not be surprising, as long as you remember that `p` and `q` do not *contain* a list; they only *refer* to a list.  Assignment copies the reference, but does not make a new list.
+
+{width:"50%"}
+![](listRefs.svg)
+
+So what do you do when you need to make a copy of a list?  For example, suppose you want to keep your original list, but also make a copy that is slightly different.  Here slicing comes to the rescue again.  It turns out that slicing *always* gets you a new list, even if the range of the slice covers the entirety of the original list.  So, you could create a complete copy of list `p` by using
+
+```
+q = p[0:p.len]
+```
+
+...but, as you learned above, you can omit the first index when it is 0 and omit the last one when it is the length of the list or string.  So the standard solution looks like this:
+
+```
+q = p[:]
+q.push "I'm unique!"
+p
+q
+```
+
+{gap:20}
+{width:"62.37%"}
+![](listCopy.svg)
+
+Think of `p[:]` as an idiom — a standard way of phrasing a concept in a language.  The concept in this case is making a complete copy.  You might even read this out loud as "copy of p", though if you forget and need to work it out at first, "p (from the beginning to the end)" is fine too.
+
+
+## Programs as Text Files
+
+So far in this book, we've written MiniScript code in two contexts: in the Try-It! page on the web, and in the REPL of command-line MiniScript.  Both of these are great for short bits of code, but not so great for larger programs.  The Try-It! page has a code limit (currently about 2000 characters), and of course typing in a REPL gets to be pretty difficult for loops or `if` blocks that are more than a few lines long.
+
+So it's time to learn to code the way professional programmers do: using a separate code editor!  In our case, any text editor will do.  But this being the modern world, let's make sure we are clear on the difference between a text editor and a word processor.
+
+text editor
+: a program that edits plain text (.txt) files.  Examples on Windows include Notepad, Notepad++, and GEdit; examples on Mac include TextEdit and BBEdit
+
+word processor
+: a program that edits formatted documents.  Microsoft Word is the most widely known word processor, but Apple Pages is another example
+
+While both kinds of applications are superficially similar in how they look and work, what they do is fundamentally different.  Text files are fairly universal, but word processors all have their own proprietary format, and their documents are generally not usable in any other program.  So, when programming, you will need to use a text editor.
+
+A few examples of text editors are given above.  If you're on Windows, Microsoft Notepad is a simple text editor that comes with the operating system, and is perfectly adequate.  Many people prefer Notepad++, which is a free replacement that has some more powerful features.  The situation on Mac is similar: the built-in TextEdit app will do, though I recommend BBEdit, which is powerful and free (though it has some additional for-pay features you probably won't need).  On Linux, your distribution probably came with a graphical text editor, and command-line editors (vi, vim, emacs, nano, etc.) also work fine.  There are many other text editors for all platforms, and any of them will work fine, so don't worry too much about which to choose.
+
+Pick one, and create a new file.  Enter the following text.
+
+{caption:"Our first MiniScript source file!"}
+```miniscript
+print "MiniScript is"
+for i in range(1, 5)
+	print "really " * i
+end for
+print "COOL!"
+```
+
+Save this file to disk as "cool.ms" (though the file extension is arbitrary, it's common practice to use ".ms" for MiniScript files).  Pay attention to where you save it; you're going to need to know its file path for the next step.
+
+Now the fun part.  Open up a new terminal or shell window, or if you are already running command-line MiniScript, enter `exit` (or press control-C) to exit.  Now you're back at the shell prompt.  As before, enter the path to your command-line MiniScript executable; but before you press Enter or Return, hit the spacebar, and then enter the path to your *cool.ms* text file.  (On some systems, you can drag the file icon from Finder or File Explorer right into the terminal/shell window, and it will enter the path for you — try that and see if it works!)  Then hit Enter/Return.  The result should look something like this.
+
+```terminal
+$ ./miniscript ~/DailyPurge/cool.ms
+MiniScript is
+really 
+really really 
+really really really 
+really really really really 
+really really really really really 
+COOL!
+$
+```
+
+The `$` above is my Unix shell prompt; yours will probably be something different, but that's OK.  The line `./miniscript ~/DailyPurge/cool.ms` is the Unix command I typed in to launch command-line MiniScript, and give it the path to my *cool.ms* file.  MiniScript read that file, executed the code in it, and then exited (returning me to my `$` shell prompt).
+
+If you see the program output above, then well done!  You wrote your very first program in a file, and then ran that program on the command line.  Now you have the ability to make your programs as long as they need to be, with the full power of whatever text editor you like, the ability to store them with your backup system, mail them to collaborators, and all those other great things you can do with disk files.
+
+If you didn't see that output, then let's get to the bottom of it before moving on.  If MiniScript didn't launch at all (i.e., you got only an error in response to your command), then you probably got the path to MiniScript incorrect.  Review and reproduce the work you did yesterday, until you're able to get command-line MiniScript to run.  It's also possible you forgot to put a space between the path to MiniScript and the path to your program; make sure to hit the spacebar in between these.
+
+If it launched, printed its version info, and then immediately exited without printing anything else, then you probably got the path to your *cool.ms* file incorrect.  Double-check each part of the path.  Remember that Windows uses backslashes (`\\`) to separate each part; Mac and Linux use forward slashes (`/`).  Also try the trick of dragging the file icon into your shell/terminal window, if you didn't already.
+
+D> You may want to use the `cd` (change directory) shell command to change your current working directory to wherever you stored your *cool.ms* file.  Then, after the path to miniscript and a space, you can simply enter *cool.ms*, or the name of any other script in that directory, without having to type the full path.
+
+{pageBreak}
+A> **Chapter Review**
+A> - You learned how to get a slice of a list or string.
+A> - You noticed that lists can be mutated, and found a way to make a copy of a list when you need one.
+A> - You created a MiniScript program using a text editor, and ran it using command-line MiniScript.
+
+{gap:340}
+{width:"25%"}
+![](chinchilla-02.svg)
+
+