khetai 0.1.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '09db06457292f856f5e69a7f1af7171cc3d1fcc39b4bf53638ed34607fbd35d0'
+  data.tar.gz: 5a11e03e0a5fbfb4f6189fe35e5e75905b57cdc7ec6efcae50b2a5d69cc56be3
+SHA512:
+  metadata.gz: c2595304f50a6ccb71b158f84377b4c10c747284081a1c4ac24f5fccbd42dc69ea074e7476626432bdd29e5519932740f577c9bb25dfe70e6421975993813fcf
+  data.tar.gz: 277cc078b123efae38ddc9731eca386d7d11adbb063f8660cbfb2acccd47d5d4f109b122818100f0f5fa526f238728b72e6812d04f02fa16082f8189798d7384

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.vscode
+*.so

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in khetai.gemspec
+gemspec
+
+gem "rake"
+gem "rake-compiler"

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    khetai (0.1.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (13.0.6)
+    rake-compiler (1.1.9)
+      rake
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  khetai!
+  rake
+  rake-compiler
+
+BUNDLED WITH
+   2.1.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 jkugs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# KhetAI
+
+## Usage
+```
+require 'khetai'
+move = KhetAI.move(board, whose_turn, max_search_depth, max_search_time)
+```
+
+## Example
+```
+require 'khetai'
+
+# initial board setup:
+# A = anubis, P = pyramid, S = scarab, X = pharaoh, L = sphinx
+# capital letters = red, lowercase letters = silver
+# 0 = north, 1 = east, 2 = south, 3 = west
+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", "--",
+        "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--", "--"]
+
+whose_turn = 1          # silver = 0, red = 1
+max_search_depth = 25   # must be between 2 and 25
+max_search_time = 5     # max search time in seconds
+
+# returns [start_index, end_index, rotation]
+move = KhetAI.move(board, whose_turn, max_search_depth, max_search_time)
+
+# move[0] = start index
+# move[1] = end index
+# move[2] = rotation (1, -1, 0) (clockwise, anticlockwise, none)
+```
+
+## Build and Deploy Commands
+```
+bundle exec rake compile
+bundle ecec rake build
+bundle exec rake release
+
+gem push pkg/<gem>
+```

data/README_ORIGINAL.md

@@ -0,0 +1,40 @@
+# Khetai
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/khetai`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'khetai'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install khetai
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/khetai.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+task :default => :spec
+
+require "rake"
+require "rake/extensiontask"
+Rake::ExtensionTask.new "khetai" do |ext|
+  ext.lib_dir = "lib/khetai"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "khetai"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/khetai/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile('khetai/khetai')

data/ext/khetai/khetai.c

@@ -0,0 +1,51 @@
+#include <ruby.h>
+#include <stdlib.h>
+#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));
+
+    char *init_board[120];
+    unsigned int array_size = (unsigned int)RARRAY_LEN(board_array);
+    for (unsigned int i = 0; i < array_size; i++)
+    {
+        VALUE square = rb_ary_entry(board_array, i);
+        init_board[i] = StringValueCStr(square);
+    }
+
+    reset_undo();
+    init_zobrist();
+    setup_board(init_board);
+
+    start_time = time(NULL);
+    max_time = NUM2INT(_max_time);
+
+    int depth = 1;
+    Move best_move = (Move)0;
+    Move current_move = (Move)0;
+    while ((time(NULL) - start_time < max_time) && (depth <= NUM2INT(max_depth)))
+    {
+        best_move = current_move;
+        current_move = alphabeta_root(depth, NUM2INT(player));
+        depth++;
+    }
+    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, 2, INT2NUM(get_rotation(best_move)));
+
+    return out;
+}
+
+void Init_khetai()
+{
+    VALUE KhetAI = rb_define_module("KhetAI");
+    rb_define_singleton_method(KhetAI, "move", move, 4);
+}

data/ext/khetai/khetai_lib.c

@@ -0,0 +1,578 @@
+#include <stdio.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include <time.h>
+#include "khetai_lib.h"
+
+Square board[120] = {0};
+enum Player whose_turn;
+
+Move undo_moves[MAX_DEPTH] = {0};
+int undo_capture_indices[MAX_DEPTH] = {0};
+Square undo_capture_squares[MAX_DEPTH] = {0};
+
+HashEntry table[TABLE_SIZE] = {0};
+uint64_t hashes[MAX_DEPTH] = {0};
+uint64_t keys[0xFF][120] = {0};
+uint64_t turn_key = 0;
+
+int undo_index = 0;
+int move_num = 0;
+bool checkmate = false;
+
+Move alphabeta_root(int depth, enum Player player)
+{
+    whose_turn = player;
+    int best_score = -MAX_SCORE;
+    Move best_move = (Move)0;
+    int alpha = -MAX_SCORE;
+    int beta = MAX_SCORE;
+    Move valid_moves[NUM_VALID_MOVES] = {0};
+    int vi = 0;
+    find_valid_moves(valid_moves, &vi);
+    for (int i = 0; i < NUM_VALID_MOVES; i++)
+    {
+        if (valid_moves[i] == 0)
+            break;
+        make_move(valid_moves[i]);
+        int score = -alphabeta(depth - 1, opposite_player(player), -beta, -alpha);
+        undo_move();
+        whose_turn = player;
+        if (score > best_score)
+        {
+            best_score = score;
+            best_move = valid_moves[i];
+        }
+        if (best_score > alpha)
+            alpha = best_score;
+        if (alpha >= beta)
+            break;
+    }
+    return best_move;
+}
+
+int alphabeta(int depth, enum Player player, int alpha, int beta)
+{
+    whose_turn = player;
+    if (depth == 0 || checkmate)
+    {
+        return player == Red ? calculate_score() : -calculate_score();
+    }
+
+    int alpha_orig = alpha;
+    Move valid_moves[NUM_VALID_MOVES] = {0};
+    int vi = 0;
+    HashEntry *entry = search_table(hashes[move_num]);
+    if (entry->key == hashes[move_num] && entry->depth >= depth)
+    {
+        if (entry->flag == EXACT)
+            return entry->score;
+        else if (entry->flag == ALPHA)
+        {
+            if (entry->score > alpha)
+                alpha = entry->score;
+        }
+        else
+        {
+            if (entry->score < beta)
+                beta = entry->score;
+        }
+
+        if (alpha >= beta)
+            return entry->score;
+
+        if (is_move_legal(entry->move))
+            valid_moves[vi++] = entry->move;
+    }
+
+    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)
+            break;
+        make_move(valid_moves[i]);
+        int score = -alphabeta(depth - 1, opposite_player(player), -beta, -alpha);
+        undo_move();
+        whose_turn = player;
+        if (score > best_score)
+        {
+            best_score = score;
+            best_move = valid_moves[i];
+        }
+        if (best_score > alpha)
+            alpha = best_score;
+        if (alpha >= beta)
+            break;
+    }
+
+    int flag = EXACT;
+    if (best_score <= alpha_orig)
+        flag = BETA;
+    else if (best_score >= beta)
+        flag = ALPHA;
+
+    insert_table(hashes[move_num], depth, flag, best_score, best_move);
+    return best_score;
+}
+
+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)
+        {
+            entry->key = key;
+            entry->depth = depth;
+            entry->flag = flag;
+            entry->score = score;
+            entry->move = move;
+        }
+    }
+    else
+    {
+        entry->key = key;
+        entry->depth = depth;
+        entry->flag = flag;
+        entry->score = score;
+        entry->move = move;
+    }
+}
+
+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)
+        {
+            int value = 0;
+            switch (get_piece(board[i]))
+            {
+            case Anubis:
+                value += anubis_score;
+                break;
+            case Pyramid:
+                value += pyramid_score;
+                break;
+            case Scarab:
+                value += scarab_score;
+                break;
+            case Pharaoh:
+                value += pharaoh_score;
+                break;
+            default:
+                break;
+            }
+            score += get_owner(board[i]) == Red ? value : -value;
+        }
+    }
+    return score += rand() % 100;
+}
+
+void make_move(Move move)
+{
+    uint64_t hash = hashes[move_num++];
+
+    int start = get_start(move);
+    // remove starting piece
+    hash ^= keys[board[start]][start];
+    int end = get_end(move);
+    int rotation = get_rotation(move);
+
+    if (rotation != 0)
+    {
+        board[start] = rotate(board[start], rotation);
+        // add starting piece back with rotation
+        hash ^= keys[board[start]][start];
+    }
+    else
+    {
+        // remove ending piece if swapping
+        if (is_piece(board[end]))
+            hash ^= keys[board[end]][end];
+
+        Square moving_piece = board[start];
+        board[start] = board[end];
+        board[end] = moving_piece;
+        // add starting piece to end location
+        hash ^= keys[board[end]][end];
+
+        // add ending piece to start position if swapping
+        if (is_piece(board[start]))
+            hash ^= keys[board[start]][start];
+    }
+
+    undo_moves[undo_index] = new_move(end, start, -rotation);
+
+    fire_laser(&hash);
+    hash ^= turn_key;
+
+    hashes[move_num] = hash;
+    undo_index++;
+}
+
+void fire_laser(uint64_t *hash)
+{
+    int i = sphinx_loc[whose_turn];
+    int laser_dir = get_orientation(board[i]);
+    bool traversing = true;
+    while (traversing)
+    {
+        i = i + directions[laser_dir];
+        if (i >= 0 && i < 120 && on_board[i] == 1)
+        {
+            if (board[i] > 0)
+            {
+                int piece = get_piece(board[i]) - 1;
+                int orientation = get_orientation(board[i]);
+                int result = reflections[laser_dir][piece][orientation];
+                if (result == Dead)
+                {
+                    if (get_piece(board[i]) == Pharaoh)
+                        checkmate = true;
+                    *hash ^= keys[board[i]][i];
+                    undo_capture_indices[undo_index] = i;
+                    undo_capture_squares[undo_index] = board[i];
+                    board[i] = (Square)0;
+                    traversing = false;
+                }
+                else if (result == Absorbed)
+                {
+                    traversing = false;
+                }
+                else
+                {
+                    laser_dir = result;
+                }
+            }
+        }
+        else
+        {
+            traversing = false;
+        }
+    }
+}
+
+void undo_move()
+{
+    move_num--;
+    undo_index--;
+
+    Square captured = (Square)undo_capture_squares[undo_index];
+    undo_capture_squares[undo_index] = 0;
+    if (captured > 0)
+    {
+        board[undo_capture_indices[undo_index]] = captured;
+        undo_capture_indices[undo_index] = 0;
+    }
+
+    Move move = undo_moves[undo_index];
+    undo_moves[undo_index] = 0;
+    int start = get_start(move);
+    int end = get_end(move);
+    int rotation = get_rotation(move);
+
+    if (rotation != 0)
+    {
+        board[start] = rotate(board[start], rotation);
+    }
+    else
+    {
+        Square moving_piece = board[start];
+        board[start] = board[end];
+        board[end] = moving_piece;
+    }
+    checkmate = false;
+}
+
+void find_valid_moves(Move *valid_moves, int *vi)
+{
+    for (int i = 0; i < 120; i++)
+    {
+        Square s = board[i];
+        enum Player piece_color = get_owner(s);
+        if (is_piece(s) && piece_color == whose_turn)
+        {
+            enum Piece piece = get_piece(s);
+            switch (piece)
+            {
+            case Anubis:
+                find_valid_anubis_pyramid_moves(i, valid_moves, vi);
+                break;
+            case Pyramid:
+                find_valid_anubis_pyramid_moves(i, valid_moves, vi);
+                break;
+            case Scarab:
+                find_valid_scarab_moves(i, valid_moves, vi);
+                break;
+            case Pharaoh:
+                find_valid_pharaoh_moves(i, valid_moves, vi);
+                break;
+            case Sphinx:
+                find_valid_sphinx_moves(i, valid_moves, vi);
+                break;
+            default:
+                break;
+            }
+        }
+    }
+}
+
+void find_valid_anubis_pyramid_moves(int i, Move *valid_moves, int *vi)
+{
+    for (int j = 0; j < 8; j++)
+    {
+        int dest = i + directions[j];
+        if (!is_piece(board[dest]) && can_move[whose_turn][dest])
+        {
+            valid_moves[(*vi)++] = new_move(i, dest, 0);
+        }
+    }
+    for (int j = 0; j < 2; j++)
+    {
+        valid_moves[(*vi)++] = new_move(i, i, rotations[j]);
+    }
+}
+
+void find_valid_scarab_moves(int i, Move *valid_moves, int *vi)
+{
+    for (int j = 0; j < 8; j++)
+    {
+        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
+            {
+                valid_moves[(*vi)++] = new_move(i, dest, 0);
+            }
+        }
+    }
+    for (int j = 0; j < 2; j++)
+    {
+        valid_moves[(*vi)++] = new_move(i, i, rotations[j]);
+    }
+}
+
+void find_valid_pharaoh_moves(int i, Move *valid_moves, int *vi)
+{
+    for (int j = 0; j < 8; j++)
+    {
+        int dest = i + directions[j];
+        if (!is_piece(board[dest]) && can_move[whose_turn][dest])
+        {
+            valid_moves[(*vi)++] = new_move(i, dest, 0);
+        }
+    }
+}
+
+void find_valid_sphinx_moves(int i, Move *valid_moves, int *vi)
+{
+    enum Player player = get_owner(board[i]);
+    enum Orientation orientation = get_orientation(board[i]);
+    int rotation = player == Silver ? (orientation == North ? -1 : 1) : (orientation == South ? -1 : 1);
+    valid_moves[(*vi)++] = new_move(i, i, rotation);
+}
+
+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];
+    }
+    hashes[0] = hash;
+
+    for (int i = 0; i < TABLE_SIZE; i++)
+    {
+        table[i].key = 0;
+        table[i].depth = 0;
+        table[i].flag = 0;
+        table[i].score = 0;
+        table[i].move = 0;
+    }
+}
+
+Square str_to_square(char *str)
+{
+    enum Player player;
+    enum Piece piece;
+    enum Orientation orientation;
+
+    if (str[0] != '-')
+    {
+        if (islower(str[0]))
+            player = Silver;
+        else
+            player = Red;
+
+        char p = tolower(str[0]);
+        if (p == 'a')
+            piece = Anubis;
+        else if (p == 'p')
+            piece = Pyramid;
+        else if (p == 's')
+            piece = Scarab;
+        else if (p == 'x')
+            piece = Pharaoh;
+        else
+            piece = Sphinx;
+
+        char o = str[1];
+        if (o == '0')
+            orientation = North;
+        else if (o == '1')
+            orientation = East;
+        else if (o == '2')
+            orientation = South;
+        else
+            orientation = West;
+
+        return (Square)((int)player << 1 | (int)piece << 2 | (int)orientation << 5);
+    }
+
+    return (Square)0;
+}
+
+void print_board()
+{
+    for (int i = 0; i < 120; i++)
+    {
+        print_piece(board[i]);
+        if ((i + 1) % 12 == 0)
+            printf("\n");
+    }
+}
+
+void print_piece(Square s)
+{
+    enum Player player = get_owner(s);
+    if (is_piece(s))
+    {
+        enum Piece piece = get_piece(s);
+        enum Orientation orientation = get_orientation(s);
+        switch (piece)
+        {
+        case Anubis:
+            if (player == Silver)
+                printf("a");
+            else
+                printf("A");
+            break;
+
+        case Pyramid:
+            if (player == Silver)
+                printf("p");
+            else
+                printf("P");
+            break;
+
+        case Scarab:
+            if (player == Silver)
+                printf("s");
+            else
+                printf("S");
+            break;
+
+        case Pharaoh:
+            if (player == Silver)
+                printf("x");
+            else
+                printf("X");
+            break;
+
+        case Sphinx:
+            if (player == Silver)
+                printf("l");
+            else
+                printf("L");
+            break;
+        default:
+            printf("-");
+            break;
+        }
+        switch (orientation)
+        {
+        case North:
+            printf("0");
+            break;
+        case East:
+            printf("1");
+            break;
+        case South:
+            printf("2");
+            break;
+        case West:
+            printf("3");
+            break;
+        default:
+            printf("-");
+            break;
+        }
+    }
+    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

@@ -0,0 +1,197 @@
+#ifndef KHET_LIB_H_INCLUDED
+#define KHET_LIB_H_INCLUDED
+
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef uint8_t Square;
+typedef uint32_t Move;
+
+#define NUM_VALID_MOVES 125
+#define MAX_SCORE 9999999
+#define MAX_DEPTH 25
+
+enum Player
+{
+    Silver,
+    Red
+};
+enum Piece
+{
+    Anubis = 1,
+    Pyramid = 2,
+    Scarab = 3,
+    Pharaoh = 4,
+    Sphinx = 5
+};
+enum Orientation
+{
+    North,
+    East,
+    South,
+    West
+};
+
+extern enum Player whose_turn;
+
+// 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 Square board[120];
+extern Move undo_moves[MAX_DEPTH];
+extern int undo_capture_indices[MAX_DEPTH];
+extern Square undo_capture_squares[MAX_DEPTH];
+extern int undo_index;
+
+static const int can_move[2][120] = {
+    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0,
+     0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+     0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+     0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+     0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+     0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+     0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+     0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+
+    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+     0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+     0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}};
+
+static const int on_board[120] = {
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
+    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 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);
+
+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 void make_move(Move move);
+extern void undo_move();
+extern void fire_laser(uint64_t *hash);
+extern bool is_move_legal(Move move);
+
+static inline bool is_piece(Square s) { return s > 0; }
+
+static inline enum Player get_owner(Square s) { return (enum Player)(s >> 1 & 0x1); }
+static inline enum Piece get_piece(Square s) { return (enum Piece)(s >> 2 & 0x7); }
+static inline enum Orientation get_orientation(Square s) { return (enum Orientation)(s >> 5 & 0x7); }
+
+static inline Move new_move(int start, int end, int rotation) { return start << 1 | end << 8 | (rotation + 2) << 15; }
+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; }
+
+static inline Square rotate(Square s, int rotation)
+{
+    int orientation = get_orientation(s);
+    orientation = (orientation + rotation) % 4;
+    if (orientation < 0)
+        orientation += 4;
+    return (s & 0x1F) + (orientation << 5);
+}
+
+static inline enum Player opposite_player(enum Player player)
+{
+    return player == Red ? Silver : Red;
+}
+
+#define Dead -1
+#define Absorbed -2
+
+// [laser direciton][piece type][piece orientation] = reflection result
+// anubis, pyramid, scarab, pharaoh, sphinx
+static const int reflections[4][5][4] = {
+    {// North
+     {Dead, Dead, Absorbed, Dead},
+     {Dead, East, West, Dead},
+     {West, East, West, East},
+     {Dead, Dead, Dead, Dead},
+     {Absorbed, Absorbed, Absorbed, Absorbed}},
+    {// East
+     {Dead, Dead, Dead, Absorbed},
+     {Dead, Dead, South, North},
+     {South, North, South, North},
+     {Dead, Dead, Dead, Dead},
+     {Absorbed, Absorbed, Absorbed, Absorbed}},
+    {// South
+     {Absorbed, Dead, Dead, Dead},
+     {East, Dead, Dead, West},
+     {East, West, East, West},
+     {Dead, Dead, Dead, Dead},
+     {Absorbed, Absorbed, Absorbed, Absorbed}},
+    {// West
+     {Dead, Absorbed, Dead, Dead},
+     {North, South, Dead, Dead},
+     {North, South, North, South},
+     {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();
+static uint64_t seed = 1070372;
+static inline uint64_t random_number()
+{
+    seed ^= seed >> 12;
+    seed ^= seed << 25;
+    seed ^= seed >> 27;
+    return seed * 0x2545F4914F6CDD1DLL;
+}
+
+#define TABLE_SIZE 0x400000
+
+#define EXACT 0
+#define ALPHA 1
+#define BETA 2
+typedef struct HashEntry
+{
+    uint64_t key;
+    int depth;
+    int flag;
+    int score;
+    Move move;
+} 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/khetai.gemspec

@@ -0,0 +1,26 @@
+require_relative 'lib/khetai/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "khetai"
+  spec.version       = KhetAI::VERSION
+  spec.authors       = ["jkugs"]
+  spec.email         = ["jkuglics@gmail.com"]
+
+  spec.summary       = "Khet AI"
+  spec.homepage      = "https://github.com/jkugs/khetai"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.extensions    = %w[ext/khetai/extconf.rb]
+end

data/lib/khetai/version.rb

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

data/lib/khetai.rb

@@ -0,0 +1,6 @@
+require "khetai/version"
+require "khetai/khetai"
+
+module KhetAI
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: khetai
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+platform: ruby
+authors:
+- jkugs
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2022-02-24 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- jkuglics@gmail.com
+executables: []
+extensions:
+- ext/khetai/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- README_ORIGINAL.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/khetai/extconf.rb
+- ext/khetai/khetai.c
+- ext/khetai/khetai_lib.c
+- ext/khetai/khetai_lib.h
+- khetai.gemspec
+- lib/khetai.rb
+- lib/khetai/version.rb
+homepage: https://github.com/jkugs/khetai
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jkugs/khetai
+  source_code_uri: https://github.com/jkugs/khetai
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Khet AI
+test_files: []