bashrw_ttt 0.1.0

data/lib/ttt/four_by_four.rb

@@ -0,0 +1,62 @@
+require 'ttt/board'
+module TTT
+  class FourByFour < Board
+    attr_accessor :x_arr, :diag_arr, :block_arr
+    def initialize
+      self.board   = Array.new(16, " ")
+      self.x_arr   = [[0,1,2,3], [4,5,6,7], [8,9,10,11], [12,13,14,15]]
+      self.diag_arr = [[0, 5, 10, 15], [3, 6, 9, 12]]
+      self.block_arr = [[0,1,4,5], [1,2,5,6], [2,3,6,7], [4,5,8,9], [5,6,9,10], [6,7,10,11], [8,9,12,13], [9,10,13,14], [10,11,14,15]]
+    end
+
+    def winner?
+      horizontal_winner? || vertical_winner? || diag_winner? || block_winner?
+    end
+
+    def horizontal_winner?
+      x_arr.each do |x_win|
+        return true if board[x_win[0]] != " " &&
+                        board[x_win[0]] == board[x_win[1]] &&
+                        board[x_win[1]] == board[x_win[2]] &&
+                        board[x_win[2]] == board[x_win[3]]
+      end
+      false
+    end
+
+    def vertical_winner?
+      x_arr.transpose.each do |y_win|
+        return true if board[y_win[0]] != " " &&
+                        board[y_win[0]] == board[y_win[1]] &&
+                        board[y_win[1]] == board[y_win[2]] &&
+                        board[y_win[2]] == board[y_win[3]]
+      end
+      false
+    end
+
+    def diag_winner?
+      diag_arr.each do |diag_win|
+         return true if board[diag_win[0]] != " " &&
+                        board[diag_win[0]] == board[diag_win[1]] &&
+                        board[diag_win[1]] == board[diag_win[2]] &&
+                        board[diag_win[2]] == board[diag_win[3]]
+
+      end
+      false
+    end
+
+    def block_winner?
+      block_arr.each do |block_win|
+         return true if board[block_win[0]] != " " &&
+                        board[block_win[0]] == board[block_win[1]] &&
+                        board[block_win[1]] == board[block_win[2]] &&
+                        board[block_win[2]] == board[block_win[3]]
+
+      end
+      false
+    end
+
+    def board_type
+      "four_by_four"
+    end
+  end
+end

data/lib/ttt/game.rb

@@ -0,0 +1,94 @@
+module TTT
+  class Game
+    attr_accessor :board, :player1, :player2, :current_player, :history, :db
+
+    def initialize(options)
+      self.board          = options[:board]
+      self.player1        = options[:player1]
+      self.player2        = options[:player2]
+      self.current_player = self.player1
+      self.history        = options.fetch(:history)
+    end
+
+    def ai_move?
+      current_player.no_gui?
+    end
+
+    def which_board
+      board.board_type
+    end
+
+    def next_move
+      return nil unless ai_move?
+      input = current_player.move(:board => board)
+      mark_move(input)
+      record_move(input)
+      switch_player
+      input
+    end
+
+    def valid_move?(input)
+      input.class == Fixnum && 0 <= input && input <= (board[].length - 1) && board.free?(input.to_i)
+    end
+
+    def mark_move(cell, side = current_player.side)
+      board.update(cell, side)
+    end
+
+    def record_move(cell, side = current_player.side)
+      history.record_move(cell, side)
+    end
+
+    def show_history
+      history.show
+    end
+
+    def adjust_move_index(index_diff)
+      history.adjust_move_index(index_diff)
+    end
+
+    def get_history_board(move_number_limit = history.move_traverser.move_index)
+      history.get_history_board(board, move_number_limit)
+    end
+
+    def initialize_history
+      history.initialize_history
+    end
+
+    def switch_player
+      if player1.side == current_player.side
+        self.current_player = self.player2
+      else
+        self.current_player = self.player1
+      end
+    end
+
+    def which_current_player?
+      current_player.equal?(player1) ? "Player 1" : "Player 2"
+    end
+
+    def last_player
+      current_player == player1 ? "Player 2" : "Player 1"
+    end
+
+    def finished?
+      board.finished?
+    end
+
+    def not_finished?
+      !board.finished?
+    end
+
+    def winner?
+      board.winner?
+    end
+
+    def draw?
+      board.draw_game?
+    end
+
+    def board_arr
+      board[]
+    end
+  end
+end

data/lib/ttt/game_history.rb

@@ -0,0 +1,37 @@
+require 'ttt/move_history'
+require 'ttt/move_traverser'
+
+module TTT
+  class GameHistory
+    attr_accessor :history, :move_traverser
+    def initialize
+      self.history         = []
+      self.move_traverser  = MoveTraverser.new(self)
+    end
+
+    def record_move(cell, side)
+      self.history << MoveHistory.new(:move => cell, :side => side)
+      inc_move_index
+    end
+
+    def inc_move_index
+      self.move_traverser.move_index = history.length
+    end
+
+    def show
+      self.history
+    end
+
+    def adjust_move_index(index_diff)
+      move_traverser.adjust_move_index(index_diff)
+    end
+
+    def get_history_board(board, move_number_limit = move_traverser.move_index)
+      move_traverser.history_board_builder(board, move_number_limit)
+    end
+
+    def initialize_history
+      move_traverser.initialize_history
+    end
+  end
+end

data/lib/ttt/game_interactor.rb

@@ -0,0 +1,126 @@
+module TTT
+  class GameInteractor
+    def initialize(db)
+      self.db = db
+    end
+
+    def add_game(game)
+      db.add_game(game)
+    end
+
+    def get_game(id)
+      db.get_game(id)
+    end
+
+    def game_list
+      db.game_list
+    end
+
+    def save_game(id, game)
+      db.save_game(id, game)
+    end
+
+    def delete_game(id)
+      db.delete_game(id)
+    end
+
+    def ai_move?(game)
+      game.ai_move?
+    end
+
+    def ai_move(id, game)
+      game.next_move
+      save_game(id, game)
+    end
+
+    def finished?(game)
+      game.finished?
+    end
+
+    def not_finished?(game)
+      !game.finished?
+    end
+
+    def winner?(game)
+      game.winner?
+    end
+
+    def winner(game)
+      game.last_player
+    end
+
+    def draw?(game)
+      game.draw?
+    end
+
+    def which_board(game)
+      game.which_board
+    end
+
+    def valid_move?(game, move)
+      game.valid_move?(move)
+    end
+
+    def get_history(game)
+      game.show_history
+    end
+
+    def get_move_traverser(game)
+      game.history.move_traverser
+    end
+
+    def save_move_traverser(id, game, move_traverser)
+      game.history.move_traverser = move_traverser
+      save_game(id, game)
+    end
+
+    def get_history_board(game)
+      game.get_history_board
+    end
+
+    def initialize_history(game)
+      game.initialize_history
+    end
+
+    def get_history_length(game)
+      game.show_history.length
+    end
+
+    def switch_player(game)
+      game.switch_player
+    end
+
+    def which_current_player?(game)
+      game.which_current_player?
+    end
+
+    def board(game)
+      game.board[]
+    end
+
+    def update_game(game, cell, side)
+      mark_move(game, cell, side)
+      record_move(game, cell, side)
+      switch_player(game)
+    end
+
+    def mark_move(game, cell, side)
+      game.mark_move(cell, side)
+    end
+
+    def record_move(game, cell, side)
+      game.record_move(cell, side)
+    end
+
+    def adjust_move_index(game, value)
+      game.history.move_traverser.adjust_move_index(value)
+    end
+
+    def get_move_index(game)
+      game.history.move_traverser.move_index
+    end
+
+    private
+    attr_accessor :db
+  end
+end

data/lib/ttt/human.rb

@@ -0,0 +1,12 @@
+require 'ttt/player'
+module TTT
+  class Human < Player
+    def no_gui?
+      false
+    end
+
+    def prompt
+      "Enter move:"
+    end
+  end
+end

data/lib/ttt/interfaces/cli/lib/cli/board_selection.rb

@@ -0,0 +1,34 @@
+module CLI
+  class BoardSelection < Selection
+    attr_accessor :board, :boards, :presenter
+
+    def initialize(boards, presenter)
+      self.boards = boards
+      self.presenter = presenter
+    end
+
+    def process
+      presenter.board_selection_prompt(boards)
+      process_board_selection(presenter.input.chomp.to_i)
+      self
+    end
+
+    def process_board_selection(selection)
+      if board_selection_input_valid?(selection)
+        set_board_string(selection)
+      else
+        presenter.error
+        process
+      end
+    end
+
+    def board_selection_input_valid?(selection)
+      return false if selection.class == Float
+      0 < selection && selection <= boards.length
+    end
+
+    def set_board_string(selection)
+      self.board = boards[selection - 1]
+    end
+  end
+end

data/lib/ttt/interfaces/cli/lib/cli/cli_game.rb

@@ -0,0 +1,186 @@
+require 'cli/player_selection'
+require 'cli/board_selection'
+require 'cli/clio'
+require 'cli/play_again'
+require 'cli/cli_presenter'
+require 'cli/walk_history'
+
+module CLI
+  class CLIGame
+    attr_accessor :context, :presenter, :id, :games
+    def initialize(context, input, output)
+      self.context = context
+      self.presenter = CLIPresenter.new(input, output)
+    end
+
+    def play
+      user_selection = @presenter.menu
+      process_command(user_selection)
+    end
+
+    def process_command(selection)
+      case selection.chomp
+      when "1" then init_game
+      when "2" then game_list
+      when "3" then exit
+      else
+        play
+      end
+    end
+
+    def init_game
+      @presenter.welcome_prompt
+      player_select   = get_player_selection
+      board_select    = get_board_selection
+      new_game        = build_game(player_select, board_select)
+      @id             = @context.add_game(new_game)
+      play_game
+    end
+
+    def get_player_selection
+      PlayerSelection.new(@context.players, @presenter).process
+    end
+
+    def get_board_selection
+      BoardSelection.new(@context.boards, @presenter).process
+    end
+
+    def build_game(pselect, bselect)
+      @context.setup.new_game(player1: pselect.player1, player2: pselect.player2, board: bselect.board)
+    end
+
+    def play_game
+      while game.not_finished?
+       move_cycle
+      end
+      game_over
+    end
+
+    def game_over
+      walk_history
+      play_again
+    end
+
+    def game
+      @context.get_game(@id)
+    end
+
+    def move_cycle
+      cur_game = game
+      player_prompt(cur_game)
+      process_next_move
+    end
+
+    def player_prompt(cur_game)
+      @presenter.player_prompt(cur_game.board.board, cur_game.show_history, cur_game.current_player)
+    end
+
+    def process_next_move
+      if @context.ai_move?(@id)
+        @context.ai_move(@id)
+      else
+        move = get_next_move
+        if validate_move(move)
+          update_move(move)
+        else
+          move_cycle
+        end
+      end
+      eval_board_state
+    end
+
+    def get_next_move
+      if game.ai_move?
+        @context.ai_move(@id)
+      else
+        @presenter.input
+      end
+    end
+
+    def validate_move(move)
+      @context.valid_move?(@id, move.to_i)
+    end
+
+    def update_move(move)
+      @context.update_game(@id, move.to_i, game.current_player.side)
+    end
+
+    def eval_board_state
+      @presenter.process_winner(game.board_arr, game.show_history, game.last_player) if game.winner?
+      @presenter.process_draw(game.board_arr, game.show_history)                     if game.finished? && !game.winner?
+    end
+
+    def game_list
+      get_games
+      if @games
+        load_game
+      else
+        no_games
+      end
+    end
+
+    def get_games
+      @games = @context.game_list
+      @games = nil if @games.length == 0
+    end
+
+    def no_games
+      @presenter.no_games
+      sleep 1
+      play
+    end
+
+    def load_game
+      selection = @presenter.process_game_list(@games)
+      if @context.get_game(selection.chomp)
+        @id = selection.chomp
+        resume_game
+      else
+        game_list
+      end
+    end
+
+    def no_games
+      @presenter.no_games
+      sleep 1
+      play
+    end
+
+    def resume_game
+      @presenter.player_prompt(game.board[], game.show_history, game.current_player)
+      eval_board_state
+      play_game
+    end
+
+    def game
+      @context.get_game(@id)
+    end
+
+    def presenter=(args)
+      @presenter = args
+    end
+
+    def presenter
+      @presenter
+    end
+
+    def context=(args)
+      @context = args
+    end
+
+    def context
+      @context
+    end
+
+    def play_again
+      exit unless PlayAgain.new(@presenter).play_again?
+      play
+    end
+
+    def walk_history
+      @walk_history = WalkHistory.new(@presenter, game)
+      @walk_history.post_game_msg
+      play_again
+    end
+  end
+end