connect_n_game 0.0.1

data/lib/cli/select_players.rb

@@ -0,0 +1,54 @@
+# coding: utf-8
+#Display and select player options.
+
+module ConnectNGame
+
+  class CLI
+
+    #Select all new players
+    def select_new_players
+      @players = []
+      top_up_players
+    end
+
+    #Make sure we have two players
+    def top_up_players
+      pick_a_player while @players.length < 2
+    end
+
+    #Have the user pick a player.
+    def pick_a_player
+      begin
+        show_players
+        print "\nEnter player #{@players.length+1} name: "
+        input = gets.strip
+        player = find_player(input)
+        puts "invalid entry #{input.inspect}" unless player
+      end until player
+
+      @players << player
+    end
+
+    #Display the available players
+    def show_players
+      puts
+      puts "Player Selection: "
+
+      width = (Player.players.map do |player|
+        player.name.length
+      end).max
+
+      Player.players.each do |player|
+        puts "  #{player.name.ljust(width+1)}  #{player.description}"
+      end
+    end
+
+    #Find the selected player.
+    def find_player(arg)
+      Player.players.find do |player|
+        player.name.downcase == arg.downcase
+      end
+    end
+
+  end
+end

data/lib/connect_n_game.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+
+require_relative 'connect_n_game/util'
+require_relative 'connect_n_game/exceptions'
+require_relative 'connect_n_game/game'
+require_relative 'connect_n_game/player'
+require_relative 'connect_n_game/ui'
+require_relative 'connect_n_game/version'
+
+#The Connect N \Game main module
+module ConnectNGame
+  #WIP
+end

data/lib/connect_n_game/exceptions.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+
+module ConnectNGame
+
+  #An invalid move was made.
+  class GameInvalidMove < StandardError; end
+
+end

data/lib/connect_n_game/game.rb

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+require_relative 'game/rack.rb'
+
+module ConnectNGame
+
+  #The \Game class of the connect_n_game.
+  #<br>Responsibility
+  #* This class is responsible for the overall operation of the game. It holds
+  #  the playing "rack", and the players. It also keeps a log of moves,
+  #  determines if the game has been won or if a stalemate has occurred.
+  #<br>Notes
+  #* The \Game class does NOT interact with the outside world. That is the
+  #  job of the UI object.
+  class Game
+
+    #The \game playing surface
+    attr_reader :rack
+
+    #Whose playing?
+    attr_reader :players
+
+    #The play log.
+    attr_reader :log
+
+    #The current player number.
+    attr_reader :current
+
+    #The last played turn number.
+    attr_reader :turn
+
+    #Create an instance of a \game object.
+    #<br>Parameters
+    #* player_ex - The player who moves first
+    #* payer_oh - The player who moves next
+    #* game_size - The size of the game connection (4..8). Default: 4
+    #<br>Returns
+    #* An instance of a \Game.
+    def initialize(player_ex, player_oh, game_size=4)
+      @game_size = game_size
+      #Set up player related data.
+      @players = { 1 => player_ex, 2 => player_oh }
+    end
+
+    #What player moves next?
+    #<br>Returns
+    #* An instance of a \Player.
+    def current_player
+      players[current]
+    end
+
+    def previous_player
+      players[(@current % 2) + 1]
+    end
+
+    #Get ready to start a game
+    def game_initialize
+      #Set up game play data.
+      @turn = 0
+      @current = 1
+      @rack = Rack.new(@game_size)
+      @log  = []
+
+      self
+    end
+
+    #Play the next move!
+    #<br>Returns
+    #* :victory, :stalemate, :continue, or :invalid_move
+    def next_move
+      channel = current_player.make_move(self, current)
+      score = rack.play_channel(channel, current)
+      @log << channel
+      @turn += 1
+
+      if score >= rack.order
+        :victory
+      elsif rack.rack_full?
+        :stalemate
+      else
+        @current = (@current % 2) + 1
+        :continue
+      end
+    end
+
+    #What was the last move?
+    def last_move
+      log[-1]
+    end
+
+  end
+
+end

data/lib/connect_n_game/game/rack.rb

@@ -0,0 +1,180 @@
+# coding: utf-8
+
+module ConnectNGame
+
+  #The class of game racks. That is a matrix of cells
+  class Rack
+
+    #The number in a row needed for victory.
+    attr_reader :order
+
+    #The depth of the playable area.
+    attr_reader :depth
+
+    #The width of the playable area.
+    attr_reader :width
+
+    #The raw playable area.
+    attr_reader :rack
+
+    #The names of the channels
+    attr_reader :channel_names
+
+    #The column weight values.
+    attr_reader :weights
+
+    #Create a rack of the appropriate order.
+    #<br>Parameters
+    #* order - The order of the game, that is the winning
+    #  number of pieces in a row.
+    def initialize(order)
+      unless (4..8).include?(order)
+        fail "Invalid game dimension #{order} not (4 .. 8)"
+      end
+
+      @order = order
+      @depth = @order + (order >> 1)
+      @width = @depth + (@depth.odd? ? 2 : 1)
+
+      @weights = [0.5]
+      weight = 4
+
+      (@width/2).times do
+        @weights << 1.0/weight
+        weight *= 2
+        @weights.insert(0, 1.0/weight)
+        weight *= 2
+      end
+
+      @channel_names = %w(A B C D E F G H I J K L M).first(width)
+
+      @rack = Array.new(@width) { [ ] }
+    end
+
+    #Get the required play channel
+    #<br>Parameters
+    #* channel - The channel number 1 .. width
+    #<br>Returns
+    #* The requested channel (array) or nil for invalid channels.
+    def get_channel(channel)
+      rack[channel-1]
+    end
+
+    #Is the selected channel full?
+    #<br>Parameters
+    #* channel - The channel number 1 .. width
+    #<br>Returns
+    #* true if full else false.
+    def channel_full?(channel)
+      get_channel(channel).length >= depth
+    end
+
+    #Is the rack full?
+    #<br>Returns
+    #* true if full (or invalid) else false.
+    def rack_full?
+      rack.each do |channel|
+        return false if channel.length < depth
+      end
+
+      true
+    end
+
+    #Get the specified cell.
+    #<br>Parameters
+    #* channel - The channel number 1 .. width
+    #* row - The row number 1 .. depth
+    #<br>Returns
+    #* The contents of the cell or nil
+    def get_cell(channel, row)
+      return nil unless valid_channel?(channel)
+      return nil unless valid_row?(row)
+
+      rack[channel-1][row-1]
+    end
+
+    #Play a specified channel.
+    #<br>Parameters
+    #* channel - The channel number 1 .. width
+    #* piece - The piece to be played.
+    #<br>Returns
+    #* The score of the move or raises \GameInvalidMove exception.
+    def play_channel(channel, piece)
+      score = score_move(channel, piece)
+      rack[channel-1] << piece if score > 0
+      score
+    end
+
+    #Determine the score obtained for moving to a specified channel
+    #<br>Parameters
+    #* channel - The channel number 1 .. width
+    #* piece - The piece to be played.
+    #<br>Returns
+    #* The score for that play 0 .. n
+    def score_move(channel, piece)
+      return -9 if channel_full?(channel)
+
+      row = channel_to_row(channel)
+
+      ([[0,1], [1,1], [1,0], [1,-1]].map do |delta|
+        dx, dy = delta
+        count_pieces(channel, row,  dx,  dy, piece) + 1 +
+        count_pieces(channel, row, -dx, -dy, piece)
+      end).max
+    end
+
+    #Count the pieces along the designated path.
+    #<br>Parameters
+    #* channel - The starting channel
+    #* row - The starting row
+    #* dx - The channel step value
+    #* dy - The row step value
+    #* piece - The piece we are looking for.
+    #<br>Returns
+    #* The score for that play 0 .. n
+    def count_pieces(channel, row, dx, dy, piece)
+      result = 0
+
+      while result < width
+        channel, row = channel+dx, row+dy
+
+        return result unless piece == get_cell(channel, row)
+
+        result += 1
+      end
+
+      fail "Looping error"
+    end
+
+    #Get the free row for the specified channel.
+    #<br>Parameters
+    #* channel - The channel number 1 .. width
+    #<br>Returns
+    #* The row number or nil.
+    def channel_to_row(channel)
+      channel_full?(channel) ? nil : rack[channel-1].length + 1
+    end
+
+    #Is this a valid channel?
+    def valid_channel?(channel)
+      (1..width).include?(channel)
+    end
+
+    #Is this a valid row?
+    def valid_row?(row)
+      (1..depth).include?(row)
+    end
+
+    #Clone the internal array.
+    def deep_clone
+      @rack = @rack.clone
+
+      (0...@width).each do |index|
+        @rack[index] = @rack[index].clone
+      end
+
+      self
+    end
+  end
+
+end

data/lib/connect_n_game/human.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+module ConnectNGame
+
+  #The Human player simply makes carbon based moves.
+  class Human < Player
+
+    #Build the player
+    def initialize(name = "Human")
+      super(name, "An actual player.", :carbon)
+    end
+
+    #Move generation is part of the user interface.
+
+    #The thrill of victory.
+    def winners_comments
+      "Congratulations #{name}! You're our winner today!"
+    end
+
+    #The agony of defeat
+    def losers_comments
+      "Too bad #{name}, you lose. Hang your head in shame."
+    end
+
+  end
+
+  Player.players << Human.new
+  Player.players << Human.new("Bruce")
+  Player.players << Human.new("Sheila")
+end

data/lib/connect_n_game/player.rb

@@ -0,0 +1,70 @@
+# coding: utf-8
+
+module ConnectNGame
+
+  #The abstract Player class of the connect_n_game.
+  #<br>Responsibility
+  #* This mostly abstract class is responsible for specifying the shared
+  #  behavior of all the sorts of players, both human and automaton. This is
+  #  where moves are generated, victory celebrated, and defeat mourned.
+  class Player
+    #Set up class instance data.
+    @players = []
+
+    class << self
+      #The list of available players.
+      attr_reader :players
+    end
+
+    # The name of this player.
+    attr_reader :name
+
+    # The description of this player.
+    attr_reader :description
+
+    #The type of this player: :carbon or :silicon
+    attr_reader :type
+
+    #Do the common player setup
+    #<br>Parameters
+    #* name - The name of the player.
+    #* description - A witty description of the player.
+    #* type - :carbon or :silicon
+    #<br>Returns
+    #* An instance of \Player
+    def initialize(name, description, type)
+       fail "Invalid type #{type}" unless [:carbon, :silicon].include?(type)
+       @name, @description, @type = name, description, type
+    end
+
+    #Is this an automaton?
+    def silicon?
+      type == :silicon
+    end
+
+    #Is this an organic life-form?
+    def carbon?
+      type == :carbon
+    end
+
+    #Make a move. This is dummy code for testing only.
+    #<br>Parameters
+    #* _game - the game being played - not used here.
+    #* piece - the piece to be played, 1 or 2.
+    #<br>Returns
+    #* A move, 1 .. rack.width
+    def make_move(_game, piece)
+      piece
+    end
+
+  end
+
+end
+
+require_relative 'human' #Humans come first!!!
+
+#Load up the players!
+Dir[File.dirname(__FILE__) + '/players/*.rb'].each {|file| require file }
+
+#Sort them
+ConnectNGame::Player.players.sort! {|a,b| a.name.casecmp(b.name) }