Pacman Game in C++

A simple console application or a quick clip game called Pacman Game in C was made for entertainment. Similar to the snake game, Pacman needs to be moved such that he travels along a predefined blue route before it is erased or eaten by Pacman. The game is easy to play and awards points for clearing paths as you go. Here you may get the source code and output screens for this project.

Program Breakdown

# include < iostream >
# include < stdio.h >
# include < windows.h >
# include < string >
# include < vector >

We are including all the necessary files required in our code.

char tmp_map [ 18 ] [ 32 ] ;
char map [ 18 ] [ 32 ] = {
    " +#############################+ " , 
    " |                             |",
    " |                             | " ,
    " | ## ########### ##   ######### | " ,
    " |   |                         | " ,
    " | | | ### |  |           |     | " ,
    "| |      |  | | ###  |   |  |  | " ,
    "| | #####|  | |      ## |     | " ,
    " | |           | ###  |      |  | " ,
    " | | ##### ###         ##       | " ,
    " |          ######  ####### ### | " ,
    " |                             | " ,
    " | # ### ####      ###   ####### | " ,
    " |                             | " ,
    " |                             | " ,
    " |                             | " ,
    " |                             | " ,
    " + ############################# + " } ;

We are declaring the structure of our game with the help of map of char type.

void ShowMap ( )
{
    for ( int i = 0 ;  i < 18 ; I + + )
    {
        Printf ( " % s \ n " , map [ i ] ) ;
    }
}

The above peace of code is used to print show the map of our game.

void gotoxy ( short x , short y )
{
    HANDLE hStdout = GetStdHandle ( STD_OUTPUT_HANDLE ) ;
    COORD position = { x , y } ;
    SetConsoleCursorPosition ( hStdout , position ) ;
}

The above peace of code show the position of pacman initially.

class entity
{
public:
    entity(int x, int y)
    {
        this->x = x;
        this->y = y;
    }

    void move_x(int p)
    {
        if (map[y][x + p] == ' ')
            x += p;
    }

    void move_y(int p)
    {
        if (map[y + p][x] == ' ')
            y += p;
    }

    void move(int p, int q)
    {
        x += p;
        y += q;
    }

    int get_x() { return x; }
    int get_y() { return y; }

    void draw(char p)
    {
        map[x][y] = p;
        gotoxy(x, y);
        printf("%c", p);
    }
private :
    int x ;
    int y ;
} ;
struct walk
{
    short walk_count ;
    short x ;
    short y ;
    short back ;
} ;
struct target
{
    short x ;
    short y ;
} ;

The above class entity is used to make our pacman move or walk in the map.

void AddArray ( int x , int y , int wc , int back )
{
    if ( tmp_map [ y ] [ x ] == ' ' || tmp_map [ y ] [ x ] == ' . ' )
    {
        tmp_map [ y ] [ x ] = ' # ' ;
        walk tmp ;
        tmp.x = x ;
        tmp.y = y ;
        tmp.walk_count = wc ;
        tmp.back = back ;
        BFSArray.push_back ( tmp ) ;
    }
}

The above peace of code will show the position of the pacman after it moves.

void FindPath ( int sx , int sy , int x , int y )
{
    memcpy ( tmp_map , map , sizeof ( map ) ) ;
    BFSArray . clear ( ) ;
    walk tmp ;
    tmp.x = sx ;
    tmp.y = sy ;
    tmp.walk_count = 0 ;
    tmp.back = -1 ;
    BFSArray.push_back ( tmp ) ;

    int i = 0 ;
    while ( i < BFSArray.size ( ) )
    {
        if ( BFSArray [ i ].x = = x & & BFSArray [ i ]. y = = y )
        {
            walk_queue.clear ( ) ;
            target tmp2 ;
            while ( BFSArray [ i ] . walk_count ! = 0 )
            {
                tmp2 . x = BFSArray [ i ] . x ;
                tmp2 . y = BFSArray [ i ] . y ;
                walk_queue . push_back ( tmp2 ) ;

                i = BFSArray [ i ] . back ;
            }
            break ;
        }
        AddArray ( BFSArray [ i ] . x + 1 , BFSArray [ i ] . y , BFSArray [ i ] . walk_count + 1 , i ) ;
        AddArray ( BFSArray [ i ] . x - 1 , BFSArray [ i ] . y , BFSArray [ i ] . walk_count + 1 , i ) ;
        AddArray ( BFSArray [ i ] . x , BFSArray [ i ] . y + 1 , BFSArray [ i ] . walk_count + 1 , i ) ;
        AddArray ( BFSArray [ i ] . x , BFSArray [ i ] . y - 1 , BFSArray [ i ] . walk_count + 1 , i ) ;

        /*
            AddArray ( BFSArray [ i ] . x + 1 , BFSArray [ i ] . y + 1 , BFSArray [ i ] . walk_count + 1 , i ) ;
            AddArray ( BFSArray [ i ] . x - 1 , BFSArray [ i ] . y + 1 , BFSArray [ i ] . walk_count + 1 , i ) ;
            AddArray ( BFSArray [ i ] . x + 1 , BFSArray [ i ] . y + 1 , BFSArray [ i ] . walk_count + 1 , i ) ;
            AddArray ( BFSArray [ i ] . x + 1 , BFSArray [ i ] . y - 1 , BFSArray [ i ] . walk_count + 1 , i ) ;

            AddArray( BFSArray [ i ] . x + 1 , BFSArray [ i ] . y - 1 , BFSArray [ i ] . walk_count + 1 , i ) ;
            AddArray( BFSArray [ i ] . x - 1 , BFSArray [ i ] . y - 1 , BFSArray [ i ] . walk_count + 1 , i ) ;
            AddArray( BFSArray [ i ] . x - 1 , BFSArray [ i ] . y + 1 , BFSArray [ i ] . walk_count + 1 , i ) ;
            AddArray( BFSArray [ i ] . x - 1 , BFSArray [ i ] . y - 1 , BFSArray [ i ] . walk_count + 1 , i ) ;
        */
        i++ ;
    }

    BFSArray . clear ( ) ;
}

This function is used by pacman to detect or find the path.

int main ( )
{
    bool running = true ;
    int x = 15 ; // hero x
    int y = 16 ; // hero y
    int old_x ;
    int old_y ; 
    int ex = 1 ;
    int ey = 1 ;

    int pts = 0 ;

    printf ( " Instruction : \ n1. Arrow Keys to move your hero \ n2. Eat the dots produced by the Eater to gain poins \ n3. Don't get caught by the Eater \ n \ n");
    printf ( " H -> Hard \ n N -> Normal \ n E -> Easy \ n \ n Input : " ) ;

In this part of driver code the user will be give instruction like arrow key to move your hero, eat the dots produced by the eater to gain points and don't get caught by the eater. It will also ask for hard, normal or easy level.

char diffi ;
    int speedmod = 3 ; 
    cin >> diffi ;

    if ( diffi = = ' N ' )
    {
        speedmod = 2 ;
    }
    else if ( diffi = = ' H ' )
    {
        speedmod = 1 ;
    }

    system ( " cls " ) ;
    ShowMap ( ) ;

    gotoxy ( x , y ) ;
    cout << " H " ;

    int frame = 0 ;

    FindPath ( ex , ey , x , y ) ;

    while ( running )
    {
        gotoxy ( x , y ) ;
        cout << " " ;

        old_x = x ;
        old_y = y ;

        if ( GetAsyncKeyState ( VK_UP ) )
        {
            if ( map [ y - 1 ] [ x ] = = ' . ' )
            {
                y - - ;
                pts + + ;
            }
            else if ( map [ y - 1 ] [ x ] = = ' ' )
                y - - ;
        }
        if ( GetAsyncKeyState ( VK_DOWN ) )
        {
            if ( map [ y + 1 ] [ x ] = = ' . ' )
            {
                y + + ;
                pts + + ;
            }
            else if ( map [ y + 1 ] [ x ] = = ' ' )
                y + + ;
        }

If the user has selected for H,N or E, the speed will increase accordingly.

Program for Pacman Game in C++

#include <iostream>
#include <stdio.h>
#include <windows.h>
#include <string>
#include <vector>
using namespace std;
char tmp_map[18][32];
char map[18][32] = {
    "+#############################+",
    "|                             |",
    "|                             |",
    "|## ########### ##   #########|",
    "|   |                         |",
    "| | |### |  |           |     |",
    "| |      |  | |###  |   |  |  |",
    "| | #####|  | |      ## |     |",
    "| |           |###  |      |  |",
    "| |##### ###         ##       |",
    "|          ######  ####### ###|",
    "|                             |",
    "|# ### ####      ###   #######|",
    "|                             |",
    "|                             |",
    "|                             |",
    "|                             |",
    "+#############################+"};

void ShowMap()
{
    for (int i = 0; i < 18; i++)
    {
        printf("%s\n", map[i]);
    }
}

void gotoxy(short x, short y)
{
    HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    COORD position = {x, y};

    SetConsoleCursorPosition(hStdout, position);
}

class entity
{
public:
    entity(int x, int y)
    {
        this->x = x;
        this->y = y;
    }

    void move_x(int p)
    {
        if (map[y][x + p] == ' ')
            x += p;
    }

    void move_y(int p)
    {
        if (map[y + p][x] == ' ')
            y += p;
    }

    void move(int p, int q)
    {
        x += p;
        y += q;
    }

    int get_x() { return x; }
    int get_y() { return y; }

    void draw(char p)
    {
        map[x][y] = p;
        gotoxy(x, y);
        printf("%c", p);
    }

private:
    int x;
    int y;
};

struct walk
{
    short walk_count;
    short x;
    short y;
    short back;
};

struct target
{
    short x;
    short y;
};

vector<target> walk_queue;

vector<walk> BFSArray;

void AddArray(int x, int y, int wc, int back)
{
    if (tmp_map[y][x] == ' ' || tmp_map[y][x] == '.')
    {
        tmp_map[y][x] = '#';
        walk tmp;
        tmp.x = x;
        tmp.y = y;
        tmp.walk_count = wc;
        tmp.back = back;
        BFSArray.push_back(tmp);
    }
}

void FindPath(int sx, int sy, int x, int y)
{
    memcpy(tmp_map, map, sizeof(map));
    BFSArray.clear();
    walk tmp;
    tmp.x = sx;
    tmp.y = sy;
    tmp.walk_count = 0;
    tmp.back = -1;
    BFSArray.push_back(tmp);

    int i = 0;
    while (i < BFSArray.size())
    {
        if (BFSArray[i].x == x && BFSArray[i].y == y)
        {
            walk_queue.clear();
            target tmp2;
            while (BFSArray[i].walk_count != 0)
            {
                tmp2.x = BFSArray[i].x;
                tmp2.y = BFSArray[i].y;
                walk_queue.push_back(tmp2);

                i = BFSArray[i].back;
            }

            break;
        }

        AddArray(BFSArray[i].x + 1, BFSArray[i].y, BFSArray[i].walk_count + 1, i);
        AddArray(BFSArray[i].x - 1, BFSArray[i].y, BFSArray[i].walk_count + 1, i);
        AddArray(BFSArray[i].x, BFSArray[i].y + 1, BFSArray[i].walk_count + 1, i);
        AddArray(BFSArray[i].x, BFSArray[i].y - 1, BFSArray[i].walk_count + 1, i);

        /*
            AddArray( BFSArray[i].x+1, BFSArray[i].y+1, BFSArray[i].walk_count+1, i );
            AddArray( BFSArray[i].x-1, BFSArray[i].y+1, BFSArray[i].walk_count+1, i );
            AddArray( BFSArray[i].x+1, BFSArray[i].y+1, BFSArray[i].walk_count+1, i );
            AddArray( BFSArray[i].x+1, BFSArray[i].y-1, BFSArray[i].walk_count+1, i );

            AddArray( BFSArray[i].x+1, BFSArray[i].y-1, BFSArray[i].walk_count+1, i );
            AddArray( BFSArray[i].x-1, BFSArray[i].y-1, BFSArray[i].walk_count+1, i );
            AddArray( BFSArray[i].x-1, BFSArray[i].y+1, BFSArray[i].walk_count+1, i );
            AddArray( BFSArray[i].x-1, BFSArray[i].y-1, BFSArray[i].walk_count+1, i );
        */
        i++;
    }

    BFSArray.clear();
}

int main()
{
    bool running = true;
    int x = 15; // hero x
    int y = 16; // hero y
    int old_x;
    int old_y;

    int ex = 1;
    int ey = 1;

    int pts = 0;

    printf("Instruction:\n1. Arrow Keys to move your hero\n2. Eat the dots produced by the Eater to gain poins\n3. Don't get caught by the Eater\n\n");
    printf("H -> Hard\nN -> Normal\nE -> Easy\n\nInput : ");

    char diffi;
    int speedmod = 3;

    cin >> diffi;

    if (diffi == 'N')
    {
        speedmod = 2;
    }
    else if (diffi == 'H')
    {
        speedmod = 1;
    }

    system("cls");
    ShowMap();

    gotoxy(x, y);
    cout << "H";

    int frame = 0;

    FindPath(ex, ey, x, y);

    while (running)
    {
        gotoxy(x, y);
        cout << " ";

        old_x = x;
        old_y = y;

        if (GetAsyncKeyState(VK_UP))
        {
            if (map[y - 1][x] == '.')
            {
                y--;
                pts++;
            }
            else if (map[y - 1][x] == ' ')
                y--;
        }
        if (GetAsyncKeyState(VK_DOWN))
        {
            if (map[y + 1][x] == '.')
            {
                y++;
                pts++;
            }
            else if (map[y + 1][x] == ' ')
                y++;
        }
        if (GetAsyncKeyState(VK_LEFT))
        {
            if (map[y][x - 1] == '.')
            {
                x--;
                pts++;
            }
            else if (map[y][x - 1] == ' ')
                x--;
        }
        if (GetAsyncKeyState(VK_RIGHT))
        {
            if (map[y][x + 1] == '.')
            {
                x++;
                pts++;
            }
            else if (map[y][x + 1] == ' ')
                x++;
        }

        if (old_x != x || old_y != y)
        {
            FindPath(ex, ey, x, y);
        }

        gotoxy(x, y);
        cout << "H";

        map[ey][ex] = '.';
        gotoxy(ex, ey);
        cout << ".";

        if (frame % speedmod == 0 && walk_queue.size() != 0)
        {
            ex = walk_queue.back().x;
            ey = walk_queue.back().y;
            walk_queue.pop_back();
        }

        gotoxy(ex, ey);
        cout << "E";

        if (ex == x && ey == y)
        {
            break;
        }

        gotoxy(32, 18);
        gotoxy(32, 1);
        cout << pts;
        Sleep(100);
        frame++;
    }

    system("cls");
    printf("You Lose and your score is : %i", pts);
    cin.get();
    cin.get();
    cin.get();
    cin.get();
    cin.get();
    cin.get();
    cin.get();
    cin.get();

    return 0;
}

Output:

Instruction:
1. Arrow Keys to move your hero
2. Eat the dots produced by the Eater to gain poins
3. Don't get caught by the Eater
H -> Hard
N -> Normal
E -> Easy

Input : N
+#############################+
|...                          | 0
|  .                          |
|##.########### ##   #########|
|  .|                         |
| |.|### |  |           |     |
| |.     |  | |###  |   |  |  |
| |.#####|  | |      ## |     |
| |......     |###  |      |  |
| |#####.###         ##       |
|       ..E ######  ####### ###|
|                             |
|# ### ####      ###   #######|
|                             |
|                             |
|                             |
|              H              |
+#############################+

You Lose and your score is : 0

Next TopicBilling Management System in C++

← prev next →