// SnakeAI.cpp : This file contains the 'main' function. Program execution begins and ends there.
//
#include <iostream>
int main( )
{
std:: cout << "Hello World!\n " ;
}
// Run program: Ctrl + F5 or Debug > Start Without Debugging menu
// Debug program: F5 or Debug > Start Debugging menu
// Tips for Getting Started:
// 1. Use the Solution Explorer window to add/manage files
// 2. Use the Team Explorer window to connect to source control
// 3. Use the Output window to see build output and other messages
// 4. Use the Error List window to view errors
// 5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
// 6. In the future, to open this project again, go to File > Open > Project and select the .sln file
#define ARENA_SIZE 13 * 13
#define ARENA_HEIGHT 13
#define ARENA_WIDTH 13
int tourToNumber[ ARENA_SIZE] ;
/* Take an x,y coordinate, and turn it into an index in the tour */
int getPathNumber( int x, int y) {
return tourToNumber[ x + ARENA_WIDTH * y] ;
}
int path_distance( int a, int b) {
if ( a < b)
return b - a - 1 ;
return b - a - 1 + ARENA_SIZE;
}
struct Maze {
struct Node {
bool visited : 1 ;
bool canGoRight : 1 ;
bool canGoDown : 1 ;
} ;
Node nodes[ ARENA_SIZE / 4 ] ;
void markVisited( int x, int y) {
nodes[ x + y * ARENA_WIDTH / 2 ] .visited = true ;
}
void markCanGoRight( int x, int y) {
nodes[ x + y * ARENA_WIDTH / 2 ] .canGoRight = true ;
}
void markCanGoDown( int x, int y) {
nodes[ x + y * ARENA_WIDTH / 2 ] .canGoDown = true ;
}
bool canGoRight( int x, int y) {
return nodes[ x + y * ARENA_WIDTH / 2 ] .canGoRight ;;
}
bool canGoDown( int x, int y) {
return nodes[ x + y * ARENA_WIDTH / 2 ] .canGoDown ;
}
bool canGoLeft( int x, int y) {
if ( x == 0 ) return false ;
return nodes[ ( x - 1 ) + y * ARENA_WIDTH / 2 ] .canGoRight ;
}
bool canGoUp( int x, int y) {
if ( y == 0 ) return false ;
return nodes[ x + ( y - 1 ) * ARENA_WIDTH / 2 ] .canGoDown ;
}
bool isVisited( int x, int y) {
return nodes[ x + y * ARENA_WIDTH / 2 ] .visited ;
}
void generate( ) {
memset ( nodes, 0 , sizeof ( nodes) ) ;
generate_r( - 1 , - 1 , 0 , 0 ) ;
generateTourNumber( ) ;
#ifdef LOG_TO_FILE
writeMazeToFile( ) ;
writeTourToFile( ) ;
#endif
}
void generate_r( int fromx, int fromy, int x, int y) {
if ( x < 0 || y < 0 || x >= ARENA_WIDTH / 2 || y >= ARENA_HEIGHT / 2 )
return ;
if ( isVisited( x, y) )
return ;
markVisited( x, y) ;
if ( fromx ! = - 1 ) {
if ( fromx < x)
markCanGoRight( fromx, fromy) ;
else if ( fromx > x)
markCanGoRight( x, y) ;
else if ( fromy < y)
markCanGoDown( fromx, fromy) ;
else if ( fromy > y)
markCanGoDown( x, y) ;
//Remove wall between fromx and fromy
}
/* We want to visit the four connected nodes randomly,
* so we just visit two randomly (maybe already visited)
* then just visit them all non-randomly. It's okay to
* visit the same node twice */
for ( int i = 0 ; i < 2 ; i++ ) {
int r = rand ( ) % 4 ;
switch ( r) {
case 0 : generate_r( x, y, x - 1 , y) ; break ;
case 1 : generate_r( x, y, x + 1 , y) ; break ;
case 2 : generate_r( x, y, x, y - 1 ) ; break ;
case 3 : generate_r( x, y, x, y + 1 ) ; break ;
}
}
generate_r( x, y, x - 1 , y) ;
generate_r( x, y, x + 1 , y) ;
generate_r( x, y, x, y + 1 ) ;
generate_r( x, y, x, y - 1 ) ;
}
SnakeDirection findNextDir( int x, int y, SnakeDirection dir) {
if ( dir == Right) {
if ( canGoUp( x, y) )
return Up;
if ( canGoRight( x, y) )
return Right;
if ( canGoDown( x, y) )
return Down;
return Left;
}
else if ( dir == Down) {
if ( canGoRight( x, y) )
return Right;
if ( canGoDown( x, y) )
return Down;
if ( canGoLeft( x, y) )
return Left;
return Up;
}
else if ( dir == Left) {
if ( canGoDown( x, y) )
return Down;
if ( canGoLeft( x, y) )
return Left;
if ( canGoUp( x, y) )
return Up;
return Right;
}
else if ( dir == Up) {
if ( canGoLeft( x, y) )
return Left;
if ( canGoUp( x, y) )
return Up;
if ( canGoRight( x, y) )
return Right;
return Down;
}
return ( SnakeDirection) - 1 ; //Unreachable
}
void setTourNumber( int x, int y, int number) {
if ( getPathNumber( x, y) ! = 0 )
return ; /* Back to the starting node */
tourToNumber[ x + ARENA_WIDTH * y] = number;
}
void generateTourNumber( ) {
const int start_x = 0 ;
const int start_y = 0 ;
int x = start_x;
int y = start_y;
const SnakeDirection start_dir = canGoDown( x, y) ? Up : Left;
SnakeDirection dir = start_dir;
int number = 0 ;
do {
SnakeDirection nextDir = findNextDir( x, y, dir) ;
switch ( dir) {
case Right:
setTourNumber( x * 2 , y * 2 , number++ ) ;
if ( nextDir == dir || nextDir == Down || nextDir == Left)
setTourNumber( x * 2 + 1 , y * 2 , number++ ) ;
if ( nextDir == Down || nextDir == Left)
setTourNumber( x * 2 + 1 , y * 2 + 1 , number++ ) ;
if ( nextDir == Left)
setTourNumber( x * 2 , y * 2 + 1 , number++ ) ;
break ;
case Down:
setTourNumber( x * 2 + 1 , y * 2 , number++ ) ;
if ( nextDir == dir || nextDir == Left || nextDir == Up)
setTourNumber( x * 2 + 1 , y * 2 + 1 , number++ ) ;
if ( nextDir == Left || nextDir == Up)
setTourNumber( x * 2 , y * 2 + 1 , number++ ) ;
if ( nextDir == Up)
setTourNumber( x * 2 , y * 2 , number++ ) ;
break ;
case Left:
setTourNumber( x * 2 + 1 , y * 2 + 1 , number++ ) ;
if ( nextDir == dir || nextDir == Up || nextDir == Right)
setTourNumber( x * 2 , y * 2 + 1 , number++ ) ;
if ( nextDir == Up || nextDir == Right)
setTourNumber( x * 2 , y * 2 , number++ ) ;
if ( nextDir == Right)
setTourNumber( x * 2 + 1 , y * 2 , number++ ) ;
break ;
case Up:
setTourNumber( x * 2 , y * 2 + 1 , number++ ) ;
if ( nextDir == dir || nextDir == Right || nextDir == Down)
setTourNumber( x * 2 , y * 2 , number++ ) ;
if ( nextDir == Right || nextDir == Down)
setTourNumber( x * 2 + 1 , y * 2 , number++ ) ;
if ( nextDir == Down)
setTourNumber( x * 2 + 1 , y * 2 + 1 , number++ ) ;
break ;
}
dir = nextDir;
switch ( nextDir) {
case Right: ++ x; break ;
case Left: -- x; break ;
case Down: ++ y; break ;
case Up: -- y; break ;
}
} while ( number ! = ARENA_SIZE) ; //Loop until we return to the start
}
#ifdef LOG_TO_FILE
void writeTourToFile( ) {
FILE * f = fopen ( "maps.txt" , "w+" ) ;
for ( int y = 0 ; y < ARENA_HEIGHT; ++ y) {
for ( int x = 0 ; x < ARENA_WIDTH; ++ x)
fprintf ( f, "%4d" , getPathNumber( x, y) ) ;
fprintf ( f, "\n " ) ;
}
fclose ( f) ;
}
void writeMazeToFile( ) {
FILE * f = fopen ( "maze.txt" , "w+" ) ;
for ( int y = 0 ; y < ARENA_HEIGHT / 2 ; ++ y) {
fprintf ( f, "#" ) ;
for ( int x = 0 ; x < ARENA_WIDTH / 2 ; ++ x)
if ( canGoRight( x, y) && canGoDown( x, y) )
fprintf ( f, "+" ) ;
else if ( canGoRight( x, y) )
fprintf ( f, "-" ) ;
else if ( canGoDown( x, y) )
fprintf ( f, "|" ) ;
else
fprintf ( f, " " ) ;
fprintf ( f, "#\n " ) ;
}
fclose ( f) ;
}
#endif
} ;
void aiInit( ) {
Maze maze;
maze.generate ( ) ;
}
enum SnakeDirection
{
Right, Left, Up, Down
} ;
SnakeDirection aiGetNewSnakeDirection( int x, int y) {
const int pathNumber = getPathNumber( x, y) ;
const int distanceToFood = path_distance( pathNumber, getPathNumber( food.x , food.y ) ) ;
const int distanceToTail = path_distance( pathNumber, getPathNumber( snake.tail_x , snake.tail_y ) ) ;
int cuttingAmountAvailable = distanceToTail - snake.growth_length - 3 /* Allow a small buffer */ ;
const int numEmptySquaresOnBoard = ARENA_SIZE - snake.drawn_length - snake.growth_length - food.value ;
// If we don't have much space (i.e. snake is 75% of board) then don't take any shortcuts */
if ( numEmptySquaresOnBoard < ARENA_SIZE / 2 )
cuttingAmountAvailable = 0 ;
else if ( distanceToFood < distanceToTail) { /* We will eat the food on the way to the tail, so take that into account */
cuttingAmountAvailable - = food.value ;
/* Once we ate that food, we might end up with another food suddenly appearing in front of us */
if ( ( distanceToTail - distanceToFood) * 4 > numEmptySquaresOnBoard) /* 25% chance of another number appearing */
cuttingAmountAvailable - = 10 ;
}
int cuttingAmountDesired = distanceToFood;
if ( cuttingAmountDesired < cuttingAmountAvailable)
cuttingAmountAvailable = cuttingAmountDesired;
if ( cuttingAmountAvailable < 0 )
cuttingAmountAvailable = 0 ;
// cuttingAmountAvailable is now the maximum amount that we can cut by
bool canGoRight = ! check_for_collision( x + 1 , y) ;
bool canGoLeft = ! check_for_collision( x - 1 , y) ;
bool canGoDown = ! check_for_collision( x, y + 1 ) ;
bool canGoUp = ! check_for_collision( x, y - 1 ) ;
SnakeDirection bestDir;
int bestDist = - 1 ;
if ( canGoRight) {
int dist = path_distance( pathNumber, getPathNumber( x + 1 , y) ) ;
if ( dist <= cuttingAmountAvailable && dist > bestDist) {
bestDir = Right;
bestDist = dist;
}
}
if ( canGoLeft) {
int dist = path_distance( pathNumber, getPathNumber( x - 1 , y) ) ;
if ( dist <= cuttingAmountAvailable && dist > bestDist) {
bestDir = Left;
bestDist = dist;
}
}
if ( canGoDown) {
int dist = path_distance( pathNumber, getPathNumber( x, y + 1 ) ) ;
if ( dist <= cuttingAmountAvailable && dist > bestDist) {
bestDir = Down;
bestDist = dist;
}
}
if ( canGoUp) {
int dist = path_distance( pathNumber, getPathNumber( x, y - 1 ) ) ;
if ( dist <= cuttingAmountAvailable && dist > bestDist) {
bestDir = Up;
bestDist = dist;
}
}
if ( bestDist >= 0 )
return bestDir;
if ( canGoUp)
return Up;
if ( canGoLeft)
return Left;
if ( canGoDown)
return Down;
if ( canGoRight)
return Right;
return Right;
}
// SnakeAI.cpp : This file contains the 'main' function. Program execution begins and ends there.
//

#include <iostream>

int main()
{
    std::cout << "Hello World!\n";
}

// Run program: Ctrl + F5 or Debug > Start Without Debugging menu
// Debug program: F5 or Debug > Start Debugging menu

// Tips for Getting Started: 
//   1. Use the Solution Explorer window to add/manage files
//   2. Use the Team Explorer window to connect to source control
//   3. Use the Output window to see build output and other messages
//   4. Use the Error List window to view errors
//   5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
//   6. In the future, to open this project again, go to File > Open > Project and select the .sln file
#define ARENA_SIZE 13 * 13
#define ARENA_HEIGHT 13
#define ARENA_WIDTH 13

int tourToNumber[ARENA_SIZE];

/* Take an x,y coordinate, and turn it into an index in the tour */
int getPathNumber(int x, int y) {
    return tourToNumber[x + ARENA_WIDTH * y];
}

int path_distance(int a, int b) {
    if (a < b)
        return b - a - 1;
    return b - a - 1 + ARENA_SIZE;
}

struct Maze {
    struct Node {
        bool visited : 1;
        bool canGoRight : 1;
        bool canGoDown : 1;
    };
    Node nodes[ARENA_SIZE / 4];
    void markVisited(int x, int y) {
        nodes[x + y * ARENA_WIDTH / 2].visited = true;
    }
    void markCanGoRight(int x, int y) {
        nodes[x + y * ARENA_WIDTH / 2].canGoRight = true;
    }
    void markCanGoDown(int x, int y) {
        nodes[x + y * ARENA_WIDTH / 2].canGoDown = true;
    }
    bool canGoRight(int x, int y) {
        return nodes[x + y * ARENA_WIDTH / 2].canGoRight;;
    }
    bool canGoDown(int x, int y) {
        return nodes[x + y * ARENA_WIDTH / 2].canGoDown;
    }
    bool canGoLeft(int x, int y) {
        if (x == 0) return false;
        return nodes[(x - 1) + y * ARENA_WIDTH / 2].canGoRight;
    }

    bool canGoUp(int x, int y) {
        if (y == 0) return false;
        return nodes[x + (y - 1) * ARENA_WIDTH / 2].canGoDown;
    }

    bool isVisited(int x, int y) {
        return nodes[x + y * ARENA_WIDTH / 2].visited;
    }

    void generate() {
        memset(nodes, 0, sizeof(nodes));
        generate_r(-1, -1, 0, 0);
        generateTourNumber();
       #ifdef LOG_TO_FILE
        writeMazeToFile();
        writeTourToFile();
       #endif
    }

    void generate_r(int fromx, int fromy, int x, int y) {
        if (x < 0 || y < 0 || x >= ARENA_WIDTH / 2 || y >= ARENA_HEIGHT / 2)
            return;
        if (isVisited(x, y))
            return;
        markVisited(x, y);

        if (fromx != -1) {
            if (fromx < x)
                markCanGoRight(fromx, fromy);
            else if (fromx > x)
                markCanGoRight(x, y);
            else if (fromy < y)
                markCanGoDown(fromx, fromy);
            else if (fromy > y)
                markCanGoDown(x, y);

            //Remove wall between fromx and fromy
        }

        /* We want to visit the four connected nodes randomly,
         * so we just visit two randomly (maybe already visited)
         * then just visit them all non-randomly.  It's okay to
         * visit the same node twice */
        for (int i = 0; i < 2; i++) {
            int r = rand() % 4;
            switch (r) {
            case 0: generate_r(x, y, x - 1, y); break;
            case 1: generate_r(x, y, x + 1, y); break;
            case 2: generate_r(x, y, x, y - 1); break;
            case 3: generate_r(x, y, x, y + 1); break;
            }
        }
        generate_r(x, y, x - 1, y);
        generate_r(x, y, x + 1, y);
        generate_r(x, y, x, y + 1);
        generate_r(x, y, x, y - 1);
    }

    SnakeDirection findNextDir(int x, int y, SnakeDirection dir) {
        if (dir == Right) {
            if (canGoUp(x, y))
                return Up;
            if (canGoRight(x, y))
                return Right;
            if (canGoDown(x, y))
                return Down;
            return Left;
        }
        else if (dir == Down) {
            if (canGoRight(x, y))
                return Right;
            if (canGoDown(x, y))
                return Down;
            if (canGoLeft(x, y))
                return Left;
            return Up;
        }
        else if (dir == Left) {
            if (canGoDown(x, y))
                return Down;
            if (canGoLeft(x, y))
                return Left;
            if (canGoUp(x, y))
                return Up;
            return Right;
        }
        else if (dir == Up) {
            if (canGoLeft(x, y))
                return Left;
            if (canGoUp(x, y))
                return Up;
            if (canGoRight(x, y))
                return Right;
            return Down;
        }
        return (SnakeDirection)-1; //Unreachable
    }
    void setTourNumber(int x, int y, int number) {
        if (getPathNumber(x, y) != 0)
            return; /* Back to the starting node */
        tourToNumber[x + ARENA_WIDTH * y] = number;
    }

    void generateTourNumber() {
        const int start_x = 0;
        const int start_y = 0;
        int x = start_x;
        int y = start_y;
        const SnakeDirection start_dir = canGoDown(x, y) ? Up : Left;
        SnakeDirection dir = start_dir;
        int number = 0;
        do {
            SnakeDirection nextDir = findNextDir(x, y, dir);
            switch (dir) {
            case Right:
                setTourNumber(x * 2, y * 2, number++);
                if (nextDir == dir || nextDir == Down || nextDir == Left)
                    setTourNumber(x * 2 + 1, y * 2, number++);
                if (nextDir == Down || nextDir == Left)
                    setTourNumber(x * 2 + 1, y * 2 + 1, number++);
                if (nextDir == Left)
                    setTourNumber(x * 2, y * 2 + 1, number++);
                break;
            case Down:
                setTourNumber(x * 2 + 1, y * 2, number++);
                if (nextDir == dir || nextDir == Left || nextDir == Up)
                    setTourNumber(x * 2 + 1, y * 2 + 1, number++);
                if (nextDir == Left || nextDir == Up)
                    setTourNumber(x * 2, y * 2 + 1, number++);
                if (nextDir == Up)
                    setTourNumber(x * 2, y * 2, number++);
                break;
            case Left:
                setTourNumber(x * 2 + 1, y * 2 + 1, number++);
                if (nextDir == dir || nextDir == Up || nextDir == Right)
                    setTourNumber(x * 2, y * 2 + 1, number++);
                if (nextDir == Up || nextDir == Right)
                    setTourNumber(x * 2, y * 2, number++);
                if (nextDir == Right)
                    setTourNumber(x * 2 + 1, y * 2, number++);
                break;
            case Up:
                setTourNumber(x * 2, y * 2 + 1, number++);
                if (nextDir == dir || nextDir == Right || nextDir == Down)
                    setTourNumber(x * 2, y * 2, number++);
                if (nextDir == Right || nextDir == Down)
                    setTourNumber(x * 2 + 1, y * 2, number++);
                if (nextDir == Down)
                    setTourNumber(x * 2 + 1, y * 2 + 1, number++);
                break;
            }
            dir = nextDir;

            switch (nextDir) {
            case Right: ++x; break;
            case Left: --x; break;
            case Down: ++y; break;
            case Up: --y; break;
            }

        } while (number != ARENA_SIZE); //Loop until we return to the start
    }
#ifdef LOG_TO_FILE
    void writeTourToFile() {
        FILE* f = fopen("maps.txt", "w+");
        for (int y = 0; y < ARENA_HEIGHT; ++y) {
            for (int x = 0; x < ARENA_WIDTH; ++x)
                fprintf(f, "%4d", getPathNumber(x, y));
            fprintf(f, "\n");
        }
        fclose(f);
    }
    void writeMazeToFile() {
        FILE* f = fopen("maze.txt", "w+");
        for (int y = 0; y < ARENA_HEIGHT / 2; ++y) {
            fprintf(f, "#");
            for (int x = 0; x < ARENA_WIDTH / 2; ++x)
                if (canGoRight(x, y) && canGoDown(x, y))
                    fprintf(f, "+");
                else if (canGoRight(x, y))
                    fprintf(f, "-");
                else if (canGoDown(x, y))
                    fprintf(f, "|");
                else
                    fprintf(f, " ");
            fprintf(f, "#\n");
        }
        fclose(f);
    }
#endif
};

void aiInit() {
    Maze maze;
    maze.generate();
}

enum SnakeDirection
{
    Right, Left, Up, Down
};

SnakeDirection aiGetNewSnakeDirection(int x, int y) {
    const int pathNumber = getPathNumber(x, y);
    const int distanceToFood = path_distance(pathNumber, getPathNumber(food.x, food.y));
    const int distanceToTail = path_distance(pathNumber, getPathNumber(snake.tail_x, snake.tail_y));
    int cuttingAmountAvailable = distanceToTail - snake.growth_length - 3 /* Allow a small buffer */;
    const int numEmptySquaresOnBoard = ARENA_SIZE - snake.drawn_length - snake.growth_length - food.value;
    // If we don't have much space (i.e. snake is 75% of board) then don't take any shortcuts */
    if (numEmptySquaresOnBoard < ARENA_SIZE / 2)
        cuttingAmountAvailable = 0;
    else if (distanceToFood < distanceToTail) { /* We will eat the food on the way to the tail, so take that into account */
        cuttingAmountAvailable -= food.value;
        /* Once we ate that food, we might end up with another food suddenly appearing in front of us */
        if ((distanceToTail - distanceToFood) * 4 > numEmptySquaresOnBoard) /* 25% chance of another number appearing */
            cuttingAmountAvailable -= 10;
    }
    int cuttingAmountDesired = distanceToFood;
    if (cuttingAmountDesired < cuttingAmountAvailable)
        cuttingAmountAvailable = cuttingAmountDesired;
    if (cuttingAmountAvailable < 0)
        cuttingAmountAvailable = 0;
    // cuttingAmountAvailable is now the maximum amount that we can cut by

    bool canGoRight = !check_for_collision(x + 1, y);
    bool canGoLeft = !check_for_collision(x - 1, y);
    bool canGoDown = !check_for_collision(x, y + 1);
    bool canGoUp = !check_for_collision(x, y - 1);

    SnakeDirection bestDir;
    int bestDist = -1;
    if (canGoRight) {
        int dist = path_distance(pathNumber, getPathNumber(x + 1, y));
        if (dist <= cuttingAmountAvailable && dist > bestDist) {
            bestDir = Right;
            bestDist = dist;
        }
    }
    if (canGoLeft) {
        int dist = path_distance(pathNumber, getPathNumber(x - 1, y));
        if (dist <= cuttingAmountAvailable && dist > bestDist) {
            bestDir = Left;
            bestDist = dist;
        }
    }
    if (canGoDown) {
        int dist = path_distance(pathNumber, getPathNumber(x, y + 1));
        if (dist <= cuttingAmountAvailable && dist > bestDist) {
            bestDir = Down;
            bestDist = dist;
        }
    }
    if (canGoUp) {
        int dist = path_distance(pathNumber, getPathNumber(x, y - 1));
        if (dist <= cuttingAmountAvailable && dist > bestDist) {
            bestDir = Up;
            bestDist = dist;
        }
    }
    if (bestDist >= 0)
        return bestDir;

    if (canGoUp)
        return Up;
    if (canGoLeft)
        return Left;
    if (canGoDown)
        return Down;
    if (canGoRight)
        return Right;
    return Right;
}