# Windows Console Game: Event Handling

The last post in this series was on writing to the console; this post I’d like to go over handling events within the Windows Console. There are two types of events we’re interested in: Keyboard Events and Mouse Events. The rest of the type of events we’re going to ignore (and MSDN actually advises this on a couple internally used event types). In order to read keyboard events and mouse events, we need to get a record of all events that have occurred to the console since the last time these events were retrieved. This can be done with the following console functions: GetNumberOfConsoleInputEventsReadConsoleInput.

In order to read the console’s input buffer (the record of events that have happened from input, including user input), we have to know how many events there are in order to dynamically allocate memory to store those events. This is where GetNumberOfConsoleInputEvents comes. It takes the read handle and a DWORD pointer as its parameters, and places the number of events there are in the address pointed by the DWORD pointer.

/* Read console input buffer and return malloc'd INPUT_RECORD array */
DWORD getInput(INPUT_RECORD **eventBuffer)
{
  /* Variable for holding the number of current events, and a point to it */
  DWORD numEvents = 0;
 
  /* Variable for holding how many events were read */
  DWORD numEventsRead = 0;
 
  /* Put the number of console input events into numEvents */
  GetNumberOfConsoleInputEvents(rHnd, &numEvents);
 
  if (numEvents) /* if there's an event */
  {
    /* Allocate the correct amount of memory to store the events */
    *eventBuffer = malloc(sizeof(INPUT_RECORD) * numEvents);

    /* Place the stored events into the eventBuffer pointer */
    ReadConsoleInput(rHnd, *eventBuffer, numEvents, &numEventsRead);
  }
 
  /* Return the amount of events successfully read */
  return numEventsRead;
}



Now that we have a function for getting the INPUT_RECORD structs, we need to be able to loop through each structure and analyze what kind of record it is, and depending on what it does we can do whatever action we like.

while(1)
{
/* Get the input and number of events successfully obtained */

/* if more than 0 are read */
{
/* loop through the amount of records */
for (i = 0; i < numEventsRead; i++)
{
/* check each event */
switch (eventBuffer[i].EventType)
{
/* if type of event is a KEY_EVENT */
case KEY_EVENT:
switch (eventBuffer[i].Event.KeyEvent.wVirtualKeyCode)
{
/* if escape key is pressed*/
case VK_ESCAPE:
return 0;
}
}
}
}
}

The above code continuously loops until a user presses the escape key on their keyboard, which then makes the program close. This works by getting the INPUT_RECORD structs into the pointer eventBuffer (which points to type INPUT_RECORD) using our getInput function, and placing the return value thereof into numEventsRead. The loop then checks for a KEY_EVENT, and if found checks to see if the escape key was pressed. Similarly, you can check to see if a MOUSE_EVENT occurred in this very same way. If you understood what I’ve explained thus far in all of this series, you should be able to check for any keypress, with the help of the virtual keycode page, and then do something thereafter.

Now how about writing something onto the console when you click your left mouse button? The first thing you’d need is to be able to check for a MOUSE_EVENT record, and get the mouse’s x and y coordinates from the MOUSE_EVENT structure. Here’s an example of a case to do such a thing:

case MOUSE_EVENT:
  offsetx = eventBuffer[i].Event.MouseEvent.dwMousePosition.X;
  offsety = eventBuffer[i].Event.MouseEvent.dwMousePosition.Y;
  if (eventBuffer[i].Event.MouseEvent.dwButtonState == FROM_LEFT_1ST_BUTTON_PRESSED)
  {
    writeImageToBuffer(consoleBuffer, REDRECTANGLE.chars, REDRECTANGLE.colors, REDRECTANGLE.width, REDRECTANGLE.height, offsetx - 1, offsety - 1);
    write = YES;
  }


This indexes the INPUT_RECORD structs when a MOUSE_EVENT structure is found, and then accesses the data members X and Y, as detailed here, and places the values of the x and y position into two integers. The large constant FROM_LEFT_1ST_BUTTON_PRESSED is a Microsoft definition for a left-click. Now what is this writeImageToBuffer function? That doesn’t seem to be a MSDN documented function… Well it’s not! It’s a simple function I wrote to write any image onto the screen buffer, given the correct parameters. The image it is writing is called REDRECTANGLE, which is actually a structure defined in a file I’ve written called redRectangle.h. The red rectangle is a square of 9 red characters, so to write this square onto where the user clicks, you must use offsetx – 1, and offsety -1, otherwise the top left of the red rectangle image will be placed on the left-click location, instead of the center.

Now lets check out redRectangle.h so you can see how I’ve set up the image of REDRECTANGLE!

/* redRectangle.h */
 
#ifndef FILEREDRECTANGLEH
#define FILEREDRECTANGLEH
 
/* A red rectangle! */
 
#define REDRECTANGLEW 3
#define REDRECTANGLEH 3
 
typedef struct
{
  int width;
  int height;
  int chars[REDRECTANGLEW * REDRECTANGLEH];
  int colors[REDRECTANGLEW * REDRECTANGLEH];
} _REDRECTANGLE;
 
_REDRECTANGLE REDRECTANGLE =
{
  REDRECTANGLEW,
  REDRECTANGLEH,
  {
    219, 219, 219,
    219, 219, 219,
    219, 219, 219,
  },
  {
    4  , 4  , 4  ,
    4  , 4  , 4  ,
    4  , 4  , 4  ,
  }
};
 
#endif /* FILEREDRECTANGLEH */
 

This was the cleanest way I could think of for setting up an image that should be compatible with all versions of C. I’ll start explaining from the top of the file. The two preprocessor directives ifndef and define are used to see if FILEREDRECTANGLEH is defined yet or not. If it is not yet defined, then the entire contents of the file will be included wherever an include of this file is placed. If the define FILEREDRECTANGLEH is already defined, it means that you’ve already included this file somewhere, and so the entire contents of the file will be skipped!

Screenshot of the final demonstration program, drawing on the window!

I have two defines for each image I write in this format, and they represent width and height as 3 in this image. These defines are critical for declaring a REDRECTANGLE, as the size needs to be defined at compile, since a template for the structure needs to be created for the program to run, and as such you need to know the size of the arrays within the REDRECTANGLE structure in order to properly place it in memory! However, the use of defines in this way makes it very simple to create other copies of images. For example, to create a new image called BLUETRIANGLE, you simply use find and replace (ctrl + h for a lot of programs) and replace all instances of REDRECTANGLE, with BLUERECTANGLE. You then would modify the color and character arrays to contain the correct data, and change the WIDTH/HEIGHT values for the defines accordingly. The structure called _REDRECTANGLE is typedef’d allowing declaration of variables by skipping writing the annoying legacy struct keyword. An instance of _REDRECTANGLE called REDRECTANGLE is then declared and initialized with the arrays containing the values for the ASCII characters, and color values.

Using this format in conjunction with the writeImageToBuffer function, you can pretty easily create new images and write them with limited amounts of code! Now lets check out a finished product: link (I didn’t want to post the entire unwieldy thing here).

The last thing to mention is that if you update the screen with WriteConsoleOutputA every loop, you’ll probably see little flickers as the screen is updated. This is simply a limitation of the function WriteConsoleOutputA. There are a few solutions to this. The easiest solution I’ve come up with is to just update screen less often, and I chose to do this by limiting the time in which the screen is updated to only when the consoleBuffer is changed. Another solution is to keep track of which portions of the screen you actually need to update, and call WriteConsoleOutputA and only write with the smallest portion of the screen as possible. Also supposedly if you update the screen with the same characters and colors multiple times it increases the chance of flickering lines, so this means you should try to avoid doing so. Lastly, you can multi-thread your program, and place just the call to WriteConsoleOutput within the additional thread. I do the first solution with a simple if statement:

  /* If write is 1, meaning the screen needs to be updated */
  if (write)
  {
    /* Write our character buffer (a single character currently) to the console buffer */
    WriteConsoleOutputA(wHnd, consoleBuffer, characterBufferSize, characterPosition, &consoleWriteArea);
    write = NO;
  }


This will only call the WriteConsoleOutputA function when write is not 0.

The entire final program demonstrates drawing a square image on the screen on left-click, and a red dot to the screen on right click. There is boundary checking on the click coordinates to prevent indexing outside of the screen!

You might by now have realized that the characters you’re writing to the screen are oddly shaped rectangles. What about nice square characters? Square characters are essential for creating a nice game :( Well the next post in this series covers setting the console’s font, font size, and even the color palette!

Series on creating a Windows Console game:

# Windows Console Game: Writing to the Console

Previously I showed you all how to set up a console window! Now lets talk about writing to the Windows console. One can use printf, or fprintf, but those options aren’t really exactly ideal; you don’t have a desired amount of control. We’re going to use the function WriteConsoleOutput in order to write a buffer of characters (array of characters) onto the console’s screen buffer. The screen buffer is the inside of your game’s window in which characters are written to and appear. In order to use the WriteConsoleOutput function, you have to pass to it a buffer of characters, which is really just an array of characters. The character buffer will be comprised of an array of CHAR_INFO structures, which is a Microsoft defined type that comes from windows.h. Lets get started with just writing a single character to the screen.

In C characters are enclosed letters or numbers enclosed in single quotes, like so: ‘c’. Characters in c, like ‘c’, are treated very similarly to integers. The main difference is that the range of a character (unsigned) is from 0 to 255, where a range of integers reaches much much higher. Due to this a character variable will be one byte in memory (8 bits). You can actually write in your code ‘c’, and it will be treated as the value of whatever the ascii value of C is, which is 99 in decimal. You can even write c – 8, and it will be treated as 99 – 8. Here is my favorite chart for all the values of all the ascii characters available, note the indices are in hexidecimal:

The CHAR_INFO structure contains two data members; a character and its attributes. The character can either be a unicode or ascii character. We’re going to stick with ascii characters within the Char.AsciiChar data member (remember, this is just an integer with a range of 0-255). The Attributes data member is a WORD type, which is just a Microsoft defined type. The WORD type is simply a 16-bit unsigned integer with a range of 0 through 65535. The Attributes data member can be viewed simply as a byte of data with the following value representations as colors:
• FOREGROUND_BLUE – 0×0001
• FOREGROUND_GREEN – 0×0002
• FOREGROUND_RED0×0004
• FOREGROUND_INTENSITY0×0008
• BACKGROUND_BLUE0×0010
• BACKGROUND_GREEN0×0020
• BACKGROUND_RED0×0040
• BACKGROUND_INTENSITY0×0080
These values are the different colors accessible for use within the Windows console. The values are represented in hexadecimal, and should be viewed as a byte:

In the picture above I’ve shown a single byte, which is 8 bits of information. Each bit can be either a 1 or a 0. The first bit is on the right (at least for this representation). If you wish for your Attributes data member to contain the value blue, then you set the first bit of this byte to 1. The second bit represents whether or not you want to add green to your color, and so on and so forth. The above image would contain the values of blue, red, and intensity. This value would be in decimal format 1 + 4 + 8, which is 13. Intensity brightens the color to be displayed. Knowing this will allow us to construct whatever color we like with some simple addition! For the first color lets mix blue, green, and intensity for a value of 11.

Here is what MSDN says for the WriteConsoleOutput function in regards to parameters required:

hConsoleOutput is simply the output handle for our window, *lpBuffer is a pointer to a buffer of CHAR_INFO structures, dwBufferSize is the size of the buffer in character elements, dwBufferCoord is the location on your console screen buffer in which to write the image, and lpWriteRegion is just a pointer to a COORD structure for dictating which portion of the console to write to. Here’s some code using this knowledge to write a character to the screen:

The code above prints the character Q to the screen in a bright cyan color. This probably seems like a lot of work to write a single character to the screen, and it sort of is. But in actuality this isn’t really how you want to write every character onto the screen. The WriteConsoleOutput function is a very slow function, and so you want to call it as little as possible. You may have heard of a term called “double buffer”, well we’re going to use a double buffer to do all of our modifying of a buffer off-screen, and once all our modifications are finished we can write a single image to the screen all in one go. To create this buffer, simply create an array of CHAR_INFO structures and initialize all of the Char.AsciiChar and Attribute data members! Here’s an example of looping through an array of CHAR_INFOs and assigning random colors to a single Char type.
The above code is creating a buffer called consoleBuffer, of a single dimensional array with the number of elements equal to WIDTH times HEIGHT, both of which are now defined at the top of the file. There is a loop that loops through all of the CHAR_INFO’s Char.AsciiChar data member, and Attributes data members initializing them. You can see how I’m assigning a random value using rand, and seeding the table at the beginning of the code with srand.

You might be a little confused by the x + WIDTH * y portion of the code. I’ve created a single dimensional array of elements WIDTH * HEIGHT, and in order to index the array during a loop as if it were a two dimensional array, you need to use a formula. The idea behind the formula is to figure out what row you want to access, by taking the number of elements in a row and multiplying it by a value. To access the first row, you multiply the WIDTH value by 0. To access the fifth row, you’d multiply WIDTH by five. This works since as the single dimensional array is written to the screen with WriteConsoleOutput, it wraps around the screen buffer once ever WIDTH elements. Then, access a specific element within that row you add in your x value.

And there you have it! A method for writing an image onto the screen of any given size on any location of the console’s screen buffer! The next post in this series will be on Event Handling.

List of all posts completed thus far:

# Windows Console Game: Setting up the Window

Have you ever seen cool looking games made with purely ASCII graphics? For example the image on the right is an amazing mock-up of an idea for a game that seems to revolve around creating some sort of city on a platform to defend from air-based attackers. I’ve done a bit of research, and have actually begun a project of creating an entire game from scratch by using the Windows Console as the platform. This is a great way for newer programmers to jump into game development for the following reasons:

• Easy construction of graphics. All the graphics are just ASCII characters with varying colors!
• Very little overhead required to get a project up and running. The Windows Console is a very simple platform to get started on.
• All the documentation you would ever need can be found on MSDN and abroad.
• The Windows Console is packaged with every version of the Windows OS that is popular today, so no extra anything is needed to be downloaded or installed in order to get coding.

This post is the first in a series that will show you some techniques that will allow you to create a game within the Windows Console. MSDN Documentation at this link contains all the info of all the documented functions available to manipulate the windows console programmatically. Most info in this post will be an explanation of the MSDN documentation with example code on how to use it. On the left is a screenshot from a game I’m developing called TerraNisi, which revolves around a walking tree character that has a goal of saving his Forest from spreading fire ghouls!

The first thing you need to do is set up handles for your window. The handles of a window are what the Windows OS use to identify and manipulate a window. A handle datatype looks like this: HANDLE. This type is defined within windows.h with a typedef, and thus you can declare variables of the HANDLE type once you include windows.h to your project. Once we set them up we have access to manipulate our own window! Observe the following code that simply sets up handles, and calls getchar in order to pause the program once opened so you can see the window:

#include /* for HANDLE type, and console functions */#include /* standard input/output */ HANDLE wHnd; /* write (output) handle */HANDLE rHnd; /* read (input handle */ 

int main(void){  /* initialize handles */  wHnd = GetStdHandle(STD_OUTPUT_HANDLE);  rHnd = GetStdHandle(STD_INPUT_HANDLE);  getchar();} 

This code doesn’t do much but set up and initialize some handles for our window. Lets set the text title for the window, as this is the simplest thing I know how to do with console functions:

#include /* for HANDLE type, and console functions */#include /* standard input/output */ HANDLE wHnd; /* write (output) handle */HANDLE rHnd; /* read (input handle */ 

int main(void){  /* initialize handles */  wHnd = GetStdHandle(STD_OUTPUT_HANDLE);  rHnd = GetStdHandle(STD_INPUT_HANDLE);    SetConsoleTitle("Our shiny new title!");    getchar();}

Now the title of your window should say “Our shiny new title!”. Congrats! You’ve used another console function called SetConsoleTitle! Moving on to something a little more difficult, lets try using SetConsoleWindowInfo.

• This function takes three parameters: the first is the output handle the screen’s buffer
• The second is a boolean – if this parameter is TRUE the coordinates specify the new upper-left and lower-right corners of the window. If it is FALSE, the coordinates are relative to the current window-corner coordinates. TRUE and FALSE are defined within windows.h as 1 and 0, and if you don’t understand the previous sentence I suggest just leaving this parameter as TRUE.
• The third parameter is a SMALL_RECT structure containing the size of the new window. This parameter will set the window’s edges to a size smaller than the screen’s buffer. This means you cannot make it larger than the default buffer size of 80×300 (width x height) until you change the buffer size, which I’ll cover momentarily.

Observe:

#include /* for HANDLE type, and console functions */#include /* standard input/output */ HANDLE wHnd; /* write (output) handle */HANDLE rHnd; /* read (input handle */ 

int main(void){  /* Window size coordinates, be sure to start index at zero! */  SMALL_RECT windowSize = {0, 0, 69, 34};    /* initialize handles */  wHnd = GetStdHandle(STD_OUTPUT_HANDLE);  rHnd = GetStdHandle(STD_INPUT_HANDLE);    /* Set the console's title */  SetConsoleTitle("Our shiny new title!");    /* Set the window size */  SetConsoleWindowInfo(wHnd, TRUE, &windowSize);    getchar();}

I chose to set the window size to 70 by 35, which is a decent size for some sort of game. Now you have successfully changed your window size! However you should immediately notice an ugly scroll bar on the right side of your console, and at the bottom of the console. This scroll bar is there because the console’s screen buffer (the inside of the window) is larger than the window. To remedy this simply change the size of the screen buffer to that of your window coordinates with the SetConsoleScreenBufferSize function. This function has only two parameters: the output handle and COORD struct for the buffer size. Observe:

#include /* for HANDLE type, and console functions */#include /* standard input/output */ HANDLE wHnd; /* write (output) handle */HANDLE rHnd; /* read (input handle */ int main(void){  /* Window size coordinates, be sure to start index at zero! */  SMALL_RECT windowSize = {0, 0, 69, 34};   /* A COORD struct for specificying the console's screen buffer dimensions */  COORD bufferSize = {70, 35};   /* initialize handles */  wHnd = GetStdHandle(STD_OUTPUT_HANDLE);  rHnd = GetStdHandle(STD_INPUT_HANDLE);   /* Set the console's title */  SetConsoleTitle("Our shiny new title!");   /* Set the window size */  SetConsoleWindowInfo(wHnd, TRUE, &windowSize);   /* Set the screen's buffer size */  SetConsoleScreenBufferSize(wHnd, bufferSize); 

  getchar();}

Thus far we have created the initialization of a nice console window! The next step is to begin writing things onto the console with a double buffering system! This may sound fancy, but in actually it’s very simple in this project. The next post in this series will be devoted to this!

Series on creating a Windows Console game:

# I Want to Learn Programming, but I Know Nothing!

I want this post to be a great resource for people who have absolutely zero knowledge of programming to be able to pick up and start coding in the language C. I feel I have a fair level of empathy for those just starting to learn (since I started learning not too long ago), and want to write this post out before I get too competent as a programmer and forget my empathy altogether!

Be aware that I’m going to use a lot of new and scary programmer terminology in this post, like statements, declarations, and initialization. Don’t be afraid, as I give a link to the definition of words when I first use them. Read the links and make sure you understand what I’m referring to.

The programming in C that I’ll be teaching you, as an absolute beginner, will be of the following steps:

• Write code
• Compile code into an executable

You can write your C code in any text editor you like. You can just simply use notepad (to open hit windows key+r and type notepad, then hit enter), though I recommend using the IDE apart of Visual Studio. Once you write some C code, save your file as a .c file and then use a compiler to turn it into a .exe file.

When installing you’ll be ask if you have a CD. Just say no and download the installation from online. Once you see this screen (mine is reinstalling however):

Be prepared to restart your computer in the middle of the installation. For some reason this installation took a long time, so be patient! After you restart, at the end of the installation it says: requires a key. Go ahead and hit the button to acquire one; you’ll need a microsoft address from something like live.com. Once you fill out this lame questionnaire with fake answers copy/paste your key into the box and continue. You’re now ready to code your C programs, and compile them.

Now Visual C++ is called Visual C++, but in actuality you’ll only be writing C code for now as I recommend avoiding C++ until you’re proficient with C. The reasons for this are simple: if you’re proficient with C, you understand its limitations. Once you understand C’s limitations and hardships, you can better utilize C++.

Now for the fun part, writing some code! I’m simply going to just give you some code to copy and paste into a .c file. Before this you need to create a .c file, however. Go to, in Visual C++, File >> New >>Project. Select Win32 Console Application -this means your application will run in a Windows console. Enter a name and a solution name (probably use the same thing for both), you can call it Test. Hit ok. This part is important, when you see this screen:

Be sure to hit the next button! We need to disable the precompiled header. Hitting next will take you to this screen:

You need to check mark the Empty Project box under Additional options, and uncheck the Precompiled header option. Hit finish! Now you’ll see some folders on to your left:

Right click on the Source Files folder (they are actually called filters not folders) and go to Add >> New Item. Click on the C++ file button, enter a filename in the Enter_Name box. Enter in “main.c” without quotes and hit Add. The added .c file should open up! Even though you specified a C++ file, since you named it a .c file it will be for C code. Now lets get to coding! Copy/paste this little bit into your main.c file:

This code is the minimum requirement for any C program to be able to run. Basically it starts, and then ends. In order to compile this code into an exe, hit Debug >> Build Solution (or F7). You’ll see some output form from the compiler in a little box at the bottom of the window It should read:

There you go! You’ve compiled your program. To run it open up the folder your solution is in. To do this you can copy paste the path to the file from your compiler output, as shown in the text above. Once you find your Test.exe (in the debug folder of your solution folder) try double clicking on it. A black box should open and then quickly close. This code starts, and then ends. I’ll teach you how to make your program pause until you hit enter later, but for now lets get into the basics of C code syntax.

In C whenever you write lines of code those lines of code are going to be turned into actions that a computer will follow. Whenever you write a statement it must end with a semi-colon ;. The ; is letting the computer know that it has reached the end of a statement. This is important, otherwise the computer running your code could perhaps mix two statements together as a single statement, which would result in strange behavior.

A variable in C is a place in memory that stores a value. There are different types of values that can be stored, and so there are different types of variables to hold those different types of values. I’d like to talk about Integers. For a more complete list of the different types of variables available in C, check out this link on Wikipedia.

Lets start with integers. An integer in C is a whole number value ranging from −2,147,483,648 to 2,147,483,647. In order to create a variable in C of the type integer, you would write:
This code declares a variable with the name myInteger, and specifies it’s type as an integer with the word int. Don’t forget your semi-colon to end the statement! Now what is the value of myInteger? Well currently it would have an undefined value since you have not initialized it yet. To initialize myInteger with a value, you can write:
The above code will place the value of 10 into myInteger. Now you can type the word myInteger somewhere in your code, and it will refer to the value inside of it, which is currently 10. The equal sign is actually an operator. An operator in C takes a value and operates on it somehow. The equal sign, called the assignment operator, takes whatever is to its right and places the value of it into whatever is on its left. This means that the following code is invalid:
The above code is invalid because it would be trying to place the value inside of the variable myInteger into 10, which is simply a constant value. Some other operators you can use to manipulate values are: – + * / %. Here is what each one does:

• - The subtraction operator. Finds the difference between two values.
• + The addition operator. Finds the sum of two values.
• * The multiplication operator. Finds the product of two values.
• / The division operator. Finds the quotient of two values..
• % The modulo operator. Finds the remainder of two divided values.
What do you think the following code does:
The above code creates an integer variable called val, and then assigns the value of 5 to it in the next line. The last line then assigns the value of val + 5 to val. You can also do the following:

The above code creates three variables all at once within a single line. All three variables var1, var2, and var3 are all of the type integer, as denoted by the int keyword. val1 and val2 are initialized as 2 and 5 respectively, then val3 is assigned the value of the sum of val1 and val2, which is 7. Note that val1 and val2 remain unchanged, as the assignment operator doesn’t change anything to the right side of it; it only assigns the value of what is on the right, to whatever is on its left.

Now what if you want to actually see the value inside of a variable? Well then you need to modify your program slightly. Take a look at the following code:
The above code introduces a couple new things. printf is a line of code that is apart of the C standard library (a bunch of features for you to use as a coder), and it prints a string onto the screen. For now, just know that anything within C code that is within double quotes “” is a string. So if you place text within double quotes, within a printf statement like above, it will be considered a string and printf will place it onto the screen when you run your program. The other new thing is the #include line. This line of code actually is telling the compiler to include a portion of the C standard library into your .C file, specifically the portion with the name stdio.h. stdio stands for Standard In Out, which is referring to input and output, which is why we need it to output a string onto the screen.
Try compiling and running this code. Sadly, your program opened and then closed very quickly. This is because your program prints the message “This is a string!” and then abruptly reaches the return 0; line and ends. To fix this, modify your code to look like so:

The line getchar(); is a function from the C standard library in stdio.h. I won’t go into the details, as that’s out of the scope of this post, but just know that this line waits for the user to hit enter before executing the next line of code, thus letting you read what you output to the screen.

In order to have your value show up on the screen, you need to modify your code slightly:

This new version of the code uses a special character within the string in the printf statement. The %d line is actually saying to place the variable i into the spot in the string where %d is located. %d basically means “insert variable of type integer into this location”. You can place more characters before and after the %d, but not in between the percent sign and the d character. This will let you see the value of the integer i on the screen! You can now try more fancy things, here’s an example program to calculate the product of two variables and print it to the screen:

And there you have it! You’ve now learned how to write a simple program to do mathematical calculations on integers and display a single integer on the screen. Congradulations!