odin-oop-with-ruby

Project: OOP with Ruby

Project 1: TicTacToe

first Version `TicTactoe`

the grid |X|.|.| is represented by an array of cell  (class Cell)
         |.|X|.|  
         |.|.|O|

class Cell cell.rb create a cell with three states :
- empty :e
- player :x :o

class Grid grid.rb create grid with cells

class Player

class Tictactoe tic_tac_toe.rb

   g = TicTacToe.start
   g.play

second version: TictacToe-rspec

the grid |X|.|.| is represented by an array of string ["X..",".X.","..O"]
         |.|X|.|  
         |.|.|O|
and to test if the current grid win compare each row column or diagonal with "XXX" or "OOO"     
[(3+3+2 )* 2 =  16 tests]
         |X|X|X|  |X|.|.|  |X|.|.|  |O|.|.|
         |.|.|.|  |X|.|.|  |.|X|.|  |.|O|.|
         |.|.|.|  |X|.|.|  |.|.|X|  |.|.|O|

 (i try TDD method in this version)

📁tictactoe

      g = TicTacToe.start
      g.loop

spec

use double to simulate output start_game_spec.rb

     describe "start game" do
  let(:output) {double("output").as_null_object}**
  let(:game){Grid.new(output)}
  context "start game" do
  it "grid when start game" do
      output.should_receive(:puts).with("\n-------\n|.|.|.|\n-------\n|.|.|.|\n-------\n|.|.|.|\n-------\n")
      game.start
    end

use stub to simulate input loop_spec.rb

    describe "#loop" do
  let(:input){double("input")}
  let(:output){double("output").as_null_object}
  let(:game){TicTacToe.new(output,nil,nil,nil,input)}

  context "player select one cell " do
   it "player  X select cell 0,0" do
    input.stub(:gets).and_return("0 0")
    output.should_receive(:puts).with("\n-------\n|X|.|.|\n-------\n|.|.|.|\n-------\n|.|.|.|\n-------\n")
    game.loop  
  end

Project 2: Mastermind

capture

class Game mastermind.rb

   game = Game.create
    game.start

class Code code.rb compare a code with a guess and return feedback
class Playerplayer.rb

class Human < Player
class Computer < Player

interface
guess : void -> string
match : string -> void

helper.rb

`class Array`
substract	[1,2].substract [1,2] = [0,0]
index_zeros	[0,2,0,4].index_zeros = [0,2]
count_zeros	[0,2,0,4].count_zeros = 2
number_match	[2,1,4].number_match [1,2,5,6] = [1,2]
any_match?	[1,2,3]any_match? [5,6,7] = true

`class Hash`
invert	{ 1: 2 , 2: 3 , 4: 3}.invert = { 2: [1], 3: [2,4]}

`class String`
to_array	"12345".to_array = [1,2,3,4,5]

comparaison guess and secret

example :

secret = [1,2,3,4]
guess = [5,2,4,3]
secret substract guess = [-4,0,-1,1]
index_zeros [1] : index of the digit at the right position
[0,1,2,3] - [1] = [0,2,3]= valid index index of the digit not at the right position
hash_guess = { 0 => 5 , 2 => 4 , 3 => 3 }.invert = { 5=> 0 , 4 => 2 , 3=> 3}
hash_secret = { 0 => 1 , 2 => 3 , 3 => 4 }.invert = { 1 => 0 , 3 => 2 , 4 => 3}
hash_guess.keys & hash_secret.keys = [3,4] digit present in guess and secret not at the right position
index_present = [2,3] index in guess of the digit not at the right position
feedback="...." feedback[1] = "+" feedback[2]="-" feedback[3]="-"

feedback = ".+--"

todo [] refactor

nxdf2015/odin-oop-with-ruby