threesmodel 0.0.3

data/lib/game_board_folder.rb

@@ -0,0 +1,86 @@
+require_relative 'line_folder'
+require "Matrix"
+# A game board keeps and manipulates the state of the game.
+class GameBoardFolder
+
+  def initialize(line_folder = LineFolder.new )
+    @line_folder = line_folder
+  end
+
+  # Folds the game board from right to left.
+  def fold_left(state)
+    new_state = []
+    state.row_vectors.each_index {|i|
+      values = state.row_vectors[i].to_a
+      values = @line_folder.fold(values)
+      new_state << values
+    }
+    Matrix.rows(new_state)
+  end
+
+  # Folds the game board from left to right.
+  def fold_right(state)
+    new_state = []
+    state.row_vectors.each {|row|
+      values = row.to_a.reverse
+      values = @line_folder.fold(values)
+      new_state << values.reverse
+    }
+    Matrix.rows(new_state)
+  end
+
+  # Folds the game board upwards.
+  def fold_up(state)
+    new_state = []
+    state.column_vectors.each {|column|
+      values = column.to_a
+      values = @line_folder.fold(values)
+      new_state << values
+    }
+    Matrix.columns(new_state)
+  end
+
+  # Folds the game board downwards.
+  def fold_down(state)
+    new_state = []
+    state.column_vectors.each {|column|
+      values = column.to_a.reverse
+      values = @line_folder.fold(values)
+      new_state << values.reverse
+    }
+    Matrix.columns(new_state)
+  end
+
+  def can_fold_left?(state)
+    foldable = false
+    state.row_vectors.each{|line|
+      foldable = (foldable or @line_folder.can_fold?(line.to_a))
+    }
+    foldable
+  end
+
+  def can_fold_right?(state)
+    foldable = false
+    state.row_vectors.each{|line|
+      foldable = (foldable or @line_folder.can_fold?(line.to_a.reverse))
+    }
+    foldable
+  end
+
+  def can_fold_up?(state)
+    foldable = false
+    state.column_vectors.each{|line|
+      foldable = (foldable or @line_folder.can_fold?(line.to_a))
+    }
+    foldable
+  end
+
+  def can_fold_down?(state)
+    foldable = false
+    state.column_vectors.each{|line|
+      foldable = (foldable or @line_folder.can_fold?(line.to_a.reverse))
+    }
+    foldable
+  end
+
+end

data/lib/game_creator.rb

@@ -0,0 +1,30 @@
+require 'Matrix'
+
+class GameCreator
+  def self.create_new_game
+    positions = random_positions(9)
+    create_matrix(positions)
+  end
+
+  def self.create_matrix(positions)
+    rows = []
+    4.times {
+      rows << [0,0,0,0]
+    }
+    positions.each {|position|
+      rows[position[0]][position[1]] = rand(1..3)
+    }
+    Matrix.rows(rows)
+  end
+
+  def self.random_positions(number_of_positions)
+    positions = []
+    while (positions.length < number_of_positions)
+      candidate_position = [rand(0..3), rand(0..3)]
+      unless positions.include?(candidate_position)
+        positions << candidate_position
+      end
+    end
+    positions
+  end
+end

data/lib/game_over_checker.rb

@@ -0,0 +1,18 @@
+require_relative 'line_folder'
+class GameOverChecker
+
+  def initialize
+    @line_folder = LineFolder.new
+  end
+
+  def game_over?(state)
+    state.row_vectors.each {|row|
+      if ((@line_folder.can_fold?(row.to_a)) or (@line_folder.can_fold?(row.to_a.reverse))) then return false end
+    }
+    state.column_vectors.each{|column|
+      if ((@line_folder.can_fold?(column.to_a)) or (@line_folder.can_fold?(column.to_a.reverse))) then return false end
+    }
+    true
+  end
+
+end

data/lib/line_folder.rb

@@ -0,0 +1,93 @@
+# The LineFolder can fold an array with four cells according to the rules of
+# threes.
+class LineFolder
+
+  def initialize
+    Array.class_eval do
+      # Determines the "wall" position and the collapses the first to collapsible cells inserting a zero at the end. Assumes a foldable line.
+      def squash
+        array = Array.new(self)
+        wall_index = wall_index_of
+        array[wall_index] = array[wall_index] + array[wall_index + 1]
+        while wall_index < 2
+          array[wall_index + 1] = array[wall_index + 2]
+          wall_index += 1
+        end
+        array[3] = 0
+        return array
+      end
+
+      def wall_index_of
+        return 0 if self[0] == 0
+        return 0 if self[0] == 1 and self[1] == 2
+        return 0 if self[0] == 2 and self[1] == 1
+        if self[0] > 2
+          return 0 if self[0] == self[1]
+        end
+        return 1 if self[1] == 0
+        return 1 if (self[0] != self[1]) and self[1] == 1 and self[2] == 2
+        return 1 if (self[0] != self[1]) and self[1] == 2 and self[2] == 1
+        return 1 if (self[0] == self[1]) and self[1] == 1 and self[2] == 2
+        return 1 if (self[0] == self[1]) and self[1] == 2 and self[2] == 1
+        if self[1] > 2
+          return 1 if self[1] == self[2]
+        end
+        return 2 if self[2] == 0
+        return 2 if self[2] == 1 and self[3] == 2
+        return 2 if self[2] == 2 and self[3] == 1
+        if self[2] > 2
+          return 2 if self[2] == self[3]
+        end
+      end
+
+    end
+  end
+
+  def fold(line)
+    if can_fold?(line) then
+      if(line == [0,0,0,0]) then return line end
+      return line.squash
+    else
+      return line
+    end
+  end
+
+  def can_fold?(line)
+    foldable = has_adjacent_one_and_two?(line)
+    foldable = (foldable or has_adjacent_equals?(line))
+    foldable = (foldable or has_non_trailing_zeros?(line))
+    return foldable
+  end
+
+  def has_non_trailing_zeros?(line)
+    first_non_zero_from_end = index_of_first_non_trailing_zero(line)
+    if (first_non_zero_from_end == nil) then return true end
+    if (line.index(0) == nil) then return false end
+    return (line.index(0) < first_non_zero_from_end)
+  end
+
+  def index_of_first_non_trailing_zero(line)
+    first_non_zero_from_end = line.rindex {|element| element != 0}
+  end
+
+  def has_adjacent_one_and_two?(line)
+    pairs = line.each_cons(2).to_a
+    index = pairs.each_index {|i|
+      if (pairs[i].sort == [1, 2])
+        return true
+      end
+    }
+    false
+  end
+
+  def has_adjacent_equals?(line)
+    pairs = line.each_cons(2).to_a
+    index = pairs.each {|pair|
+      if(pair[0] == pair[1] and (pair[0] > 2))
+        return true
+      end
+    }
+    false
+  end
+
+end

data/lib/next_number_determinator.rb

@@ -0,0 +1,21 @@
+class NextNumberDeterminator
+  def initialize
+    @score_table = [0,1,2,3,6,12,24,48,96,192,384,768,1536,3072,6144]
+  end
+
+  def highest_number(game_board)
+    highest = 0
+    game_board.row_vectors.each {|row|
+      row.to_a.each {|value|
+        if (value > highest) then
+          highest = value
+        end
+      }
+    }
+    return highest
+  end
+
+  def select_number(game_board)
+    @score_table[rand(1..([3, @score_table.index(highest_number(game_board))-2].max))]
+  end
+end

data/lib/next_number_positioner.rb

@@ -0,0 +1,10 @@
+# This class is responsible for selecting the number to add to a certain game
+# board state and to select the cell where the number should go
+class NextNumberPositioner
+
+  # Selects one of the candidate positions to add the next number
+  def select_position(candidates)
+      return candidates[rand(0..candidates.size - 1)]
+  end
+
+end

data/lib/score_calculator.rb

@@ -0,0 +1,27 @@
+# This class is responsible for calculating the score for a given game board.
+class ScoreCalculator
+
+    @@score_table = {0 => 0, 1 => 0, 2 => 0,
+                   3 => 3, 6 => 9,
+                   12 => 27,
+                   24 => 81,
+                   48 => 243,
+                   96 => 729,
+                   192 => 2187,
+                   384 => 6561,
+                   768 => 19683,
+                   1536 => 59049,
+                   3072 => 177147,
+                   6144 => 531441}
+
+  def self.score_for(game_board)
+    score = 0
+    game_board.row_vectors.each {|vector|
+      vector.to_a.each {|val|
+        score = score + @@score_table[val]
+      }
+    }
+    score
+  end
+
+end

data/lib/threesmodel/version.rb

@@ -0,0 +1,3 @@
+module Threesmodel
+  VERSION = "0.0.3"
+end

data/lib/threesmodel.rb

@@ -0,0 +1,113 @@
+require "threesmodel/version"
+require 'candidate_translator'
+require 'candidate_extractor'
+require 'game_board_folder'
+require 'next_number_positioner'
+require 'next_number_determinator'
+require 'game_over_checker'
+require 'game_creator'
+require 'securerandom'
+require 'matrix'
+require 'score_calculator'
+
+module Threesmodel
+  class InternalAPI
+    def initialize
+
+    end
+  end
+  class GameController
+
+    def initialize
+      @games = {}
+      @next_number = {}
+      @candidate_extractor = CandidateExtractor.new
+      @candidate_translator = CandidateTranslator.new
+      @game_over_checker = GameOverChecker.new
+      @next_number_determinator = NextNumberDeterminator.new
+      @number_positioner = NextNumberPositioner.new
+      @game_board_folder = GameBoardFolder.new
+    end
+
+    def start_new_game
+      id = SecureRandom.uuid
+      @games[id] = GameCreator.create_new_game
+      @next_number[id] = getNextNumber(@games[id])
+      respond_to_player(id, @next_number[id])
+    end
+
+    def fold_right(id)
+      game = @games[id]
+      unless (@game_board_folder.can_fold_right?(game))
+        return did_not_fold(game, id)
+      end
+      candidates = @candidate_translator.translate_right_fold(@candidate_extractor.fold_right_candidates(game))
+      game = @game_board_folder.fold_right(game)
+      prepare_for_next_fold(candidates, game, id)
+    end
+
+    def fold_left(id)
+      game = @games[id]
+      unless (@game_board_folder.can_fold_left?(game))
+        return did_not_fold(game, id)
+      end
+      candidates = @candidate_translator.translate_left_fold(@candidate_extractor.fold_left_candidates(game))
+      game = @game_board_folder.fold_left(game)
+      prepare_for_next_fold(candidates, game, id)
+    end
+
+    def fold_down(id)
+      game = @games[id]
+      unless (@game_board_folder.can_fold_down?(game))
+        return did_not_fold(game, id)
+      end
+      candidates = @candidate_translator.translate_down_fold(@candidate_extractor.fold_down_candidates(game))
+      game = @game_board_folder.fold_down(game)
+      prepare_for_next_fold(candidates, game, id)
+    end
+
+    def fold_up(id)
+      game = @games[id]
+      unless (@game_board_folder.can_fold_up?(game))
+        return did_not_fold(game, id)
+      end
+      candidates = @candidate_translator.translate_up_fold(@candidate_extractor.fold_up_candidates(game))
+      game = @game_board_folder.fold_up(game)
+      prepare_for_next_fold(candidates, game, id)
+    end
+
+    def did_not_fold(game, id)
+      respond_to_player(id, @next_number[id])
+    end
+
+    def prepare_for_next_fold(candidates, game, id)
+      game = add_next_number(id, candidates, game)
+      @next_number[id] = getNextNumber(game)
+      @games[id] = game
+      respond_to_player(id, @next_number[id])
+    end
+
+    def add_next_number(id, candidates, game)
+      coordinates = @number_positioner.select_position(candidates)
+      new_state = []
+      game.row_vectors.each_index {|i|
+        values = game.row_vectors[i].to_a
+        if (coordinates[0] == i)
+          values[coordinates[1]] = @next_number[id]
+        end
+        new_state << values
+      }
+      Matrix.rows(new_state)
+    end
+
+    def getNextNumber(game)
+      @next_number_determinator.select_number(game)
+    end
+
+    def respond_to_player(id, next_number)
+      {:id => id, :game => @games[id], :next_number => next_number, :game_over => @game_over_checker.game_over?(@games[id]), :score => ScoreCalculator.score_for(@games[id]) }
+    end
+
+  end
+
+end

data/spec/candidate_extraction_spec.rb

@@ -0,0 +1,34 @@
+require_relative "../lib/candidate_extractor"
+require "Matrix"
+
+describe CandidateExtractor do
+
+  before(:each) do
+    @candidate_extractor = CandidateExtractor.new
+  end
+
+  it "extracts no candidates form an unfoldable board" do
+    game = Matrix.rows([[3, 1, 1, 3],
+                               [6, 1, 1, 6],
+                               [12, 1, 3, 12],
+                               [24, 1, 6, 24]])
+    expect(@candidate_extractor.fold_left_candidates(game)).to eq([])
+    expect(@candidate_extractor.fold_right_candidates(game)).to eq([])
+    expect(@candidate_extractor.fold_up_candidates(game)).to eq([])
+    expect(@candidate_extractor.fold_down_candidates(game)).to eq([])
+  end
+
+  it "extracts a single candidate form a board with one foldable line" do
+    expect(@candidate_extractor.fold_left_candidates(
+      Matrix.rows([[3,1,1,3],[6,1,1,6],[12,1,2,12],[24,1,6,24]]))).to eq([[2,3]])
+  end
+
+  it "extracts all four candidates form a board where all lines fold" do
+    expect(@candidate_extractor.fold_left_candidates(
+      Matrix.rows([[3,3,1,3],
+                   [6,3,3,6],
+                   [12,1,12,12],
+                   [3,3,3,3]]))).to eq([[0,3], [1,3], [2,3], [3,3]])
+  end
+
+end

data/spec/candidate_translator_spec.rb

@@ -0,0 +1,36 @@
+require_relative '../lib/candidate_translator'
+describe CandidateTranslator do
+
+  it "translates left fold candidates with same candidates" do
+    translator = CandidateTranslator.new
+    expect(translator.translate_left_fold([[0,3]])).to eq [[0,3]]
+    expect(translator.translate_left_fold([[0,3], [1,3]])).to eq [[0,3], [1,3]]
+    expect(translator.translate_left_fold([[0,3], [1,3], [2,3]])).to eq [[0,3], [1,3], [2,3]]
+    expect(translator.translate_left_fold([[0,3], [1,3], [2,3], [3,3]])).to eq [[0,3], [1,3], [2,3], [3,3]]
+  end
+
+  it "translates right fold candidates with mirrored candidates" do
+    translator = CandidateTranslator.new
+    expect(translator.translate_right_fold([[0,3]])).to eq [[3,0]]
+    expect(translator.translate_right_fold([[1,3]])).to eq [[2,0]]
+    expect(translator.translate_right_fold([[2,3]])).to eq [[1,0]]
+    expect(translator.translate_right_fold([[3,3]])).to eq [[0,0]]
+  end
+
+  it "translates down fold candidates" do
+    translator = CandidateTranslator.new
+    expect(translator.translate_down_fold([[0,3]])).to eq [[0,0]]
+    expect(translator.translate_down_fold([[1,3]])).to eq [[0,1]]
+    expect(translator.translate_down_fold([[2,3]])).to eq [[0,2]]
+    expect(translator.translate_down_fold([[3,3]])).to eq [[0,3]]
+  end
+
+  it "translates up fold candidates" do
+    translator = CandidateTranslator.new
+    expect(translator.translate_up_fold([[0,3]])).to eq [[3,3]]
+    expect(translator.translate_up_fold([[1,3]])).to eq [[3,2]]
+    expect(translator.translate_up_fold([[2,3]])).to eq [[3,1]]
+    expect(translator.translate_up_fold([[3,3]])).to eq [[3,0]]
+  end
+
+end

data/spec/custom_matchers.rb

@@ -0,0 +1,27 @@
+module CustomMatchers
+  class BeOneOf
+    def initialize(expected)
+      @expected = expected
+    end
+
+    def matches?(target)
+      @target = target
+      if(@target.respond_to? :keys) then
+        @expected.include?(@target.keys[0])
+      else
+        @expected.include?(@target)
+      end
+    end
+
+    def failure_message
+      "expected #{@target} to be one of the elements of #{@expected}"
+    end
+
+    def failure_message_when_negated
+      "expected #{@target} not to be one of the elements of #{@expected}"
+    end
+  end
+  def be_one_of(expected)
+    BeOneOf.new(expected)
+  end
+end

data/spec/game_board_folder_spec.rb

@@ -0,0 +1,50 @@
+require_relative "../lib/game_board_folder"
+require "Matrix"
+
+describe GameBoardFolder do
+
+  before(:each) do
+    @game_board_folder = GameBoardFolder.new
+  end
+
+  it "can create game board" do
+    expect(@game_board_folder).to_not eq(nil)
+  end
+
+  it "can fold all rows to the left" do
+    expect(@game_board_folder.fold_left(
+      Matrix.rows([[0,1,2,0],
+                   [0,1,2,0],
+                   [0,1,2,0],
+                   [0,1,2,0]])).row(0).to_a).to eq([1,2,0,0])
+  end
+
+  it "can fold all rows to the right" do
+    expect(@game_board_folder.fold_right(
+      Matrix.rows([[0,1,2,0],
+                   [0,1,2,0],
+                   [0,1,2,0],
+                   [0,1,2,0]])).row(0).to_a).to eq([0,0,1,2])
+  end
+
+  it "can fold all rows up" do
+    state = @game_board_folder.fold_up(
+      Matrix.rows([[0,0,0,0],
+                   [1,1,1,1],
+                   [2,2,2,2],
+                   [0,0,0,0]]))
+    expect(state.row(0).to_a).to eq([1,1,1,1])
+    expect(state.row(1).to_a).to eq([2,2,2,2])
+  end
+
+  it "can fold all rows down" do
+    state = @game_board_folder.fold_down(
+      Matrix.rows([[0,0,0,0],
+                   [1,1,1,1],
+                   [2,2,2,2],
+                   [0,0,0,0]]))
+    expect(state.row(2).to_a).to eq([1,1,1,1])
+    expect(state.row(3).to_a).to eq([2,2,2,2])
+  end
+
+end

data/spec/game_creator_spec.rb

@@ -0,0 +1,36 @@
+require 'rspec'
+require_relative '../lib/game_creator'
+require 'custom_matchers'
+
+describe 'Create new Game' do
+
+  include CustomMatchers
+
+  it 'should randomly position nine cells' do
+    game_state = GameCreator.create_new_game()
+    expect(cells_in_game(game_state)).to eq(9)
+  end
+
+  it 'should determine nine coordinates' do
+    expect(GameCreator.random_positions(9).size).to eq(9)
+  end
+
+  it 'should only use 1s 2s and 3s when initiating game board' do
+    game_state = GameCreator.create_new_game()
+    game_state.row_vectors.each{|row|
+      row.to_a.each{|value|
+        expect(value).to be_one_of([0,1,2,3])
+      }
+    }
+  end
+end
+
+def cells_in_game(game_state)
+  cells = 0
+  game_state.row_vectors.each{|row|
+    row.to_a.each{|val|
+      if val > 0 then cells = cells + 1 end
+    }
+  }
+  cells
+end

data/spec/line_folder_spec.rb

@@ -0,0 +1,87 @@
+require_relative "../lib/line_folder"
+
+describe LineFolder do
+
+    before(:each) do
+      @line_folder = LineFolder.new
+    end
+
+    it "can find wall in position zero" do
+      expect([0,0,1,2].wall_index_of).to eq(0)
+      expect([1,2,0,0].wall_index_of).to eq(0)
+      expect([2,1,0,0].wall_index_of).to eq(0)
+      expect([0,1,0,0].wall_index_of).to eq(0)
+      expect([3,3,0,0].wall_index_of).to eq(0)
+    end
+
+    it "can find wall in position one" do
+      expect([1,1,2,2].wall_index_of).to eq(1)
+      expect([2,2,1,2].wall_index_of).to eq(1)
+      expect([3,2,1,2].wall_index_of).to eq(1)
+      expect([2,3,3,2].wall_index_of).to eq(1)
+      expect([1,0,2,2].wall_index_of).to eq(1)
+    end
+
+    it "can find wall in position two" do
+      expect([1,1,1,2].wall_index_of).to eq(2)
+      expect([2,2,2,1].wall_index_of).to eq(2)
+      expect([2,2,3,3].wall_index_of).to eq(2)
+      expect([2,2,0,3].wall_index_of).to eq(2)
+    end
+
+    it "can fold when line has leading zeros" do
+      expect(@line_folder.can_fold?([0,0,1,2])).to eq(true)
+    end
+
+    it "can not fold when line is all ones" do
+      expect(@line_folder.can_fold?([1,1,1,1])).to eq(false)
+    end
+
+    it "can fold when line has a one and a two adjacent" do
+      expect(@line_folder.can_fold?([1,2,1,1])).to eq(true)
+    end
+
+    it "can fold when line has a two and a one adjacent" do
+      expect(@line_folder.can_fold?([2,1,1,1])).to eq(true)
+    end
+
+    it "can fold over two equal numbers larger than 2" do
+      expect(@line_folder.can_fold?([3,3,6,12])).to eq(true)
+    end
+
+    it "folds undetectably when all zero line" do
+      expect(@line_folder.fold([0,0,0,0])).to eq([0,0,0,0])
+    end
+    it "folds by shifting onto leading zeros" do
+      expect(@line_folder.fold([0,0,1,2])).to eq([0,1,2,0])
+    end
+
+    it "folds by shifting onto zeros" do
+      expect(@line_folder.fold([1,0,1,2])).to eq([1,1,2,0])
+    end
+
+    it "folds by adding one and two at a wall" do
+      expect(@line_folder.fold([1,2,0,0])).to eq([3,0,0,0])
+    end
+
+    it "folds by adding one and two at a non foldable cell" do
+      expect(@line_folder.fold([3,2,1,0])).to eq([3,3,0,0])
+    end
+
+    it "folds by adding equal numbers at a wall" do
+      expect(@line_folder.fold([3,3,0,0])).to eq([6,0,0,0])
+    end
+
+    it "folds by adding equal numbers at a non foldable cell" do
+      expect(@line_folder.fold([12,6,6,3])).to eq([12,12,3,0])
+    end
+
+    it "only folds first pair of equal numbers " do
+      expect(@line_folder.fold([12,12,3,3])).to eq([24,3,3,0])
+    end
+
+    it "prioritizes leftwards folds" do
+      expect(@line_folder.fold([1,2,0,3])).to eq([3,0,3,0])
+    end
+
+end