bot that wins sometimes

Makefile

@@ -5,8 +5,8 @@ all: fanorona
 test: fanorona
 	socat TCP4-CONNECT:alpaga.hammerle.me:4455 EXEC:"./fanorona"
 	
-fanorona: source/Main.cpp source/Game.cpp source/Game.h source/String.cpp source/String.h
-	g++ source/Main.cpp source/Game.cpp source/String.cpp ${ARGS}
+fanorona: source/Main.cpp source/Game.cpp source/Game.h source/String.cpp source/String.h source/Vector.cpp source/Vector.h
+	g++ source/Main.cpp source/Game.cpp source/String.cpp source/Vector.cpp ${ARGS}
 	
 clean:
 	rm -f fanorona

source/Game.cpp

@@ -3,7 +3,25 @@
 #include "Game.h"
 #include "Types.h"
 
-Game::Game() : activeX(-1), activeY(-1), directionX(0), directionY(0), lastLocation(0) {
+std::array<Vector, 8> Game::neighbours;
+std::array<Vector, 9 * 5> Game::fieldVectors;
+
+Game::Game() : active(-1, -1), direction(0, 0), lastLocation(0) {
+    neighbours[0].set(1, 0);
+    neighbours[1].set(0, 1);
+    neighbours[2].set(-1, 0);
+    neighbours[3].set(0, -1);
+    neighbours[4].set(1, 1);
+    neighbours[5].set(-1, 1);
+    neighbours[6].set(1, -1);
+    neighbours[7].set(-1, -1);
+
+    uint index = 0;
+    for(uint y = 0; y < 5; y++) {
+        for(uint x = 0; x < 9; x++) {
+            fieldVectors[index++].set(x, y);
+        }
+    }
 }
 
 void Game::print(String& s) const {
@@ -20,22 +38,22 @@ void Game::print(String& s) const {
     s.append("\n\r");
 }
 
-void Game::printLine(String& s, int index) const {
+void Game::printLine(String& s, int y) const {
     static const char map[] = {
         '#', 'O', '.'
     };
-    s.append(index + '0').append(' ');
+    s.append(y + '0').append(' ');
     for(int x = 0; x < 8; x++) {
-        if(x == activeX && index == activeY) {
+        if(active.compare(x, y)) {
             s.append("*-");
             continue;
         }
-        s.append(map[fields[x][index]]).append('-');
+        s.append(map[fields[x][y]]).append('-');
     }
-    if(8 == activeX && index == activeY) {
+    if(active.compare(8, y)) {
         s.append('*');
     } else {
-        s.append(map[fields[8][index]]);
+        s.append(map[fields[8][y]]);
     }
     s.append("\n\r");
 }
@@ -57,15 +75,15 @@ void Game::parse() {
         if(s == "select stone:") {
             std::cerr << s;
             s.clear();
-            selectStone();
+            makeSelection();
         } else if(s == "select location to move:") {
             std::cerr << s;
             s.clear();
-            selectLocationToMove();
+            makeMove();
         } else if(s == "select stone to take:") {
             std::cerr << s;
             s.clear();
-            selectStoneToTake();
+            takeStone();
         }
     }
 }
@@ -81,21 +99,20 @@ void Game::consumeLine() const {
     }
 }
 
-void Game::consumeLine(uint index) {
+void Game::consumeLine(uint y) {
     std::cin.get();
     std::cin.get();
-    for(uint i = 0; i < 9; i++) {
+    for(uint x = 0; x < 9; x++) {
         char c = std::cin.get();
         if(c == '#') {
-            fields[i][index] = BLACK;
+            fields[x][y] = BLACK;
         } else if(c == '.') {
-            fields[i][index] = EMPTY;
+            fields[x][y] = EMPTY;
         } else if(c == 'O') {
-            fields[i][index] = WHITE;
+            fields[x][y] = WHITE;
         } else if(c == '*') {
-            activeX = i;
-            activeY = index;
-            fields[i][index] = WHITE;
+            active.set(x, y);
+            fields[x][y] = WHITE;
         } else {
             std::cerr << "game field parsing error\n";
         }
@@ -113,129 +130,251 @@ void Game::parseFields() {
     std::cerr << s;
 }
 
-void Game::selectStone() {
+bool Game::isInRange(const Vector& v) const {
+    return v.x >= 0 && v.x <= 8 && v.y >= 0 && v.y <= 4;
+}
+
+bool Game::areNeighbours(const Vector& from, const Vector& to) const {
+    if(from == to) {
+        return false;
+    }
+    Vector diff = from - to;
+    if(diff.x < -1 || diff.x > 1 || diff.y < -1 || diff.y > 1) {
+        return false;
+    }
+    if(diff.x == 0 || diff.y == 0) {
+        return true;
+    }
+    return !((from.x & 1) ^ (from.y & 1));
+}
+
+void Game::removeLine(const Vector& from, const Vector& to, FieldState state) {
+    Vector current = to;
+    Vector diff = to - from;
+    while(true) {
+        current += diff;
+        if(!isInRange(current) || !hasState(current, state)) {
+            return;
+        }
+        setState(current, EMPTY);
+    }
+}
+
+uint Game::getRank(const Vector& from, const Vector& to, FieldState state) const {
+    Vector current = to;
+    Vector diff = to - from;
+    uint rank = 0;
+    while(true) {
+        current += diff;
+        if(!isInRange(current) || !hasState(current, state)) {
+            return rank;
+        }
+        rank++;
+    }
+}
+
+void Game::addLocation(const Vector& v) {
+    if(lastLocation < lastLocations.size()) {
+        lastLocations[lastLocation] = v;
+        lastLocation++;
+    }
+}
+
+bool Game::isInQueue(const Vector& v) const {
+    for(uint i = 0; i < lastLocation; i++) {
+        if(lastLocations[i] == v) {
+            return true;
+        }
+    }
+    return false;
+}
+
+uint Game::getStoneTakes(const Vector& from, const Vector& to) const {
+    if(!isInRange(to) || !hasState(to, EMPTY) || !areNeighbours(from, to) || isInQueue(to) || (to - from) == direction) {
+        return 0;
+    }
+    FieldState enemy = (hasState(from, BLACK) ? WHITE : BLACK);
+    uint rankA = getRank(from, to, enemy);
+    uint rankB = getRank(to, from, enemy);
+    if(rankA == 0 && rankB == 0) {
+        return 0;
+    }
+
+    Game copy = *this;
+    uint rank = 0;
+    if(rankA >= rankB) {
+        copy.removeLine(from, to, enemy);
+        rank = rankA;
+    } else {
+        copy.removeLine(to, from, enemy);
+        rank = rankB;
+    }
+    copy.addLocation(from);
+    copy.move(from, to);
+
+    uint maxRank = 0;
+    for(Vector& m : neighbours) {
+        uint rank = copy.getStoneTakes(to, to + m);
+        if(rank > maxRank) {
+            maxRank = rank;
+        }
+    }
+
+    return rank + maxRank;
+}
+
+uint Game::getStoneFreedom(const Vector& from) const {
+    if(hasState(from, EMPTY)) {
+        return 0;
+    }
+    uint counter = 0;
+    for(const Vector& m : neighbours) {
+        Vector to = from + m;
+        if(!isInRange(to) || !areNeighbours(from, to) || !hasState(to, EMPTY)) {
+            continue;
+        }
+        counter++;
+    }
+    return counter;
+}
+
+uint Game::getFreedom(FieldState state) const {
+    int sum = 0;
+    for(const Vector& v : fieldVectors) {
+        if(hasState(v, state)) {
+            sum += getStoneFreedom(v);
+        }
+    }
+    return sum;
+}
+
+bool Game::hasState(const Vector& v, FieldState state) const {
+    return fields[v.x][v.y] == state;
+}
+
+Game::FieldState Game::getState(const Vector& v) const {
+    return fields[v.x][v.y];
+}
+
+void Game::setState(const Vector& v, FieldState state) {
+    fields[v.x][v.y] = state;
+}
+
+void Game::move(const Vector& from, const Vector& to) {
+    direction = to - from;
+    setState(to, getState(from));
+    setState(from, EMPTY);
+}
+
+void Game::makeSelection() {
     lastLocation = 0;
-    directionX = 0;
-    directionY = 0;
-
-    Location from;
-    int rank = -1;
-    for(int bx = 0; bx < 9; bx++) {
-        for(int by = 0; by < 5; by++) {
-            if(fields[bx][by] != EMPTY) {
+    direction.set(0, 0);
+
+    Vector selection(0, 0);
+    int maxRank = -100000;
+    for(Vector& to : fieldVectors) {
+        if(!hasState(to, EMPTY)) {
+            continue;
+        }
+        for(Vector& m : neighbours) {
+            Vector from = to + m;
+            if(!isInRange(from) || !hasState(from, WHITE) || !areNeighbours(from, to)) {
                 continue;
             }
-            for(int mx = -1; mx <= 1; mx++) {
-                for(int my = -1; my <= 1; my++) {
-                    int x = bx + mx;
-                    int y = by + my;
-                    if((mx == 0 && my == 0) || !isInRange(x, y) || !areNeighbours(bx, by, x, y) || fields[x][y] != WHITE) {
-                        continue;
-                    }
-                    int rankA = getRank(bx, by, x, y);
-                    int rankB = getRank(x, y, bx, by);
-                    if(rankA > rank) {
-                        rank = rankA;
-                        from = {x, y};
-                    }
-                    if(rankB > rank) {
-                        rank = rankB;
-                        from = {x, y};
-                    }
-                }
+            int rank = getQuality(from, to);
+            if(rank > maxRank) {
+                maxRank = rank;
+                selection = from;
             }
         }
     }
-    std::cout << from.x << " " << from.y << "\n";
+    std::cout << selection.x << " " << selection.y << "\n";
 }
 
-void Game::selectLocationToMove() {
-    Location to;
-    int rank = -1;
-    for(int mx = -1; mx <= 1; mx++) {
-        for(int my = -1; my <= 1; my++) {
-            int x = activeX + mx;
-            int y = activeY + my;
-            if((mx == 0 && my == 0) || (mx == directionX && my == directionY) || !isInRange(x, y) ||
-                    !areNeighbours(activeX, activeY, x, y) || fields[x][y] != EMPTY || isInQueue(x, y)) {
+void Game::makeMove() {
+    Vector maxTo(0, 0);
+    int maxRank = -100000;
+    for(Vector& m : neighbours) {
+        Vector to = active + m;
+        if(!isInRange(to) || !hasState(to, EMPTY) || isInQueue(to) || !areNeighbours(active, to) || m == direction) {
+            continue;
+        }
+        if(lastLocation > 0) {
+            int rank = getRank(active, to, BLACK) + getRank(to, active, BLACK);
+            if(rank == 0) {
                 continue;
             }
-            int rankA = getRank(x, y, activeX, activeY);
-            int rankB = getRank(activeX, activeY, x, y);
-            if(rankA > rank) {
-                rank = rankA;
-                to = {x, y};
-            }
-            if(rankB > rank) {
-                rank = rankB;
-                to = {x, y};
-            }
+        }
+        int rank = getQuality(active, to);
+        if(rank > maxRank) {
+            maxRank = rank;
+            maxTo = to;
         }
     }
-    addLocation(activeX, activeY);
-    directionX = to.x - activeX;
-    directionY = to.y - activeY;
-    std::cout << to.x << " " << to.y << "\n";
+    addLocation(active);
+    direction = maxTo - active;
+    std::cerr << maxTo.x << " " << maxTo.y << "\n";
+    std::cout << maxTo.x << " " << maxTo.y << "\n";
 }
 
-void Game::selectStoneToTake() {
-    int rankA = getRank(activeX, activeY, activeX + directionX, activeY + directionY);
-    int rankB = getRank(activeX + directionX, activeY + directionY, activeX, activeY);
-    if(rankA > rankB) {
-        std::cout << (activeX + directionX * 2) << " " << (activeY + directionY * 2) << "\n";
+void Game::takeStone() {
+    uint rankA = getRank(active, active + direction, BLACK);
+    uint rankB = getRank(active + direction, active, BLACK);
+    Vector v;
+    if(rankA >= rankB) {
+        v = active + direction + direction;
     } else {
-        std::cout << (activeX - directionX) << " " << (activeY - directionY) << "\n";
+        v = active - direction;
     }
+    std::cout << v.x << " " << v.y << "\n";
 }
 
-bool Game::isInRange(int x, int y) const {
-    return x >= 0 && x <= 8 && y >= 0 && y <= 4;
-}
+int Game::getQuality(const Vector& from, const Vector& to) const {
+    int quality = getStoneTakes(from, to);
 
-bool Game::areNeighbours(int x, int y, int x2, int y2) const {
-    if(x == x2 && y == y2) {
-        return false;
-    }
-    int diffX = x - x2;
-    int diffY = y - y2;
-    if(diffX < -1 || diffX > 1 || diffY < -1 || diffY > 1) {
-        return false;
-    }
-    if(diffX == 0 || diffY == 0) {
-        return true;
+    Game copy = *this;
+    copy.move(from, to);
+    uint rankA = copy.getRank(from, to, BLACK);
+    uint rankB = copy.getRank(to, from, BLACK);
+    if(rankA >= rankB) {
+        copy.removeLine(from, to, BLACK);
+    } else {
+        copy.removeLine(to, from, BLACK);
     }
-    return !((x & 1) ^ (y & 1));
-}
+    copy.lastLocation = 0;
+    copy.direction.set(0, 0);
 
-int Game::getRank(int x, int y, int x2, int y2) const {
-    int diffX = x2 - x;
-    int diffY = y2 - y;
-    int rank = 0;
-    while(true) {
-        x2 += diffX;
-        y2 += diffY;
-        if(!isInRange(x2, y2) || fields[x2][y2] != BLACK) {
-            return rank;
+    int whiteFreedom = copy.getFreedom(WHITE);
+    int blackFreedom = copy.getFreedom(BLACK);
+
+    int maxRank = -1;
+    for(Vector& to : fieldVectors) {
+        if(!copy.hasState(to, EMPTY)) {
+            continue;
+        }
+        for(Vector& m : neighbours) {
+            Vector from = to + m;
+            if(!copy.isInRange(from) || !copy.hasState(from, BLACK)) {
+                continue;
+            }
+            int rank = copy.getStoneTakes(from, to);
+            if(rank > maxRank) {
+                maxRank = rank;
+            }
         }
-        rank++;
     }
-}
 
-void Game::addLocation(int x, int y) {
-    if(lastLocation >= lastLocations.size()) {
-        // safely to ignore, such long turns will never happen
-        return;
+    int black = countBlack();
+    if(black >= 8) {
+        black = 1;
     }
-    lastLocations[lastLocation].x = x;
-    lastLocations[lastLocation].y = y;
-    lastLocation++;
+    return quality - maxRank * black + (whiteFreedom - blackFreedom) / 4;
 }
 
-bool Game::isInQueue(int x, int y) const {
-    for(uint i = 0; i < lastLocation; i++) {
-        if(lastLocations[i].x == x && lastLocations[i].y == y) {
-            return true;
-        }
+int Game::countBlack() const {
+    int blackCounter = 0;
+    for(Vector& v : fieldVectors) {
+        blackCounter += hasState(v, BLACK);
     }
-    return false;
+    return blackCounter;
 }

source/Game.h

@@ -5,6 +5,7 @@
 
 #include "String.h"
 #include "Types.h"
+#include "Vector.h"
 
 class Game final {
 public:
@@ -18,33 +19,49 @@ public:
 
 private:
     void consumeLine() const;
-    void consumeLine(uint index);
+    void consumeLine(uint y);
     void parseFields();
-    void selectStone();
-    void selectLocationToMove();
-    void selectStoneToTake();
 
-    bool isInRange(int x, int y) const;
+    bool isInRange(const Vector& v) const;
     void print(String& s) const;
-    void printLine(String& s, int index) const;
-    int getRank(int x, int y, int x2, int y2) const;
-    bool areNeighbours(int x, int y, int x2, int y2) const;
+    void printLine(String& s, int y) const;
+    
+    bool areNeighbours(const Vector& from, const Vector& to) const;
 
-    void addLocation(int x, int y);
-    bool isInQueue(int x, int y) const;
+    void addLocation(const Vector& v);
+    bool isInQueue(const Vector& v) const;
+    
+    void removeLine(const Vector& from, const Vector& to, FieldState state);
+    uint getRank(const Vector& from, const Vector& to, FieldState state) const;
+
+    uint getStoneTakes(const Vector& from, const Vector& to) const;
+
+    uint getStoneFreedom(const Vector& from) const;
+    uint getFreedom(FieldState state) const;
+
+    bool hasState(const Vector& v, FieldState state) const;
+    FieldState getState(const Vector& v) const;
+    void setState(const Vector& v, FieldState state);
+    
+    void move(const Vector& from, const Vector& to);
+    
+    void makeSelection();
+    void makeMove();
+    void takeStone();
+    
+    int getQuality(const Vector& from, const Vector& to) const;
+    
+    int countBlack() const;
 
     FieldState fields[9][5];
-    int activeX;
-    int activeY;
-    int directionX;
-    int directionY;
-
-    struct Location {
-        int x;
-        int y;
-    };
-    std::array<Location, 20> lastLocations;
+    Vector active;
+    Vector direction;
+    
+    std::array<Vector, 20> lastLocations;
     uint lastLocation;
+
+    static std::array<Vector, 8> neighbours;
+    static std::array<Vector, 9 * 5> fieldVectors;
 };
 
 #endif

source/Vector.cpp

@@ -0,0 +1,31 @@
+#include "Vector.h"
+
+Vector::Vector(int x, int y) : x(x), y(y) {
+}
+
+void Vector::set(int x, int y) {
+    this->x = x;
+    this->y = y;
+}
+
+bool Vector::compare(int x, int y) const {
+    return this->x == x && this->y == y;
+}
+
+Vector& Vector::operator+=(const Vector& other) {
+    x += other.x;
+    y += other.y;
+    return *this;
+}
+
+Vector Vector::operator+(const Vector& other) const {
+    return Vector(x + other.x, y + other.y);
+}
+
+Vector Vector::operator-(const Vector& other) const {
+    return Vector(x - other.x, y - other.y);
+}
+
+bool Vector::operator==(const Vector& other) const {
+    return compare(other.x, other.y);
+}

source/Vector.h

@@ -0,0 +1,20 @@
+#ifndef VECTOR_H
+#define VECTOR_H
+
+struct Vector final {
+    Vector(int x = 0, int y = 0);
+    
+    void set(int x, int y);
+    
+    bool compare(int x, int y) const;
+    Vector& operator+=(const Vector& other);
+    Vector operator+(const Vector& other) const;
+    Vector operator-(const Vector& other) const;
+    bool operator==(const Vector& other) const;
+    
+    int x;
+    int y;
+
+};
+
+#endif