connect_n_game 0.0.1

data/lib/connect_n_game/players/basic.rb

@@ -0,0 +1,39 @@
+# coding: utf-8
+
+module ConnectNGame
+
+  #The EchoMoves echoes moves when possible.
+  class BasicMoves < Player
+
+    #Build the player
+    def initialize(name = "Basic")
+      super(name, "Minimum tactical analysis.", :silicon)
+    end
+
+    #Make a move. This bot picks the move with the highest score.
+    #<br>Parameters
+    #* game - the game being played.
+    #* piece - the piece to be played, 1 or 2.
+    #<br>Returns
+    #* A move, 1 .. rack.width
+    def make_move(game, piece)
+      (game.rack.weights.each_with_index.map do |weight, index|
+        channel = index + 1
+        [weight + game.rack.score_move(channel, piece), channel]
+      end).sort.show_weights("Scan").last[1]
+    end
+
+    #The thrill of victory.
+    def winners_comments
+      "#{name} says 'A genius in my own mind!'"
+    end
+
+    #The agony of defeat
+    def losers_comments
+      "#{name} says 'Hmmm... What did I miss?'"
+    end
+
+  end
+
+  Player.players << BasicMoves.new
+end

data/lib/connect_n_game/players/echo.rb

@@ -0,0 +1,45 @@
+# coding: utf-8
+
+module ConnectNGame
+
+  #The EchoMoves echoes moves when possible.
+  class EchoMoves < Player
+
+    #Build the player
+    def initialize(name = "Echo")
+      super(name, "Really unoriginal.", :silicon)
+    end
+
+    #Make a move. This bot parrots the previous move when it can,
+    #and moves randomly when it cannot.
+    #<br>Parameters
+    #* game - the game being played.
+    #* _piece - the piece to be played, 1 or 2. (Not used here)
+    #<br>Returns
+    #* A move, 1 .. rack.width
+    def make_move(game, _piece)
+      channel = game.last_move
+
+      unless channel && !game.rack.channel_full?(channel)
+        begin
+          channel = rand(1..(game.rack.width))
+        end while game.rack.channel_full?(channel)
+      end
+
+      channel
+    end
+
+    #The thrill of victory.
+    def winners_comments
+      "#{name} says 'How did this happen?'"
+    end
+
+    #The agony of defeat
+    def losers_comments
+      "#{name} says 'Yes! I came in second!'"
+    end
+
+  end
+
+  Player.players << EchoMoves.new
+end

data/lib/connect_n_game/players/just_random.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+module ConnectNGame
+
+  #The JustRandom player simply make random moves.
+  class JustRandom < Player
+
+    #Build the player
+    def initialize(name = "Random")
+      super(name, "Moves randomly.", :silicon)
+    end
+
+    #Make a move. This bot moves randomly.
+    #<br>Parameters
+    #* game - the game being played.
+    #* _piece - the piece to be played, 1 or 2. (Not used here)
+    #<br>Returns
+    #* A move, 1 .. rack.width
+    def make_move(game, _piece)
+      begin
+        channel = rand(1..(game.rack.width))
+      end while game.rack.channel_full?(channel)
+
+      channel
+    end
+
+    #The thrill of victory.
+    def winners_comments
+      "#{name} says 'It was all up to pure skill!'"
+    end
+
+    #The agony of defeat
+    def losers_comments
+      "#{name} says 'No comment.'"
+    end
+
+  end
+
+  Player.players << JustRandom.new
+end

data/lib/connect_n_game/players/middle.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+
+module ConnectNGame
+
+  #The EchoMoves echoes moves when possible.
+  class MiddleMoves < Player
+
+    #Build the player
+    def initialize(name = "Middle")
+      super(name, "Moves toward the middle", :silicon)
+    end
+
+    #Make a move. This bot prefers to play the middle.
+    #<br>Parameters
+    #* game - the game being played.
+    #* _piece - the piece to be played, 1 or 2. (Not used here)
+    #<br>Returns
+    #* A move, 1 .. rack.width
+    def make_move(game, _piece)
+      weights = game.rack.weights.each_with_index.to_a
+
+      weights.sort.reverse_each do |weight, index|
+        channel = index + 1
+        return channel unless game.rack.channel_full?(channel)
+      end
+    end
+
+    #The thrill of victory.
+    def winners_comments
+      "#{name} says 'Slow and steady wins the race!'"
+    end
+
+    #The agony of defeat
+    def losers_comments
+      "#{name} says 'I lost to the lunatic fringe!'"
+    end
+
+  end
+
+  Player.players << MiddleMoves.new
+end

data/lib/connect_n_game/players/prudent.rb

@@ -0,0 +1,67 @@
+# coding: utf-8
+
+module ConnectNGame
+
+  #The EchoMoves echoes moves when possible.
+  class Prudent < Player
+
+    #Build the player
+    def initialize(name = "Prudent")
+      super(name, "Minimum tactical analysis with some defense.", :silicon)
+    end
+
+    #Make a move. This bot picks the move with the highest score.
+    #<br>Parameters
+    #* game - the game being played.
+    #* piece - the piece to be played, 1 or 2.
+    #<br>Returns
+    #* A move, 1 .. rack.width
+    def make_move(game, piece)
+      #Compute the moves of the first ply.
+      first_ply = (game.rack.weights.each_with_index.map do |weight, index|
+        channel = index + 1
+        [weight + game.rack.score_move(channel, piece), channel]
+      end).sort.show_weights("Scan 1")
+
+      #If we're done, stop.
+      return first_ply.last[1] if first_ply.last[0] >= game.rack.order
+
+      #Factor in the behavior of the opponent.
+      (0...(first_ply.length)).each do |index|
+        copy = game.rack.clone.deep_clone
+
+        copy.rack[first_ply[index][1]-1] << piece
+        first_ply[index][0] -= check_opponent(copy, (piece % 2) + 1)
+      end
+
+      first_ply.sort.show_weights("Scan 2").last[1]
+    end
+
+    #Check for the opponent's best moves at this level
+    def check_opponent(rack, piece)
+      threshold = rack.order - 1
+      result = 0
+
+      (1..rack.width).each do |channel|
+        score = rack.score_move(channel, piece)
+        score *= 2 if score > threshold
+        result += score if score >= threshold
+      end
+
+      result
+    end
+
+    #The thrill of victory.
+    def winners_comments
+      "#{name} says 'Good moves must give way to better!'"
+    end
+
+    #The agony of defeat
+    def losers_comments
+      "#{name} says 'How could I have missed this?'"
+    end
+
+  end
+
+  Player.players << Prudent.new
+end

data/lib/connect_n_game/ui.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+
+module ConnectNGame
+
+  #The abstract \UI (User Interface) class of the connect_n_game.
+  class UI
+  end
+
+end

data/lib/connect_n_game/util.rb

@@ -0,0 +1,26 @@
+# coding: utf-8
+
+#A small utility module
+module Utl
+  #An array with some letters in it and a place holder at zero.
+  Letters = %w(x A B C D E F G H I J K L M N O P Q R S T U V W X Y Z)
+
+  #Convert a channel name to its number.
+  #<br>Parameters
+  #* letter - the letter that was played.
+  #<br>Returns
+  #* The channel number (1..26) or nil if invalid.
+  def self.name_to_channel(letter)
+    Letters.find_index(letter[0].upcase)
+  end
+
+  #Convert a channel number to its name.
+  #<br>Parameters
+  #* channel - the channel number (1..26),
+  #<br>Returns
+  #* The channel letter.
+  def self.channel_to_name(channel)
+    Letters[channel]
+  end
+
+end

data/lib/connect_n_game/version.rb

@@ -0,0 +1,5 @@
+
+module ConnectNGame
+  #The version of the Connect N \Game.
+  VERSION = "0.0.1"
+end

data/tests/test_game.rb

@@ -0,0 +1,53 @@
+# coding: utf-8
+
+require_relative '../lib/connect_n_game'
+gem              'minitest'
+require          'minitest/autorun'
+
+#Test the standard fOOrth library.
+class GameTester < Minitest::Test
+
+  #Test that this test was run!
+  def test_dummy
+    assert_equal(ConnectNGame::VERSION.class, String)
+  end
+
+  #Test that it knows how to play.
+  def test_taking_turns
+    pl1 = ConnectNGame::Player.new("A", "OK",   :silicon)
+    pl2 = ConnectNGame::Player.new("B", "GOOD", :carbon)
+
+    game = ConnectNGame::Game.new(pl1, pl2).game_initialize
+
+    assert_equal(4, game.rack.order)
+    assert_equal(pl1, game.current_player)
+    assert_equal(:continue, game.next_move)
+    assert_equal(1, game.turn)
+
+    assert_equal(pl2, game.current_player)
+    assert_equal(:continue, game.next_move)
+    assert_equal(2, game.turn)
+
+    assert_equal(pl1, game.current_player)
+    assert_equal(:continue, game.next_move)
+    assert_equal(3, game.turn)
+
+    assert_equal(pl2, game.current_player)
+    assert_equal(:continue, game.next_move)
+    assert_equal(4, game.turn)
+
+    assert_equal(pl1, game.current_player)
+    assert_equal(:continue, game.next_move)
+    assert_equal(5, game.turn)
+
+    assert_equal(pl2, game.current_player)
+    assert_equal(:continue, game.next_move)
+    assert_equal(6, game.turn)
+
+    assert_equal(pl1, game.current_player)
+    assert_equal(:victory, game.next_move)
+    assert_equal(7, game.turn)
+  end
+
+
+end

data/tests/test_module.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+
+require_relative '../lib/connect_n_game'
+gem              'minitest'
+require          'minitest/autorun'
+
+#Test the standard fOOrth library.
+class ConnectNGameTester < Minitest::Test
+
+  #Test that all the pieces are in the box!
+  def test_modules_and_classes_exist
+    assert_equal(ConnectNGame.class, Module)
+    assert_equal(ConnectNGame::VERSION.class, String)
+    assert_equal(ConnectNGame::Game.class, Class)
+    assert_equal(ConnectNGame::Player.class, Class)
+    assert_equal(ConnectNGame::UI.class, Class)
+  end
+
+
+end

data/tests/test_player.rb

@@ -0,0 +1,55 @@
+# coding: utf-8
+
+require_relative '../lib/connect_n_game'
+gem              'minitest'
+require          'minitest/autorun'
+
+#Test the standard fOOrth library.
+class PlayerTester < Minitest::Test
+
+  #Test that this test was run!
+  def test_dummy
+    assert_equal(String, ConnectNGame::VERSION.class)
+  end
+
+  def test_abstract_behaviours
+    #It should have the attributes of name, description, and type.
+    atp = ConnectNGame::Player.new("Ted", "Cool", :carbon)
+    assert_equal("Ted", atp.name)
+    assert_equal("Cool", atp.description)
+    assert_equal(:carbon, atp.type)
+    assert(atp.carbon?)
+    refute(atp.silicon?)
+
+    #It should reject invalid player types.
+    assert_raises { ConnectNGame::Player.new("Ted", "Cool", :germanium) }
+  end
+
+  #We should be able to sort players alphabetically by name.
+  def test_that_it_is_sortable
+    aop = []
+    aop << ConnectNGame::Player.new("Ted",   "Cool",    :carbon)
+    aop << ConnectNGame::Player.new("apple", "Cooler",  :silicon)
+    aop << ConnectNGame::Player.new("Ed",    "Coolest", :carbon)
+
+    aop.sort! {|a,b| a.name.casecmp(b.name) }
+
+    assert_equal("apple", aop[0].name)
+    assert(aop[0].silicon?)
+    refute(aop[0].carbon?)
+
+    assert_equal("Ed",    aop[1].name)
+    refute(aop[1].silicon?)
+    assert(aop[1].carbon?)
+
+    assert_equal("Ted",   aop[2].name)
+    refute(aop[2].silicon?)
+    assert(aop[2].carbon?)
+  end
+
+  #Test that it loads up available players.
+  def test_player_loading
+    assert_equal(Array, ConnectNGame::Player.players.class)
+  end
+
+end

data/tests/test_rack.rb

@@ -0,0 +1,222 @@
+# coding: utf-8
+
+require_relative '../lib/connect_n_game'
+gem              'minitest'
+require          'minitest/autorun'
+
+#Test the standard fOOrth library.
+class RackTester < Minitest::Test
+
+  #Test that this test was run!
+  def test_dummy
+    assert_equal(ConnectNGame::VERSION.class, String)
+  end
+
+  #Test that we can create racks.
+  def test_creating_racks
+    assert_raises { ConnectNGame::Rack.new(3) }
+
+    tr = ConnectNGame::Rack.new(4)
+    assert_equal(4, tr.order)
+    assert_equal(6, tr.depth)
+    assert_equal(7, tr.width)
+    assert_equal([[],[],[],[],[],[],[]], tr.rack)
+    assert_equal(%w(A B C D E F G), tr.channel_names)
+    assert_equal([0.0078125, 0.03125, 0.125, 0.5, 0.25, 0.0625,
+                  0.015625], tr.weights)
+
+    tr = ConnectNGame::Rack.new(5)
+    assert_equal(5, tr.order)
+    assert_equal(7, tr.depth)
+    assert_equal(9, tr.width)
+    assert_equal([[],[],[],[],[],[],[],[],[]], tr.rack)
+    assert_equal(%w(A B C D E F G H I), tr.channel_names)
+    assert_equal([0.001953125, 0.0078125, 0.03125, 0.125, 0.5,
+                  0.25, 0.0625, 0.015625, 0.00390625], tr.weights)
+
+    tr = ConnectNGame::Rack.new(6)
+    assert_equal(6, tr.order)
+    assert_equal(9, tr.depth)
+    assert_equal(11, tr.width)
+    assert_equal([[],[],[],[],[],[],[],[],[],[],[]], tr.rack)
+    assert_equal(%w(A B C D E F G H I J K), tr.channel_names)
+    assert_equal([0.00048828125, 0.001953125, 0.0078125, 0.03125,
+                  0.125, 0.5, 0.25, 0.0625, 0.015625, 0.00390625,
+                  0.0009765625], tr.weights)
+
+    tr = ConnectNGame::Rack.new(7)
+    assert_equal(7, tr.order)
+    assert_equal(10, tr.depth)
+    assert_equal(11, tr.width)
+    assert_equal([[],[],[],[],[],[],[],[],[],[],[]], tr.rack)
+    assert_equal(%w(A B C D E F G H I J K), tr.channel_names)
+    assert_equal([0.00048828125, 0.001953125, 0.0078125, 0.03125,
+                  0.125, 0.5, 0.25, 0.0625, 0.015625, 0.00390625,
+                  0.0009765625], tr.weights)
+
+    tr = ConnectNGame::Rack.new(8)
+    assert_equal(8, tr.order)
+    assert_equal(12, tr.depth)
+    assert_equal(13, tr.width)
+    assert_equal([[],[],[],[],[],[],[],[],[],[],[],[],[]], tr.rack)
+    assert_equal(%w(A B C D E F G H I J K L M), tr.channel_names)
+    assert_equal([0.0001220703125, 0.00048828125, 0.001953125,
+                  0.0078125, 0.03125, 0.125, 0.5, 0.25, 0.0625,
+                  0.015625, 0.00390625, 0.0009765625,
+                  0.000244140625], tr.weights)
+
+    assert_raises { ConnectNGame::Rack.new(9) }
+  end
+
+  #Test that it can retrieve channels
+  def test_get_channel
+    (4..8).each do |order|
+      tr = ConnectNGame::Rack.new(order)
+
+      (1..(tr.width)).each do |ch|
+        assert_equal([], tr.get_channel(ch))
+      end
+    end
+  end
+
+  #Test that it knows when a channel is full
+  def test_channel_and_rack_full
+    (4..8).each do |order|
+      tr = ConnectNGame::Rack.new(order)
+
+      #The channels are being filled.
+      (1..tr.depth).each do | _depth |
+
+        refute(tr.rack_full?)
+
+        (1..tr.width).each do | channel |
+
+          refute(tr.channel_full?(channel))
+
+          tr.get_channel(channel) << 1
+        end
+      end
+
+      #Now all the channels should be full.
+      (1..tr.width).each do | channel |
+        assert(tr.channel_full?(channel))
+      end
+
+      assert(tr.rack_full?)
+    end
+  end
+
+  #Test that we can query individual cells
+  def test_get_cell
+    tr = ConnectNGame::Rack.new(4)
+    assert_equal(nil, tr.get_cell(1,1))
+    assert_equal(nil, tr.get_cell(1,2))
+    assert_equal(nil, tr.get_cell(1,3))
+
+    tr.get_channel(1) << 1
+    assert_equal(1, tr.get_cell(1,1))
+    assert_equal(nil, tr.get_cell(1,2))
+    assert_equal(nil, tr.get_cell(1,3))
+
+    tr.get_channel(1) << 2
+    assert_equal(1, tr.get_cell(1,1))
+    assert_equal(2, tr.get_cell(1,2))
+    assert_equal(nil, tr.get_cell(1,3))
+
+    tr.get_channel(1) << 1
+    assert_equal(1, tr.get_cell(1,1))
+    assert_equal(2, tr.get_cell(1,2))
+    assert_equal(1, tr.get_cell(1,3))
+  end
+
+  #Test that we can play a channel.
+  def test_play_channel
+    tr = ConnectNGame::Rack.new(4)
+
+    assert_equal(1, tr.play_channel(1, 1))
+    assert_equal(2, tr.play_channel(1, 1))
+    assert_equal(3, tr.play_channel(1, 1))
+    assert_equal(4, tr.play_channel(1, 1))
+    assert_equal(5, tr.play_channel(1, 1))
+    assert_equal(6, tr.play_channel(1, 1))
+
+    #Playing a full channel has no effect or score.
+    assert_equal(6, tr.get_channel(1).length)
+    assert_equal(-9, tr.play_channel(1, 1))
+    assert_equal(6, tr.get_channel(1).length)
+  end
+
+  #Test getting the free row for a channel
+  def test_channel_to_row
+    tr = ConnectNGame::Rack.new(4)
+
+    assert_equal(1, tr.channel_to_row(1))
+
+    tr.play_channel(1,1)
+    assert_equal(2, tr.channel_to_row(1))
+
+    tr.play_channel(1,1)
+    assert_equal(3, tr.channel_to_row(1))
+
+    tr.play_channel(1,1)
+    assert_equal(4, tr.channel_to_row(1))
+
+    tr.play_channel(1,1)
+    assert_equal(5, tr.channel_to_row(1))
+
+    tr.play_channel(1,1)
+    assert_equal(6, tr.channel_to_row(1))
+
+    tr.play_channel(1,1)
+    assert_equal(nil, tr.channel_to_row(1))
+  end
+
+  #Test that we can count cells around a position.
+  def test_score_move
+    tr = ConnectNGame::Rack.new(4)
+    #.......
+    #.......
+    #.......
+    #.......
+
+    assert_equal(1, tr.play_channel(3,1))
+    #.......
+    #.......
+    #.......
+    #..X....
+
+    assert_equal(2, tr.play_channel(4,1))
+    #.......
+    #.......
+    #.......
+    #..XX...
+
+    assert_equal(2, tr.play_channel(4,1))
+    #.......
+    #.......
+    #...X...
+    #..XX...
+
+    assert_equal(2, tr.play_channel(3,1))
+    #.......
+    #.......
+    #..XX...
+    #..XX...
+
+    assert_equal(3, tr.play_channel(3,1))
+    #.......
+    #..X....
+    #..XX...
+    #..XX...
+
+    assert_equal(4, tr.play_channel(3,1))
+    #..X....
+    #..X....
+    #..XX...
+    #..XX...
+
+    #It should not hang either!
+    assert_raises { tr.score_move(3, nil) }
+  end
+
+end