fork download

copy

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

prog.cpp:123:5: error: ‘SnakeDirection’ does not name a type
     SnakeDirection findNextDir(int x, int y, SnakeDirection dir) {
     ^~~~~~~~~~~~~~
prog.cpp: In member function ‘void Maze::generate()’:
prog.cpp:75:9: error: ‘memset’ was not declared in this scope
         memset(nodes, 0, sizeof(nodes));
         ^~~~~~
prog.cpp:75:9: note: ‘memset’ is defined in header ‘<cstring>’; did you forget to ‘#include <cstring>’?
prog.cpp:5:1:
+#include <cstring>
 
prog.cpp:75:9:
         memset(nodes, 0, sizeof(nodes));
         ^~~~~~
prog.cpp: In member function ‘void Maze::generateTourNumber()’:
prog.cpp:173:15: error: ‘SnakeDirection’ does not name a type
         const SnakeDirection start_dir = canGoDown(x, y) ? Up : Left;
               ^~~~~~~~~~~~~~
prog.cpp:174:9: error: ‘SnakeDirection’ was not declared in this scope
         SnakeDirection dir = start_dir;
         ^~~~~~~~~~~~~~
prog.cpp:177:27: error: expected ‘;’ before ‘nextDir’
             SnakeDirection nextDir = findNextDir(x, y, dir);
                           ^~~~~~~~
                           ;
prog.cpp:178:21: error: ‘dir’ was not declared in this scope
             switch (dir) {
                     ^~~
prog.cpp:178:21: note: suggested alternative: ‘div’
             switch (dir) {
                     ^~~
                     div
prog.cpp:179:18: error: ‘Right’ was not declared in this scope
             case Right:
                  ^~~~~
prog.cpp:181:21: error: ‘nextDir’ was not declared in this scope
                 if (nextDir == dir || nextDir == Down || nextDir == Left)
                     ^~~~~~~
prog.cpp:181:50: error: ‘Down’ was not declared in this scope
                 if (nextDir == dir || nextDir == Down || nextDir == Left)
                                                  ^~~~
prog.cpp:181:69: error: ‘Left’ was not declared in this scope
                 if (nextDir == dir || nextDir == Down || nextDir == Left)
                                                                     ^~~~
prog.cpp:183:21: error: ‘nextDir’ was not declared in this scope
                 if (nextDir == Down || nextDir == Left)
                     ^~~~~~~
prog.cpp:183:32: error: ‘Down’ was not declared in this scope
                 if (nextDir == Down || nextDir == Left)
                                ^~~~
prog.cpp:183:51: error: ‘Left’ was not declared in this scope
                 if (nextDir == Down || nextDir == Left)
                                                   ^~~~
prog.cpp:185:21: error: ‘nextDir’ was not declared in this scope
                 if (nextDir == Left)
                     ^~~~~~~
prog.cpp:185:32: error: ‘Left’ was not declared in this scope
                 if (nextDir == Left)
                                ^~~~
prog.cpp:188:18: error: ‘Down’ was not declared in this scope
             case Down:
                  ^~~~
prog.cpp:190:21: error: ‘nextDir’ was not declared in this scope
                 if (nextDir == dir || nextDir == Left || nextDir == Up)
                     ^~~~~~~
prog.cpp:190:50: error: ‘Left’ was not declared in this scope
                 if (nextDir == dir || nextDir == Left || nextDir == Up)
                                                  ^~~~
prog.cpp:190:69: error: ‘Up’ was not declared in this scope
                 if (nextDir == dir || nextDir == Left || nextDir == Up)
                                                                     ^~
prog.cpp:192:21: error: ‘nextDir’ was not declared in this scope
                 if (nextDir == Left || nextDir == Up)
                     ^~~~~~~
prog.cpp:192:32: error: ‘Left’ was not declared in this scope
                 if (nextDir == Left || nextDir == Up)
                                ^~~~
prog.cpp:192:51: error: ‘Up’ was not declared in this scope
                 if (nextDir == Left || nextDir == Up)
                                                   ^~
prog.cpp:194:21: error: ‘nextDir’ was not declared in this scope
                 if (nextDir == Up)
                     ^~~~~~~
prog.cpp:194:32: error: ‘Up’ was not declared in this scope
                 if (nextDir == Up)
                                ^~
prog.cpp:197:18: error: ‘Left’ was not declared in this scope
             case Left:
                  ^~~~
prog.cpp:199:21: error: ‘nextDir’ was not declared in this scope
                 if (nextDir == dir || nextDir == Up || nextDir == Right)
                     ^~~~~~~
prog.cpp:199:50: error: ‘Up’ was not declared in this scope
                 if (nextDir == dir || nextDir == Up || nextDir == Right)
                                                  ^~
prog.cpp:201:21: error: ‘nextDir’ was not declared in this scope
                 if (nextDir == Up || nextDir == Right)
                     ^~~~~~~
prog.cpp:201:32: error: ‘Up’ was not declared in this scope
                 if (nextDir == Up || nextDir == Right)
                                ^~
prog.cpp:203:21: error: ‘nextDir’ was not declared in this scope
                 if (nextDir == Right)
                     ^~~~~~~
prog.cpp:206:18: error: ‘Up’ was not declared in this scope
             case Up:
                  ^~
prog.cpp:208:21: error: ‘nextDir’ was not declared in this scope
                 if (nextDir == dir || nextDir == Right || nextDir == Down)
                     ^~~~~~~
prog.cpp:210:21: error: ‘nextDir’ was not declared in this scope
                 if (nextDir == Right || nextDir == Down)
                     ^~~~~~~
prog.cpp:212:21: error: ‘nextDir’ was not declared in this scope
                 if (nextDir == Down)
                     ^~~~~~~
prog.cpp:216:13: error: ‘dir’ was not declared in this scope
             dir = nextDir;
             ^~~
prog.cpp:216:13: note: suggested alternative: ‘div’
             dir = nextDir;
             ^~~
             div
prog.cpp:216:19: error: ‘nextDir’ was not declared in this scope
             dir = nextDir;
                   ^~~~~~~
prog.cpp:219:18: error: ‘Right’ was not declared in this scope
             case Right: ++x; break;
                  ^~~~~
prog.cpp:220:18: error: ‘Left’ was not declared in this scope
             case Left: --x; break;
                  ^~~~
prog.cpp:221:18: error: ‘Down’ was not declared in this scope
             case Down: ++y; break;
                  ^~~~
prog.cpp:222:18: error: ‘Up’ was not declared in this scope
             case Up: --y; break;
                  ^~
prog.cpp: In function ‘SnakeDirection aiGetNewSnakeDirection(int, int)’:
prog.cpp:269:72: error: ‘food’ was not declared in this scope
     const int distanceToFood = path_distance(pathNumber, getPathNumber(food.x, food.y));
                                                                        ^~~~
prog.cpp:269:72: note: suggested alternative: ‘feof’
     const int distanceToFood = path_distance(pathNumber, getPathNumber(food.x, food.y));
                                                                        ^~~~
                                                                        feof
prog.cpp:270:72: error: ‘snake’ was not declared in this scope
     const int distanceToTail = path_distance(pathNumber, getPathNumber(snake.tail_x, snake.tail_y));
                                                                        ^~~~~
prog.cpp:289:24: error: ‘check_for_collision’ was not declared in this scope
     bool canGoRight = !check_for_collision(x + 1, y);
                        ^~~~~~~~~~~~~~~~~~~

Standard output is empty