text2048 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a002ee28cb82470ec94b93d63f285f907d2eaaa2
-  data.tar.gz: 1c290e6b0968fbcc2978d701f640f8f0c750a383
+  metadata.gz: f364841e360557b497346d9675f24e39bdbb89d1
+  data.tar.gz: 1031bd3cea22c6120431459873d7631720578a30
 SHA512:
-  metadata.gz: 0a5da8d1544c359adfd7212a9cd9cac4ec81cd7f4f056ddbf5b6ee5ac2e81cc3963727f0bb0ba4a1b0a69b72893fd9902b0ebec7c8b3c8b018e92f806a0e7a92
-  data.tar.gz: 51f12d2914d8ebb9cff9a10500a9de1494a9d48936cf777d1bba2261c763b546c12063eecdedb2b57d5da0af45b41e87dffc46fd36141a8070e8d1393414a09e
+  metadata.gz: e4a9a739cac549134076522d78d58bd573ce241af8ff57d92e27672db25f3acbe2e078adeda68f3efdb405558075d253c9c92eb5731eaaa84d26c8b03dfa8803
+  data.tar.gz: 400794ed86e36d7ecb25fabe136d24c4c2cf0cbc22475abb5d214cc975549027e335fea4e9a4a082e84fdc85c6aa63ffebc489540ab551f4f9de0665f3b082dd

data/Rakefile

@@ -39,7 +39,7 @@ end
 begin
   require 'reek/rake/task'
   Reek::Rake::Task.new do |t|
-    t.fail_on_error = false
+    t.fail_on_error = true
     t.verbose = false
     t.reek_opts = '--quiet'
     t.source_files = FileList['lib/**/*.rb']

data/features/step_definitions/2048_steps.rb

@@ -4,7 +4,7 @@ require 'text2048'
 
 Given(/^a board:$/) do |string|
   layout = string.split("\n").reduce([]) do |memo, row|
-    memo << row.split(' ').map { |each| each == '_' ? nil : each.to_i }
+    memo << row.split(' ').map { |each| each.to_i }
   end
   @view = Text2048::TextView.new(output)
   @board = Text2048::Board.new(layout)

data/lib/text2048.rb

@@ -2,4 +2,5 @@
 
 require 'text2048/board'
 require 'text2048/curses_view'
+require 'text2048/monkey_patch/array'
 require 'text2048/text_view'

data/lib/text2048/app.rb

@@ -28,7 +28,7 @@ module Text2048
     end
 
     def start
-      @view.update(@board)
+      generate 2
       loop do
         @view.win if @board.win?
         @view.game_over if @board.lose?
@@ -62,8 +62,8 @@ module Text2048
       last
     end
 
-    def generate
-      @board.generate
+    def generate(num_tiles = 1)
+      num_tiles.times { @board.generate }
       @view.update(@board)
       @view.zoom_tiles(@board.generated_tiles)
     end

data/lib/text2048/board.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
+require 'text2048/monkey_patch/array'
 require 'text2048/tile'
-require 'text2048/tiles'
 
 # This module smells of :reek:UncommunicativeModuleName
 module Text2048
@@ -10,26 +10,21 @@ module Text2048
     attr_reader :score
     attr_reader :tiles
 
-    def initialize(tiles = nil, score = 0)
+    def initialize(tiles = Array.new(4) { Array.new(4, 0) }, score = 0)
+      @tiles = tiles.to_h
       @score = score
-      if tiles
-        @tiles = tiles.to_h
-      else
-        @tiles = (Array.new(4) { Array.new(4) }).to_h
-        2.times { generate }
-      end
     end
 
     def initialize_copy(board)
       @tiles = board.tiles.dup
     end
 
+    def [](coord)
+      @tiles[coord]
+    end
+
     def to_a
-      @tiles.reduce(Array.new(4) { Array.new(4) }) do |array, (key, value)|
-        row, col = key
-        array[row][col] = value && value.to_i
-        array
-      end
+      [0, 1, 2, 3].map { |each| row(each) }
     end
 
     def win?
@@ -42,24 +37,21 @@ module Text2048
       end.size == 4 * 4
     end
 
-    def left
-      tiles, score = move(:left)
-      self.class.new tiles, @score + score
+    def right
+      board, score = move_right
+      self.class.new board, @score + score
     end
 
-    def right
-      tiles, score = move(:right)
-      self.class.new tiles, @score + score
+    def left
+      reverse :right
     end
 
     def up
-      tiles, score = transpose { move(:left) }
-      self.class.new tiles, @score + score
+      transpose :left
     end
 
     def down
-      tiles, score = transpose { move(:right) }
-      self.class.new tiles, @score + score
+      transpose :right
     end
 
     def merged_tiles
@@ -73,7 +65,7 @@ module Text2048
     def generate
       loop do
         sample = @tiles.keys.sample
-        unless @tiles[sample]
+        if @tiles[sample] == 0
           @tiles[sample] = Tile.new(rand < 0.8 ? 2 : 4, :generated)
           return
         end
@@ -82,22 +74,31 @@ module Text2048
 
     private
 
-    def move(direction)
-      to_a.reduce([[], 0]) do |memo, each|
-        tiles, score = memo
-        row, sc = Tiles.new(each).__send__ direction
-        [tiles << row, score + sc]
+    def move_right
+      to_a.reduce([[], 0]) do |(board, score), each|
+        row, row_score = each.rmerge
+        [board << row, score + row_score]
       end
     end
 
+    def transpose(direction)
+      klass = self.class
+      board = klass.new(to_a.transpose, @score).__send__(direction)
+      klass.new board.to_a.transpose, board.score
+    end
+
+    def reverse(direction)
+      klass = self.class
+      board = klass.new(to_a.map(&:reverse), @score).__send__(direction)
+      klass.new board.to_a.map(&:reverse), board.score
+    end
+
     def find_tiles(status)
-      @tiles.select { |_key, each| each && each.status == status }.keys
+      @tiles.select { |_key, each| each.status == status }.keys
     end
 
-    def transpose(&block)
-      board = self.class.new(to_a.transpose, @score)
-      tiles, score = board.instance_eval(&block)
-      [tiles.transpose, score]
+    def row(index)
+      [index].product([0, 1, 2, 3]).map { |each| @tiles[each] }
     end
   end
 end

data/lib/text2048/monkey_patch/array/board.rb

@@ -7,11 +7,12 @@ module Text2048
       # 2048 related methods
       module Board
         def to_h
-          tiles = {}
-          [0, 1, 2, 3].product([0, 1, 2, 3]).each do |col, row|
-            tiles[[col, row]] = self[col][row]
+          [0, 1, 2, 3].product([0, 1, 2, 3]).reduce({}) do |memo, (col, row)|
+            tile = self[col][row]
+            memo[[col, row]] =
+              tile.respond_to?(:status) ? tile : Text2048::Tile.new(tile)
+            memo
           end
-          tiles
         end
       end
     end

data/lib/text2048/monkey_patch/array/tile.rb

@@ -7,22 +7,29 @@ module Text2048
       # 2048 related methods
       module Tile
         def rmerge
-          score = 0
-          tiles = dup
-          (size - 1).downto(1) do |each|
-            if tiles[each - 1] && tiles[each - 1] == tiles[each]
-              tiles[each] = Text2048::Tile.new(tiles[each].to_i * 2, :merged)
-              tiles[each - 1] = nil
-              score += tiles[each].to_i
-            end
+          shrink
+          score = (size - 1).downto(1).reduce(0) do |memo, each|
+            memo + (self[each] == self[each - 1] ? merge_left(each) : 0)
           end
-          [tiles, score]
+          [fill_length(4), score]
         end
 
-        def rshrink
-          orig_size = size
-          tiles = compact
-          ::Array.new(orig_size - tiles.size) + tiles
+        def merge_left(index)
+          value = self[index].to_i * 2
+          self[index] = Text2048::Tile.new(value, :merged)
+          self[index - 1] = nil
+          value
+        end
+
+        def shrink
+          delete(0)
+          map! { |each| each.clear_status }
+        end
+
+        def fill_length(len)
+          compact!
+          unshift(Text2048::Tile.new(0)) until size == len
+          self
         end
       end
     end

data/lib/text2048/text_view.rb

@@ -11,7 +11,7 @@ module Text2048
       end
 
       def to_s
-        @row.map { |each| each ? each.to_s : '_' }.join(' ')
+        @row.map { |each| each != 0 ? each : '_' }.join(' ')
       end
     end
 

data/lib/text2048/tile.rb

@@ -15,6 +15,15 @@ module Text2048
       @status = status
     end
 
+    def clear_status
+      @status = nil
+      self
+    end
+
+    def merged?
+      @status == :merged
+    end
+
     def ==(other)
       @value == other.to_i
     end

data/lib/text2048/version.rb

@@ -3,5 +3,5 @@
 # This module smells of :reek:UncommunicativeModuleName
 module Text2048
   # gem version.
-  VERSION = '0.4.0'.freeze
+  VERSION = '0.5.0'.freeze
 end

data/spec/array_spec.rb

@@ -0,0 +1,189 @@
+# encoding: utf-8
+
+require 'text2048'
+
+describe Array do
+  def tiles_with(contents)
+    contents.map { |each| Text2048::Tile.new(each) }
+  end
+
+  context '[0, 0, 0, 0]' do
+    Given(:tiles) { tiles_with([0, 0, 0, 0]) }
+
+    describe '#rmerge' do
+      When(:score) { tiles.rmerge[1] }
+
+      Then { tiles == [0, 0, 0, 0] }
+      And { score == 0 }
+      And { !tiles[0].merged? }
+      And { !tiles[1].merged? }
+      And { !tiles[2].merged? }
+      And { !tiles[3].merged? }
+    end
+  end
+
+  context '[2, 0, 0, 0]' do
+    Given(:tiles) { tiles_with([2, 0, 0, 0]) }
+
+    describe '#rmerge' do
+      When(:score) { tiles.rmerge[1] }
+
+      Then { tiles == [0, 0, 0, 2] }
+      And { score == 0 }
+      And { !tiles[0].merged? }
+      And { !tiles[1].merged? }
+      And { !tiles[2].merged? }
+      And { !tiles[3].merged? }
+    end
+  end
+
+  context '[0, 2, 0, 0]' do
+    Given(:tiles) { tiles_with([0, 2, 0, 0]) }
+
+    describe '#rmerge' do
+      When(:score) { tiles.rmerge[1] }
+
+      Then { tiles == [0, 0, 0, 2] }
+      And { score == 0 }
+      And { !tiles[0].merged? }
+      And { !tiles[1].merged? }
+      And { !tiles[2].merged? }
+      And { !tiles[3].merged? }
+    end
+  end
+
+  context '[0, 0, 2, 0]' do
+    Given(:tiles) { tiles_with([0, 0, 2, 0]) }
+
+    describe '#rmerge' do
+      When(:score) { tiles.rmerge[1] }
+
+      Then { tiles == [0, 0, 0, 2] }
+      And { score == 0 }
+      And { !tiles[0].merged? }
+      And { !tiles[1].merged? }
+      And { !tiles[2].merged? }
+      And { !tiles[3].merged? }
+    end
+  end
+
+  context '[0, 0, 0, 2]' do
+    Given(:tiles) { tiles_with([0, 0, 0, 2]) }
+
+    describe '#rmerge' do
+      When(:score) { tiles.rmerge[1] }
+
+      Then { tiles == [0, 0, 0, 2] }
+      And { score == 0 }
+      And { !tiles[0].merged? }
+      And { !tiles[1].merged? }
+      And { !tiles[2].merged? }
+      And { !tiles[3].merged? }
+    end
+  end
+
+  context '[0, 2, 0, 2]' do
+    Given(:tiles) { tiles_with([0, 2, 0, 2]) }
+
+    describe '#rmerge' do
+      When(:score) { tiles.rmerge[1] }
+
+      Then { tiles == [0, 0, 0, 4] }
+      And { score == 4 }
+      And { !tiles[0].merged? }
+      And { !tiles[1].merged? }
+      And { !tiles[2].merged? }
+      And { tiles[3].merged? }
+    end
+  end
+
+  context '[2, 2, 0, 0]' do
+    Given(:tiles) { tiles_with([2, 2, 0, 0]) }
+
+    describe '#rmerge' do
+      When(:score) { tiles.rmerge[1] }
+
+      Then { tiles == [0, 0, 0, 4] }
+      And { score == 4 }
+      And { !tiles[0].merged? }
+      And { !tiles[1].merged? }
+      And { !tiles[2].merged? }
+      And { tiles[3].merged? }
+    end
+  end
+
+  context '[2, 2, 2, 0]' do
+    Given(:tiles) { tiles_with([2, 2, 2, 0]) }
+
+    describe '#rmerge' do
+      When(:score) { tiles.rmerge[1] }
+
+      Then { tiles == [0, 0, 2, 4] }
+      And { score == 4 }
+      And { !tiles[0].merged? }
+      And { !tiles[1].merged? }
+      And { !tiles[2].merged? }
+      And { tiles[3].merged? }
+    end
+  end
+
+  context '[2, 2, 2, 2]' do
+    Given(:tiles) { tiles_with([2, 2, 2, 2]) }
+
+    describe '#rmerge' do
+      When(:score) { tiles.rmerge[1] }
+
+      Then { tiles == [0, 0, 4, 4] }
+      And { score == 8 }
+      And { !tiles[0].merged? }
+      And { !tiles[1].merged? }
+      And { tiles[2].merged? }
+      And { tiles[3].merged? }
+    end
+  end
+
+  context '[4, 4, 2, 2]' do
+    Given(:tiles) { tiles_with([4, 4, 2, 2]) }
+
+    describe '#rmerge' do
+      When(:score) { tiles.rmerge[1] }
+
+      Then { tiles == [0, 0, 8, 4] }
+      And { score == 12 }
+      And { !tiles[0].merged? }
+      And { !tiles[1].merged? }
+      And { tiles[2].merged? }
+      And { tiles[3].merged? }
+    end
+  end
+
+  context '[0, 4, 0, 2]' do
+    Given(:tiles) { tiles_with([0, 4, 0, 2]) }
+
+    describe '#rmerge' do
+      When(:score) { tiles.rmerge[1] }
+
+      Then { tiles == [0, 0, 4, 2] }
+      And { score == 0 }
+      And { !tiles[0].merged? }
+      And { !tiles[1].merged? }
+      And { !tiles[2].merged? }
+      And { !tiles[3].merged? }
+    end
+  end
+
+  context 'with [16, 8, 4, 2]' do
+    Given(:tiles) { tiles_with([16, 8, 4, 2]) }
+
+    describe '#rmerge' do
+      When(:score) { tiles.rmerge[1] }
+
+      Then { tiles == [16, 8, 4, 2] }
+      And { score == 0 }
+      And { !tiles[0].merged? }
+      And { !tiles[1].merged? }
+      And { !tiles[2].merged? }
+      And { !tiles[3].merged? }
+    end
+  end
+end

data/spec/text2048/board_spec.rb

@@ -3,22 +3,57 @@
 require 'text2048'
 
 describe Text2048::Board, '.new' do
+  context 'without arguments' do
+    Given(:board) { Text2048::Board.new }
+
+    Then { board.generated_tiles.empty? }
+    And { board.merged_tiles.empty? }
+    And { board.score == 0 }
+
+    describe '#generate' do
+      When { board.generate }
+      Then { board.generated_tiles.size == 1 }
+    end
+  end
+
+  context 'with one 2048 tile' do
+    Given(:board) do
+      Text2048::Board.new([[0, 0, 0, 0],
+                           [0, 0, 0, 0],
+                           [0, 2048, 0, 0],
+                           [0, 0, 0, 0]])
+    end
+
+    Then { board.win? }
+  end
+
+  context 'with tiles which cannot be merged' do
+    Given(:board) do
+      Text2048::Board.new([[2, 4, 8, 16],
+                           [4, 8, 16, 32],
+                           [8, 16, 32, 64],
+                           [16, 32, 64, 128]])
+    end
+
+    Then { board.lose? }
+  end
+
   context 'with all zeroes' do
     Given(:board) do
-      Text2048::Board.new([[nil, nil, nil, nil],
-                           [nil, nil, nil, nil],
-                           [nil, nil, nil, nil],
-                           [nil, nil, nil, nil]])
+      Text2048::Board.new([[0, 0, 0, 0],
+                           [0, 0, 0, 0],
+                           [0, 0, 0, 0],
+                           [0, 0, 0, 0]])
     end
 
     describe '#to_a' do
       When(:result) { board.to_a }
 
       Then do
-        result == [[nil, nil, nil, nil],
-                   [nil, nil, nil, nil],
-                   [nil, nil, nil, nil],
-                   [nil, nil, nil, nil]]
+        result == [[0, 0, 0, 0],
+                   [0, 0, 0, 0],
+                   [0, 0, 0, 0],
+                   [0, 0, 0, 0]]
       end
     end
 
@@ -26,51 +61,55 @@ describe Text2048::Board, '.new' do
       When(:result) { board.right }
 
       Then do
-        result.to_a == [[nil, nil, nil, nil],
-                        [nil, nil, nil, nil],
-                        [nil, nil, nil, nil],
-                        [nil, nil, nil, nil]]
+        result.to_a == [[0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0],
+                        [0, 0, 0, 0]]
       end
+      And { result.score == 0 }
     end
   end
 
   context 'with four 2s' do
     Given(:board) do
-      Text2048::Board.new([[2, nil, nil, nil],
-                           [nil, 2, nil, nil],
-                           [nil, nil, 2, nil],
-                           [nil, nil, nil, 2]])
+      Text2048::Board.new([[2, 0, 0, 0],
+                           [0, 2, 0, 0],
+                           [0, 0, 2, 0],
+                           [0, 0, 0, 2]])
     end
 
     describe '#right' do
       When(:result) { board.right }
 
       Then do
-        result.to_a == [[nil, nil, nil, 2],
-                        [nil, nil, nil, 2],
-                        [nil, nil, nil, 2],
-                        [nil, nil, nil, 2]]
+        result.to_a == [[0, 0, 0, 2],
+                        [0, 0, 0, 2],
+                        [0, 0, 0, 2],
+                        [0, 0, 0, 2]]
       end
+      And { result.score == 0 }
     end
   end
 
   context 'with six 2s that can be merged' do
     Given(:board) do
-      Text2048::Board.new([[2, nil, 2, nil],
-                           [nil, 2, nil, nil],
-                           [nil, 2, nil, 2],
-                           [nil, nil, nil, 2]])
+      Text2048::Board.new([[2, 0, 2, 0],
+                           [0, 2, 0, 0],
+                           [0, 2, 0, 2],
+                           [0, 0, 0, 2]])
     end
 
     describe '#right' do
       When(:result) { board.right }
 
       Then do
-        result.to_a == [[nil, nil, nil, 4],
-                        [nil, nil, nil, 2],
-                        [nil, nil, nil, 4],
-                        [nil, nil, nil, 2]]
+        result.to_a == [[0, 0, 0, 4],
+                        [0, 0, 0, 2],
+                        [0, 0, 0, 4],
+                        [0, 0, 0, 2]]
       end
+      And { result[[0, 3]].merged? }
+      And { result.score == 8 }
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: text2048
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Yasuhito Takamiya
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-07 00:00:00.000000000 Z
+date: 2014-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -57,11 +57,10 @@ files:
 - lib/text2048/monkey_patch/array/tile.rb
 - lib/text2048/text_view.rb
 - lib/text2048/tile.rb
-- lib/text2048/tiles.rb
 - lib/text2048/version.rb
+- spec/array_spec.rb
 - spec/spec_helper.rb
 - spec/text2048/board_spec.rb
-- spec/text2048/tiles_spec.rb
 - text2048.gemspec
 homepage: http://github.com/yasuhito/text2048
 licenses:
@@ -88,9 +87,9 @@ signing_key:
 specification_version: 4
 summary: Text mode 2048 game.
 test_files:
+- spec/array_spec.rb
 - spec/spec_helper.rb
 - spec/text2048/board_spec.rb
-- spec/text2048/tiles_spec.rb
 - features/game_over.feature
 - features/move_down.feature
 - features/move_left.feature

data/lib/text2048/tiles.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-require 'forwardable'
-require 'text2048/monkey_patch/array'
-require 'text2048/tile'
-
-# This module smells of :reek:UncommunicativeModuleName
-module Text2048
-  # Each row or column of a game board.
-  class Tiles
-    extend Forwardable
-
-    def initialize(list)
-      @list = list.map { |each| each ? Tile.new(each) : nil }
-    end
-
-    def right
-      list, score = @list.rshrink.rmerge
-      [list.rshrink, score]
-    end
-
-    def left
-      list, score = @list.reverse.rshrink.rmerge
-      [list.rshrink.reverse, score]
-    end
-
-    def_delegators :@list, :map, :rshrink
-  end
-end

data/spec/text2048/tiles_spec.rb

@@ -1,115 +0,0 @@
-# encoding: utf-8
-
-require 'text2048'
-
-describe Text2048::Tiles, '.new' do
-  context 'with [nil, nil, nil, nil]' do
-    Given(:tiles) { Text2048::Tiles.new([nil, nil, nil, nil]) }
-
-    describe '#right' do
-      When(:result) { tiles.right }
-
-      Then { result[0] == [nil, nil, nil, nil] }
-    end
-  end
-
-  context 'with [2, nil, nil, nil]' do
-    Given(:tiles) { Text2048::Tiles.new([2, nil, nil, nil]) }
-
-    describe '#right' do
-      When(:result) { tiles.right }
-
-      Then { result[0] == [nil, nil, nil, 2] }
-    end
-  end
-
-  context 'with [nil, 2, nil, nil]' do
-    Given(:tiles) { Text2048::Tiles.new([nil, 2, nil, nil]) }
-
-    describe '#right' do
-      When(:result) { tiles.right }
-
-      Then { result[0] == [nil, nil, nil, 2] }
-    end
-  end
-
-  context 'with [nil, nil, 2, nil]' do
-    Given(:tiles) { Text2048::Tiles.new([nil, nil, 2, nil]) }
-
-    describe '#right' do
-      When(:result) { tiles.right }
-
-      Then { result[0] == [nil, nil, nil, 2] }
-    end
-  end
-
-  context 'with [nil, nil, nil, 2]' do
-    Given(:tiles) { Text2048::Tiles.new([nil, nil, nil, 2]) }
-
-    describe '#right' do
-      When(:result) { tiles.right }
-
-      Then { result[0] == [nil, nil, nil, 2] }
-    end
-  end
-
-  context 'with [2, 2, nil, nil]' do
-    Given(:tiles) { Text2048::Tiles.new([2, 2, nil, nil]) }
-
-    describe '#right' do
-      When(:result) { tiles.right }
-
-      Then { result[0] == [nil, nil, nil, 4] }
-    end
-  end
-
-  context 'with [2, 2, 2, nil]' do
-    Given(:tiles) { Text2048::Tiles.new([2, 2, 2, nil]) }
-
-    describe '#right' do
-      When(:result) { tiles.right }
-
-      Then { result[0] == [nil, nil, 2, 4] }
-    end
-  end
-
-  context 'with [2, 2, 2, 2]' do
-    Given(:tiles) { Text2048::Tiles.new([2, 2, 2, 2]) }
-
-    describe '#right' do
-      When(:result) { tiles.right }
-
-      Then { result[0] == [nil, nil, 4, 4] }
-    end
-  end
-
-  context 'with [4, 4, 2, 2]' do
-    Given(:tiles) { Text2048::Tiles.new([4, 4, 2, 2]) }
-
-    describe '#right' do
-      When(:result) { tiles.right }
-
-      Then { result[0] == [nil, nil, 8, 4] }
-    end
-  end
-
-  context 'with [nil, 4, nil, 2]' do
-    Given(:tiles) { Text2048::Tiles.new([nil, 4, nil, 2]) }
-
-    describe '#right' do
-      When(:result) { tiles.right }
-
-      Then { result[0] == [nil, nil, 4, 2] }
-    end
-  end
-
-  context 'with [16, 8, 4, 2]' do
-    Given(:tiles) { Text2048::Tiles.new([16, 8, 4, 2]) }
-
-    describe '#right' do
-      When(:result) { tiles.right }
-
-      Then { result[0] == [16, 8, 4, 2] }
-    end
-  end
-end