pacman

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