Randy "CecilSunkure" Gaul's Game Programming Blog

Windows Console Game: Painter's Algorithm

2011-12-05T13:10:00.001-08:00

The previous post in this series was on a wonderful bag of tricks used to set a custom color palette (awesome!) and change the font and font size. In this post we'll be going over the painter's algorithm, and how to actually make use of it in your game.

The painter's algorithm is a very simple priority paradigm which dictates when you place what image onto the screen.

For example suppose you have three different images; the sky, a cloud, and the sun. You want to display these images, but you don't want the sun overlapping a cloud (physically impossible), or even worse have the blue sky overlap everything. To solve this you simply draw images onto the screen starting with the one that is going to be furthest back in terms of depth, which would be the sky.

Example of drawing sky, then sun, then cloud. Correct.

Example of drawing sky, then cloud, then sun. Wrong.

If we recall the article on event handling, the article actually taught a method for producing and writing images to the screen by using header files to hold image data and a function to write images to an array (or buffer) of CHAR_INFO structures. Using the same system, you can create images in header files and then write them to the screen in the correct order so that images overlap each other at the proper times. The way you go about this is to have your array of CHAR_INFO structures for writing images to. Then once you've manipulated the array (or buffer) all you want, you then pass it to the WriteConsoleOutput function and place it onto the screen in one fell swoop.

Here's a screenshot of a demo program I wrote just for this specific purpose!

Rendering of images with transparency using painter's algorithm.

Note: Read this article for info on resizing font, this will allow

you to have square characters like in the image above (8x8).

Building from our knowledge gained in the previous posts, I've put together a nice demo that displays the images above, and lets you draw on the screen with the left and right clicks of the mouse. Lets examine some of the code:

#ifndef FILESUNH
#define FILESUNH

/* A SUN background! */

#define SUNW 15
#define SUNH 15

typedef struct
{
int width;
int height;
int chars[SUNW * SUNH];
int colors[SUNW * SUNH];
} _SUN;

_SUN SUN =
{
SUNW,
SUNH,
{
255,255,255,255,255,255,255,177,255,255,255,255,255,255,255,
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
255,255,255,177,255,255,255,177,255,255,255,177,255,255,255,
255,255,255,255,177,255,255,255,255,255,177,255,255,255,255,
255,255,255,255,255,255,177,177,177,255,255,255,255,255,255,
255,255,255,255,255,177,178,219,178,177,255,255,255,255,255,
255,255,255,255,177,178,219,219,219,178,177,255,255,255,255,
177,255,177,255,177,219, 94,219, 94,219,177,255,177,255,177,
255,255,255,255,177,178,219,126,219,178,177,255,255,255,255,
255,255,255,255,255,177,178,219,178,177,255,255,255,255,255,
255,255,255,255,255,255,177,177,177,255,255,255,255,255,255,
255,255,255,255,177,255,255,255,255,255,177,255,255,255,255,
255,255,255,177,255,255,255,177,255,255,255,177,255,255,255,
255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,
255,255,255,255,255,255,255,177,255,255,255,255,255,255,255,
},
{
0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 62, 0, 0, 0, 62, 0, 0, 0, 62, 0, 0, 0,
0, 0, 0, 0, 62, 0, 0, 0, 0, 0, 62, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 62, 62, 62, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 62, 62, 14, 62, 62, 0, 0, 0, 0, 0,
0, 0, 0, 0, 62, 62, 14, 14, 14, 62, 62, 0, 0, 0, 0,
62, 0, 62, 0, 62, 14,224, 14,224, 14, 62, 0, 62, 0, 62,
0, 0, 0, 0, 62, 62, 14,224, 14, 62, 62, 0, 0, 0, 0,
0, 0, 0, 0, 0, 62, 62, 14, 62, 62, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 62, 62, 62, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 62, 0, 0, 0, 0, 0, 62, 0, 0, 0, 0,
0, 0, 0, 62, 0, 0, 0, 62, 0, 0, 0, 62, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 0, 0, 0, 0,
}
};

#endif /* FILESUNH */

The above code is the header file for the image of the sun. As shown in this article, you can easily create new images! The most interesting thing about this image is the 255 character code in the chars array. This code is actually used for transparency. I modified our old writeImageToBuffer code to account for transparency by adding in a single if statement. If the loop finds a character of 255, it does nothing and skips the character. This will leave whatever character was already written in that particular location alone, thus creating transparency! Take a look at the new writeImageToBuffer function:

/* Writes an image to the buffer */

void writeImageToBuffer(CHAR_INFO buffer[], int chars[], int colors[], int imageBUFFERWIDTH, int imageBUFFERHEIGHT, int xoffset, int yoffset)

{
int x, y;

/* Keep xoffset and yoffset within the screen's boundaries */
boundCheck(&xoffset, &yoffset);

for (y = 0; y < imageBUFFERHEIGHT; ++y)
{
for (x = 0; x < imageBUFFERWIDTH; ++x)
{
if (chars[x + imageBUFFERWIDTH * y] != (unsigned char)255)
{
buffer[(x + xoffset) + BUFFERWIDTH * (y + yoffset)].Char.AsciiChar =
chars[x + imageBUFFERWIDTH * y];
buffer[(x + xoffset) + BUFFERWIDTH * (y + yoffset)].Attributes =
colors[x + imageBUFFERWIDTH * y];
}
}
}
return;
}

As I said, there's simply a new if statement to make sure that the character 255 is not written onto the screen. 255 in ASCII is a character you'll more than likely find pretty useless, as it just fills the whole space with foreground, though you have the exact same thing with 219 without any nasty side affects that 255 can ensue on your code. Basically 255 is the perfect ASCII index for transparency as it's pretty much useless as anything else.

The last thing to show in this demo is the order in which you actually write images onto the buffer, being sky sun and cloud. This is really simple as shown here:

writeImageToBuffer(consoleBuffer, SKY.chars, SKY.colors, SKY.width, SKY.height, 0, 0);
writeImageToBuffer(consoleBuffer, SUN.chars, SUN.colors, SUN.width, SUN.height, 10, 5);
writeImageToBuffer(consoleBuffer, CLOUD.chars, CLOUD.colors, CLOUD.width, CLOUD.height, 15, 11);

And there you have it! By ensuring that you write images in the correct order in terms of depth, you overwrite images farther back with images closer up creating a proper sense of depth to the viewer.

Windows Console Game: Set Custom Color Palette and Font Size

2011-12-01T14:25:00.001-08:00

Last post the topic was of event handling, this article is going to cover a treat! I have recently been graced with a great sample source code of a program that can alter the windows console font, color palette, and font size. If you've ever searched for methods of changing these aspects, if you're like me, you'd have found a whole lot of nothing. Luckily, like I mentioned, someone gave me some sample source code that I'd like to share.

The source code, as I was told and will now tell you, is filled with a whole lot of a whole lot of ugliness, undocumented Windows functions, and magic. Despite these scary facts this source code is pretty easy to use and grants access to some very nice to have features, that can make the creating of a console game much prettier! For example say you are creating an ASCII game in the Windows Console and realize that you're stuck with the default key size of 8x12 pixels. This sucks. Now constructing square images is going to be a gigantic pain! It would be wonderful if you could have all of your characters simply be squares! Well, there's a nice 8x8 Terminal font that is available to use.

Here are the source files:

source

I've modified the files so that they should compile cleanly in Visual Studio 2010, and in GCC 4.X.X. Once compiled the exe should run a short demo displaying a few different things, including modifying the console's color palette and setting it to the default colors, changing the font type, and changing the font size.

This all works by using a few functions from kernel32.dll, some of which are undocumented and thus very difficult to use. I don't know exactly how everything works, and a good amount of it I don't understand whatsoever - though this is to be expected when messing with things that don't have documentation. The goal is for me to explain just what is necessary to understand the idea of what's going on so you can apply these desired features to your own console application.

Lets start off by explaining the main function.

int main(void)
{
    /* Setting the color palette to the default colors
    /* Browse MSDN for COLORREF to learn more about these RGB values */
  COLORREF palette[16] = 
  {
    0x00000000, 0x00800000, 0x00008000, 0x00808000,
    0x00000080, 0x00800080, 0x00008080, 0x00c0c0c0,
    0x00808080, 0x00ff0000, 0x0000ff00, 0x00ffff00,
    0x000000ff, 0x00ff00ff, 0x0000ffff, 0x00ffffff
  };
    /* Search MSDN for the RGB macro to easily generate COLORREF values */

  SetConsolePalette(palette, 6, 6, L"");
  printf("Small default font.\n");
  Sleep(2000);
  
  SetConsolePalette(palette, 1, 2, L"Lucida Console");
  printf("Too tiny to read Lucida!\n");
  Sleep(2000);
  
  if (windowsVersionTest())
  {
    SetConsolePalette(palette, 8, 12, L"Consolas");
    printf("More of a normal Consolas size.\n");
  }
  else
  {
    SetConsolePalette(palette, 8, 12, L"Lucidas");
    printf("More of a normal Lucidas size.\n");
  }
  Sleep(2000);
  
  SetConsolePalette(palette, 43, 72, L"Lucida Console");
  printf("Huge Lucida!\n");
  
  getchar();

  return 0;
}

This function has an array of hex numbers at the top. These numbers correspond to the color palette in the Windows Console's properties:

The eight colors above correspond to the eight elements of the palette array. You can change them to any RBG value, and you can test out different values like in the screenshot above, by messing with the Red Blue and Green color value fields. Just be sure to leave the left two digits in your hex values as 0, as only the first six digits are used.

SetConsolePalette is a wrapper function that sets a console's palette, console font size, and console font. The first parameter is a color palette, the second is the font's x dimension, third is the font's y dimension, and last is the name of the font you wish to switch to in the form of a wide character literal. Available fonts are Terminal, Lucidas, and Consolas by default. In order to have more available, you have to make them! Making fonts is definitely outside of the scope of this article, however. It should be noted that Consolas is only available in Vista/7 versions of Windows, and not available in XP. If you want to use the Terminal font, on lines 109 and 139 you must set the value of the 0 to 0x30. Which line you modify depends on your OS. Just modify both of those lines if you don't know which corresponds to one you need.

That is about all the info you really need to simply use the source code! If you want to try to learn more, study the comments throughout the source code and/or ask me questions in the comments section. You can also try googling bits of the source code and see what you come up with. Googling CONSOLE_INFO came up with a lot of variations of the source I've posted, with some differing comments throughout the source files.

I haven't created my own custom font yet, though I did find a nice tool here for editing and developing raster fonts. In the near future I'll probably create my own custom font for the console game(s) I'm creating as school projects. The next article in this series is on painter's algorithm.

Windows Console Game: Event Handling

2011-11-26T11:21:00.001-08:00

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: GetNumberOfConsoleInputEvents; ReadConsoleInput.

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;
}

The above code is a function that places an array of INPUT_RECORD structures into the content of the pointer pointed by the parameter eventBuffer. If you're confused about the double asterisk **, then read the rest of the paragraph. If you already understand what this function is doing, skip to the next paragraph. The asterisk, known as the dereference operator, can be read as "the content pointed by". In order for this getInput function to place the INPUT_RECORD structs into the address pointed by a pointer, we have to pass a pointer to a pointer to the function -otherwise we'd only pass the value of a pointer to the function, which isn't what we want. Then, to access the the pointer we passed, we'd use one asterisk. To access the value pointed by the pointer that is pointed to by the parameter pointer, we must use a second *. See the below diagram for a visual representation. On the left, Pointer 1 is dereferenced giving you direct access to Pointer2. Pointer2 is dereferenced giving you direct access to the INPUT_RECORD. The right side of the diagram uses two dereferences to directly access INPUT_RECORD in a single stroke.

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 */
numEventsRead = getInput(&eventBuffer);

/* if more than 0 are read */
if (numEventsRead)
{
/* 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!

Windows Console Game: Writing to the Console

2011-11-16T15:47:00.001-08:00

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 - 0x0001
FOREGROUND_GREEN - 0x0002
FOREGROUND_RED - 0x0004
FOREGROUND_INTENSITY - 0x0008
BACKGROUND_BLUE - 0x0010
BACKGROUND_GREEN - 0x0020
BACKGROUND_RED - 0x0040
BACKGROUND_INTENSITY - 0x0080

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:

BOOL WINAPI WriteConsoleOutput(
  __in     HANDLE hConsoleOutput,
  __in     const CHAR_INFO *lpBuffer,
  __in     COORD dwBufferSize,
  __in     COORD dwBufferCoord,
  __inout  PSMALL_RECT lpWriteRegion
);

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:

#include <windows.h> /* for HANDLE type, and console functions */
#include <stdio.h> /* 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};
  
  /* Setting up different variables for passing to WriteConsoleOutput */
  COORD characterBufferSize = {1, 1};
  COORD characterPosition = {0, 0};
  SMALL_RECT consoleWriteArea = {0, 0, 0, 0}; 
  
  /* A CHAR_INFO structure containing data about a single character */
  CHAR_INFO characterQ;
  characterQ.Char.AsciiChar = 'Q'; /* Setting the Char.Ascii data member of characterQ to the value of 'Q' */
  
  /* Setting up the color values for our Q character: blue + green + intensity */
  characterQ.Attributes = FOREGROUND_BLUE | FOREGROUND_GREEN |
                          FOREGROUND_INTENSITY;
 
  /* 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);
  
  /* Write our character buffer (a single character currently) to the console buffer */
  WriteConsoleOutputA(wHnd, &characterQ, characterBufferSize, characterPosition, &consoleWriteArea);
 
  getchar();

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.

#include <windows.h> /* for HANDLE type, and console functions */
#include <stdio.h> /* standard input/output */
#include <stdlib.h> /* included for rand */

#define WIDTH 70
#define HEIGHT 35

HANDLE wHnd; /* write (output) handle */
HANDLE rHnd; /* read (input handle */

int main(void)
{
  int x, y;
  
  srand(time(0));
  
  /* Window size coordinates, be sure to start index at zero! */
  SMALL_RECT windowSize = {0, 0, WIDTH - 1, HEIGHT - 1};

  /* A COORD struct for specificying the console's screen buffer dimensions */
  COORD bufferSize = {WIDTH, HEIGHT};
  
  /* Setting up different variables for passing to WriteConsoleOutput */
  COORD characterBufferSize = {WIDTH, HEIGHT};
  COORD characterPosition = {0, 0};
  SMALL_RECT consoleWriteArea = {0, 0, WIDTH - 1, HEIGHT - 1};
  
  /* A CHAR_INFO structure containing data about a single character */
  CHAR_INFO consoleBuffer[WIDTH * HEIGHT];
 
  /* 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);
  
  for (y = 0; y < HEIGHT; ++y)
  {
    for (x = 0; x < WIDTH; ++x)
    {
      consoleBuffer[x + WIDTH * y].Char.AsciiChar = (unsigned char)219;
      consoleBuffer[x + WIDTH * y].Attributes = rand() % 256;
    }
  }
  
  /* Write our character buffer (a single character currently) to the console buffer */
  WriteConsoleOutputA(wHnd, consoleBuffer, characterBufferSize, characterPosition, &consoleWriteArea);
 
  getchar();
}

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.

Source(s):
http://benryves.com/
http://msdn.microsoft.com/en-us/library/windows/desktop/ms682073(v=vs.85).aspx

Windows Console Game: Setting up the Window

2011-11-16T10:34:00.001-08:00

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 <windows.h> /* for HANDLE type, and console functions */
#include <stdio.h> /* 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 <windows.h> /* for HANDLE type, and console functions */
#include <stdio.h> /* 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 80x300 (width x height) until you change the buffer size, which I'll cover momentarily.

Observe:

#include <windows.h> /* for HANDLE type, and console functions */
#include <stdio.h> /* 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 <windows.h> /* for HANDLE type, and console functions */
#include <stdio.h> /* 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!

Source(s):
http://benryves.com/
http://msdn.microsoft.com/en-us/library/windows/desktop/ms682073(v=vs.85).aspx

I Want to Learn Programming, but I Know Nothing!

2011-11-15T21:49:00.000-08:00

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!

So you want to learn to program. Great! So you're reading this article, and here you'll learn to start with C on a Windows Operating System. Starting with C is an excellent place to start, as it grounds you with a very solid base of understanding for programming in general, that of which I feel is easily transferable to other languages! I even feel that once you learn the basics of C and transfer to another language (I recommend Python!) you'll be better off in the long run than if you started with another language and then moved to C (perhaps start with Java and move to C). I won't get into deep details about this point as that's out of the scope of this article, but you should definitely take my word on the matter!

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

An executable is a .exe file that your computer can run, and when this executable file is run your computer will actually follow the steps you wrote in your code, thus running your code as a program! Compiling your code is actually a step that a compiler does for you, in which it translates your C code into machine code. Machine code can be viewed as a lot of very hard to read 1's and 0's, also known as binary. The reason people don't code directly in machine code is because it's so hard to read. C is a nice translation of machine code for people to work with. If you want to learn more about how computers work on a very low level, I suggest reading Code: The Hidden Language of Computer Hardware and Software by Charles Petzhold.

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 Dev-C++. 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.

Now what about this compiler business. You might have already googled for a C compiler by now and noticed that there is a multitude of compilers out there. Luckily I have one to recommend to you! Download and install Dev-C++.

When installing just install with all default settings. On your first run you must choose a language (probably English) and then you'll see a screen that looks like:

You should just hit the green Next button, as this feature is actually useful later on. Hit yes again to create a cache now, followed by ok. Close the annoying tips toolbar once the program starts, and walla! You're now ready to code your C programs, and compile them!

Now Dev-C++ is called Dev-C++, but in actuality you'll only be writing C code for now as I highly 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 Dev-C++, File >> New >> Source File. Save this file wherever you like, but make sure it is a .c file. Now paste the following code into your .c file:

int main(void)

{
  return 0;

}

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 Execute >> Compile and Run (or f9). You'll see a quick flash of two boxes. One box was Dev-C++ saying something about your program compiling - who cares. The next box was bigger and darker, and was actually your program running within a Windows Console, also known as cmd. Remember what I said moments ago? 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.

Take a look back at your code you copy/pasted and lets check out what these different lines of code do. int main(void) is setting up the part of your code the program starts at. Every single time any program is ever started that was written in C, it starts at the line with main in it. This line is actually creating what is called the main function. I won't go into detail on exactly what a function is, as all you need to know for now is that this is the first code that is run when your program is started, and then the next line below it will be read then executed, and so on. The open curly bracket { is beginning of the main function, and the } is the end of the main function. For now you're going to write all your code within these two brackets. It's standard C syntax that code within two curly brackets is one tab farther to the right than the code outside of those two curly brackets, which is why the return 0; line is indented. The last thing to explain is this return 0; business. The return 0; line is actually the line of code that ends your program. Once your code is run and this line is executed, your program ends immediately. The 0 is actually a value returned to your operating system letting it know that the program ended successfully. If this sounds confusing, then don't worry about it - all you need to know is that when this line is reached your program ends.

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:

int myInteger;

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:

myInteger = 10;

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:

10 = myInteger;

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:

int val;

val = 5;

val = val + 5;

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:

int val1, val2, val3;

val1 = 2;

val2 = 5;

val3 = val1 + val2;

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:

#include <stdio.h>



int main(void)

{
  printf("This is a string!");


  return 0;

}

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 <stdio.h> 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:

#include <stdio.h>



int main(void)

{
  printf("This is a string!");
  getchar();


  return 0;

}

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:

#include <stdio.h>



int main(void)

{
  int i;


  i = 5;
  printf("%d", i);


  getchar();
  return 0;

}

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:

#include <stdio.h>



int main(void)

{
  int i, j, k;


  i = 5;
  j = 10;
  k = i * j;
  printf("%d", k);


  getchar();
  return 0;

}

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!

Batch Files: Tips and Tricks

2011-10-11T20:20:00.000-07:00

I spent a lot of time one weekend creating a utility I call AutoGCC. GCC is a compiler that comes with Cygwin for Windows. When running this compiler and finishing assignments there are a whole lot of very annoying commands and actions to complete, that are highly repetitive. Perfect situation for constructing a utility! Here is a link to the program, which I update as I find bugs or think of additional features: http://www.mediafire.com/?v3q5f4ntvceq4wa

There are a few tips and tricks I learned about batch programming that I'd like to share, and to document for my own future reference.

You can use parentheses to link multiple lines so they are treated as a single line. This allows you to make nicely formatted if statements, like so:

if not exist %CD%\error_files\ (

mkdir %CD%\error_files\

)

The next trick that took me forever to understand the syntax of, is string manipulation. Take the variable %PATH% for example. It is a string. However what if I want to modify a portion of this string to my own liking? Look at the following: %PATH:;c:\AutoGCC=%

%PATH:;c:\folder=%

That code actually searches for a matching sequence of characters of the sequence ";c:\folder", and will set that portion of the string %PATH% to nothing. This is basically deleting an element from the %PATH% variable. You could also have done:

%PATH:;c:\folder=;c:\LOL%

Which would change the element ;c:\folder to ;c:\LOL.

There is also a nice way to edit the path (or any registry key) of a user's machine by editing the registry key for the system path! This will however require a restart to take effect. Here is the syntax I used in AutoGCC to modify my system's path (type reg add /? for information on the reg add command):

reg add "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Environment" /v Path /t REG_EXPAND_SZ /d "%PATH:;c:\AutoGCC=%" /f

You can also use the CALL command to launch a specific portion of your code as if it were its own batch file. This is really useful for making functions within your batch file. Take a look at the following code:

if exist %file% (

if %var% NEQ 2 (
call FUNCTION_1
)
)

:FUNCTION_1
do stuff...
...
...
goto EOF

The above code will go to the line labeled with FUNCTION_1 if %file% exists, and then return just below the goto FUNCTION_1 statement once the line goto EOF is reached. goto EOF sends the control to the end of the file, though since FUNCTION_1 was called by a call command, it is as if it is an emulated batch script of its own, and the emulation will close, not the original environment that called it.

These few things are extremely useful for me when working on my batch scripts, and hopefully will be for you as well!

TL Secret

2011-09-06T22:35:00.001-07:00

First person to quote this sentence (back on TL at the Lessons thread), and the one directly after it, will win a free one hour lesson! Additionally whoever is the 100th poster in this thread (cmon, we can get that many posts!) will win a free one hour lesson as well!

Edit: This contest is long over :P

Status Update: New Book, C++ Primer 5th Edition

2010-11-15T22:02:00.000-08:00

Yay! I've finished C Programming a Moder Approach Second Edition and have moved onto the book C++ Primer Plus 5th Edition (don't download unless you own the book like I do)! Things are fantastic ex dee. Sadly, I don't have an extremely informative post this time around as I was wrapping up the end of my C book, and the topics weren't too notable. Most of the topics were things like file I/O and standard library function reference, things that aren't really new concepts, and things that wouldn't be good topics for blog posts. Although, I did cover a chapter about low-level programming, and am considering writing a post about bitwise operators and also about the low-level programming chapter in that C book.

This post mainly serves as a status update.

Memory Allocation and Linked Lists

2010-11-13T02:45:00.000-08:00

Memory Allocation

Memory allocation allows the programmer to allocate a block of memory of a desired size, and then store data into the block, along with initializing a pointer pointing to this block of memory. In order to do so, I'll explain the use of malloc(), realloc(), free(), and calloc().

malloc() will allocate a block of memory, although it will not initialize it, and returns a pointer to the block of memory allocated. The prototype of malloc() looks like: void malloc(size_t size);. size_t is an integer type defined in the C library, which is an unsigned integer. So, size is just an integer and represents the amount of bytes to be allocated. Since malloc() will return a pointer to a block of allocated memory, you need a pointer in order to make use of a call to malloc(), like so:

//Memory allocation for a character array of n number of elements

char *p;
p = malloc(n + 1);

//you could also do:

p = (char *) malloc(n + 1);

Since a character in C is one byte the, numerical argument for malloc() ends up just being a simple integer. However, if you were allocating memory for any other type of data you would need to use the sizeof() function to determine how much memory to allocate.

int *p;
p = malloc(sizeof(int));

//you could also do:

p = (char *) malloc(sizeof(int));

Just as a reminder, if you ever need to figure out how many elements an array has, use the following idiom: num_Elements = (sizeof(array) / sizeof(array[0])). That will take the size of all the elements divided by the size of a single element, giving you an integer resultant.

realloc() will change the size of a previously allocated block of memory. The prototype for realloc() is: void *realloc(void *ptr, size_t size);. ptr must point to a block of memory that was previously used in a call to malloc() or realloc(). The size parameter can be either larger or smaller than the original block.

calloc() is similar to malloc() in all ways except in that it initializes the bytes to 0 within the block.

free() is very easy to use; simply pass a pointer that points to a memory block we no longer need, and it will be available for reuse later on.

Linked Lists

A linked list is a chain of structures (called nodes), where each node contains a pointer to the next node in the chain. The last node in the list would contain a null pointer. The advantages of using a linked list over an array, is that you can add in nodes anywhere in the list you want, and you can delete nodes anywhere you want. You can also create many types of data structures like graphs and trees using linked lists.

Here are the barebones of a basic node:

struct node {
  //... here would be the node's data
  struct node *next;
};

To access a member of a structure through a pointer to a structure there is a "shortcut" operator called the right arrow selection operator ->. The right arrow selection operator allows you to access the member of a value pointed by a pointer. The following are equal:

(*node).data = 10;

//this is the same as:

node->data = 10;

In order to add a node to the beginning of the linked list, all you need to do is create a temporary variable to hold your new node, assign the value of your new node to the variable, and modify your new node to point to the old first node. Since adding a new node to the beginning of a list is such a common task, I'll show a sample function on how to do so. In order for a function to directly add a new node to a list, you need to be able to pass a pointer to the function and make it point elsewhere. Since arguments are passed by value, you can't simply pass a pointer to a function, since the function will then only be able to modify a copy of the pointer passed to it. Instead, you would need to pass a pointer to a pointer, then, you can make the pointer point elsewhere.

void add(struct node **list, int n)
{
  struct node *new_node;

  new_node = malloc(sizeof(struct node));
  if (new_node == NULL) //the macro NULL is defined in stdlib.h
  {
    printf("Error: Malloc failed to allocate necessary space.");
    exit(EXIT_FAILURE);
  }
  new_node->value = n;
  new_node->mext = *list;
  *list = new_node; //modifies the value pointed by list, which is a pointer
}

In the above example, list is a pointer to the first node in a linked list. Since we pass a pointer to a pointer (when we call this function we would use &first in the first argument, being the address of the first node), we are able to update the list pointer to point to our newly added node.

In order to search through a list, from beginning to end, you would usually use a for loop. The idiom is actually very simple. You scan the value and make your comparison on the first node, then make your iteration point to the next node:

for (p = first; p != NULL; p -> next)
  ... //whatever code you want to loop

Remember how I mentioned that the last node in the list contains a null pointer? The NULL macro defined in stdlib.h has the value of a NULL pointer, and as such the loop will stop on the last node of the list.

The idea behind deleting a node is to search for your desired deletion and make the previous node point to the node directly ahead of your node to be deleted. One method of doing so, is to keep a "trailing pointer". You scan through each node and keep a pointer to the node previously scanned, so that you can delete the current node and make the previous node point the next one in the list. Here is a sample function that searches for a node with a value inside of it (this value could be the node's ID, or whatever you are searching for) and deletes the node using free().

struct node *delete(struct node *list, val)
{
  struct node *current, *previous;

  for (current = list, previous = NULL;
       current != NULL && current -> data_Member != val;
       previous = current, current = current -> next)
    ;

  if (current == NULL)  //val was not found, end of list reached
    return list
  if (previous == NULL) //val was in the first node
    list = list -> next;
  else                  //val was found within a node
    prev -> next;
  
  free(current);
  return list;
}

The for loop in this function actually just has a null statement, because all the actions are done in the iteration portion of the for loop; the previous node is set to the currently being scanned, and the currently being scanned is set to the next node. The for loop stops once the value you are searching for is found, or if the end of the list is found. The two if and the else statements catch all the possible outcomes of the for loop. If the first node in the list is going to be deleted (if previous equals NULL), you need to make your list pointer point to the second node.

Structures Unions and Enumerations

2010-11-10T17:53:00.000-08:00

Structures

Out of the three data types structures are the most important, so I'll start by going over them. Structures are similar to arrays in that they hold data. However, a structure's data is referenced by name rather than numerical index. The data inside structures is private; each new structure provides a new scope. Here is an example of how to declare a structure with a couple variables of that structure type:

struct {
  int ident;
  char name[LEN + 1];
  int val;
} part1, part2;

part1 and part2 are now both the exact same data-type, and each have the same members as each other. A structure can also be initialized while it is declared, like so:

struct {
  int ident;
  char name[LEN + 1];
  int val;
} part1 = {1, "Mobo", 200},
  part2 = {2, "PSU", 75};

Alternatively you can use the designator operator "." to assign values to structure members, like so:

struct {
  int ident;
  char name[LEN + 1];
  int val;
} part1 = {.ident = 1, .name = "Mobo", .val = 200},
  part2 = {.ident = 2, .name = "PSU", .val = 75};

It doesn't matter where in the initializer that a member is given a value if it is given a value by a designator. However, is there is no designator, then the value will be given to the corresponding member in the order from top to bottom of the structure, and from left to right of the initializer. LEN is just a constant defined in a preprocessor directive, and could be whatever the coder chose. You must add one to compensate for an end of line null character.

Structures of the same type can be copied with the = operator. Although, you cannot use the == or != whether or not structures are of the same type. part1 and part2 from the above example are both the exact same structure type. However, in the following example, part1 and part2 are not the exact same, and cannot be used with the = operator:

struct {
  int ident;
  char name[LEN + 1];
  int val;
} part1;

struct {
  int ident;
  char name[LEN + 1];
  int val;
} part2;

Since you can use the assignment operator with structures it is a slight surprise that arrays within structures will be copied from one to another. This can be useful for creating "dummy" structures that are used just for the purpose of copying one array to another.

So far I've shown two examples of declaring structures without using a structure tag. Once you've created a tag for a structure, you can treat a structure as a data type, like so:

struct pc_Hardware{
  int ident;
  char name[LEN + 1];
  int val;
};

struct pc_Hardware part1 =  {.ident = 1, .name = "Mobo", .val = 200};

It is also possible for a function to use a structure as an argument. However, using a structure as an argument can cause a lot of overhead. It's actually usually better to pass a pointer to a structure to a function, and then use the pointer to modify the members as needed. Functions can also return structures. Similarly, you might have a function return a pointer to a structure instead of an actual structure.

A structure can also be nested within another structure, as a data member. This is useful to create "categories" of members within a structure. Suppose you have a structure that holds data about computer hardware, and there are a total of four different brands of hardware. You could have each member of the structure represent a type of hardware, and within each structure you could hold information about the hardware brand.

Unions

A union is similar to a structure in all ways, except in that the compiler will allocate enough space for only the largest of all the union members. This means that all members of a union will all share the same space in memory. Altering one member of a union will overwrite the data of all others. This means that only one member of a union can hold data at any given time. Unions are usually used as a means of saving space. In my last computer hardware example, a union could have been used in place of a structure for holding the names of the brand, as the hardware usually wouldn't be made by two different companies at once (as long as the brand name doesn't go over the LEN limit, which is just a constant that can be defined as any amount you want to specify).

Arrays of unions can also be useful. Suppose you need an array that can hold either integers or floats. You can't simply create an array that can hold either, since an array must be universally one type. You can however create an array of unions rather easily. Consider this example:

union {
  int i;
  float f;
} Number;

Number a[100];

Now the array a can hold in each element either a float or integer type. Here is how one could assign either a float or integer into the array:

a[0].i = 1;
a[1].f = 10.01;

The biggest problem with using unions is that there is no way to tell which data member was last altered, and thus knowing which member actually holds a value. Often times programmers will nest a union within a structure, having the structure have one other data member. This other member within the structure will act as a "tag field" so that the programmer can keep track of which member holds a value.

Enumerations

Enumerations are good for creating new definitions of data types that have only a few different possible values. An enumeration would be good for creating a boolean variable, or perhaps a variable to represent suit in a deck of cards. The benefits of using an enumeration over preprocessor directives for defining such things is that anyone reading your code can easily see all the possible variants of your variable, and see that each one is of the same type. Enumerations can increase readability and code cleanliness.

enum suit { CLUBS, SPADES, DIAMONDS, HEARTS };

The above example shows how set up an enumeration for the different suits of a deck. This is much better than using #define directives, in that it obeys C's scope rules; an enumeration declared within a function won't affect the rest of the program. The members of this enumeration can be used just the same as #define directives.

The members of an enumeration are actually integers. CLUBS is equivalent to the integer 0, and HEARTS 3. One could use the suits defined in the above enumeration just as if SPADES were the integer 1, and so on. You can also specify exactly the integer amount that a member will equal, like so:

enum suit { CLUBS, SPADES = 7, DIAMONDS, HEARTS = 20 } s;

s = CLUBS;
s++;

CLUBS would default to 0, although DIAMONDS would default to 8, which is one more than the previous member. s was assigned the value of CLUBS (zero), then in the next line was incremented to 1.

Enumerations are perfect creating "tag fields" for unions to determine which of the members of a union were last modified. Here is an example:

struct {
  enum { INT, FLOAT } kind;
  union {
    int i;
    float f;
  } u;
} Number;

The above struct can be used in our original union example where an array of unions was created. This structure has advantages in that the programmer will be able to tell whether or not each array element holds an integer or float with the "tag field" kind.

Sources: http://www.mediafire.com/?yf0z4x44k240q1o (particularly chapter 16)

Pointers: Basics

2010-11-06T14:21:00.000-07:00

A pointer in C is a data type that holds the address to a specific block of memory within your computer's memory. The address in the pointer can be used to modify the contents thereof, or to cycle through other addresses in memory adjacent to such. It is also possible to use pointer arithmetic (addition and subtraction), though you cannot multiply or divide pointers. Take a look at the following diagram:

P is a pointer that has been declared and initialized with the value of the address 1884. P points to the block in memory next to the blocks with addresses of 1883 and 1885. C requires that every pointer point to only a specific type. There are no restrictions on what type of referenced data a pointer may reference to; pointers can even point to pointers.

int *p;

double *q;

char *r;

The above shows three ways of declaring a pointer as three different types of data. The only difference between declaring a pointer and a variable, is that a pointer's identifier must be preceded by the asterisk symbol.

Address and Dereference Operators

There are two different operators that are very commonly used with pointers. The first, which you've seen in the form of multiplication and when declaring a pointer, is the asterisk *, which is called the dereference operator (or also known as the indirection operator). You can translate the * literally into "the value pointed by". So, if we take P from our example above, and type *P, then *P means "the value pointed by" P. *P would equal whatever value is within the block of memory 1884. Actually, *P would be another alias for the value within the address 1884. This is because by modifying *P we actually directly modify the value within the address 1884. Suppose *P is an int value:

*p = 76;

This line of code would change the value within the address 1884 into the integer 76.

The second operator is the Address operator &. & can be translated literally into "the address of". This operator is particularly useful for assigning a value to a pointer, like so:

int val = 7;

int *p;

p = &val;



//You could also do:



int *p = &val;

Usually you wouldn't know exactly what the address of val is before assigning it to a pointer, as it could be anywhere within memory while your program is running. What is important, is that you can assign the address to a pointer.

Uses of Pointers

Imagine you need a function that modifies a variable. You cannot simply pass the variable to the function, since you can only pass the value of your variable to the function. This is due to the fact that the data within functions is private. You could however, pass a pointer to the function, and then use the dereference operator to directly modify the value pointed by the address. Consider the following:

#include <stdio.h>

int clear(int *x)
{
  *x = 0;
}

int main(void)
{
  int a = 5;

  clear(a);

  printf("%d", a);

  return 0;
}

You can also have a function return a pointer, like the following:

#include <stdio.h>

int *max( int *a, int *b)
{
  if (*a > *b)
    return a;
  else
    return b;
}

This function, when given pointers to two integers, will return a pointer to whichever integer is larger.

Pointers and arrays are used together all the time. Say we initialize pointer P and make it point to the first element of a[4]:

int a[4], *p;

p = &a[0];

Here is what we have just done graphically:

P now points to the first element of array a[]. Suppose we do the following:

*p = 7;

a[0] now equals 7. Here is what we have just done graphically:

So far this whole process doesn't seem too useful, but, where things start getting really useful is when you use pointer arithmetic to cycle through each element of the array using a pointer. C allows the following combinations of pointer arithmetic, and only these combination:

Adding an integer to a pointer

Subtracting an integer from a pointer

Subtracting one pointer from another pointer

Adding integer i to pointer P will cause P to point i elements ahead from where P originally pointed to. Similarly, if P points to a[x], then P + i points to a[x + i] (assuming a[x + i] even exists).

If P points to element a[x], then P - i points to a[x - i].

When one pointer is subtracted from another, the result is the distance in array elements from the two pointers.

It is also valid to compare pointers with the comparisons ==, !=, <=, and >=. However, in order for these comparisons to actually have meaning the two pointers being compared would need to point within the same array.

Pointers are also good for processing arrays, since you can apply addition and subtraction upon pointers. Though one could just as easily use array subscripting for such a task, pointers can be faster and less resource intensive (depending on the compiler; some compilers have no efficiency discrepancy between array subscripting and array processing via pointers).

#define VAL 10

int a[VAL], *p;

sum = 0;
for (p = &a[0]; p < &a[VAL]; p++)
  sum += *p;

The above code fragment shows how to sum all elements of an array with p. Note that this loop will not fire once p equals a[VAL], due to the properties of a for loop, thus the address a[VAL] won't actually be analyzed and the program will not produce an error during compilation.

A very important thing to note, is that the name of an array can be used as a pointer to the first element of an array.

int a[5];

*a = 7; //stores 7 in a[0]

*(a + 1) = 12; //stores 12 in a[1]

In general, a + i is the same as &a[i]. Also, *(a + i) is equivalent to a[i]. Also, the fact that an array name can serve as a pointer makes it easier to process them with for loops.

for (p = &a[0]; p < &a[VAL]; p++)
  sum += *p;

//this is the same as the following:

for (p =a; p < a + VAL; p++)
  sum += *p;

When passing an array to a function, the compiler passes a pointer to the first element in the array to the function. This is important to know.

Using all that I've explained so far, you can write loops to process both rows or columns of 2D arrays using pointers, like so (processing a row):

//loop that clears a row of a 2D array

int a[rows][cols], *p, row;

row = x; //x is an integer that represents our selected row

for (p = a[row]; p < a[i] + cols; p++)
  *p = 0;

Processing a column isn't as simple, since a 2D array has the first array be an array of arrays, meaning it's an array of rows.

//loop that clears a column of a 2D array

int a[rows][cols], (*p)[cols], col;

col = x; //x is an integer that represents our selected column

for (p = a; p < a[rows]; p++)
  (*p)[col] = 0;

I have declared p to be a pointer to an array of integers, which will be used as a row in the loop. The parentheses are necessary to be around the *p, otherwise p would be an array of pointers rather than a pointer to an array. In the expression p = a, a is equal to the address of a[0]. We know this from recalling the earlier quote:

In general, a + i is the same as &a[i]. Also, *(a + i) is equivalent to a[i].

Sources for this post:
* http://www.mediafire.com/?yf0z4x44k240q1o (particularly chapter 12)

2D Array Practice

2010-11-02T16:14:00.000-07:00

In the book C Programming a Moder Approach Second Edition there is a programming project at the end of chapter 8 that asks you to write a program that creates a randomized walk across a 10x10 field, where each step is shown as a letter from the alphabet, and each blank space is shown as a period. The end result should look something like this:

a . . . . . . . . .

b c . . . . . . . .

e d . . . p q r . .

f . . . . o . s . .

g h i j . n u t . .

. . . k l m v . . .

. . . . . . w . . .

. . . . z y x . . .

. . . . . . . . . .

. . . . . . . . . .

In order to do this, you initialize a 2D array, fill it with periods, randomly choose a number between 0-3 to represent a direction to move, detect if the move was a valid move (and re-randomize the move if it wasn't), then make the move chosen. Each time a move is chosen, use a new letter from the alphabet.

Overall, this was extremely simple. If I were writing this program without such specific rules as the programming book gave me, I would have made the array 12x12 instead of 10x10. This would allow me to line the edges with a value other than ".", and I could use that value on the edges to detect collision. This is a lot simpler than detecting if it is the edge of the array, since I can't simply use if board[y][x + 1] != '.', as a period can't exist out of the edge of the arrays.

I'll post the source code the most interesting part of the program:

for (column = 0; column < 10; column++)
{
  for (row = 0; row < 10; row++)
  {
    printf("%c ", board[column][row]);
  }
  printf("\n");
}

This cycles through the first row, and prints out all the contents. It does this by adding one to column during each iteration, and printing out a piece of the board using the token column as a coordinate. The same thing happens with the row token as well. Then, the next row, and the next row. Just before these two for loops I modify the current field and place a letter in wherever the current coordinates are, so that these two loops print out the move that just occurred as a letter.

Overall I didn't learn anything new, but I still needed to write this program in order to get used to the syntax of C. Here is the source and .exe for the full program.

PRNGs (Pseudo-Random Number Generator)

2010-11-01T18:36:00.000-07:00

Computers cannot truly generate random numbers, as computers are simply mechanisms that react to actions that are enacted upon them. In order to compensate for this, to generate a random number computers use a PRNG (pseudo random number generator). PRNGs can generate seemingly random numbers rather effectively.

One way to generate a random number in C is to use the rand() function, which is lies within the standard library of C. Here is an example:

#include <stdio.h> /* included for printf */

#include <stdlib.h> /* included for rand */



int main(void)

{

  int i;



  for (i = 0; i < 10; i++)

    printf("%i\n", rand());



  return 0;

}

Depending on your compiler, the output of this program will output ten numbers. However, this program will always output the same ten numbers in the same order. I've learned that the GCC compiler will have the rand() function return a value with an upper bound of 2,147,483,647 (2³²-1), compared to upper bounds of 32,767 (2¹⁶-1) from most other compilers.

In order to have this program output different numbers each time it is run, you need to do what is called seeding the PRNG. Seeding will affect the sequence in which the rand() function begins outputting numbers. In order to seed the rand() function, you use srand(). Here is an example:

#include <stdio.h> /* included for printf */

#include <stdlib.h> /* included for rand */



int main(void)

{

  int i;

  srand(1)

  for (i = 0; i < 10; i++)

    printf("%i\n", rand());



  return 0;

}

This seeded the PRNG with the integer 1, and will now output ten different numbers than the last program. Although, this still doesn't solve our problem; how do we randomly seed the PRNG? In order to do so, you can use the time() function. The time() function will return the number of seconds elapsed since Jan 1st 1970. This is the method of randomly seeding that DigiPen has shown their Freshman incoming students. Example:

#include <stdio.h> /* included for printf */

#include <stdlib.h> /* included for rand */



int main(void)

{

  int i;

  srand(time(0));

  for (i = 0; i < 10; i++)

    printf("%i\n", rand());



  return 0;

}

Now this program will produce a different set of numbers every time it is run. Although, what if you wanted to produce a random number within a specific range? You could use the modulo operator, like so:

#include <stdio.h> /* included for printf */

#include <stdlib.h> /* included for rand */



int main(void)

{

  int i;

  srand(time(0));

  for (i = 0; i < 10; i++)

    printf("%i\n", rand() % 10 + 1); //Random int from 1-10



  return 0;

}

Although I've been told this is error-prone and tedious, and it is much preferred to create your own wrapper function around rand().

int randomInt(int low, int high)
{
return (rand() % (high - low + 1) + low);
}

Installing Cygwin and Practicing C

2010-11-01T16:35:00.000-07:00

Yesterday's time was mainly spent installing Cygwin and running through selected exercises from the book C Programming a Modern Approach Second Edition (yep, I have a link for you this time!). The exercises I selected to do were all selected for DigiPen Freshman to do. If you're also interested in doing these, I have them all here:

Homework Assignments

Assignment	You should have reviewed the material by class on this date.
1. Read Chapter one in the textbook. 2. Make sure you can read from and write to your submit folder, if you plan on using it. 3. Read this page about the MSDNAA	Thursday, September 9, 2010.
Read chapters 1 and 2 from An Introduction to GCC	Friday, September 17, 2010.
Chapter 2: Exercises #1 - 10	Thursday, September 23, 2010.
Chapter 3: Exercises #1, #2, #4, #5	Friday, September 24, 2010.
Chapter 4: Exercises #1, #9, #10, #11, #12, #14, #15	Monday, October 4, 2010.
Chapter 5: Exercises #1, #2, #3, #5, #6, #7, #8, #10, #11	Friday, October 8, 2010.
Chapter 6: Exercises #1, #2, #3, #4, #5, #8, #11, #14	Monday, October 11, 2010.
Start reading the Style Guide for CS120 We haven't covered all of the topics yet, but you can read about the things we've learned. An example of consistent formatting style. This does not follow the CS120 style requirements, but it's an example of how one professional company does things. They also talk about the Seven Pillars of Pretty Code.	N/A
Chapter 9: Exercises #1, #2, #8, #9	Monday, October 18, 2010.
Read pages 686-687 in the textbook	Tuesday, October 19, 2010.
Chapter 8: Exercises #1, #2, #3, #5, #10, #11	Friday, October 29, 2010.
Chapter 7: Exercises #2, #3, #4, #5, #6, #9 through 15	Wednesday, Nov 3, 2010.

So far, I've completed most of the exercises all the way down to the chapter five column. Here's the source and .exe's of all I've worked on yesterday (these are actually the programming projects from the book and are not the exercises listed above): http://www.mediafire.com/?f40uv0sz0w9fdmt

Aside from all that code I just linked you all to, I also spent a great deal of time downloading and installing Cygwin. For those of you who don't know, Cygwin is Linux-like environment for Windows, and allows you to use the GCC compiler. DigiPen Freshman use it, so, I'm going to use it as well. So far I actually really enjoy using the GCC compiler, as it has such useful warnings and error reporting messages. Although, if you do want to install Cygwin just realize that's it is a bitch to get up and running if it's your first time doing so. Luckily I was able to read some of my friend's installation notes from their teacher in order to get it up and running. In the future I can write a short post on installing Cygwin, and have a nice .iso torrent for installing the precise version of Cygwin that DigiPen provided their Freshman this year. Right now though my Demonoid account is new and so I can't currently upload any new torrents. Update: Demonoid account can finally upload, torrent link here: http://www.demonoid.com/files/details/2453265/35110160/

In order to compile a source file with Cygwin you have to type out a long string with a bunch of commands. After some time of re-writing the annoying phrase "gcc -mno-Cygwin-Wall hello.c -o hello-no_Cygwin.exe", my roommate let me know that by pressing the up arrow key, you can copy the entire last command straight into the prompt, and then hit enter.

Next I plan to read more of C Programming a Modern Approach Second Edition, and finish up more exercises that I have listed above, as well as finish up the programming projects at the end of each chapter -particularly the ones that seem difficult.

There is one last thing I'd like to share, and it is a link to a very interesting article about a program that can find optimized build orders for the SCII Zerg race. I won't comment too much about this, as it's a bit off-topic for this blog, but, I just wanted to say that the whole field of AI and learning simulations is a very, very interesting field. I would absolutely love a career in something similar, but, I have a long time before deciding what to specialize in (game programming wise).

Blog Revives!

2010-10-31T15:42:00.000-07:00

Today I've decided to revive my blog, as I'm regularly studying computer science once more.

I had a hiccup in studying due to an issue with attending college, and I will be attending this next year. As such, I'll be doing independent studies of Math, Computer Science, and Game Design.

I currently live near the DigiPen campus, and as such have access to both their library and students. I even have access to the students' assignments and some of their class resources. Since I'll be attending DigiPen next year I've decided to switch solely to C and C++ (starting with C of course). I do however want to finish one final Python project, which is my Mini RPG game. I want to finish this, because people actually seem interested in it, as seen here.

I currently have a nice system for displaying two dimensional rooms into the windows console, as well as a battle system. I have a friend who added a teleport spell into the source file, which thrusts you up to three spaces. Here is a link which shows the instructions for playing the game, as well as a lot more information about the game. Here is a download link for the current .exe at this time: http://www.mediafire.com/?h1yvm61xr5a9tfr

Action Key:
w - Move up
a - Move Left
s - Move down
d - Move Right
e - Action button. Use this while standing next to something.
i - Inventory. Read all the text in the inventory, or you may miss an important operation (like how to discard an item, or equip an item).

Character key:
O   - This is your character.
/   - This is a wall. Your character cannot move over it
{"} - This is a treasure chest.
{_} - This is an unopened treasure chest.
[/] - This is a door.
S   - This is the store.
&   - This is CecilSunkure!!

Here are three links to resources that I plan to utilize in order to create a console based game like these DigiPen Freshman games:

http://msdn.microsoft.com/en-us/library/ms682010(VS.85).aspx

http://www.benryves.com/tutorials/winconsole/

http://www.tomshardware.com/forum/65918-13-technique-fast-win32-console-drawing

I am also currently reading through the book C Programming A Modern Approach Second Edition. This book is used by DigiPen Freshman, and so I'll be going through the entire thing before starting a console application.

I plan to be updating this blog regularly with whatever I learn, with a goal of archiving a path one can take to become a professional programmer from start to finish, as well as the goal of solidifying whatever I learn. You know how the saying goes: Docendo Discimus (Latin for "by teaching, we learn").

Blog Ends

2010-07-10T12:18:00.000-07:00

And this is the end of the epic blog that once was.

I'm unable to attend DigiPen due to my parents just recently deciding that they will not be helping me by taking out the Parent Plus loan. Since I have no rich or reliable relatives, I have no cosigner for private loans either.

I've already taken care of my living arrangement, and I will be moving into the Redmond area to study art on my own. This blog may just turn into my own art blog, who knows. The main point is this: There will be no more programming for a very long time on this blog.

If you wish for a more in-depth description of my situation, or wish to ask me anything, my email is CecilSunkure@hotmail.com

Wish me luck.

Absence

2010-06-22T14:08:00.000-07:00

Well, I've been grounded.

I shall resume posting once DigiPen starts up, or once I gain reliable computer access once again. I apologize.

News:
-I have no time to get the Django powered site up and running before school starts, so I have cancelled those plans.
-I won't be coding in Python anymore, unless it is to finish up that Mini RPG I started a long time ago.

Wish me luck.

Django: DjangoBook

2010-05-15T21:54:00.000-07:00

I believe I'm about due for a status check! I've been hammering away at this: http://djangobook.com/. That there is a nice book on how to use the web development framework Django.

Django was coded entirely in Python, and doesn't require any third party libraries for use. Django is constantly maintained by a slew of experienced coders, and is rather well documented. I've gone through 8 chapters of this book, plus the four tutorial chapters at this site in four days. I've been spending my time coding away on my own local development server -which is shipped with a Django installment. I've yet to deploy my code onto the site; chapter 12 is about that and I'm currently on chapter nine of the DjangoBook.

At this point in time I've coded some pages which include form submission and validation, requesting a viewer's metadata and displaying it in a table format, querying/modifying database information, searching through a database, the admin pages shipped with Django, and more things I can't think of off the top of my head.

Django follows a MVC design pattern where the Content, Backend, and Page Layout are all separated into isolated sections. The point of this is to allow for loose coupling between the different functions of the site, where almost nothing is hard-coded. This allows for copying//pasting pre-existing files into new locations, and for developers with different skill-sets to work collaboratively and efficiently. This works out great between me and our layout guy, as neither of us are at all good at doing each others' jobs. Using Django terms, MVC could be called MTV. MTV stands for Models Templates and Views. Models = site contest, Templates = page layouts, and Views = backend site logic (controlled via python modules, woot!). It's great to be able to keep using Python all the while learning a web development schema. For those of you who think Python is worthless, I Lol at you and your naivety.

And yes, all the backend logic is safely hidden away from the page source as to not allow reverse engineering of the site's workings.

At this rate, I should have a decent amount of functioning pages up for my team to see my current progress in a couple days. I also spoke with a few DigiPen students who are entering their Freshman year as well, and they seemed pretty enthusiastic about using the site's forums. All is going well.

Linear Algebra: Rotation Matrices

2010-05-13T19:33:00.000-07:00

A day or so ago I looked up the topic of using rotation matrices to modify the angle of a vector by an arbitrary amount. I visited none other than the WikiPedia page for rotation matrices.

The idea behind rotation matrices is to solve for the x and y coordinates after the rotation by using two separate equations. Here is a rotation matrix for 2 dimensions:

That matrix will rotate the 2D plane counterclockwise by angle θ. Using this knowledge, the new x and y coordinates for a point on a rotated vector would be solved for using these two equations:

Very simple! So here is an example problem: Say you have vector AB. AB = (2, 3).

To solve for a rotated counterclockwise version of this vector you input your desired angle of rotation in for θ, 2 for x and 3 for y. This rotation matrix rotates a 2D plane clockwise:

Rotation in 3 dimensions is basically the same process. All that is different is the z coordinate and modified rotation matrices. You simply solve for each individual coordinate with the rotation matrices for the z, x, and y axis. These three rotation matrices and more are found at the WikiPedia page for rotation matrices.

Mini RPG and Future Plans

2010-05-13T19:08:00.000-07:00

I've decided to try and start a project with a couple good friends; we are going to construct a website. One is the bill payer and public relations, the other is layout design/client side coding, and I am the server side coder. I plan to use a development framework called Django. The website we are creating is planned to have a focus on StarCraft 1 and 2 map making. We want forums, a download database, a wiki, and a shoutbox later down the road. Our layout guy is rather talented, and the owner is pretty good at creating images. Things look bright for us three. We also want a focus on art development and coding -this would be great for DigiPen students as well. 3D modelling is a great option to have for SC2 mapping, and as is coding in general. It would be perfect if I can get my future DigiPen colleagues to use our site as a forum to communicate to each other with.

The best thing about Django is that it allows full support of Python modules to be used for the site's logic, and makes for rather fast development. Also, I already am familiar with python, and all the while learning to construct this website I will enhance my coding skills.

We currently have a domain set up at http://mappingdynasty.org. When this post was created the only thing on the site was the index.html page, which just holds some hmtl lines to display a picture that our owner created. Go ahead and check it out ^.^

Today I also worked on my Mini RPG. I added about 75 lines of code. I added a monster class, almost finished the battle function, modified and updated the main loop, and made some minor changes to the character class to allow for holding weapons and having hit points. I am really loving object orientation for this little program; things are super organized and simplified. I can't imagine creating this program without using any classes D:

I haven't had time to actually test the source file for bugs and errors, but I believe it is working.

Here is a link to my source: http://www.mediafire.com/download.php?mgmzmwnnwdg

Linear Algebra: Basics

2010-05-11T15:31:00.000-07:00

Today with my math teacher I went over some of the basics of linear algebra. The two topics I went over included solving for the intersection of two lines in 3D space, and finding the angle between two vectors. The rest of the mathematical topics I'll try to cover in the near future include: finding a vector orthogonal to two other vectors in 3D space; finding the time T during the intersection of ray between a circle of sphere; using a matrix to rotate a vector by an arbitrary angle. I found these topics, as well as an entire survival guide for DigiPen students, at this site here. Hopefully by explaining the math I went over today I can solidify my own understanding.

First off: solving for the intersection of two lines in 3D space. I know how to do this in matrix form, as it is easiest and simplest in matrix form. Here is a matrix of the x y and z coordinates for a point in 3D space: [x, y, z]. An equation for a vector in 3D space consists of a point on a line, and the direction vector of a line multiplied by a magnitude. This magnitude represents the length of the line, whereas the timestep, or t, represents a constant.

Here is an equation for a line in 3D space: L1 = [2, 4, -1] + t[-1, 2, 3]. I just chose these numbers at random because they really don't matter. The first matrix is a point on the line. The second matrix is the rise, run, and the z equivalent to rise or run (just like two dimensional lines). You need a point on the line, otherwise the direction vector (rise//run//zrun) could sit anywhere in space. Without the direction vector for your line, you line could be facing in any direction as long as it sits on your point. The t is the magnitude of the direction vector, and these could be used as something to define the distance something traveled over time of t. t is just a constant.

In order to solve for the intersection of two lines, I'll quickly show the process with some variables. Here are the two lines: L1 = [a, b, c] + t[d, e, f]; L2 = [g, h, i] + r[j, k, l]. Now since these two equations each represent a line, the point of intersection is going to be a point that can be used to satisfy either of the equations. You just set both of the equations equal to each other, one variable at a time (x, y and z) and solve for each one. To solve for the x coordinate of the intersection you would use a + td = g + rj. You do this for variable a through c corresponding to d through f. Then using substitution, if need be, you can solve for t and then solve for the rest of the variables, thus getting a final matrix of [x, y, z].

The second thing I learned today was finding the angle between two vectors. Luckily, you only need the direction vectors of the line equations. This makes sense because no matter where the lines are in space, they will have the same angle of intersection as long as the direction of the lines face in stays constant. To do this, you use the equation of:

Theta, the zero thingy on the left, is the angle you are solving for. a and b both represent matrices that represent direction vectors, like the direction vectors in the line equations earlier in this post. Arccos is cos^-1. The a and b on the top half of the right side of the equation is pronounced as a dot b. The dot is the operator for the dot product. The dot product is used to find the scalar projection of a onto b, and vise versa. I honestly don't fully understand what exactly the dot product does yet (read last paragraph, I understand it now), but for now I just need it for equations like this one, and it returns a scalar value. To use the dot product on two 1x3 matrices, you would do this: [a, b, c] dot [d, e, f] = ((a x d) + (b x e) + (c x f). The |a| represents the magnitude of a, which is the length of a. If the direction vector of a line is representing velocity vectors, then the magnitude of a would be the speed of the direction vector. To find the magnitude of a 1x3 matrix you do this: |M| = |[a, b, c]| = sqrt(a^(2) + b^(2) + c^(2)). Does that look familiar? It should; it's basically the Pythagorean Theorem in 3D. It takes the rise, run, and zrun and converts the three into a length value, just like the Pythagorean Theorem does with two lines, except this is with three.

Now once you find a dot b, and magnitude of a times magnitude of b, you then divide a dot by magnitude of a times magnitude of b, then arccos that value which results in your angle!

Dot product explained: Okay! I so I did a bit of research and asked a couple people some questions and now I understand what the value returned by the dot product does. It projects a vector onto another vector and returns the length. A dot B also equals B dot A, which makes sense because multiplication itself is commutative, and the formula for the dot product is just multiplication of three values. Here is a picture to help visualize this:

The blue line would be the dot product of A and B. This is very useful for collision in programming, and transforming vectors from one grid space to another. Here is a good example of using the dot product for 2D collision detection of convex polygons:

The red and blue are both one dimensional projections of the objects onto a line. The dotted line is perpendicular one side length of one of the objects. In the diagram is looks like it is perpendicular to both, which is fine, but it is important to understand that the dotted line is normal to one of the sides of one of the polygons. Once you find a dotted line that is perpendicular to a side of one of the shapes, you use the dot product on a two dimensional matrix and project both of the shapes onto the normal to the dotted line. You can then compare the two projections to see if they overlap. If the two projections overlap, you then try the entire process over for a different side of one of the polygons. Once you try this algorithm over each of the sides of each object and no collision vector was detected (a collision vector would be the length of overlap formed by overlapping projections) in at least one of the iterations, then the two objects are not colliding with one another.

Sources:
http://www.mvps.org/directx/articles/math/dot/index.htm
http://en.wikipedia.org/wiki/Dot_product
http://www.gamedev.net/reference/programming/features/verletPhys/page2.asp

Game Design: Positive and Negative Feedback; Flow Control

2010-05-10T09:49:00.000-07:00

As I've said a few times in the past, I have been reading Rules of Play: Game Design Fundamentals. Lately I have also been applying what I've learned into judging StarCraft mapping contests, like this one, and weaving them into my own map like this one. I've decided to take some of the knowledge and tools I've gained and write a post here about them. First, I want to talk about positive and negative feedback back loops in two different contexts.

The first context I want to talk about them in, is in the study of cybernetics.

Cybernetics deals with the ways a system gauges its effect and makes necessary adjustments. The simplest cybernetic device consists of a sensor, a comparator, and an activator. The sensor provides feedback to the comparator, which determines whether the machine is deviating from its established norm. The comparator then provides guidance to the activator, which produces an output that affects the environment in some way. This fundamental process of output-feedback-adjust-ment is the basis of cybernetics.—Stephen Littlejohn, Theories of Human Communication

As this quote explains, cybernetics is a study of how a system reacts and makes adjustments to the current state of the system. This should sound rather relevant to video games. This type of automated reaction is used all the time; have you ever played a game that automatically tiers to the user's level of skill? There are two primary types of adjustments that are made upon a system, these two are positive and negative feedback reactions, usually used within a loop.

For example, take a room with a thermostat and a heater. When this room's sensor, the thermostat, reads a certain temperature it can trigger the heater to react. This system can be rigged to perform a negative feedback reaction in which the heater heats the room when the temperature is less than or equal to a certain amount. Assuming the room naturally cools, the room's temperate will oscillate between a few degrees and stay that way, all the while the room's specific state is constantly changing. A positive feedback loop would be if the heater turns on when the temperate is equal to or greater than a specific temperature. In a positive feedback loop, the temperature of the room will spiral up and up once it hits a certain activation point. Both positive and negative feedback loops are essential tools to be used in game design.

Too often I see games designed in StarCraft maps that are too hard or too easy, or too hard or too easy once the player reaches a certain point. I also see games made in which the leader has no way of letting the other players catch up to him, because he has such a great advantage over the other players. I also see the losers in a game have no means of catching up to the leaders. What's the point of continuing play if the outcome of the match has already been determined in the middle of the game because the leading player has a tremendous advantage over the rest of the players? These types of design flaws can be controlled with positive and negative feedback loops. Usually positive feedback loops are harmful to a game's flow (flow will be explained more in depth soon), and should be switched out for negative feedback loops. If a leading player seems to be constantly destroying all the other players in an unfair way, create a negative feedback response in which the system (the game) reacts and hinders the leading player. Similarly, you can give advantages to the players in last place to encourage and help them catch up to the leaders.

A great example of a negative feedback response is in the game Super Mario Cart. In Super Mario Cart there are weapons you gain from running into question marked boxes with your cart. Once you hit one you obtain a random weapon. You have a much greater chance to obtain a powerful weapon when you are near last place in the race, and you have a much greater chance to obtain a weak weapon when you are in first place. This sort of automated reaction the system generates creates a much more compelling form of gameplay, in which all the racers are usually closely pitted against each other neck to neck until the very end of the race. This generates an exciting play in which the outcome of the overall match remains uncertain till the very end.

The second meaning of positive and negative feedback would be rewards and punshiments to a player. Simply put, rewards are great to use to encourage players to make certain choices, and punishments are used to deter certain behavior. There is also a third category known as negative feedback. Negative feedback is not necessarily a punishment, but is used to deter a player from making specific choices. For example say you do not want your game to be focused on fighting, although you want to have an occasional enemy in your game. It turns out that too many players are focusing on finding and fighting enemies rather than experiencing your game how you designed it to be experienced. You do not want to punish the player as to deter them from playing at all, so what you could do instead is implement a clever negative feedback mechanism. You might be thinking that you could just make enemies stronger and therefore make the player want to avoid them -this might just make finding and killing enemies an interesting challenge for the player. Instead you could give the player absolutely no reward for killing the enemy (no points or anything), you could also make enemy encounters not worth the risk (as in making the player restart the level if an enemy kills them, or have enemies be "thieves" where if they hit you you lose items). If your goal is to make enemies something the player wants to avoid, give the player a reason to avoid them. If you find that fighting these enemies is truly fun for the players, you could also switch your game to a fighting one; it's your design, you decide.

Flow; flow would be the fine balance between difficulty in a game and the player's skills. Skills do not just include physical coordination; skills also include knowledge of the game's workings, knowledge of the other player's skill level, physical coordination, intelligence level, and response time. There are more than likely many many more forms of skill which I did not mention, but these should give a general idea. The difficulty of the game is pretty self-explanatory. The flow channel of a game is a narrow isle where the difficulty of the game is perfectly balanced and matched to the skill level of the player. Here is a diagram of the flow channel graphed with challenge over skill level:

As you can see, it can be hard to create a flow in gameplay for all different types of players. One way that game designers achieve balanced flow is to apply positive and/or negative feedback loops to a game's processes.

Here is an interesting excerpt from the book Rules of Play that talks about the design process for a game made by two designers:

In a wonderful essay published on Gamasutra.com, Jesse Schell and Joe Shochet of Disney Imagineering write about the process of designing Pirates of the Caribbean-Battle for the Buccaneer Gold, a game "ride" where a group of players stands on a motion-platform pirate ship surrounded by video projections. During the game, one player steers the ship while the other players operate a number of cannons, firing at monsters, forts, and enemy vessels. Pirates of the Caribbean is designed as a condensed five-minute experience, and it was essential that players feel properly challenged at every moment of the game.
In their design analysis, Schell and Shochet detail a number of design problems that had to be overcome in order to maximize player enjoyment. For example, during playtesting they identified as a problem the fact that the player steering the ship could take the ship to what they call "dull places," leading to a less engaging experience for all of the players. In the selected quotes below, Schell and Shochet outline some solutions to this problem:
Architectural Weenies: "Weenie" is a phrase coined by Walt Disney himself. It refers to the technique used on movie sets of guiding stage dogs by holding up part of a sausage… In the case of Pirates, [there are] three main "weenies," one for each island: a volcano, an enormous fort, and a plume of smoke coming from a burning town. No matter which way the boat is facing, at least one of these "weenies" is in view. Since the coolest action takes place at the islands, [we wanted] to guide the captains to go there.
Guide Ships: Since the short-term goal of the game is to fire on other pirate ships, captains strive to get near these ships so that their gunners can get a clear shot. Many of the ships in the Pirates world are "on their way" to the islands mentioned above. Many captains, in just trying to stay near these ships find that just as they have destroyed the ship, they have arrived at one of the islands, without even trying to get there.
Sneak attacks: What if the captain ignores the guide ships? Even if he heads toward one of the "weenies" it might mean as long as a minute during which the gunners have little to shoot at. For this reason, [we] created special "sneak attack" ships that "magically" appear behind the players' ship, and quickly pull up alongside, when no other boats are in range.
The Waterspout: This was [a] nickname for [a] "last ditch" forcefield that surrounds the game play area.If a captain tries to sail out of the main game play area and out to open sea, they hit the forcefield, and the ship is "magically" pointed back to where the action is. The few guests who see this don't even realize that anything unusual has happened. They are just pleased to have their boat going somewhere cool.
Schell and Shochet are thinking in very experiential terms, using clever techniques to subtly guide player action in meaningful directions. At the time of its release, Pirates was a very high-tech production, featuring real-time 3D graphics, physically engaging cannon-firing interfaces, and a large motion platform to simulate a pirate ship rocking on the waves. Often in these instances, a desire to "properly" simulate a coherent 3D space or "correctly" output logical behavior for computer-controlled characters overshadows the design of the actual play experience. But Schell and Shochet had no hesitation in making pirate ships "magically" appear to guide the player, or abandoning "realistic" physics to have the player's ship turn on a dime to facilitate navigation. As they put it,"By choosing to be less concerned with reality and more concerned with what was fun, we created an experience that…is easier to adapt to, quicker to learn, and is a better show." In game design, player experience should always trump so-called "realism."

Boredom and anxiety, as game design watchwords, are wonderful because they speak directly to player experience. As you shape and sculpt your players' pleasure, you are guiding them between the Scylla and Charybdis of anxiety and boredom.This task is made all the more difficult because, as we know, the experience of play can only be indirectly designed. How do you create a set of rules that maximizes the play of pleasure for your audience?

The designers of this game implement two negative feedback loops. Did you see them? Onewould be the sneak attack ships. These ships react to the players being all alone at seas, and then appear out of nowhere to create an exciting experience. The other would be the water spout; the water spout reacts to the players entering the boundaries of the map, then spins them in the correct direction, thus keeping the game in a specific state. The guideships and weenies would be more a form of positive feedback in which encourage the player to make specific decisions. The guideships encourage the players to travel to the key focul points of the game while the weenies create enticing visual scenes that players are likely to travel to. Both of these provide the players with a reward and a reason to take specific actions.

2D Physics: Collision and Velocity Vectors

2010-05-08T16:29:00.000-07:00

I'm back from working on that SC map, and recently I found this link. That link is a flash game of a 2D physics tutorial, and it covers just about everything you would need to know for 2D physics. The part I was most interested in was how to find the velocity vectors of a ball after collision with a wall, with any angle for the wall.

I ended up finding two different methods for doing so, both assuming the collision is perfectly elastic and that any acceleration given is a constant. If the acceleration is not a constant, then the timestep between calculations is going to be needed to be cut down in order to minimize the error generated.

First I will go over the simplest method. This methods solves for the new angle the object travels in after collision, then uses this angle to solve for the new velocity vectors after collision with the wall.

When a ball collides in an elastic collision with a point on the wall, the new angle formed is a reflection over the normal to the parallel of the wall. This means that the angle formed between the object's path of travel while it is moving at the wall, is equal to the angle formed between the wall and the object's path of travel as it leaves the wall. Knowing this, a simple equation can be used to solve for the new angle after collision:

180 + 2C - A = B

A is the angle of incidence, C is the normal to the wall at the point of impact, and B is the resulting angle. Here is an example:

The angle of incidence is going to be 360, and the normal to the wall is 45 + 90.

180 + 2(135) - 360 = 90

Now that the resulting angle is found, you can use this angle to solve for the new x and y velocity components. Using simple trigonometry we know that the x component is going to be cos(B), and the y component is going to be sin(B). Using the velocity of the object in place of magnitude for our equation, you can use these two equations to solve for the new x and y velocity vectors:

Velx = mag * cos(B)

Vely = mag * sin(B)

Now you all you have to do is apply your Velx and Vely to your object each timestep and it will travel away from the wall with a convincing collision. You can also use these two equations to modify the angle of travel of an object. For instance say an object is travelling near a magnet. You can create a rough simulation of "pull" by changing the angle of A to B by just adding or subtracting to A. To do this you would first need to know the angle of the line formed between the magnet and the object, which can be represented by D. Once you find this, you can use it to compare to A. Depending on whether A is greater or lesser than D you just add or subtract to A. You can also simulate acceleration towards the magnet by modifying the magnitude depending on what the distance to the magnet currently is.

Note: You can substitute in arctan(y/x) for A if you know the slope of the object's travel, which is y/x. This is known from standard trigonometry, where tan(A) = y/x.

And there you have it! Now time for the second method, which is explained in my link at the top of the post. Actually, the link in my post doesn't really explain the process of coming up with the formulas goes, but oh well. If you know Velx and Vely from before the collision, then you can use these two formulas:

final Vx = Vxcos(2A) + Vysin(2A)

final Vy = Vxsin(2A) - Vycos(2A)

One more thing to note: You can use two points on a line to calculate the slope of that line by using rise over run. The formula is: A = arctan(x1 - x2/y1 - y2). This is extremely useful for collisions between two balls. You take the center coordinate for each ball, calculate the slope made between these two points, and use the normal slope to this slope as your "wall", then run the calculations this post describes to find the velocity vectors of both the x and y after collision. Instead of calculating the slope then finding the normal to this slope, you can use arctan(x1 - x2/y2-y1) to directly find the slope to the normal. This makes sense since a normal line's rise will be the same as the line's rise, although the runs will be reversed. So, the y1 and y2 switch positions, thus mirroring the runs of each slope.

Mini RPG: Continued

2010-05-05T09:58:00.000-07:00

I have been working on a StarCraft map for a week long contest at StarEdit.net, however, today I forgot to bring my flashdrive with me so I now have no access to my mapfile and cannot work on it. Since I am unable to work on that for most of today, I decided to work on this file since I can copy//paste the source from my older post :)

Today I added in some comments to my code for easier read, added in a tiny method for the character class to add inventory items to the inventory (which is just a single list within the character class), created an item class, and started on the function that handles battles.

Overall progress is going at a decent pace while working on this project, but, I am not spending much time on it currently due to the week long contest I had mentioned.

At the moment this file doesn't do anything new, but has new code within it.

Here is my current source file: http://www.mediafire.com/?ymwminmhige

Mini RPG: Just Started

2010-04-26T15:24:00.000-07:00

I have started on my mini-RPG! As of now I have a field and character class. The field has three obstacles in it now, and the entire field is represented by the currentMap list shown at the beginning of the source code. A 1 is a wall, 0 is empty space, 2 is an obstacle (not walkable), and 3 is a newline character.

At the moment the obstacles are represented by one of five different characters, and each obstacle is assigned one of these characters during the instantiation (creation) of the game field's instance. This way, random characters are generated for the obstacles and stay that way the entire game.

For now the only things that this does are create a field and print it when you hit enter, and move the character around. In order to detect collision I created an isValidMove function. This function checks to see if the next move the player can take will be anything but a 0 or not, and returns True or False.

import random

currentMap = [
    [1, 1, 1, 1, 1, 3],
    [1, 0, 0, 0, 1, 3],
    [1, 2, 0, 0, 1, 3],
    [1, 0, 0, 0, 1, 3],
    [1, 0, 0, 2, 1, 3],
    [1, 0, 0, 0, 1, 3],
    [1, 0, 2, 0, 1, 3],
    [1, 0, 0, 0, 1, 3],
    [1, 1, 1, 1, 1, 3]
    ]

class gameField:
    def __init__(self, mapData=[0]):
        self.mapData = mapData
        self.string = ''
        self.blocks = []
        for i in range(len(self.mapData)):
            for j in range(len(self.mapData[i])):
                if self.mapData[i][j] == 2:
                    r = random.randrange(1, 5)
                    if r == 1:
                        self.blocks.append(' v ')
                    if r == 2:
                        self.blocks.append(' x ')
                    if r == 3:
                        self.blocks.append(' ^ ')
                    if r == 4:
                        self.blocks.append(' * ')
                    if r == 5:
                        self.blocks.append(' ~ ')

class character:
    def __init__(self, x=0, y=0, field=None):
        self.crds = [x, y]
        self.x = self.crds[0]
        self.y = self.crds[1]
        self.field = field

    def __str__(self):
        s = ''
        r = 0
        for i in range(len(self.field.mapData)):
            for j in range(len(self.field.mapData[i])):
                if self.field.mapData[i][j] == 4:
                    self.field.mapData[i][j] = 0
        self.field.mapData[self.y][self.x] = 4
        for i in range(len(self.field.mapData)):
            for j in range(len(self.field.mapData[i])):
                if self.field.mapData[i][j] == 0:
                    s += '   '
                elif self.field.mapData[i][j] == 1:
                    s += ' / '
                elif self.field.mapData[i][j] == 2:
                    r += 1
                    if r == 1:
                        s += self.field.blocks[0]
                    if r == 2:
                        s += self.field.blocks[1]
                    if r == 3:
                        s += self.field.blocks[2]
                elif self.field.mapData[i][j] == 3:
                    s += '\n'
                elif self.field.mapData[i][j] == 4:
                    s += ' O '
        self.field.string = s
        return self.field.string

    def isValidMove(self, move):
        if move == 'a':
            if self.field.mapData[self.y][self.x - 1] != 0:
                return False
        if move == 'a':
            if self.field.mapData[self.y][self.x - 1] == 0:
                return True
        if move == 'w':
            if self.field.mapData[self.y - 1][self.x] != 0:
                return False
        if move == 'w':
            if self.field.mapData[self.y - 1][self.x] == 0:
                return True
        if move == 's':
            if self.field.mapData[self.y + 1][self.x] != 0:
                return False
        if move == 's':
            if self.field.mapData[self.y + 1][self.x] == 0:
                return True
        if move == 'd':
            if self.field.mapData[self.y][self.x + 1] != 0:
                return False
        if move == 'd':
            if self.field.mapData[self.y][self.x + 1] == 0:
                return True

currentGameField = gameField(currentMap)
currentCharacter = character(3, 1, currentGameField)

while True:
    print(currentCharacter)
    char = raw_input()
    if char == 'a':
        if currentCharacter.isValidMove(char):
            currentCharacter.x -= 1
    if char == 'd':
        if currentCharacter.isValidMove(char):
            currentCharacter.x += 1
    if char == 'w':
        if currentCharacter.isValidMove(char):
            currentCharacter.y -= 1
    if char == 's':
        if currentCharacter.isValidMove(char):
            currentCharacter.y += 1

After that is complete, I'll add in an option to enter your inventory and have a chance of a random battle sequence after each step the player takes.

Hopefully in the future I will have support for having multiple rooms, doors to and from rooms, and a .txt loader that can load maps from a .txt file. We'll see how things go.

Here is an example of some output text:

/ / / / /
/           /
/ v        /
/ O        /
/        ^ /
/           /
/     v     /
/           /
/ / / / /

d
/ / / / /
/           /
/ v        /
/     O     /
/        ^ /
/           /
/     v     /
/           /
/ / / / /

The character is the O, and the / are walls, the rest are just impassable obstacles. I hit the d key, and moved the character a space right.

Card Simulation: Complete

2010-04-19T21:21:00.000-07:00

I have finished my Mau Mau card game!!

There are now two "unique" cards. Playing a seven makes the next player draw a card, and playing an Ace makes the next player lose a turn. The face up stack now sets itself as the deck and shuffles when the deck empties. If a player plays all their cards in their hand they win, and the program exits using sys.exit().

I may in the future add in support for multiple Ai players, but for now I shall not. I want to start on a new and more complicated project, and I don't feel that working on this much more will help me to learn much more.

Currently 333 lines of code.

Here is a link to the .exe file in case you want to play it:
http://www.mediafire.com/?jjymynjngdz

Here is a link to the .py source file:
http://www.mediafire.com/?jnzum2zdrdv

As for my next project, I want to make a very small fighting game. The game will be text based, and will feature a small map, a battle sequence, and random battle events while walking on the map. I also want to have a interactive map (e.g. open doors), as well as a very limited inventory for dealing out different attacks. All in all, I want to have about 3 enemies. Basically this project is a mini-RPG, without upgradeable stats or any storyline. The point of the project is just to solidify my general coding capabilities, along with furthering my use of OO.

Card Simulation: Continued

2010-04-17T16:38:00.000-07:00

Here is a code update for the day. I have to spend the rest of my day doing homework, so I don't know what progress will be made throughout the weekend. I may work on this more tomorrow.

Here is a link to the current build's source code.

As you can see, I have an Ai working to play against me. I currently don't have anything to have a player win the game, so there should be an exception thrown during one of the Ai's methods or during the makeMove method when either player has no cards in their hand.

The Ai works by creating a list of cards available to play, then randomly choosing one to play. If none of the cards in the Ai's are playable then it will draw a card from the deck. This reminds me, if the deck empties then there should be a thrown exception as well, as I haven't coded switching the stack with the deck when the deck is empty.

Since I created an Ai class, I should be able to instantiate multiple Ai instances with ease to allow for multiple Ai players to be playing simultaneously.

Once I work on this some more, I plan to handle the mentioned exceptions that should be thrown, as well as begin working on creating some unique cards. For now I like the "make next player skip their turn" and "wild card". The wild card would allow the player to switch the current suit to any suit desired.

Here is a .exe in case you wanted to play the game ^^
http://download510.mediafire.com/13dumzc1bodg/awtwokn2wmt/Cards1.7z

Card Simulation

2010-04-15T16:13:00.000-07:00

Lately I have been documenting my experience with creating a deck simulator here, which is being written with Python 2.5.6.

I plan to continue documenting my progress at the link above, as well as on this blog. I posted the above link so that anyone that would like to can see all previous posts I've made up to my current point of development, which will be explained throughout this post.

I have chosen to create a card game called MauMau. MauMau is a game very similar to Uno, the main difference being that MauMau is played with a traditional deck of cards.

I currently have created a card class, deck class, MauMau class, and hand class. I manipulate these within the main function, which is the game loop. I also have created a function for determining if a player move is a valid move.

My immediate plans for the game is to:

- Create the used stack pile.
- Allow players to make a move by playing a card onto the used stack pile.
- Create an Ai which plays available cards, and draws if unavailable.
- Create rules for unique cards, like lose a turn, etc.

Here is my current build:

"""
To do:
- Create the used stack pile.
- Allow players to make a move by playing a card onto the used stack pile.
- Create an Ai which plays available cards, and draws if unavailable.
- Create rules for unique cards, like lose a turn, etc.

Created by: CecilSunkure
"""

import sys
import random

ACES_HIGH = True
GAME_RUNNING = True

class card:
    suits = ["Clubs",
             "Diamonds",
             "Hearts",
             "Spades" ]
    ranks = ["Ace",
             "2",
             "3",
             "4",
             "5",
             "6",
             "7",
             "8",
             "9",
             "10",
             "Jack",
             "Queen",
             "King" ]

    def __init__(self, suit=0, rank=0):
        self.suit = suit
        self.rank = rank

    def __str__(self):
        return (self.ranks[self.rank] + " of " + self.suits[self.suit])

class deck:
    def __init__(self):
        self.cards = []
        for suit in range(4):
            for rank in range(12):
                self.cards.append(card(suit, rank))

    def __str__(self):
        s = ''
        for i in range(len(self.cards)):
            s = s + str(self.cards[i]) + '\n'
        return s


    def shuffle(self):
        import random
        cards_length = len(self.cards)
        for i in range(cards_length):
            j = random.randrange(i, cards_length)
            self.cards[i], self.cards[j] = self.cards[j], self.cards[i]

    def remove(self, card):
        if card in self.cards:
            self.cards.remove(card)
            return True
        else:
            return False

    def draw(self):
        return self.cards.pop()

    def is_empty(self):
        return (len(self.cards) == 0)

    def deal(self, hands, num_cards=999):
        for i in range(num_cards):
            if self.is_empty(): break
            card = self.pop()
            hand = hands[i % len(hands)]
            hand.add(card)

    def pop(self):
        return self.cards.pop()

class hand(deck):
    def __init__(self, player=''):
        self.cards = []
        self.player = player

    def add(self, card):
        self.cards.append(card)

    def __str__(self):
        s = self.player + "'s Hand"
        t = 0
        if self.is_empty():
            s = s + " is empty\n"
        else:
            s = s + " contains\n"
        for i in range(len(self.cards)):
            t += 1
            s = s + str(t) + '. ' + str(self.cards[i]) + '\n'
        return s

class MauMau:
    def __init__(self, stack=0, topCard=0):
        self.deck = deck()
        self.deck.shuffle()
        self.players = []
        self.stack = stack
        self.topCard = topCard

    def getName(self):
        print('Welcome to Mau Mau!')
        player = raw_input()
        print('What is your name?')
        player = raw_input()
        print('')
        return player

    def startCard(self):
        self.topCard = self.deck.pop()

    def cmp_topCard(self, other):
        if self.topCard.suit == other.suit:
            if self.topCard.rank == other.rank:
                return True

def isValidMove(move, hand, game, handlen):
    """Used to determine if a move by checking to see if the move is an integer, followed by and testing to see
    if the proposed move is within the length of the hand passed to this function. Finally, this function
    makes sure that the proposed card to be played is valid within the rules of the game (same rank)."""
    x = []
    for i in range(1, (handlen+2)):
        x.append(i)

    try:
        int(move)
    except:
        print('That is not a valid move (not int).\n')
        return False

    if int(move) not in x:
        print('That is not a valid move (not 1-' + str(handlen+1) + ').\n')
        return False

    if move != str(handlen+1):
        if game.topCard.rank == hand.cards[(int(move)-1)].rank:
            return True
        else:
            return False
    elif move == str(handlen+1):
        return True

def main():
    """This function is the main loop used for running the Class MauMau. The turns between Ai and human are
    represented by integers, and those integers are used in if statements to determine which player is currently
    taking their turn."""
    #turn = random.randrange(2) + 1 <-- A comment for now, so for testing the human always goes.
    turn = 0
    game = MauMau()
    name = game.getName()
    hand1 = hand(name)
    hand2 = hand("CPU")
    game.deck.deal([hand1], 5)
    game.deck.deal([hand2], 5)
    game.startCard()

    if turn == 1:
        print('The computer will go first, as decided at random.')
    else:
        print('You will move first, as decided at random.')

    while GAME_RUNNING:
        print ('///' + '\n' + '/// ' + str(game.topCard) + '\n' + '///' + '\n')
        print (hand1)

        if turn == 1:
            print ('The computer will now take its turn, hit enter to proceed.')
            Move = raw_input()
        else:
            print ('Choose a card to play (1-' + str(len(hand1.cards)) + ') or draw a card (' + str((len(hand1.cards)+1)) + ').')
            Move = raw_input()

            if isValidMove(Move, hand1, game, len(hand1.cards)):
                print('Valid move check passed.\n')

                if Move == str(len(hand1.cards)+1):
                    hand1.add(game.deck.draw())
            else:
                print('Valid move check failed.\n')


if __name__ == "__main__":
    main()

In order to use the stack of cards for the face up cards that were already played, I plan to implement a common stack. A stack would be a list or array that is used to grab values out of in the order of the last appended first. I created a test module (.py file) before actually using it in the game. I have yet to implement something similar, but the source for this test is here:

#A test module for creating a stack.

run = True
stack = []

while run:
    print('Stack, Pop, end, or continue? (1, 2, 3, enter)')
    yesno = raw_input()

    if yesno == '1':
        print('Enter a value to stack')
        a = raw_input()
        stack.append(a)

    if yesno == '2':
        try:
            stack.pop()
            b = stack.pop()
            print(b)
        except:
            print('Stack is empty.\n')

    if yesno == '3':
        run = False

   Development is moving at a decent pace. Most of the time I am debugging the code I have written, but I am learning a ton. I've become very much more familiar with object orientation through the use of all my classes, and this project is definitely helping to enhance my overall coding ability. It's really pretty exciting :)

Here is a link to a .exe of my current build: http://download503.mediafire.com/m5ydqyl9zzng/nyfzyamykzi/Cards.7z

ActionScript 3 (Flash)

2010-03-27T18:18:00.000-07:00

Well, I to be honest haven't taken a break from coding; I've been dabbling in ActionScript. I took a look at the Shootorials on Kongregate, and I realized how easy AS3 was to use. I honestly composed this game found in this tutorial (on page 1) in about 6 hours. I'm still contemplating spending my summer with C/C++, or ActionScript. Seeing how easy AS3 is to use, I may just spend my summer trying to develop a game in order to make some spare cash. On the other hand, I could spend my summer coding in C/C++ to get a bit of a headstart for DigiPen.

I found the website http://freeactionscript.com, and immediately fell in love with all of the sample code. Take a look here if you are at all interesting in coding flash games.

I've also been spending my time reading Rules of Play: Game Design Fundamentals in order to better understand what makes games fun to play. I plan to utilize this knowledge to finish my RPG which is being constructed as a StarCraft 1 map file.

So far, I plan to balance out the three of these projects during my summer, focusing mainly on finishing my RPG, and coding a decent AS3 game, all the while keeping brushed up on C/C++ with my collection of C/C++ books I have sitting on my computer.

If you have any suggestions, comments, or questions about the above links or ideas, please feel free to let me know by commenting!!

Caeser Cipher

2010-02-25T10:40:00.000-08:00

Now I have finished up the encryption chapter of this book. The entire idea behind the encryption is to shift each character of a string over by a certain amount. Whenever a character of a string exited the parameters of a-z or A-Z, you just add or subtract 26, thus "wrapping" your encryption around and back, so that letters are only encrypted into letters. This took me about 30 minutes total to create. Here is my source code:

import sys

def getMode():
    print('Do you want to encrypt decrypt, or brute force a message?')
    mode = raw_input().lower()
    if mode in 'encrypt decrypt e d brute b'.split():
        return mode
    else:
        print('You need to enter in one of the following: e, d, b')

def getMessage():
    print('Enter your message.')
    return raw_input()

def getKey():
    key = 0

    while True:
        print('Enter in a number for your key, 1-25.')
        key = int(raw_input())
        if (key >= 1 and key <= 25):
            return key

def getTranslatedMessage(key, mode, message):
    if mode[0] == 'd':
        key = -key

    translated = ''

    for symbol in message:
        if symbol.isalpha():
            num = ord(symbol)
            num += key

            if symbol.isupper():
                if num > ord('Z'):
                    num -= 26
                elif num < ord('A'):
                    num += 26
            elif symbol.islower():
                if num > ord('z'):
                    num -= 26
                elif num < ord('a'):
                    num += 26

            translated += chr(num)
        else:
            translated += symbol

    return translated

def playAgain():
    print('Do you wish to continue? (yes or no)')
    return raw_input().lower().startswith('y')

Again = True

while True:
    mode = getMode()
    message = getMessage()
    if mode != 'b':
        Key = getKey()
    print('Your translated text is:')
    if mode != 'b':
        print(getTranslatedMessage(Key, mode, message))
    else:
        for key in range(1, 26 + 1):
            print(key, getTranslatedMessage(key, 'decrypt', message))
    if not playAgain():
        sys.exit

The next chapter of this book is here. This chapter goes over the Reversi game. I won't be constructing a program from this chapter as it doesn't really introduce any new concepts. The Ai for the reversi game just runs through each possible move and chooses the one that results in the most points. I will be skipping over chapter 14, and chapter 15, and heading straight into chapter 16. Chapter 16 is going over graphics and animation; I'll be starting to use the Pygame engine.

Sonar

2010-02-24T17:08:00.000-08:00

I have finished up creating a game that functions almost the same as the game in this chapter. The game I created is slightly different in how the code works in a few specific areas, but altogether the example code in this chapter, and mine, should be fairly similar. Here is my source code:

#Sonar

import random
import sys

def drawBoard(board):
    hline = '    '
    for i in range(1, 6):
        hline += (' ' * 9) + str(i)

    print(hline)
    print('   ' + ('0123456789' * 6))
    print('')

    for i in range(15):
        if i < 10:
            es = ' '
        else:
            es = ''
        print('%s%s %s %s' % (es, i, getRow(board, i), i))

    print('')
    print('   ' + ('0123456789' * 6))
    print(hline)

def getRow(board, row):
    boardc = ''

    for i in range(60):
        boardc += board[i][row]
    return boardc

def getNewBoard():
    board = []

    for x in range(60):
        board.append([])
        for y in range(15):
            if random.randint(0, 1) == 1:
                board[x].append('~')
            else:
                board[x].append('`')

    return board

def placeChests(chestAmount):
    chests = []

    for i in range(chestAmount):
        chests.append([random.randint(0, 59), random.randint(0, 14)])
    return chests

def isValidMove(x, y):
    if (x >= 0 and x <= 59 and y >= 0 and y <= 14):
        return True
    else:
        return False

def makeMove(board, chests, x, y):
    if not isValidMove(x, y):
        return False

    smalld = 100
    for cx, cy in chests:
        if (abs(cx - x) > abs(cy - y)):
            distance = abs(cx - x)
        else:
            distance = abs(cy - y)

        if distance < smalld:
            smalld = distance

    if smalld == 0:
        chests.remove([x, y])
        return 'You have found a treasure chest!'
    else:
        if smalld < 10:
            board[x][y] = str(smalld)
            return 'Treasure has been detected at a distance of %s' % (smalld)
        else:
            board[x][y] = '0'
            return 'Treasure is nowhere to be found within range.'

def enterPlayerMove():
    print('Enter in two integers (0-59, 0-14), otherwise type quit to exit the game.')

    while True:
        move = raw_input()
        if move.lower() == 'quit':
            sys.exit

        move = move.split()
        if len(move) == 2 and move[0].isdigit() and move[1].isdigit() and isValidMove(int(move[0]), int(move[1])):
            return [int(move[0]), int(move[1])]

        print('Enter in two integers (0-59, 1-15), otherwise type quit to exit the game.')

def playAgain():
    print('Do you want to play again? (yes or no)')
    return input().lower().startswith('y')

print('S O N A R !')

while True:
    sonarDevices = 16
    theBoard = getNewBoard()
    previousMoves = []
    playerMovec = []
    drawBoard(theBoard)
    print('Where do you want to place your sonar device?')
    secretChests = placeChests(3)

    while sonarDevices > 0:

        if sonarDevices > 1: extraSsonar = 's'
        else: extraSsonar = ''
        if len(secretChests) > 1: extraSchest = 's'
        else: extraSchest = ''
        print('You have %s sonar device%s left. %s treasure chest%s remaining.' % (sonarDevices, extraSsonar, len(secretChests), extraSchest))

        x, y = enterPlayerMove()
        playerMovec.append([x, y])
        result = makeMove(theBoard, secretChests, x, y)

        if sonarDevices < 16:
            if playerMovec[len(previousMoves)-1] == previousMoves[len(previousMoves)-1]:
                sonarDevices -= 1
            else:
                result = False
                drawBoard(theBoard)
                print('You have already placed a sonar device here!')

        previousMoves.append([x, y])

        if sonarDevices == 16:
            sonarDevices -= 1
        if result == False:
            continue
        else:
            if result == 'You have found a treasure chest!':
                for x, y in previousMoves:
                    makeMove(theBoard, secretChests, x, y)
            drawBoard(theBoard)
            print(result)
        if len(secretChests) == 0:
                print('You have found all the sunken treasure chests! Congratulations and good game!')
                break

    if sonarDevices == 0:
        print('We\'ve run out of sonar devices! Now we have to turn the ship around and head')
        print('for home with treasure chests still out there! Game over.')
        print('    The remaining chests were here:')
        for x, y in theChests:
            print('    %s, %s' % (x, y))

    if not playAgain():
        sys.exit()

A large difference between my code, and the example code, is the fact that I have support for allowing the player to suffer no negative penalty (a loss of one of the sonar beacons) for trying to place a sonar over an area that was placed during the previous turn. This honestly, took me forever to figure out how to do. I finally decided on creating two copies of all previous turns, and then use these two copies to see if the last values in the two lists equal one another, before the value in the second list had been appended. This way, I compared the value of entered coordinates to the value of previous coordinates, and didn't subtract from the overall sonar amount when this happened.

The math is simple, and the whole Cartesian Plane didn't really teach me anything new. Although, if you don't understand how the math in my makeMove() function doesn't work, you might need to read over this chapter again.

I plan to go other the thirteenth chapter, here, for my next post. This seems rather interesting, as it is about cryptology.

Let me know if you see something I could improve upon in this code. Hopefully my lack of commenting the code isn't detrimental, if it is let me know and I'll add in comments.

Bagels

2010-02-23T14:54:00.000-08:00

The name of the game I have created for this post, is the game Bagels. Bagels is a game where the user guesses a three digit number, and the computer responds with "Fermi" for every digit that is in the right place that you guessed, and "Pico" for every digit that you guessed which is in the wrong place, but is still a digit in the secret number.

The concepts that this game goes over are hardcoding and nested loops, the chapter is this one: http://inventwithpython.com/chapter10.html.

A nested loop is simply a loop within a loop. This is useful for when you want to iterate something x times, for every time y appears, or something similar.

Hardcoding is a coding practice where the coder codes the program so that changing of simple variables requires changing lots of code. This program was programmed without hardcoding, where a couple constants (variables that do not change while the program is running, which are represented with caps, although, are actually just normal variables in Python) can be changed to change how the game is played.

import random

def getSecretNumbers(numDigits):

    numbers = list(range(10))
    random.shuffle(numbers)

    secretNum = ''
    for i in range(numDigits):
        secretNum += str(numbers[i])

    return secretNum

def getClues(guess, secretNum):

    if guess == secretNum:
        return 'You have guessed the correct number!'

    clue = []

    for i in range(len(guess)):
        if guess[i] == secretNum[i]:
            clue.append('Fermi')
        elif guess[i] in secretNum:
            clue.append('Pico')

    if len(clue) == 0:
        return 'Bagels'

    clue.sort()

    return ' '.join(clue)

def isOnlyDigits(num):

    if num == '':
        return False

    for i in num:
        if i not in '1 2 3 4 5 6 7 8 9'.split():
            return False

    return True

def playAgain():

    print('Do you want to play again? Yes or no.')
    return raw_input().lower().startswith('y')

NUMDIGITS = 3
MAXGUESS = 10

print('I am thinking of a %s-digit number. Try to guess what it is.' % (NUMDIGITS))
print('Here are some clues:')
print('When I say:    That means:')
print(' Pico         One digit is correct but in the wrong position.')
print(' Fermi        One digit is correct and in the right position.')
print(' Bagels       No digit is correct.')

while True:
    secretNum = getSecretNumbers(NUMDIGITS)
    print('I have thought up a number. You have %s guesses to get it.' % (MAXGUESS))

    numGuesses = 1
    while numGuesses <= MAXGUESS:
        guess = ''
        while len(guess) != NUMDIGITS or not isOnlyDigits(guess):
            print('Guess #%s: ' % (numGuesses))
            guess = raw_input()

        clue = getClues(guess, secretNum)
        print(clue)
        numGuesses += 1

        if guess == secretNum:
            break
        if numGuesses > MAXGUESS:
            print('You ran out of guesses. The answer was %s.' % (secretNum))

    if not playAgain():
        break

My code should be pretty much identicle to the code in the example program, as there aren't really any easier ways to code this program; this is a really rather cut and draw program to create.

This part of the program confused me for a moment:

def getSecretNumbers(numDigits):

    numbers = list(range(10))
    random.shuffle(numbers)

These lines create a list of numbers and then shuffle them. When I first saw these lines, the first one confused me: numbers = list(range(10)). I wasn't sure why the auther was changing the range() to list() inside of the range. Although, in the book it explained that if I wanted to store a list of integers, they needed to be converted from an iterator (value of range) into a list. This made sense, although the author didn't go into detail about exactly what the value of a range was. I assume it's just an amount of iterations to perform, which isn't what I would want if I wanted a list to store variables in.

I plan to run through chapter eleven of this book for my next post. This should be a relatively easy chapter, as it just goes through the basics of a Cartesian coordinate system.

Finishing Tic Tac Toe

2010-02-22T19:38:00.000-08:00

Aha! So I coded up my own version of Tic Tac Toe. I did take a look at my old program that I posted up before (here) in a couple spots where I couldn't pinpoint my own bugs, but other than that I wrote this thing without a reference. This, pretty much just solidified my understanding and familiarity of Python syntax even further. Not much else to explain. Here is my source code:

import random

def drawBoard():
   print(board[1] + '|' + board[2] + '|' + board[3])
   print('-----')
   print(board[4] + '|' + board[5] + '|' + board[6])
   print('-----')
   print(board[7] + '|' + board[8] + '|' + board[9])

def pickYourLetter():

   letter = ''

   while (letter != 'X' and letter != 'O'):
   print('Would you like to X or O?')
   letter = raw_input().upper()

   if (letter != 'X' and letter != 'O'):
   print('Uhm, I said X or O.')

   if letter == 'X':
   return ['X', 'O']
   else:
   return ['O', 'X']

def whoGoesFirst():

   if random.randint(0, 1) == 1:
   return 'player'
   else:
   return 'computer'

def getPlayerMove(theBoard):

   move = ' '

   while move not in '1 2 3 4 5 6 7 8 9'.split() or not isSpaceFree(theBoard, int(move)):
   print('It is your turn to move.')
   move = raw_input()

   return int(move)

def isSpaceFree(theBoard, move):

   return board[move] == ' '

def makeMove(board, letter, move):

   board[move] = letter

def isWinner(b, l):
   return ((b[1] == l and b[2] == l and b[3] == l) or
   (b[4] == l and b[5] == l and b[6] == l) or
   (b[7] == l and b[8] == l and b[9] == l) or
   (b[1] == l and b[4] == l and b[7] == l) or
   (b[2] == l and b[5] == l and b[8] == l) or
   (b[3] == l and b[6] == l and b[9] == l) or
   (b[1] == l and b[5] == l and b[9] == l) or
   (b[3] == l and b[5] == l and b[7] == l))

def isTie(board):

   for i in range(1, 10):
   if isSpaceFree(board, i):
   return False

   return True

def getBoardCopy(theBoard):

   dupeBoard = []

   for i in board:
   dupeBoard.append(i)

   return dupeBoard

def getComputerMove(theBoard, letter):

   if computerLetter == 'X':
   playerLetter = 'O'
   else:
   playerLetter = 'X'

   for i in range(1, 10):
   copy = getBoardCopy(theBoard)
   if isSpaceFree(copy, i):
   makeMove(copy, computerLetter, i)
   if isWinner(copy, computerLetter):
   return i

   for i in range(1, 10):
   copy = getBoardCopy(theBoard)
   if isSpaceFree(copy, i):
   makeMove(copy, playerLetter, i)
   if isWinner(copy, playerLetter):
   return i

   move = chooseRandomMove(theBoard, [1, 3, 7, 9])
   if move != None:
   return move

   if isSpaceFree(board, 5):
   return 5

   return chooseRandomMove(board, [2, 4, 6, 8])

def chooseRandomMove(theBoard, moveList):

   moves = []
   for i in moveList:
   if isSpaceFree(theBoard, i):
   moves.append(i)

   if len(moves) != 0:
   return random.choice(moves)
   else:
   return None

def playAgain():

   print('Do you want to play again? (yes or no)')
   return raw_input().lower().startswith('y')



while True:

   board = [' '] * 10
   print('This is Tic Tac Toe.')

   playerLetter, computerLetter = pickYourLetter()

   gameIsPlaying = True
   currentTurn = whoGoesFirst()

   if currentTurn == 'player':
   print('You will move first, as decided at random.')
   else:
   print('The computer will move first, as decided at random.')

   while gameIsPlaying == True:

   if currentTurn == 'player':
   drawBoard()

   move = getPlayerMove(board)
   makeMove(board, playerLetter, move)

   if isWinner(board, playerLetter):
   drawBoard()
   print('You have won the game!')
   gameIsPlaying = False
   else:
   if isTie(board):
   drawBoard()
   print('Game is a tie!!')
   gameIsPlaying = False
   else:
   currentTurn = 'computer'

   else:
   move = getComputerMove(board, computerLetter)
   makeMove(board, computerLetter, move)

   if isWinner(board, computerLetter):
   drawBoard()
   print('You have lost the game!')
   gameIsPlaying = False
   else:
   if isTie(board):
   drawBoard()
   print('Game is a tie!')
   gameIsPlaying = False
   else:
   currentTurn = 'player'

   if not playAgain():
   break

And that is my code. Here is the exe file in case you are interested: http://www.mediafire.com/?oodckz5oxmy

Anyways, I plan to go over this chapter tomorrow and follow through with constructing the program from scratch without referring to the example code http://inventwithpython.com/chapter10.html.

I had a few troubles throughout the program, and the most annoying one was in the definitions of winning. I had constantly placed a 1 in place of a lower case L, and this resulted in bad things. I also had a couple typos here and there, things like typing = instead of ==, and vise versa.

One thing in particular that I found interesting while creating this program, was the "None" value. Here is a quote from the book "Calls to functions that do not return anything (that is, they exit by reaching the end of the function and not from a return statement) will evaluate to None." This was useful in that whenever I wanted the Ai in my simulation to choose a random location to place his letter, say, one of the four corners; if all four of these corners were taken, I could return the value of None instead of one of the values for one of the four corners.

I also learned from this chapter some interesting aspects of list referencing. Take a look at this function:

def makeMove(board, letter, move):
   board[move] = letter

It would seem like this function wouldn't do anything due to the change of the board list being of the private scope by default, since it is happening within the function itself. This is because the word "board" isn't actually the list board, it is just a reference to that list passed onto the function as an argument. This means that when we have the line board[move] = letter we aren't modifying the data stored in a variable, but we are modifying the data stored in the list, which is referenced by the word "board". Here is a quote from the book that explains this: "When you assign a list to a variable with the = sign, you are actually assigning a reference to the list. A reference is a value that points to some bit of data, and a list reference is a value that points to a list."

Starting up Python!

2010-02-22T10:40:00.000-08:00

Well, sadly, I have no more time for C++, and I probably won't for a couple months. Things are getting really busy. Although, I have good news; I started a programming club at my highschool that meets once a week, where I teach them all how to code in Python. For the time being, my next posts will be about my learnings of Python.

I chose Python after doing a little bit of research; Python is a language that was created to allow coders to create code quickly and efficiently. Readability of Python was also a concern while developing the Python environment. As such, Python is great for readability and for quickly coding programs. Although Python is great at what it was intended to be used for, Python isn't made to create highly optimized code for intense programming (things like 3D rendering). Although, you can create visual programs that render in 3D, Python code can only be optimized so much.

I spent this weekend reading some of the chapters from this excellent book on programming games in Python, with the Pygame engine. Here is the book I am currently reading: http://inventwithpython.com/chapters/. I am currently on nine.

I am working with Python 2.6, as this has the most up-to-date third party support from things like Pygame and Py2Exe.

I recommend that anyone reading this check out the Pygame.org website, and sift around through the tutorials there, as well as check out the source code for some of the more simple programs that are on display there.

Over the course of chapter nine, I created a game of TicTacToe. The player can choose to play as X's or O's, and I have a functioning Ai.

At this point in time, I do have a working program, although, I created it while using the example code in the book as reference. As an exercise, my next post will be about me trying to create the entire program without reference code whatsoever.

Here is my source code for my program:

import random

def drawBoard(board):
    #This function draws the board whenever it is called. The board is represented as an array.

    print(' ' + board[7] + ' | ' + board[8] + ' | ' + board[9])
    print('   |   |')
    print('-----------')
    print('   |   |')
    print(' ' + board[4] + ' | ' + board[5] + ' | ' + board[6])
    print('   |   |')
    print('-----------')
    print('   |   |')
    print(' ' + board[1] + ' | ' + board[2] + ' | ' + board[3])
    print('   |   |')

def getPlayerLetter():
    #This function allows the human to choose whether they play as an X or O.

    letter = ''

    while not (letter == 'X' or letter == 'O'):
        print('What would you like to play as? X or O?')
        letter = raw_input().upper()

        if letter != 'X' and letter != 'O':
            print('You can only pick X or O to play as.')

    if letter == 'X':
        return ['X', 'O']
    else:
        return ['O', 'X']

def whoGoesFirst():
    #This function randomly picks which player goes first.

    if random.randint(0, 1) == 1:
        return 'player'
    else:
        return 'computer'

def getPlayerMove(board):
    #Captures the player's input on their desired move for their turn.

    move = ' '

    while move not in '1 2 3 4 5 6 7 8 9'.split() or not isSpaceFree(board, int(move)):
        print('What is your next move?')
        move = raw_input()
    return int(move)

def isSpaceFree(board, move):
    #Return true if the move is available on the board.

    return board[move] == ' '

def makeMove(board, letter, move):
    board[move] = letter

def isWinner(bo, le):
    # Given a board and a player's letter, this function returns True if that player has won.
    # We use bo instead of board and le instead of letter so we don't have to type as much.

    return ((b[7] == l and b[8] == l and b[9] == l) or # across the top
    (b[4] == l and b[5] == l and b[6] == l) or # across the middle
    (b[1] == l and b[2] == l and b[3] == l) or # across the bottom
    (b[7] == l and b[4] == l and b[1] == l) or # down the left side
    (b[8] == l and b[5] == l and b[2] == l) or # down the middle
    (b[9] == l and b[6] == l and b[3] == l) or # down the right side
    (b[7] == l and b[5] == l and b[3] == l) or # diagonal
    (b[9] == l and b[5] == l and b[1] == l)) # diagonal

def isBoardFull(board):
    #Checks to see if the board is full or not.

    for i in range(1, 10):
        if isSpaceFree(board, i):
            return False

    return True

def getComputerMove(board, computerLetter):
    #Determines how to react depending on which letter (X or O) the computer player has.

    if computerLetter == 'X':
        playerLetter = 'O'
    else:
        playerLetter = 'X'

    # Check if the computer can win in the next move.
    for i in range(1, 10):
        copy = getBoardCopy(board)
        if isSpaceFree(copy, i):
            makeMove(copy, computerLetter, i)
            if isWinner(copy, computerLetter):
                return i

    # Check if the player could win on his next move, and block them.
    for i in range(1, 10):
        copy = getBoardCopy(board)
        if isSpaceFree(copy, i):
            makeMove(copy, playerLetter, i)
            if isWinner(copy, playerLetter):
                return i

    # Try to take one of the corners, if they are free.
    move = chooseRandomMoveFromList(board, [1, 3, 7, 9])
    if move != None:
        return move

    # Try to take the center, if it is free.
    if isSpaceFree(board, 5):
        return 5

    # Move on one of the sides.
    return chooseRandomMoveFromList(board, [2, 4, 6, 8])

def chooseRandomMoveFromList(board, movesList):
    # Returns a valid move from the passed list on the passed board.
    # Returns None if there is no valid move.

    possibleMoves = []
    for i in movesList:
        if isSpaceFree(board, i):
            possibleMoves.append(i)

    if len(possibleMoves) != 0:
        return random.choice(possibleMoves)
    else:
        return None

def getBoardCopy(board):
    #This returns a copy of the actual board, used to simulate or test things.

    dupeBoard = []

    for i in board:
        dupeBoard.append(i)

    return dupeBoard

def playAgain():
    # This function returns True if the player wants to play again, otherwise it returns False.

    print('Do you want to play again? (yes or no)')
    return raw_input().lower().startswith('y')


while True:
    #Resets the board.
    theBoard = [' '] * 10
    playerLetter, computerLetter = getPlayerLetter()
    currentTurn = whoGoesFirst()
    print('The ' + currentTurn + ' player will go first.')

    gameIsPlaying = True

    while gameIsPlaying:
        if currentTurn == 'player':
            #Player's turn.

            drawBoard(theBoard)
            move = getPlayerMove(theBoard)
            makeMove(theBoard, playerLetter, move)

            if isWinner(theBoard, playerLetter):
                drawBoard(theBoard)
                print('You have won the game!')
                gameIsPlaying = False
            else:
                if isBoardFull(theBoard):
                    drawBoard(theBoard)
                    print('The game is a tie!')
                    break
                else:
                    currentTurn = 'computer'

        else:
            #Computer player's turn.
            move = getComputerMove(theBoard, computerLetter)
            makeMove(theBoard, computerLetter, move)

            if isWinner(theBoard, computerLetter):
                drawBoard(theBoard)
                print('The computer has beaten you! You lose.')
                gameIsPlaying = False
            else:
                if isBoardFull(theBoard):
                    drawBoard(theBoard)
                    print('The game is a tie!')
                    break
                else:
                    currentTurn = 'player'

    if not playAgain():
        break

As you might notice, this code is pretty darn similar to my reference code. As I mentioned, I will as my next project re-write this entire program without any reference.

I would say that the most interesting part of creating this program, was the Ai. The Ai really only cycles through a copy of the currently existing board, and searches for any winning moves from either player. If it finds one, it takes it. If not, it moves to one of the currently open corners, randomly. If all the corners are taken, the Ai moves into the middle space. If that is taken, it moves onto one of the four last spaces, at random. This algorithm is pretty darn simple, but it is effective at playing Tic Tac Toe.

Overall, I would say I gained a better understanding of Python syntax more than anything while writing this program.

I tried to include a source file, and my exe, although I'm currently having troubles uploading. I'll try to remember to modify this post with some links, in case anyone wanted to download the exe or the source. Edit: No, I will not be supplying the exe//source code this time ;P

C++ Objects

2010-01-07T20:43:00.000-08:00

While reading through chapter one of http://www.planetpdf.com/codecuts/pdfs/eckel/TIC2Vone.zip I learned what classes, objects, and member objects are. I also learned what inheritance and polymorphism are.

To solidify my learning of this chapter, I'll summarize each of these concepts, then go back through the book and confirm what I wrote.

Classes:
Classes are what are known as "types" of objects. A class is simply a group of objects which are related in some way, and programmers can define their own classes, as well as re-use pre-existing classes from other code.

Objects:
Objects are what makes up a class. Similar objects are grouped together into classes, and usually perform very similar functions and share similar behaviors. Objects can be cloned with each clone performing independently of the other clones.

Member Objects:
Member objects are objects from different classes all piled together to construct a new type of class. This concept is known as composition. Composition should be looked to use when creating new classes over inheritance, because it will result in simpler and cleaner designs.

Inheritance:
Inheritance is the act of taking a class and cloning it, then making necessary modifications to it.

Polymorphism:
Polymorphism is the idea of creating code to be executed without being dependent on specific data types. This is useful when you want to treat a variety of objects with the same function call. Although, this means that what code specifically executes won't be determined until runtime. This is where late binding comes into play. Late binding allows the object's properties to determine which actions to take during runtime when a particular function or command is called or sent. This will allow a single call to something like "draw" to be applicable to a wide range of objects of class "shape" without having to worry about which type of shape is being operated upon.

I plan to tomorrow take a look at chapter 2, which covers the implementation of objects in code.

2010-01-06T21:26:00.000-08:00

Just got back from Winter Break. This alone should explain the long span between my two last posts.

In an attempt to keep this blog from becoming a diary, I want to jump straight back into my old daily routine of programming after homework//school.

I have some interesting links to share today. The first link is a link to a site in which I will be basing future studies on. I came across this site via a friend who is in their Junior year of college, and pursuing a degree in CS. He recommended that I read these books and follow along in them: http://www.planetpdf.com/developer/article.asp?ContentID=6634

I will begin with the first book labeled as Volume 1 (filename TIC2Vone.pdf) found at this link: http://www.planetpdf.com/codecuts/pdfs/eckel/TIC2Vone.zip

Before I head into this book, I will also be studying this code: http://codepad.org/aqUQbCTd

That, is code that demonstrates tokenizing in C++ just like I did before, and it creates a square. The difference between this code and my code, is that my code sucks and this doesn't. I will look over this code, understand it, then try to replicate something similar using it as a reference. Once I create a similar console program, I will then try to replicate the code once more without using the linked code as reference (unless I get stuck). This allows me to understand the code at a level of detail that is beneficial to me as I learn to use the C++ language.

Classes

2009-12-05T22:44:00.000-08:00

Well, I was a bit caught up with some last minute homework last week, so I haven't posted in a couple days. Tsk Tsk.

So what I went over today, was the Classes and Classes II page, at both of these links:
http://cplusplus.com/doc/tutorial/classes/
http://cplusplus.com/doc/tutorial/classes2/

I gained an understanding of why classes are useful, and I also found out that they are almost exactly the same as structures, except that the default access of the members of a class is private juxtapose to public.

It was a lot of reading, and some tinkering, to understand both of these pages pretty well. I haven't created any code with the knowledge gained from these two pages, except for just some small modifications to make sure I understood what I was reading. Here is an example: I wrote a small circle class, and then printed the area of my circle:

#include <cstdlib>
#include <iostream>
using namespace std;

class CCircle {
   float x;
   public:
   void set_values (float);
   float area () {return (x*3.14159265*x);}
};

void CCircle::set_values (float a) {
   x = a;
}

int main () {
   CCircle circ, circb, circc;
   circ.set_values (3);
   circb.set_values (5);
   circc.set_values (7);
   cout << "circ area: " << circ.area() << endl;
   cout << "circb area: " << circb.area() << endl;
   cout << "circc area: " << circc.area() << endl;
   system("PAUSE");
   return EXIT_SUCCESS;
}

I plan to go over the next two pages in this tutorial, which are on friendship//inheritance, and polymorphism. Hopefully, I can read through those, and create some small programs like the one I made today. So tomorrow, I will create another small program using a class, and I will also use pointers and dynamic memory to do so. After this, I will read those next to article pages. I also have quite a bit of homework to do tomorrow, so we'll see how far I get.

Lately the articles and blogs on both gamasutra and gamedev.net have been a bit bland, so sadly, I have no interesting articles for anyone to read this time :P