Simple Output

• It may be useful to refer to refer to the diagram illustrating the Draw-Update loop (which explains that your initialization code will be called once, and then the XNACS1Lib will repeatedly call your Update method (after which it will Draw the screen) ), in order to have a clear picture of how your game executes.

Goals:

• To write a game/program that interacts with users via the XNACS1Lib library. 
• In this tutorial, we will:
  1. Learn what I/O (input and output) are
  2. Examine the XNACS1Lib code that produces an output message

1. Obtain the example code

• Here is the zip file to the source files and compiled executable of this example.
• Here is the keyboard mapping for the XBOX 360 controller.  
• Here is the main tutorial page for working with XNACS1Lib, and here is the complete documentation of the library: html-page or compiled html help file .

In this tutorial (and the next), we will examine Input and Output in an XNACS1Lib-based video game program.  Input and Output are often abbreviated as 'I/O'.  'Input' refers to any data (information) that the computer program receives (i.e., data that is sent "in" to the program, from the program's point of view).. Examples of input might include a button being pushed on the XBox360 controller, a key being pressed on the computer's keyboard, data that the program reads from a file stored on the hard drive, or data received over a network from another computer .  'Output' refers to any data (information) that the program sends back to the rest of the world.  Examples of output might include a textual message on printed the screen (including things like the player's current score), shapes and pictures on the screen, information saved to a file (stored on the hard drive), or sending data over a network to another computer.  Keep in mind that when we use the term 'computer', we mean anything that functions like a computer - your desktop PC, your laptop, your XBox, and even     items like your mobile phone, etc.

Many textbooks focus on 'Console' I/O.  Console I/O programs mostly print out messages to a 'console' (or 'command prompt', or 'command interpreter', etc), then wait for you to type input something, then do something with that input, then restart the process by printing out a message.  While console I/O looks primitive, it has a lot of advantages over programs that are based on a Graphical User Interface (GUI - a program that has windows, buttons, etc):

1. Console IO is extremely easy to do
   You don't need to write a lot of code to do this, nor do you need to understand very complicated concepts to make it work

2. It's very quick to do
   Many simple messages can be printed with only a single line of code.

3. It allows someone who's new to programming to immediately move past the I/O issues, and move on to actually learning how to work with the core computational concepts that make programming useful. 

In contrast, most GUI based programs require substantial amounts of overhead - windows need to be created, text needs to be written onto the windows to label the various buttons, controls, and widgets that the user will interact with, etc.  Even web applications have substantial overhead when one's goal is to learn computer programming.  Web applications commonly require at least a basic understanding of (x)HTML (and maybe CSS, too), forms and other means of sending data between the browser and server, basic SQL (or some other storage technology), etc, etc.  In comparison, the primitive 'print a message, get user input, repeat' loop of console I/O is quick and easy to use.  For more information about I/O, please consult your textbook, and/or your instructor. 

In these tutorials, we'll be looking at creating graphical, interactive programs, including video game programs.  For right now, we're going to look at how to create some output that is similar to the console output that your textbook is focusing on.  In future tutorials, we'll look at how to create graphical output (drawing rectangles and circles on the screen, including how to put an image from a file over a circle/rectangle), and more advanced input (for example, how to create a game that reacts to buttons being pushed, or a joystick/thumbstick being moved).

Let's look at the C# source code that produces the messages at the top and bottom of the screen.  Since the only thing that this program does is print a message to the screen, we don't really need to add anything to the Initialize step, just to the Update step .

• InitializeWorld():
  Since we want the lower-left corner to still be at (0,0), and since we want the width of the window to be 100 units wide, InitializeWorld looks the same as in previous tutorials:

  protected override void   InitializeWorld() {     World.SetWorldCoordinate( new Vector2 (0,0), 100.0f); }

•  UpdateWorld():

  UpdateWorld will check to see if the program should exit, and if not, then it will print a message to the screen:

  protected override void UpdateWorld() {    if (GamePad.ButtonBackClicked())         this .Exit();       EchoToTopStatus( "1 2 3: XNA Rocks!" );    EchoToBottomStatus( "45 67 89: So do you!" ); }

• First, let's look at syntax issues (i.e., issues relating to 'what do you type?')
  • Note the two new lines (each line is also called a statement ) :
       EchoToTopStatus( "1 2 3: XNA Rocks!" );
       EchoToBottomStatus( "45 67 89: So do you!" );
  • Note that the new lines are INSIDE the open curly brace ( { ) and the matching close curly brace ( } ).  Remember that the braces mark the beginning and end of the UpdateWorld method, so it makes sense that if we want to print the messages inside the UpdateWorld method, we'll need to put the new code inside the braces
  • Remember that C# is case-sensitive, so you'll need to type EchoToTopStatus exactly, and not Echototopstatus, nor ECHOTOTOPSTATUS, etc.
  • Since we want to print a textual message to the top of the screen (as opposed to, say, printing a number to the top of the screen), we need to tell C# that 1 2 3: XNA Rocks! is text.  We do this by surrounding our message with double quotes .  This means that you need a double-quote at the start to tell C# where the message begins, and another at the end, to tell C# where the message ends.  You get a double-quote character by holding down the shift key, and pressing the single/double quote key; note putting two single quotes right next to each other will NOT work.  So, any textual messages should be enclosed in double quotes, like so: " 1 2 3: XNA Rocks! "
  • Don't forget the semi-colon ( ; ) at the end of each statement.  The semi-colon is required at the end of every statement.  Since most statements are put on their own line, this means that you frequently (but not always) need a semi-colon at the end of each line.
• Next, let's look at semantic issues (i.e., issues relating to 'what does this mean?')
  • By putting EchoToTopStatus( "1 2 3: XNA Rocks!" ); into your program, what you are doing is telling C# to use the EchoToTopStatus command.  Since the words 'command' and 'method' are pretty much two words that mean the same thing, this is often described as calling a method.   Specifically, your code is calling the EchoToTopStatus method here.  The EchoToTopStatus method takes whatever is inside the parentheses, and puts that at the top of the screen.  Similarly, the EchoToBottomStatus command (method) puts a message at the bottom of the screen. 
    • Where do these commands come from?   EchoToTopStatus , and EchoToBottomStatus are methods that are build into the XNACS1Base class, which your Game1 class inherits from.  What this means is that since your Game1 extends the functionality built into the XNACS1Base (which is part of the XNACS1Lib.dll that is part of the Visual Studio solution that you're working with), you can use EchoToTopStatus and EchoToBottomStatus like a command.
  • These commands are executed from top to bottom.  That means that when doing the Update step, the program FIRST does the EchoToTopStatus command, THEN does the EchoToBottomStatus   command.  In this particular case, the order doesn't matter because each of the commands don't have any affect on the other command.  But if you put following the commands into the UpdateWorld method:
    

    protected override void UpdateWorld() {    if (GamePad.ButtonBackClicked())         this .Exit();    EchoToTopStatus( "1 2 3: XNA Rocks!" );    EchoToTopStatus( "45 67 89: So do you!" ); }

    
    then you would only see 45 67 89: So do you! at the top of the screen, since the results of the first EchoToTopStatus would replaced by the results of the second EchoToTopStatus .

    • This is what's called a sequence.  Your textbook may discuss this in more detail.
  • As you create more and more complicated programs, you will make mistakes, which you will need to find and fix.  One way to verify that your program is doing the right thing is to have the program print out messages, telling you want it's doing.  This way you can check that your program is doing the right thing.

FURTHER EXERCISES::  

1. Start from a blank starter project (1000.201, if you need it), and re-do the code from memory as much as possible.  On your first try, do what you can, and keep the above code open so that when you get stuck, you can quickly look up what you forgot (and that after you finish a line, so that you can compare your line to the 'correct' line).  On the next try, do the same thing, but try to use the finished code less.  Repeat this until you can type everything, without referring the tutorial's code.
   • Repeat this exercise daily for several days, so that you really get the hang of this.  As you go on, periodically review this by re-doing this exercise.
2. Make sure that you change the output message, for both the top and bottom status areas.  Also, try setting things up so that your program prints a message to ONLY the top, or ONLY the bottom of the screen.
3. As you create games (or any other programs, for that matter), you will accidentally do the wrong thing, and as a result, your program (or game) will have errors in it. While you should want to avoid doing this, it will be inevitable. Therefore, you will need to develop some skill at fixing errors. You will start to do that here, in this exercise.
   
   You should try making the following errors, and record both the error message that the compiler gives you, as well as your own interpretation, in the following table.
   (For each error, you should make the error, then fill in the table, THEN FIX THE ERROR before going on to the next error)

   Error:	Compiler Message:	Your Interpretation:
   In UpdateWorld, remove the starting and/or ending curly brace
   Right after the InitializeWorld method, add an EXTRA close curly brace
   In UpdateWorld, on the line that has EchoToTopStatus, remove the parentheses ? the ( and /or )
   In UpdateWorld, on the line that has EchoToTop/BottomStatus, try changing the capitalization of EchoToTopStatus
   In UpdateWorld, remove a semi-colon
   Try at least three more things, on your own:

   • There are a couple of key ideas to take away from this exercise:
     1. The compiler's error message is an indicator of where the compiler got confused , which may or may not be the actual cause of the error
     2. You'll notice that the compiler's error messages tend to be cryptic and hard to read.  Still, the compiler will tell which line it got confused on, and many errors have fairly distinctive error messages.  Try to get a feel for the overall intent of an error message, and use it as a hint for finding the real error.
     3. Finding and fixing errors is a skill that you need to develop in order to program.  It'll take time and practice, but it's an important skill.

	This work is supported in part by a grant from Microsoft Research under the Computer Gaming Curriculum in Computer Science RFP, Award Number 15871 and 16531.
2/8/2010