Pacman Game In C++

pacman is one of the most famous game in all over the world . In this game there is a pac-man ( H) and Eater (E) .Eat the dots produced by the Eater to gain points . If your pac-man get collapse with eater game will over . You move your hero with arrow keys and keep running away from eater and eat the dots to increase points . You can select one of three difficulty  modes  to make game more interesting.

This program is in object oriented approach focus on to make it easy to understand if you have any query you can comment below. 

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

 cout<<"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";
 cout<<"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");
 cout<<"You Lose and your score is : "<< pts<<endl ;
 cin.get();
 cin.get();
 cin.get();
 cin.get();
 cin.get();
 cin.get();
 cin.get();
 cin.get();

 return 0;
}