khetai 0.2.3 → 0.3.2

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

@@ -3,51 +3,45 @@
 
 #include "ai_loader.h"
 
-#include <FL/Fl_Widget.H>
-#include <FL/Fl_PNG_Image.H>
 #include <FL/Fl_Input.H>
+#include <FL/Fl_PNG_Image.H>
+#include <FL/Fl_Widget.H>
 #include <string>
-#include <vector>
 #include <unordered_map>
+#include <vector>
 
-class GameBoard : public Fl_Widget
-{
-public:
+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
-    {
+    enum Color {
         SILVER = 1,
         RED = 2
     };
-    enum LaserDirection
-    {
+    enum LaserDirection {
         NORTH = 1,
         EAST = 2,
         SOUTH = 3,
         WEST = 4
     };
-    enum PieceType
-    {
+    enum PieceType {
         ANUBIS,
         PYRAMID,
         SCARAB,
         PHARAOH,
         SPHINX
     };
-    enum PieceOrientation
-    {
+    enum PieceOrientation {
         ORIENT_NORTH,
         ORIENT_EAST,
         ORIENT_SOUTH,
         ORIENT_WEST
     };
-    enum ReflectionResult
-    {
+    enum ReflectionResult {
         RESULT_DEAD,
         RESULT_ABSORBED,
         RESULT_EAST,
@@ -55,8 +49,7 @@ public:
         RESULT_SOUTH,
         RESULT_NORTH
     };
-    enum MovePermission
-    {
+    enum MovePermission {
         S = 1,
         R = 2,
         B = 3
@@ -66,7 +59,7 @@ public:
     static std::pair<PieceType, PieceOrientation> getPieceTypeAndOrientation(const std::string &piece_str);
     static void laser_timer_cb(void *data);
 
-private:
+  private:
     AILoader ai_loader;
     int rows = 8, cols = 10, clicked_row = -1, clicked_col = -1, square_selected_num = -1;
     int cell_width, cell_height;

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

@@ -1,28 +1,23 @@
 #include "game_board_util.h"
 
-#include <iostream>
 #include <cstring>
+#include <iostream>
 
-std::vector<std::string> flatten_2d_vector_with_buffer(const std::vector<std::vector<std::string>> &vec2d)
-{
+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)
-        {
+    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)
-        {
+    for (const auto &row : buffered_vec2d) {
+        for (const auto &elem : row) {
             flattened.push_back(elem);
         }
     }
@@ -30,11 +25,9 @@ std::vector<std::string> flatten_2d_vector_with_buffer(const std::vector<std::ve
     return flattened;
 }
 
-char **vector_to_c_array(const std::vector<std::string> &vec)
-{
+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)
-    {
+    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());
     }
@@ -42,17 +35,14 @@ char **vector_to_c_array(const std::vector<std::string> &vec)
     return c_array;
 }
 
-void free_c_array(char **c_array, size_t size)
-{
-    for (size_t i = 0; i < size; ++i)
-    {
+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)
-{
+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 reset_undo = ai_loader.get_reset_undo();
     auto setup_board = ai_loader.get_setup_board();
@@ -80,8 +70,7 @@ Move call_ai_move(AILoader &ai_loader, const std::vector<std::vector<std::string
     int depth = 1;
     Move best_move = (Move)0;
     Move current_move = (Move)0;
-    while (depth <= max_depth)
-    {
+    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));
@@ -106,16 +95,7 @@ Move call_ai_move(AILoader &ai_loader, const std::vector<std::vector<std::string
     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;
-}
+void get_row_col(int index, int &row, int &col) {
+    row = (index / 12) - 1;
+    col = (index % 12) - 1;
+}

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

@@ -3,8 +3,8 @@
 
 #include "ai_loader.h"
 
-#include <vector>
 #include <string>
+#include <vector>
 
 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);

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

@@ -1,24 +1,20 @@
+#include "game_board.h"
 #include <FL/Fl.H>
+#include <FL/Fl_Box.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:
+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 handle(int event) override {
         int result = Fl_Int_Input::handle(event);
-        if (event == FL_KEYDOWN || event == FL_KEYUP || event == FL_PASTE)
-        {
+        if (event == FL_KEYDOWN || event == FL_KEYUP || event == FL_PASTE) {
             const char *value = this->value();
-            if (value[0] == '-')
-            {
+            if (value[0] == '-') {
                 this->value("");
             }
         }
@@ -26,8 +22,7 @@ public:
     }
 };
 
-int main(int argc, char **argv)
-{
+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);
 
@@ -50,7 +45,7 @@ int main(int argc, char **argv)
 
     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");
+    max_depth_input->value("25");
     board->max_depth_input = max_depth_input;
 
     window->end();

data/ext/khetai/dev/main.c

@@ -1,7 +1,7 @@
+#include "../khetai_lib.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
-#include "../khetai_lib.h"
 
 char *init_board[120] =
     {"--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--",
@@ -15,8 +15,7 @@ char *init_board[120] =
      "--", "--", "--", "p3", "a0", "x0", "a0", "--", "--", "--", "l0", "--",
      "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"};
 
-int main()
-{
+int main() {
     init_zobrist();
     srand((unsigned)time(NULL));
 
@@ -31,9 +30,8 @@ int main()
     int depth = 1;
     Move best_move = (Move)0;
     Move current_move = (Move)0;
-    while (depth <= max_depth)
-    {
-        current_move = alphabeta_root(depth, Red);
+    while (depth <= max_depth) {
+        current_move = alphabeta_root(depth, RED);
         if (time(NULL) - start_time < max_time)
             best_move = current_move;
         else

data/ext/khetai/khetai.c

@@ -1,26 +1,29 @@
+#include "khetai_lib.h"
 #include <ruby.h>
 #include <stdlib.h>
 #include <time.h>
-#include "khetai_lib.h"
 
-VALUE move(VALUE self, VALUE board_array, VALUE _player, VALUE _max_depth, VALUE _max_time)
-{
+static int convert_index(int i) {
+    int row = (i / 12) - 1;
+    int col = (i % 12) - 1;
+
+    return (row * 10) + col;
+}
+
+VALUE move(VALUE self, VALUE board_array, VALUE _player, VALUE _max_depth, VALUE _max_time) {
     // verify parameters
     int player = NUM2INT(_player);
-    if (player < 0 || player > 1)
-    {
+    if (player < 0 || player > 1) {
         rb_raise(rb_eArgError, "player must be 0 (silver) or 1 (red)");
     }
 
     int max_time = NUM2INT(_max_time);
-    if (max_time < 1)
-    {
+    if (max_time < 1) {
         rb_raise(rb_eArgError, "max_time (seconds) must be 1 or greater");
     }
 
     int max_depth = NUM2INT(_max_depth);
-    if (max_depth < 2 || max_depth > 25)
-    {
+    if (max_depth < 2 || max_depth > 25) {
         rb_raise(rb_eArgError, "max_depth (ply) must be between 2 and 25");
     }
 
@@ -29,33 +32,27 @@ VALUE move(VALUE self, VALUE board_array, VALUE _player, VALUE _max_depth, VALUE
     unsigned int array_size = (unsigned int)RARRAY_LEN(board_array);
 
     // verify board_array is valid
-    if (array_size != 80)
-    {
+    if (array_size != 80) {
         rb_raise(rb_eArgError, "board_array must have exactly 80 elements");
     }
     const char valid_pieces[] = {'L', 'A', 'X', 'P', 'S', 'p', 'a', 'x', 's', 'l'};
     size_t valid_pieces_count = 10;
-    for (unsigned int i = 0; i < array_size; i++)
-    {
+    for (unsigned int i = 0; i < array_size; i++) {
         VALUE element = rb_ary_entry(board_array, i);
-        if (!RB_TYPE_P(element, T_STRING) || RSTRING_LEN(element) != 2)
-        {
+        if (!RB_TYPE_P(element, T_STRING) || RSTRING_LEN(element) != 2) {
             rb_raise(rb_eArgError, "each element in board_array must be 2 characters");
         }
 
         // check if element in board_array is a valid string
         const char *element_str = RSTRING_PTR(element);
         int is_valid = 0;
-        for (unsigned int j = 0; j < valid_pieces_count; j++)
-        {
-            if ((element_str[0] == valid_pieces[j] && element_str[1] >= '0' && element_str[1] <= '3') || strcmp(element_str, "--") == 0)
-            {
+        for (unsigned int j = 0; j < valid_pieces_count; j++) {
+            if ((element_str[0] == valid_pieces[j] && element_str[1] >= '0' && element_str[1] <= '3') || strcmp(element_str, "--") == 0) {
                 is_valid = 1;
                 break;
             }
         }
-        if (!is_valid)
-        {
+        if (!is_valid) {
             rb_raise(rb_eArgError, "each element in board_array must be a valid piece (example: 'p1') or empty ('--')");
         }
     }
@@ -64,22 +61,19 @@ VALUE move(VALUE self, VALUE board_array, VALUE _player, VALUE _max_depth, VALUE
     char *init_board[120];
 
     // top and bottom row padding
-    for (unsigned int i = 0; i < 12; i++)
-    {
+    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++)
-    {
+    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 board passed from ruby
-    for (unsigned int i = 0; i < array_size; i++)
-    {
+    for (unsigned int i = 0; i < array_size; i++) {
         VALUE square = rb_ary_entry(board_array, i);
         init_board[13 + ((i % 10) + ((i / 10) * 12))] = StringValueCStr(square);
     }
@@ -95,8 +89,7 @@ VALUE move(VALUE self, VALUE board_array, VALUE _player, VALUE _max_depth, VALUE
     int depth = 1;
     Move best_move = (Move)0;
     Move current_move = (Move)0;
-    while ((time(NULL) - start_time < max_time) && (depth <= max_depth))
-    {
+    while ((time(NULL) - start_time < max_time) && (depth <= max_depth)) {
         best_move = current_move;
         current_move = alphabeta_root(depth, player);
         depth++;
@@ -104,15 +97,14 @@ VALUE move(VALUE self, VALUE board_array, VALUE _player, VALUE _max_depth, VALUE
     make_move(best_move);
 
     VALUE out = rb_ary_new2(3);
-    rb_ary_store(out, 0, INT2NUM(get_start(best_move)));
-    rb_ary_store(out, 1, INT2NUM(get_end(best_move)));
+    rb_ary_store(out, 0, INT2NUM(convert_index(get_start(best_move))));
+    rb_ary_store(out, 1, INT2NUM(convert_index(get_end(best_move))));
     rb_ary_store(out, 2, INT2NUM(get_rotation(best_move)));
 
     return out;
 }
 
-void Init_khetai()
-{
+void Init_khetai() {
     VALUE KhetAI = rb_define_module("KhetAI");
     rb_define_singleton_method(KhetAI, "move", move, 4);
 }