Skip to content

Embed URL

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Joy of Clojure Chess Example in Familiar/JRuby
# Rough translation from Joy of Clojure refs example in Familiar
# https://github.com/daveray/familiar
# https://github.com/joyofclojure/book-source/blob/master/src/joy/refs.clj
$initial_board = [[:o, :k, :o],
[:o, :o, :o],
[:o, :K, :o]].to_clojure
# (defn board-map [f bd]
# (vec (map #(vec (for [s %] (f s))) bd)))
def board_map(f, bd)
Familiar.with do
vec(map(fn {|v| vec(map f, v)}, bd))
end
end
# (defn reset!
# "Resets the board state. Generally these types of functions are a
# bad idea, but matters of page count force our hand."
# []
# (def board (board-map ref initial-board))
# (def to-move (ref [[:K [2 1]] [:k [0 1]]]))
# (def num-moves (ref 0)))
def reset!
$board = board_map Familiar[:ref], $initial_board
$to_move = Familiar.ref [[:K, [2, 1]], [:k, [0, 1]]].to_clojure
$num_moves = Familiar.ref 0
end
# (defn neighbors
# ([size yx]
# (neighbors [[-1 0] [1 0] [0 -1] [0 1]] size yx))
# ([deltas size yx]
# (filter
# (fn [new-yx] (every? #(< -1 % size) new-yx))
# (map #(vec (map + yx %)) deltas))))
def neighbors(deltas, size, yx)
#deltas = [[-1, 0], [1, 0], [0, -1], [0, 1]].to_clojure
Familiar.with do
plus = self[:+]
on_board = fn {|v| -1 < v && v < size }
filter fn {|new_yx| every? on_board, new_yx},
map(fn {|v| vec(map plus, yx, v)}, deltas)
end
end
#(def king-moves (partial neighbors [[-1 -1] [-1 0] [-1 1] [0 -1] [0 1] [1 -1] [1 0] [1 1]] 3))
$king_moves = Familiar.with do
partial fn(method(:neighbors).to_proc),
[[-1, -1], [-1, 0], [-1, 1], [0, -1], [0, 1], [1, -1], [1, 0], [1, 1]].to_clojure,
3
end
#(defn good-move? [to enemy-sq] (when (not= to enemy-sq) to))
def good_move?(to, enemy_sq)
to != enemy_sq ? to : nil
end
#(defn choose-move [[[mover mpos][_ enemy-pos]]]
# [mover
# (some #(good-move? % enemy-pos) (shuffle (king-moves mpos)))])
def choose_move(tm)
Familiar.with do
mover = ffirst(tm)
mpos = second(first(tm))
enemy_pos = second(second(tm))
vector mover,
some(fn {|v| good_move?(v, enemy_pos)},
shuffle($king_moves.invoke(mpos)))
end
end
#(defn place [from to] to)
$place = Familiar.fn {|from, to| to}
# (defn move-piece [[piece dest] [[_ src] _]]
# (alter (get-in board dest) place piece)
# (alter (get-in board src ) place :o)
# (alter num-moves inc))
def move_piece(move, to_move)
Familiar.with do
piece = first(move)
dest = second(move)
src = second(first(to_move))
alter get_in($board, dest), $place, piece
alter get_in($board, src), $place, :o.to_clojure
alter $num_moves, self[:inc]
end
end
# (defn update-to-move [move]
# (alter to-move #(vector (second %) move)))
def update_to_move(move)
Familiar.with do
alter $to_move, fn {|v| vector(second(v), move)}
end
end
# (defn make-move []
# (dosync
# (let [move (choose-move @to-move)]
# (move-piece move @to-move)
# (update-to-move move))))
def make_move
Familiar.dosync do
move = choose_move $to_move.deref
move_piece move, $to_move.deref
update_to_move move
end
end
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Something went wrong with that request. Please try again.