khetai 0.1.7 → 0.2.0

data/ext/khetai/dev/fltk-ui/game_board.h

@@ -0,0 +1,105 @@
+#ifndef GAMEBOARD_H
+#define GAMEBOARD_H
+
+#include "ai_loader.h"
+
+#include <FL/Fl_Widget.H>
+#include <FL/Fl_PNG_Image.H>
+#include <FL/Fl_Input.H>
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+class GameBoard : public Fl_Widget
+{
+public:
+    GameBoard(int X, int Y, int W, int H, const char *L = 0);
+    Fl_Input *max_time_input, *max_depth_input;
+    void draw() override;
+    int handle(int event) override;
+    void init(const std::vector<std::vector<std::string>> &pieces);
+
+    enum Color
+    {
+        SILVER = 1,
+        RED = 2
+    };
+    enum LaserDirection
+    {
+        NORTH = 1,
+        EAST = 2,
+        SOUTH = 3,
+        WEST = 4
+    };
+    enum PieceType
+    {
+        ANUBIS,
+        PYRAMID,
+        SCARAB,
+        PHARAOH,
+        SPHINX
+    };
+    enum PieceOrientation
+    {
+        ORIENT_NORTH,
+        ORIENT_EAST,
+        ORIENT_SOUTH,
+        ORIENT_WEST
+    };
+    enum ReflectionResult
+    {
+        RESULT_DEAD,
+        RESULT_ABSORBED,
+        RESULT_EAST,
+        RESULT_WEST,
+        RESULT_SOUTH,
+        RESULT_NORTH
+    };
+    enum MovePermission
+    {
+        S = 1,
+        R = 2,
+        B = 3
+    };
+
+    static std::string getPieceFilename(char piece, int direction);
+    static std::pair<PieceType, PieceOrientation> getPieceTypeAndOrientation(const std::string &piece_str);
+    static void laser_timer_cb(void *data);
+
+private:
+    AILoader ai_loader;
+    int rows = 8, cols = 10, clicked_row = -1, clicked_col = -1, square_selected_num = -1;
+    int cell_width, cell_height;
+    bool square_selected = false;
+    bool laser_active = false;
+    int laser_step = 3;
+    LaserDirection laser_direction;
+    float laser_y, laser_x;
+    bool remove_piece = false;
+    int laser_square_row, laser_square_col, remove_row, remove_col;
+    int l_idx;
+    std::vector<std::vector<std::string>> board_pieces;
+    std::vector<Fl_Image *> piece_images;
+    std::vector<std::tuple<int, int, int, int>> laser_path;
+    std::vector<std::tuple<int, int, int, int>> laser_path_squares;
+
+    static std::unordered_map<LaserDirection, std::unordered_map<PieceType, std::unordered_map<PieceOrientation, ReflectionResult>>> reflections_map;
+    static std::unordered_map<char, std::string> piece_map;
+    static std::unordered_map<int, int> rotate_left_map;
+    static std::unordered_map<int, int> rotate_right_map;
+    static const MovePermission move_permissions[8][10];
+
+    void drawInnerSquares();
+    void rotateSelectedPiece(bool clockwise);
+    void moveSelectedPiece(int end_square);
+    void swapPieces(int swap_square);
+    void deletePiece();
+    void resetPieces();
+    void fireLaser(Color color);
+    void updateLaserPosition();
+    void calculateLaserPathSquares();
+    bool squareContainsPiece(int square_num);
+    void rebuildReloadKhetAILib();
+};
+
+#endif

data/ext/khetai/dev/fltk-ui/game_board_util.cpp

@@ -0,0 +1,119 @@
+#include "game_board_util.h"
+
+#include <iostream>
+#include <cstring>
+
+std::vector<std::string> flatten_2d_vector_with_buffer(const std::vector<std::vector<std::string>> &vec2d)
+{
+    size_t new_rows = vec2d.size() + 2;
+    size_t new_cols = vec2d.empty() ? 0 : vec2d[0].size() + 2;
+
+    std::vector<std::vector<std::string>> buffered_vec2d(new_rows, std::vector<std::string>(new_cols, "--"));
+
+    for (size_t i = 0; i < vec2d.size(); ++i)
+    {
+        for (size_t j = 0; j < vec2d[i].size(); ++j)
+        {
+            buffered_vec2d[i + 1][j + 1] = vec2d[i][j];
+        }
+    }
+
+    std::vector<std::string> flattened;
+    for (const auto &row : buffered_vec2d)
+    {
+        for (const auto &elem : row)
+        {
+            flattened.push_back(elem);
+        }
+    }
+
+    return flattened;
+}
+
+char **vector_to_c_array(const std::vector<std::string> &vec)
+{
+    char **c_array = new char *[vec.size()];
+    for (size_t i = 0; i < vec.size(); ++i)
+    {
+        c_array[i] = new char[vec[i].size() + 1];
+        std::strcpy(c_array[i], vec[i].c_str());
+    }
+
+    return c_array;
+}
+
+void free_c_array(char **c_array, size_t size)
+{
+    for (size_t i = 0; i < size; ++i)
+    {
+        delete[] c_array[i];
+    }
+    delete[] c_array;
+}
+
+Move call_ai_move(AILoader &ai_loader, const std::vector<std::vector<std::string>> &board_pieces, Player player, int max_depth, int max_time)
+{
+    auto init_zobrist = ai_loader.get_init_zobrist();
+    auto setup_board = ai_loader.get_setup_board();
+    auto print_board = ai_loader.get_print_board();
+    auto set_time_parameters = ai_loader.get_set_time_parameters();
+    auto alphabeta_root = ai_loader.get_alphabeta_root();
+    auto make_move = ai_loader.get_make_move();
+    auto get_start = ai_loader.get_get_start();
+    auto get_end = ai_loader.get_get_end();
+    auto get_rotation = ai_loader.get_get_rotation();
+
+    char **c_board = vector_to_c_array(flatten_2d_vector_with_buffer(board_pieces));
+
+    init_zobrist();
+    srand((unsigned)time(NULL));
+
+    setup_board(c_board);
+    printf("\nStarting Board:\n");
+    print_board();
+
+    time_t start_time = time(NULL);
+    set_time_parameters(max_time, start_time);
+
+    int depth = 1;
+    Move best_move = (Move)0;
+    Move current_move = (Move)0;
+    while (depth <= max_depth)
+    {
+        printf("\nDEPTH: %-3d->   ", depth);
+        current_move = alphabeta_root(depth, player);
+        printf("MOVE -> START: %d, END: %d, ROTATION: %d\n", get_start(current_move), get_end(current_move), get_rotation(current_move));
+        if ((time(NULL) - start_time < max_time))
+            best_move = current_move;
+        else
+            break;
+        depth++;
+    }
+    make_move(best_move);
+
+    printf("\n========================\n\n");
+    printf("Ending Board:\n");
+    print_board();
+
+    printf("\nDEPTH: %d\n", depth - 1);
+
+    int start = get_start(best_move);
+    int end = get_end(best_move);
+    int rotation = get_rotation(best_move);
+    std::cout << "START: " << start << ", END: " << end << ", ROTATION: " << rotation << std::endl;
+    return best_move;
+}
+
+void get_row_col(int index, int &row, int &col)
+{
+    int border_width = 1;
+    int width_with_border = 10 + 2 * border_width;
+
+    int adjusted_index = index;
+
+    int row_with_border = adjusted_index / width_with_border;
+    int col_with_border = adjusted_index % width_with_border;
+
+    row = row_with_border - border_width;
+    col = col_with_border - border_width;
+}

data/ext/khetai/dev/fltk-ui/game_board_util.h

@@ -0,0 +1,15 @@
+#ifndef GAME_BOARD_UTIL_H
+#define GAME_BOARD_UTIL_H
+
+#include "ai_loader.h"
+
+#include <vector>
+#include <string>
+
+std::vector<std::string> flatten_2d_vector_with_buffer(const std::vector<std::vector<std::string>> &vec2d);
+char **vector_to_c_array(const std::vector<std::string> &vec);
+void free_c_array(char **c_array, size_t size);
+Move call_ai_move(AILoader &ai_loader, const std::vector<std::vector<std::string>> &board_pieces, Player player, int max_depth, int _max_time);
+void get_row_col(int index, int &row, int &col);
+
+#endif

data/ext/khetai/dev/fltk-ui/khet.cpp

@@ -0,0 +1,59 @@
+#include <FL/Fl.H>
+#include <FL/Fl_Double_Window.H>
+#include <FL/Fl_Input.H>
+#include <FL/Fl_Int_Input.H>
+#include <FL/Fl_Box.H>
+#include "game_board.h"
+
+class PositiveIntInput : public Fl_Int_Input
+{
+public:
+    PositiveIntInput(int X, int Y, int W, int H, const char *L = 0)
+        : Fl_Int_Input(X, Y, W, H, L) {}
+
+    int handle(int event) override
+    {
+        int result = Fl_Int_Input::handle(event);
+        if (event == FL_KEYDOWN || event == FL_KEYUP || event == FL_PASTE)
+        {
+            const char *value = this->value();
+            if (value[0] == '-')
+            {
+                this->value("");
+            }
+        }
+        return result;
+    }
+};
+
+int main(int argc, char **argv)
+{
+    Fl_Double_Window *window = new Fl_Double_Window(800, 600, "Khet AI");
+    GameBoard *board = new GameBoard(50, 50, 700, 504);
+
+    std::vector<std::vector<std::string>> init_board = {
+        {"L2", "--", "--", "--", "A2", "X2", "A2", "P1", "--", "--"},
+        {"--", "--", "P2", "--", "--", "--", "--", "--", "--", "--"},
+        {"--", "--", "--", "p3", "--", "--", "--", "--", "--", "--"},
+        {"P0", "--", "p2", "--", "S2", "S3", "--", "P1", "--", "p3"},
+        {"P1", "--", "p3", "--", "s1", "s0", "--", "P0", "--", "p2"},
+        {"--", "--", "--", "--", "--", "--", "P1", "--", "--", "--"},
+        {"--", "--", "--", "--", "--", "--", "--", "p0", "--", "--"},
+        {"--", "--", "p3", "a0", "x0", "a0", "--", "--", "--", "l0"}};
+
+    board->init(init_board);
+
+    Fl_Box *max_time_label = new Fl_Box(50, 10, 80, 30, "Max Time:");
+    PositiveIntInput *max_time_input = new PositiveIntInput(125, 15, 30, 20);
+    max_time_input->value("5");
+    board->max_time_input = max_time_input;
+
+    Fl_Box *max_depth_label = new Fl_Box(250, 10, 80, 30, "Max Depth:");
+    PositiveIntInput *max_depth_input = new PositiveIntInput(325, 15, 30, 20);
+    max_depth_input->value("10");
+    board->max_depth_input = max_depth_input;
+
+    window->end();
+    window->show(argc, argv);
+    return Fl::run();
+}

data/ext/khetai/dev/main.c

@@ -15,9 +15,6 @@ char *init_board[120] =
      "--", "--", "--", "p3", "a0", "x0", "a0", "--", "--", "--", "l0", "--",
      "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"};
 
-time_t start_time;
-int max_time;
-
 int main()
 {
     init_zobrist();
@@ -26,17 +23,21 @@ int main()
     setup_board(init_board);
     print_board();
 
-    start_time = time(NULL);
-    max_time = 5;
+    time_t start_time = time(NULL);
+    int max_time = 5;
+    set_time_parameters(max_time, start_time);
     int max_depth = 25;
 
     int depth = 1;
     Move best_move = (Move)0;
     Move current_move = (Move)0;
-    while ((time(NULL) - start_time < max_time) && (depth <= max_depth))
+    while (depth <= max_depth)
     {
-        best_move = current_move;
         current_move = alphabeta_root(depth, Red);
+        if (time(NULL) - start_time < max_time)
+            best_move = current_move;
+        else
+            break;
         depth++;
     }
     make_move(best_move);

data/ext/khetai/dev/main.rb

@@ -1,15 +1,14 @@
 require_relative "../../../lib/khetai/khetai.so"
 
-board = ["--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--",
-         "--", "L2", "--", "--", "--", "A2", "X2", "A2", "P1", "--", "--", "--",
-         "--", "--", "--", "P2", "--", "--", "--", "--", "--", "--", "--", "--",
-         "--", "--", "--", "--", "p3", "--", "--", "--", "--", "--", "--", "--",
-         "--", "P0", "--", "p2", "--", "S2", "S3", "--", "P1", "--", "p3", "--",
-         "--", "P1", "--", "p3", "--", "s1", "s0", "--", "P0", "--", "p2", "--",
-         "--", "--", "--", "--", "--", "--", "--", "P1", "--", "--", "--", "--",
-         "--", "--", "--", "--", "--", "--", "--", "--", "p0", "--", "--", "--",
-         "--", "--", "--", "p3", "a0", "x0", "a0", "--", "--", "--", "l0", "--",
-         "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"]
+board = ["L2", "--", "--", "--", "A2", "X2", "A2", "P1", "--", "--",
+         "--", "--", "P2", "--", "--", "--", "--", "--", "--", "--",
+         "--", "--", "--", "p3", "--", "--", "--", "--", "--", "--",
+         "P0", "--", "p2", "--", "S2", "S3", "--", "P1", "--", "p3",
+         "P1", "--", "p3", "--", "s1", "s0", "--", "P0", "--", "p2",
+         "--", "--", "--", "--", "--", "--", "P1", "--", "--", "--",
+         "--", "--", "--", "--", "--", "--", "--", "p0", "--", "--",
+         "--", "--", "p3", "a0", "x0", "a0", "--", "--", "--", "l0"]
+
 
 move = KhetAI.move(board, 1, 6, 5)
 puts move.to_s

data/ext/khetai/khetai.c

@@ -3,28 +3,44 @@
 #include <time.h>
 #include "khetai_lib.h"
 
-time_t start_time;
-int max_time;
-
 VALUE move(VALUE self, VALUE board_array, VALUE player, VALUE max_depth, VALUE _max_time)
 {
     srand((unsigned)time(NULL));
 
+    // khetai_lib assumes an extra level of padding around the board
     char *init_board[120];
     unsigned int array_size = (unsigned int)RARRAY_LEN(board_array);
+
+    // top and bottom row padding
+    for (unsigned int i = 0; i < 12; i++)
+    {
+        init_board[i] = "--";
+        init_board[108 + i] = "--";
+    }
+
+    // left and right column padding
+    for (unsigned int i = 0; i < 8; i++)
+    {
+        init_board[12 * (i + 1)] = "--";
+        init_board[12 * (i + 2) - 1] = "--";
+    }
+
+    // fill in the rest of the baord passed from ruby
     for (unsigned int i = 0; i < array_size; i++)
     {
         VALUE square = rb_ary_entry(board_array, i);
-        init_board[i] = StringValueCStr(square);
+        init_board[13 + ((i % 10) + ((i / 10) * 12))] = StringValueCStr(square);
     }
 
     reset_undo();
     init_zobrist();
     setup_board(init_board);
 
-    start_time = time(NULL);
-    max_time = NUM2INT(_max_time);
+    time_t start_time = time(NULL);
+    int max_time = NUM2INT(_max_time);
+    set_time_parameters(max_time, start_time);
 
+    // iterative deepening
     int depth = 1;
     Move best_move = (Move)0;
     Move current_move = (Move)0;

data/ext/khetai/khetai_lib.c

@@ -4,6 +4,9 @@
 #include <time.h>
 #include "khetai_lib.h"
 
+int max_time;
+time_t start_time;
+
 Square board[120] = {0};
 int pharaoh_loc[2] = {0};
 enum Player whose_turn;
@@ -51,6 +54,9 @@ Move alphabeta_root(int depth, enum Player player)
         if (alpha >= beta)
             break;
     }
+
+    // print final score for testing purposes:
+    // printf("SCORE: %-10d\n", best_score);
     return best_move;
 }
 
@@ -91,6 +97,7 @@ int alphabeta(int depth, enum Player player, int alpha, int beta)
     find_valid_moves(valid_moves, &vi);
     int best_score = -MAX_SCORE;
     Move best_move = (Move)0;
+
     for (int i = 0; (i < NUM_VALID_MOVES && (time(NULL) - start_time < max_time)); i++)
     {
         if (valid_moves[i] == 0)
@@ -125,7 +132,7 @@ void insert_table(uint64_t key, int depth, int flag, int score, Move move)
     HashEntry *entry = search_table(key);
     if (entry->key != 0)
     {
-        if (depth > entry->depth)
+        if (depth < entry->depth)
         {
             entry->key = key;
             entry->depth = depth;
@@ -167,8 +174,9 @@ int calculate_score()
                 value += rand() % 20;
                 break;
             case Scarab:
-                value += 100 / (distance_from_pharaoh(i, pharaoh_loc[opposite_player(get_owner(s))])) * 10;
-                value += rand() % 10;
+                int max_distance = 16;
+                int base_score = 1000;
+                value += (max_distance - distance_from_pharaoh(i, pharaoh_loc[opposite_player(get_owner(s))])) * base_score / max_distance;
                 break;
             case Pharaoh:
                 value += pharaoh_score;
@@ -225,7 +233,7 @@ void make_move(Move move)
             hash ^= keys[board[start]][start];
 
         if (get_piece(moving_piece) == Pharaoh)
-            pharaoh_loc[whose_turn] = end;
+            pharaoh_loc[get_owner(moving_piece)] = end;
     }
 
     undo_moves[undo_index] = new_move(end, start, -rotation);
@@ -314,7 +322,7 @@ void undo_move()
         board[end] = moving_piece;
 
         if (get_piece(moving_piece) == Pharaoh)
-            pharaoh_loc[get_owner(board[end])] = end;
+            pharaoh_loc[get_owner(moving_piece)] = end;
     }
     checkmate = false;
 }
@@ -375,14 +383,7 @@ void find_valid_scarab_moves(int i, Move *valid_moves, int *vi)
         int dest = i + directions[j];
         if (can_move[whose_turn][dest])
         {
-            if (is_piece(board[dest]))
-            {
-                if (get_piece(board[dest]) == Anubis || get_piece(board[dest]) == Pyramid)
-                {
-                    valid_moves[(*vi)++] = new_move(i, dest, 0);
-                }
-            }
-            else
+            if (!is_piece(board[dest]) || get_piece(board[dest]) != Pharaoh)
             {
                 valid_moves[(*vi)++] = new_move(i, dest, 0);
             }
@@ -615,3 +616,13 @@ void print_piece(Square s)
     else
         printf("--");
 }
+
+int get_start_wrapper(Move move) { return get_start(move); }
+int get_end_wrapper(Move move) { return get_end(move); }
+int get_rotation_wrapper(Move move) { return get_rotation(move); }
+
+void set_time_parameters(int _max_time, time_t _start_time)
+{
+    max_time = _max_time;
+    start_time = _start_time;
+}

data/ext/khetai/khetai_lib.h

@@ -4,6 +4,10 @@
 #include <stdint.h>
 #include <stdbool.h>
 
+#ifdef __cplusplus
+#include <ctime>
+#endif
+
 typedef uint8_t Square;
 typedef uint32_t Move;
 
@@ -83,27 +87,42 @@ static const int on_board[120] = {
     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
 
-extern void setup_board(char *init_board[120]);
-extern Square str_to_square(char *str);
-extern void print_board();
-extern void print_piece(Square s);
-extern void reset_undo();
+extern time_t start_time;
+extern int max_time;
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+    void set_time_parameters(int _max_time, time_t _start_time);
+    void reset_undo();
+    void init_zobrist();
+    void setup_board(char *board[]);
+    Move alphabeta_root(int depth, enum Player player);
+    void make_move(Move move);
+    void print_board();
+
+#ifdef __cplusplus
+}
+#endif
+
+Square str_to_square(char *str);
+void print_piece(Square s);
 
-extern void find_valid_moves(Move *valid_moves, int *vi);
-extern void find_valid_anubis_pyramid_moves(int i, Move *valid_moves, int *vi);
-extern void find_valid_scarab_moves(int i, Move *valid_moves, int *vi);
-extern void find_valid_pharaoh_moves(int i, Move *valid_moves, int *vi);
-extern void find_valid_sphinx_moves(int i, Move *valid_moves, int *vi);
+void find_valid_moves(Move *valid_moves, int *vi);
+void find_valid_anubis_pyramid_moves(int i, Move *valid_moves, int *vi);
+void find_valid_scarab_moves(int i, Move *valid_moves, int *vi);
+void find_valid_pharaoh_moves(int i, Move *valid_moves, int *vi);
+void find_valid_sphinx_moves(int i, Move *valid_moves, int *vi);
 
-extern Move alphabeta_root(int depth, enum Player player);
-extern int alphabeta(int depth, enum Player player, int alpha, int beta);
-extern int calculate_score();
-extern int distance_from_pharaoh(int i, int p);
+int alphabeta(int depth, enum Player player, int alpha, int beta);
+int calculate_score();
+int distance_from_pharaoh(int i, int p);
 
-extern void make_move(Move move);
-extern void undo_move();
-extern void fire_laser(uint64_t *hash);
-extern bool is_move_legal(Move move);
+void undo_move();
+void fire_laser(uint64_t *hash);
+bool is_move_legal(Move move);
 
 static inline bool is_piece(Square s) { return s > 0; }
 
@@ -116,6 +135,17 @@ static inline int get_start(Move m) { return m >> 1 & 0x7F; }
 static inline int get_end(Move m) { return m >> 8 & 0x7F; }
 static inline int get_rotation(Move m) { return (m >> 15 & 0x3) - 2; }
 
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    int get_start_wrapper(Move move);
+    int get_end_wrapper(Move move);
+    int get_rotation_wrapper(Move move);
+#ifdef __cplusplus
+}
+#endif
+
 static inline Square rotate(Square s, int rotation)
 {
     int orientation = get_orientation(s);
@@ -161,16 +191,13 @@ static const int reflections[4][5][4] = {
      {Dead, Dead, Dead, Dead},
      {Absorbed, Absorbed, Absorbed, Absorbed}}};
 
-extern time_t start_time;
-extern int max_time;
 extern uint64_t keys[0xFF][120];
 extern uint64_t hashes[MAX_DEPTH];
 extern uint64_t turn_key;
 extern int move_num;
 extern bool checkmate;
 
-extern void init_zobrist();
-extern uint64_t get_board_hash();
+uint64_t get_board_hash();
 static uint64_t seed = 1070372;
 static inline uint64_t random_number()
 {
@@ -196,6 +223,6 @@ typedef struct HashEntry
 
 extern HashEntry table[TABLE_SIZE];
 static inline HashEntry *search_table(uint64_t key) { return &table[key % TABLE_SIZE]; };
-extern void insert_table(uint64_t key, int depth, int flag, int score, Move move);
+void insert_table(uint64_t key, int depth, int flag, int score, Move move);
 
-#endif // KHET_LIB_H_INCLUDED extern uint64_t get_board_hash();
+#endif // KHET_LIB_H_INCLUDED

data/lib/khetai/version.rb

@@ -1,3 +1,3 @@
 module KhetAI
-  VERSION = "0.1.7"
+  VERSION = "0.2.0"
 end