khetai 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09db06457292f856f5e69a7f1af7171cc3d1fcc39b4bf53638ed34607fbd35d0'
-  data.tar.gz: 5a11e03e0a5fbfb4f6189fe35e5e75905b57cdc7ec6efcae50b2a5d69cc56be3
+  metadata.gz: 57b893b2ca7a9ab8690ce116801bbd6286bc5856c7f87d01b7d51a7bbd6cc8f9
+  data.tar.gz: 433c4c67445b585526e598f6c04c53ca9e3ce67dab012a65aafa9922d18d8a80
 SHA512:
-  metadata.gz: c2595304f50a6ccb71b158f84377b4c10c747284081a1c4ac24f5fccbd42dc69ea074e7476626432bdd29e5519932740f577c9bb25dfe70e6421975993813fcf
-  data.tar.gz: 277cc078b123efae38ddc9731eca386d7d11adbb063f8660cbfb2acccd47d5d4f109b122818100f0f5fa526f238728b72e6812d04f02fa16082f8189798d7384
+  metadata.gz: 5e85bedabf5229ac1abad59889e2d2980e0fe194ad42d3acff67fb72817ed6755b59798af3a7312836cc225bb044f1bc12641edb30f4693e37e91144581ac142
+  data.tar.gz: f7cb8d7735f580752ed50ca8f4cf084a5398bbac70d26b32da6c9a61049de9a79b68aceac685afe5a907ec8bea83ba24e72fcf3c991a88145996c5a8563b85e3

data/.gitignore

@@ -6,5 +6,6 @@
 /pkg/
 /spec/reports/
 /tmp/
+/build/
 .vscode
 *.so

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    khetai (0.1.6)
+    khetai (0.1.7)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,5 +1,10 @@
 # KhetAI
 
+## Install
+```
+gem install khetai
+```
+
 ## Usage
 ```
 require 'khetai'
@@ -40,7 +45,7 @@ move = KhetAI.move(board, whose_turn, max_search_depth, max_search_time)
 ## Build and Deploy Commands
 ```
 bundle exec rake compile
-bundle ecec rake build
+bundle exec rake build
 bundle exec rake release
 
 gem push pkg/<gem>

data/ext/khetai/dev/CMakeLists.txt

@@ -0,0 +1,5 @@
+cmake_minimum_required(VERSION 3.10)
+
+project(khetai LANGUAGES C)
+
+add_executable(khetai main.c ../khetai_lib.c)

data/ext/khetai/dev/main.c

@@ -0,0 +1,50 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "../khetai_lib.h"
+
+char *init_board[120] =
+    {"--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--",
+     "--", "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", "--",
+     "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"};
+
+time_t start_time;
+int max_time;
+
+int main()
+{
+    init_zobrist();
+    srand((unsigned)time(NULL));
+
+    setup_board(init_board);
+    print_board();
+
+    start_time = time(NULL);
+    max_time = 5;
+    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))
+    {
+        best_move = current_move;
+        current_move = alphabeta_root(depth, Red);
+        depth++;
+    }
+    make_move(best_move);
+
+    printf("\n========================\n\n");
+    print_board();
+
+    printf("\nDEPTH: %d\n", depth - 1);
+
+    return 0;
+}

data/ext/khetai/dev/main.rb

@@ -0,0 +1,15 @@
+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", "--",
+         "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"]
+
+move = KhetAI.move(board, 1, 6, 5)
+puts move.to_s

data/ext/khetai/khetai_lib.c

@@ -5,7 +5,9 @@
 #include "khetai_lib.h"
 
 Square board[120] = {0};
+int pharaoh_loc[2] = {0};
 enum Player whose_turn;
+enum Player starter;
 
 Move undo_moves[MAX_DEPTH] = {0};
 int undo_capture_indices[MAX_DEPTH] = {0};
@@ -23,6 +25,7 @@ bool checkmate = false;
 Move alphabeta_root(int depth, enum Player player)
 {
     whose_turn = player;
+    starter = player;
     int best_score = -MAX_SCORE;
     Move best_move = (Move)0;
     int alpha = -MAX_SCORE;
@@ -145,24 +148,27 @@ int calculate_score()
 {
     int score = 0;
     int anubis_score = 500;
-    int scarab_score = 750;
     int pyramid_score = 1000;
     int pharaoh_score = 100000;
     for (int i = 0; i < 120; i++)
     {
-        if (board[i] > 0)
+        Square s = board[i];
+        if (is_piece(s))
         {
             int value = 0;
-            switch (get_piece(board[i]))
+            switch (get_piece(s))
             {
             case Anubis:
                 value += anubis_score;
+                value -= distance_from_pharaoh(i, pharaoh_loc[get_owner(s)]) * 10;
                 break;
             case Pyramid:
                 value += pyramid_score;
+                value += rand() % 20;
                 break;
             case Scarab:
-                value += scarab_score;
+                value += 100 / (distance_from_pharaoh(i, pharaoh_loc[opposite_player(get_owner(s))])) * 10;
+                value += rand() % 10;
                 break;
             case Pharaoh:
                 value += pharaoh_score;
@@ -170,10 +176,20 @@ int calculate_score()
             default:
                 break;
             }
-            score += get_owner(board[i]) == Red ? value : -value;
+            score += get_owner(s) == Red ? value : -value;
         }
     }
-    return score += rand() % 100;
+    return score;
+}
+
+int distance_from_pharaoh(int i, int p)
+{
+    int px = p / 12;
+    int py = p % 12;
+    int ix = i / 12;
+    int iy = i % 12;
+    int m_distance = abs(px - ix) + abs(py - iy);
+    return m_distance;
 }
 
 void make_move(Move move)
@@ -204,9 +220,12 @@ void make_move(Move move)
         // add starting piece to end location
         hash ^= keys[board[end]][end];
 
-        // add ending piece to start position if swapping
+        // add ending piece to start location if swapping
         if (is_piece(board[start]))
             hash ^= keys[board[start]][start];
+
+        if (get_piece(moving_piece) == Pharaoh)
+            pharaoh_loc[whose_turn] = end;
     }
 
     undo_moves[undo_index] = new_move(end, start, -rotation);
@@ -214,6 +233,9 @@ void make_move(Move move)
     fire_laser(&hash);
     hash ^= turn_key;
 
+    // testing that hashing works properly
+    // printf("\nHASH:\t%lu\nBOARD:\t%lu\n", hash, get_board_hash());
+
     hashes[move_num] = hash;
     undo_index++;
 }
@@ -228,18 +250,20 @@ void fire_laser(uint64_t *hash)
         i = i + directions[laser_dir];
         if (i >= 0 && i < 120 && on_board[i] == 1)
         {
-            if (board[i] > 0)
+            Square s = board[i];
+            if (is_piece(s))
             {
-                int piece = get_piece(board[i]) - 1;
-                int orientation = get_orientation(board[i]);
+                int piece = get_piece(s) - 1;
+                int orientation = get_orientation(s);
                 int result = reflections[laser_dir][piece][orientation];
                 if (result == Dead)
                 {
-                    if (get_piece(board[i]) == Pharaoh)
+                    if (get_piece(s) == Pharaoh)
                         checkmate = true;
-                    *hash ^= keys[board[i]][i];
+                    // remove piece
+                    *hash ^= keys[s][i];
                     undo_capture_indices[undo_index] = i;
-                    undo_capture_squares[undo_index] = board[i];
+                    undo_capture_squares[undo_index] = s;
                     board[i] = (Square)0;
                     traversing = false;
                 }
@@ -288,6 +312,9 @@ void undo_move()
         Square moving_piece = board[start];
         board[start] = board[end];
         board[end] = moving_piece;
+
+        if (get_piece(moving_piece) == Pharaoh)
+            pharaoh_loc[get_owner(board[end])] = end;
     }
     checkmate = false;
 }
@@ -387,14 +414,74 @@ void find_valid_sphinx_moves(int i, Move *valid_moves, int *vi)
     valid_moves[(*vi)++] = new_move(i, i, rotation);
 }
 
+void init_zobrist()
+{
+    for (int i = 0; i < 0xFF; i++)
+    {
+        for (int j = 0; j < 120; j++)
+        {
+            keys[i][j] = random_number();
+        }
+    }
+    turn_key = random_number();
+}
+
+uint64_t get_board_hash()
+{
+    uint64_t hash = 0;
+    for (int i = 0; i < 120; i++)
+    {
+        if (is_piece(board[i]))
+            hash ^= keys[board[i]][i];
+    }
+    if (whose_turn == starter)
+        hash ^= turn_key;
+    return hash;
+}
+
+bool is_move_legal(Move move)
+{
+    int start = get_start(move);
+    int end = get_end(move);
+    if (is_piece(board[start]) && get_owner(board[start]) == whose_turn)
+    {
+        if (!is_piece(board[end]) || get_rotation(move) != 0)
+            return true;
+        else if (is_piece(board[end]) && get_piece(board[start]) == Scarab && get_piece(board[end]) < 3)
+            return true;
+    }
+    return false;
+}
+
+void reset_undo()
+{
+    undo_index = 0;
+    for (int i = 0; i < MAX_DEPTH; i++)
+    {
+        undo_moves[i] = 0;
+        undo_capture_indices[i] = 0;
+        undo_capture_squares[i] = 0;
+    }
+}
+
 void setup_board(char *init_board[120])
 {
     uint64_t hash = 0;
     for (int i = 0; i < 120; i++)
     {
         board[i] = str_to_square(init_board[i]);
-        if (board[i] > 0)
-            hash ^= keys[board[i]][i];
+        Square s = board[i];
+        if (is_piece(s))
+        {
+            hash ^= keys[s][i];
+            if (get_piece(s) == Pharaoh)
+            {
+                if (get_owner(s) == Silver)
+                    pharaoh_loc[Silver] = i;
+                else if (get_owner(s) == Red)
+                    pharaoh_loc[Red] = i;
+            }
+        }
     }
     hashes[0] = hash;
 
@@ -528,51 +615,3 @@ void print_piece(Square s)
     else
         printf("--");
 }
-
-void reset_undo()
-{
-    undo_index = 0;
-    for (int i = 0; i < MAX_DEPTH; i++)
-    {
-        undo_moves[i] = 0;
-        undo_capture_indices[i] = 0;
-        undo_capture_squares[i] = 0;
-    }
-}
-
-void init_zobrist()
-{
-    for (int i = 0; i < 0xFF; i++)
-    {
-        for (int j = 0; j < 120; j++)
-        {
-            keys[i][j] = random_number();
-        }
-    }
-    turn_key = random_number();
-}
-
-bool is_move_legal(Move move)
-{
-    int start = get_start(move);
-    int end = get_end(move);
-    if (is_piece(board[start]) && get_owner(board[start]) == whose_turn)
-    {
-        if (!is_piece(board[end]) || get_rotation(move) != 0)
-            return true;
-        else if (is_piece(board[end]) && get_piece(board[start]) == Scarab && get_piece(board[end]) < 3)
-            return true;
-    }
-    return false;
-}
-
-uint64_t get_board_hash()
-{
-    uint64_t hash = 0;
-    for (int i = 0; i < 120; i++)
-    {
-        if (board[i] > 0)
-            hash ^= keys[board[i]][i];
-    }
-    return hash;
-}

data/ext/khetai/khetai_lib.h

@@ -33,12 +33,15 @@ enum Orientation
 };
 
 extern enum Player whose_turn;
+extern enum Player starter;
 
 // north, east, south, west, diagonals
 static const int directions[8] = {-12, 1, 12, -1, (12 + 1), (12 - 1), (-12 + 1), (-12 - 1)};
 static const int rotations[2] = {1, -1};
 static const int sphinx_loc[2] = {106, 13};
 
+extern int pharaoh_loc[2];
+
 extern Square board[120];
 extern Move undo_moves[MAX_DEPTH];
 extern int undo_capture_indices[MAX_DEPTH];
@@ -95,6 +98,7 @@ extern 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);
 
 extern void make_move(Move move);
 extern void undo_move();
@@ -166,6 +170,7 @@ extern int move_num;
 extern bool checkmate;
 
 extern void init_zobrist();
+extern uint64_t get_board_hash();
 static uint64_t seed = 1070372;
 static inline uint64_t random_number()
 {
@@ -192,6 +197,5 @@ 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);
-extern uint64_t get_board_hash();
 
 #endif // KHET_LIB_H_INCLUDED extern uint64_t get_board_hash();

data/lib/khetai/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: khetai
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - jkugs
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-02-24 00:00:00.000000000 Z
+date: 2022-03-05 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -27,6 +27,9 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- ext/khetai/dev/CMakeLists.txt
+- ext/khetai/dev/main.c
+- ext/khetai/dev/main.rb
 - ext/khetai/extconf.rb
 - ext/khetai/khetai.c
 - ext/khetai/khetai_lib.c