Geisha Studios

The players, both the human and the computer controlled, are represented in the game as an struct.

          
<<player struct definition>>=
typedef struct {
    <<player struct members>>
} player_t;

        

To know where to draw the players as well as use their position to check whether they bounce the ball back or miss, the game must store the players' X and Y coordinates. I’ll limit the screen’s size to 80 characters wide and 25 characters in height, which is the standard size for Windows' console, and thus storing the players' position in a char is enough. I don’t use unsigned char because I need to know when a player tries to go outside the visible screen, and is easier, in terms of logic flow, to rectify a negative coordinate than to prevent it to underflow.

          
<<player struct members>>=
char x;
char y;

        

Players can only move vertically, either up or down, on their side of the screen. They can’t move horizontally. To know in which sense on the vertical direction the player is moving, if any, I’ll need a sense member in the player’s structure. This member can have three values:

          
<<constants>>=
#define SENSE_UP -1
#define SENSE_DOWN 1
#define SENSE_NONE 0

        

Given the limited range of value and that the values can be negative, the sense field can be a char type.

          
<<player struct members>>=
char sense;

        

These values are chosen in such a way that adding the sense value to y, the game updates the player’s vertical position correctly without a need for a check the value of sense.

          
<<update player position function>>=
void
player_update_position(player_t *player)
{
    assert(player != NULL && "Tried to update a NULL player");
    player->y += player->sense;

        

To be able to assert that player is not a NULL pointer before updating the position, I have to include their headers. NULL is defined in stdlib.h.

          
<<headers>>=
#include <assert.h>
#include <stdlib.h>

        

The lowest a player’s position can be is 0, which is the screen’s first. Conversely, the highest a position can be is 24, which is the screen’s lowest row. That is why adding 1 (SENSE_DOWN) to the player’s position moves it down while adding -1 (SENSE_UP) (or subtracting 1) moves it up.

          
<<constants>>=
#define MIN_Y 0
#define MAX_Y 24

        

It is necessary to keep the player within limits when updating the position and set its sense to SENSE_NONE because the player can’t move any further in the current sense.

          
<<update player position function>>=
    if (player->y >= MAX_Y) {
        player->y = MAX_Y;
        player->sense = SENSE_NONE;
    } else if (player->y <= MIN_Y) {
        player->y = MIN_Y;
        player->sense = SENSE_NONE;
    }
}

        

Each player has also an score. Arbitrarily, I’ve chosen 21 to be the maximum possible score, in which case the game ends and whoever reached this amount wins the game.

          
<<constants>>=
#define MAX_SCORE 21

        

Even If I had allowed a larger score, reaching an score of 255 would be frankly boring. Then, storing the score as an unsigned char is enough.

          
<<player struct members>>=
unsigned char score;

        

            
<<set player position function>>=
void
player_set_position(player_t *player, char x, char y)
{
    assert(player != NULL && "Tried to set position to a NULL player.");
    player->x = x;
    player->y = y;
    player->sense = SENSE_NONE;
}

          

            
<<set initial players position>>=
player_set_position(&left_player, LEFT_PLAYER_X, CENTER_Y);
player_set_position(&right_player, RIGHT_PLAYER_X, CENTER_Y);

          

            
<<constants>>=
#define LEFT_PLAYER_X 1
#define RIGHT_PLAYER_X 77
#define CENTER_Y 12

          

            
<<set score to zero>>=
left_player.score = 0;
right_player.score = 0;

          

            
<<constants>>=
#define PADDLE_CHAR (' ' | A_REVERSE)

          

            
<<headers>>=
#include <curses.h>

          

            
<<constants>>=
#define BACKGROUND_CHAR ' '

          

            
<<draw player function>>=
void
player_draw(const player_t *player)
{
    assert(player != NULL && "tried to draw a NULL player.");

    mvaddch(player->y - 3, player->x, BACKGROUND_CHAR);
    mvaddch(player->y - 2, player->x, PADDLE_CHAR);
    mvaddch(player->y - 1, player->x, PADDLE_CHAR);
    mvaddch(player->y + 0, player->x, PADDLE_CHAR);
    mvaddch(player->y + 1, player->x, PADDLE_CHAR);
    mvaddch(player->y + 2, player->x, PADDLE_CHAR);
    mvaddch(player->y + 3, player->x, BACKGROUND_CHAR);
}

          

            
<<draw players>>=
player_draw(&left_player);
player_draw(&right_player);

          

            
<<draw players score>>=
mvprintw(SCORE_Y, LEFT_PLAYER_SCORE_X, "%02i", left_player.score);
mvprintw(SCORE_Y, RIGHT_PLAYER_SCORE_X, "%02i", right_player.score);

          

            
<<constants>>=
#define LEFT_PLAYER_SCORE_X 35
#define RIGHT_PLAYER_SCORE_X 40
#define SCORE_Y 0

          

            
<<set player sense by key function>>=
void
player_set_sense_by_key(player_t *player, int key)
{
    assert(player != NULL && "Tried to set the sense to a NULL player.");
    switch(key) {
        case KEY_UP:
        case 'w':
        case 'k':
            player->sense = (player->sense == SENSE_UP) ? SENSE_NONE : SENSE_UP;
            break;

        case KEY_DOWN:
        case 's':
        case 'j':
            player->sense = (player->sense == SENSE_DOWN) ? SENSE_NONE : SENSE_DOWN;

        default:
            /* Nothing to do.  This key gets ignored. */
            break;
    }
}

          

            
<<get keyboard input>>=
key = getch();
if (key == 'q') {
    quit = 1;
    break;
}
player_set_sense_by_key(&left_player, key);

          

Like the players, the ball is also represented in the game as an struct.

          
<<ball struct definition>>=
typedef struct {
    <<ball struct members>>
} ball_t;

        

Again, the game needs to know where the ball is located on the screen in order to properly draw it and also to check whether it needs to bounce or a player scored. Unlike the players, though, the game will update the ball position using sub-character position, i.e., factional positions, to allow for smoother diagonal movements and more control about the ball’s speed. That means that the x and y positions are floats.

          
<<ball struct members>>=
float x;
float y;

        

When drawing the ball, the game needs to truncate the values of x and y because the curses library requires integer positions to print characters on the terminal.

          
<<draw ball function>>=
void
ball_draw(const ball_t *ball)
{
    mvaddch((int)ball->y, (int)ball->x, BALL_CHAR);
}

        

The character for the ball is a capital O.

          
<<constants>>=
#define BALL_CHAR 'O'

        

Another difference between the players and the ball, is that the ball can move either vertically or horizontally. And, for each direction, it can move in both senses. Therefore, I need to keep two sense members. Both ‘float` to match the coordinates’ type.

          
<<ball struct members>>=
float xsense;
float ysense;

        

The technique used to update the ball’s position is the same used for players, but instead of integers, the senses are floating point numbers. Even so, the same rules apply:

In the case of ysense, though, I allow more that just -1, 0, and 1 as value, because I want to have a ball that changes its speed depending on how it bounces off the players.

          
<<update ball position function>>=
void
ball_update_position(ball_t *ball, const player_t *left_player, const player_t *right_player)
{
    <<update ball position variables>>

    assert (ball != NULL && "Tried to update the position to a NULL ball");
    assert (left_player != NULL && "I can't update the ball position without left player");
    assert (right_player != NULL && "I can't update the ball position without right player");

    ball->x += ball->xsense;
    <<check collision between ball and players>>
    ball->y += ball->ysense;
    <<check collision between ball and walls>>
}

        

            
<<set ball position function>>=
void
ball_set_position(ball_t *ball, float x, float y, float xsense)
{
    assert(ball != NULL && "Tried to set position to a NULL ball.");
    ball->x = x;
    ball->y = y;
    ball->xsense = xsense;
    ball->ysense = ((rand() % 3) / 4.0f) - 0.25f;
}

          

            
<<set initial ball sense>>=
ball.xsense = SENSE_LEFT;

          

            
<<set initial ball position>>=
ball_set_position(&ball, CENTER_X, CENTER_Y, -ball.xsense);

          

            
<<constants>>=
#define CENTER_X 38
#define SENSE_LEFT -1

          

            
<<erase ball function>>=
void
ball_erase(const ball_t *ball)
{
    mvaddch((int)ball->y, (int)ball->x, BACKGROUND_CHAR);
}

          

            
<<check collision between ball and walls>>=
if ((int)ball->y > MAX_Y) {
    ball->y = MAX_Y;
    ball->ysense = -ball->ysense;
} else if ((int)ball->y < MIN_Y ) {
    ball->y = MIN_Y;
    ball->ysense = -ball->ysense;
}

          

            
<<update ball position variables>>=
const player_t *colliding_player = NULL;

          

            
<<check collision between ball and players>>=
if ((int)ball->x == left_player->x && (int)ball->y <= left_player->y + 2 &&
    (int)ball->y >= left_player->y - 2) {
    colliding_player = left_player;
}

          

            
<<check collision between ball and players>>=
else if ((int)ball->x == right_player->x && (int)ball->y <= right_player-> y + 2 &&
    (int)ball->y >= right_player->y - 2) {
    colliding_player = right_player;
}

          

            
<<check collision between ball and players>>=
if (NULL != colliding_player) {
    ball->xsense = -ball->xsense;
    ball->x += 2 * ball->xsense;

          

            
<<check collision between ball and players>>=
    ball->ysense += 0.25f * colliding_player->sense;
}

          

            
<<track ball function>>=
void
player_track_ball(player_t *player, const ball_t *ball)
{
    assert(player != NULL && "Tried to make a NULL player track a ball.");
    assert(ball != NULL && "Tried to track a NULL ball.");

    if ((int)ball->y > player->y) {
        player->sense = SENSE_DOWN;
    } else if ((int)ball->y < player->y) {
        player->sense = SENSE_UP;
    } else {
        player->sense = SENSE_NONE;

          

            
<<track ball function>>=
        if (ball->ysense == SENSE_NONE &&
            (ball->x == player->x + 1) || (ball->x == player->x - 1)) {
            player->sense = (rand() % 3) - 1;
        }
    }
}

          

            
<<init random number generator>>=
srand(time(NULL));

          

            
<<headers>>=
#include <time.h> // for time.
#include <stdlib.h> // for srand and rand.

          

            
<<track ball>>=
player_track_ball(&right_player, &ball);

          

As with any table game, Pong needs to have a net between the two players. For this game it is just a vertical line from the first row to the last on the screen. In this case, the symbol to print to screen is the ACS_VLINE defined in curses.h.

          
<<constants>>=
#define NET_CHAR ACS_VLINE

        

The function that draw the net moves at the center of the first row and print a vertical line down to the last using this character.

          
<<draw net function>>=
void
net_draw()
{
    move(MIN_Y, CENTER_X);
    vline(NET_CHAR, MAX_Y + 1);
}

        

Since this game has no menu, the main’s game loop is implemented inside the main function.

The first thing I need is a variable to know when to stop the game and quit.

          
<<main variables>>=
int quit;

        

This variable is set to FALSE at the very beginning and is only set to to TRUE when the user tells that she wants to quit.

          
<<main>>=
int
main()
{
    <<main variables>>

    quit = FALSE;
    <<initialization routines>>
    while (!quit) {
        <<play game>>
    }
    return EXIT_SUCCESS;
}

        

Before the main game loop starts, the game needs to initialize the curses library, the random number generator, as some of the game’s status, such as the players' score and the initial ball’s sense.

          
<<initialization routines>>=
<<init curses>>
<<init random number generator>>
<<set score to zero>>
<<set initial ball sense>>

        

After that, the game can begin creating the players, the ball and setting their initial position.

          
<<main variables>>=
ball_t ball;
player_t left_player;
player_t right_player;

        

          
<<play game>>=
<<set initial players position>>
<<set initial ball position>>

        

Then it just waits until the user enters space. It needs, thus, a variable to store the player’s input.

          
<<main variables>>=
int key;

        

With this variable it can wait until the user presses ‘space` or q, in which case the game ends. Before that, though, it is nice to see something on the screen so it draws the players’ and ball’s current position, the net, the scores and the net.

          
<<play game>>=
clear();
<<draw players>>
net_draw();
<<draw players score>>
ball_draw(&ball);
refresh();

do {
    key = getch();
    if ('q' == key) {
        quit = TRUE;
        break;
    }
} while (key != ' ');

if (quit) {
    break;
}

        

To avoid moving the ball and paddles on the screen too fast to be playable, the game updates the players' and ball’s position once every some loops. I’ve chosen the values for the players and ball to be the same, but they could be different.

          
<<constants>>=
#define BALL_SPEED 12 /* number of loop before update. */
#define PLAYER_SPEED 12 /* number of loop before update. */

        

To know when to update the positions, I need a pair of variables to keep track of the number of loops remaining before the players and the ball can be updated.

          
<<main variables>>=
int ball_update;
int player_update;

        

These variables are decremented each loop and when reach 0, the player’s position can be updated.

          
<<update players position>>=
if (0 == --player_update) {
    player_update_position(&left_player);
    player_update_position(&right_player);
    player_update = PLAYER_SPEED;
}

        

The same for the ball. But, in the case of the ball, I also need to check whether the ball passed through any of the players. In that case, the game increments the other player’s score and ends the match.

          
<<update ball position>>=
if (0 == --ball_update) {
    ball_erase(&ball);
    ball_update_position(&ball, &left_player, &right_player);
    ball_update = BALL_SPEED;

    if ((int)ball.x < left_player.x) {
        in_match = FALSE;
        ++right_player.score;
    } else if ((int)ball.x > right_player.x) {
        in_match = FALSE;
        ++left_player.score;
    }
}

        

At the match’s beginning, these update variables are at their maximum value.

          
<<play game>>=
ball_update = BALL_SPEED;
player_update = PLAYER_SPEED;

        

After that, the match starts until one of the players scores 21 points.

          
<<main variables>>=
int in_match;

        

          
<<play game>>=
in_match = TRUE;
while (in_match) {
    <<play match>>
}

if (left_player.score >= MAX_SCORE || right_player.score >= MAX_SCORE) {
    quit = TRUE;
}

        

In order to know approximately how much a loop lasts, the game will pause some milliseconds each loop after drawing and after updating the positions. The number of milliseconds I’ve chosen is arbitrary and make the game run fine.

          
<<constants>>=
#define GAME_SPEED 2 /* milliseconds per loop. */

        

          
<<play match>>=
<<draw players>>
net_draw();
<<draw players score>>
ball_draw(&ball);
refresh();
napms(GAME_SPEED);

        

Then we need to get the input from the user in order to update her paddle. The computer player also tracks the ball’s position.

          
<<play match>>=
<<get keyboard input>>
<<track ball>>

        

And, finally, update the players and ball, if necessary, and pause again.

          
<<play match>>=
<<update players position>>
<<update ball position>>
napms(GAME_SPEED);

        

Before the game can draw anything on the screen, it needs to initialize the curses library. The first thing to do, thus, is to initialize the main terminal screen.

initscr will already show an error message and call exit if it can’t initialize the library. That means I don’t need any additional check for errors.

          
<<init curses>>=
initscr();

        

Pong don’t need to show the cursor while writing all the characters around the screen, thus I set it to invisible. If this fails, I ignore any errors and keep the cursor’s visibility.

          
<<init curses>>=
curs_set(0); /* 0 == cursor is invisible. */

        

As input, the game needs to be able to get cursor keys events to move the player. In curses this is translated to a call to keypad. Also, I don’t want to see the input keys on screen, therefore I need to disable the echo.

          
<<init curses>>=
noecho();
keypad(stdscr, TRUE);

        

By default, curses will wait until the user presses enter before giving to the application any other pressed input. As it would be cumbersome to expect the user to press enter every time, I make curses give out which key is entered as soon as it is pressed.

          
<<init curses>>=
raw();

        

What is also not acceptable in this game is for it to pause until the user presses a key when calling getch. To disable this behaviour, I need to call nodelay.

          
<<init curses>>=
nodelay(stdscr, TRUE);

        

Finally, once the game is over and must quit, I need to clean up curses. I will use atexit to clean up the window when exit gets called, but I can’t pass endwin directly as a parameter to this function because the prototypes don’t match: endwin returns an int but atexit expects a function with no parameters that returns nothing. Instead, I’ll write a new function, called cleanup, with the proper function signature for atexit which calls endwin.

          
<<clean up function>>=
void
cleanup()
{
    endwin();
}

        

Now I can use this function to clean up curses at exit.

          
<<init curses>>=
atexit(cleanup);