text2048 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f364841e360557b497346d9675f24e39bdbb89d1
-  data.tar.gz: 1031bd3cea22c6120431459873d7631720578a30
+  metadata.gz: 3b38ba8bba87211b11aec9d46187e5e67edb98e9
+  data.tar.gz: f8238c1b70544f21ed8a7d260947e513f5e248ca
 SHA512:
-  metadata.gz: e4a9a739cac549134076522d78d58bd573ce241af8ff57d92e27672db25f3acbe2e078adeda68f3efdb405558075d253c9c92eb5731eaaa84d26c8b03dfa8803
-  data.tar.gz: 400794ed86e36d7ecb25fabe136d24c4c2cf0cbc22475abb5d214cc975549027e335fea4e9a4a082e84fdc85c6aa63ffebc489540ab551f4f9de0665f3b082dd
+  metadata.gz: e6dd1f5d927c70135e72be6c56a76870b545a77455f0582d17f20c14b2226be70b09878d5e76a4ba1ae8a5f1b74cf9dc13bc37d4f61e61f2a370b88314bacd35
+  data.tar.gz: f24978440f3041a49956726d910cdc472f7b618181910cdd34195b6f1cc07b675dac8e7fe5dd8e1bb6b08a04ffabf72110b58448db731f91567308c2d3e79715

data/Rakefile

@@ -3,7 +3,7 @@
 require 'bundler/gem_tasks'
 require 'coveralls/rake/task'
 
-task default: [:test, :reek, :rubocop]
+task default: [:test, :reek, :flog, :flay, :rubocop]
 task test: [:spec, :cucumber, 'coveralls:push']
 task travis: :default
 
@@ -49,3 +49,57 @@ rescue LoadError
     $stderr.puts 'Reek is disabled'
   end
 end
+
+begin
+  require 'flog'
+  desc 'Analyze for code complexity'
+  task :flog do
+    flog = Flog.new(continue: true)
+    flog.flog(*FileList['lib/**/*.rb'])
+    threshold = 19
+
+    bad_methods = flog.totals.select do |name, score|
+      !(/##{flog.no_method}$/ =~ name) && score > threshold
+    end
+    bad_methods.sort { |a, b| a[1] <=> b[1] }.reverse.each do |name, score|
+      printf "%8.1f: %s\n", score, name
+    end
+    unless bad_methods.empty?
+      fail "#{bad_methods.size} methods have a complexity > #{threshold}"
+    end
+  end
+rescue LoadError
+  task :flog do
+    $stderr.puts 'Flog is disabled'
+  end
+end
+
+begin
+  require 'rake/tasklib'
+  require 'flay'
+  require 'flay_task'
+
+  FlayTask.new do |t|
+    t.dirs = FileList['lib/**/*.rb'].map do |each|
+      each[/[^\/]+/]
+    end.uniq
+    t.threshold = 0
+    t.verbose = true
+  end
+rescue LoadError
+  task :flay do
+    $stderr.puts 'Flay is disabled'
+  end
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new do |t|
+    t.options = ['--no-private']
+    t.options << '--debug' << '--verbose' if verbose == true
+  end
+rescue LoadError
+  task :yard do
+    $stderr.puts 'YARD is disabled'
+  end
+end

data/bin/2048

@@ -5,4 +5,6 @@ $LOAD_PATH.unshift(File.dirname(File.realpath(__FILE__)) + '/../lib')
 
 require 'text2048/app'
 
-Text2048::App.new.start
+app = Text2048::App.new
+app.generate(2)
+loop { app.step }

data/lib/text2048/app.rb

@@ -1,49 +1,39 @@
 # encoding: utf-8
 
-require 'curses'
 require 'text2048'
 
 # This module smells of :reek:UncommunicativeModuleName
 module Text2048
   # Controller class.
   class App
-    include Curses
+    attr_reader :board
+    attr_reader :view
 
-    KEYS = {
-      'h' => :left, 'l' => :right, 'k' => :up, 'j' => :down,
-      Key::LEFT => :left, Key::RIGHT => :right,
-      Key::UP => :up, Key::DOWN => :down,
-      '+' => :larger, '-' => :smaller,
-      'q' => :quit
-    }
+    def initialize(view = CursesView.new, board = Board.new)
+      @view = view
+      @board = board
+    end
 
-    def initialize
-      @view = CursesView.new
-      @board = Board.new
-      init_screen
-      curs_set(0)
-      noecho
-      stdscr.keypad(true)
-      at_exit { close_screen }
+    def generate(num_tiles = 1)
+      num_tiles.times { @board = @board.generate }
+      @view.update(@board)
+      @view.zoom_tiles(@board.generated_tiles)
     end
 
-    def start
-      generate 2
-      loop do
-        @view.win if @board.win?
-        @view.game_over if @board.lose?
-        input KEYS[Curses.getch]
-      end
+    def step
+      @view.win if @board.win?
+      @view.game_over if @board.lose?
+      input @view.command
     end
 
     private
 
     def input(command)
       case command
-      when :left, :right, :up, :down
-        move_and_generate(command)
       when :larger, :smaller
         @view.__send__ command, @board
+      when :left, :right, :up, :down
+        move_and_generate(command)
       when :quit
         exit 0
       end
@@ -51,21 +41,15 @@ module Text2048
 
     def move_and_generate(command)
       last = move(command)
-      generate if @board.to_a != last.to_a
+      generate if @board.generate?(last)
     end
 
     def move(command)
-      last = @board.dup
+      last = @board
       @board = @board.__send__(command)
       @view.update(@board)
       @view.pop_tiles(@board.merged_tiles)
       last
     end
-
-    def generate(num_tiles = 1)
-      num_tiles.times { @board.generate }
-      @view.update(@board)
-      @view.zoom_tiles(@board.generated_tiles)
-    end
   end
 end

data/lib/text2048/board.rb

@@ -1,104 +1,147 @@
 # encoding: utf-8
 
 require 'text2048/monkey_patch/array'
+require 'text2048/monkey_patch/hash'
 require 'text2048/tile'
 
 # This module smells of :reek:UncommunicativeModuleName
 module Text2048
-  # Game board
+  # 2048 game board
   class Board
+    # @return [Number] returns the current score
     attr_reader :score
-    attr_reader :tiles
 
     def initialize(tiles = Array.new(4) { Array.new(4, 0) }, score = 0)
-      @tiles = tiles.to_h
+      @all_tiles = tiles.to_h
       @score = score
     end
 
-    def initialize_copy(board)
-      @tiles = board.tiles.dup
-    end
-
-    def [](coord)
-      @tiles[coord]
-    end
+    # @!group Move
 
-    def to_a
-      [0, 1, 2, 3].map { |each| row(each) }
-    end
-
-    def win?
-      @tiles.any? { |_key, value| value.to_i >= 2048 }
-    end
-
-    def lose?
-      right.left.up.down.tiles.select do |_key, each|
-        each.to_i > 0
-      end.size == 4 * 4
-    end
+    # @!macro [new] move
+    #   Move the tiles to the $0.
+    #   @return [Board] returns a new board
 
+    # @macro move
     def right
-      board, score = move_right
-      self.class.new board, @score + score
+      board, score = to_a.reduce([[], @score]) do |(rows, sc), each|
+        row, row_sc = each.right
+        [rows << row, sc + row_sc]
+      end
+      new_board(board, score)
     end
 
+    # @macro move
     def left
-      reverse :right
+      flip_horizontal { right }
     end
 
+    # @macro move
     def up
-      transpose :left
+      transpose { left }
     end
 
+    # @macro move
     def down
-      transpose :right
+      transpose { right }
+    end
+
+    # @!endgroup
+
+    # @!group Tiles
+
+    # @return [Array<Tile>] the list of tiles
+    def tiles
+      @all_tiles.select { |_key, each| each.to_i > 0 }
     end
 
+    # @return [Array] the list of +[row, col]+ of the merged tiles
     def merged_tiles
       find_tiles :merged
     end
 
+    # @return [Array] the list of +[row, col]+ of the newly generated tiles
     def generated_tiles
       find_tiles :generated
     end
 
+    # Need to generate a new tile?
+    # @param other [Board] the previous {Board} object
+    # @return [Boolean] generate a new tile?
+    def generate?(other)
+      to_a != other.to_a
+    end
+
+    # Generates a new tile
+    # @return [Board] a new board
     def generate
-      loop do
-        sample = @tiles.keys.sample
-        if @tiles[sample] == 0
-          @tiles[sample] = Tile.new(rand < 0.8 ? 2 : 4, :generated)
-          return
-        end
-      end
+      tiles = @all_tiles.dup
+      tiles[sample_zero_tile] = Tile.new(rand < 0.8 ? 2 : 4, :generated)
+      new_board(tiles, @score)
+    end
+
+    # @!endgroup
+
+    # @!group Win/Lose
+
+    def win?
+      @all_tiles.any? { |_key, value| value.to_i >= 2048 }
+    end
+
+    def lose?
+      right.left.up.down.tiles.size == 4 * 4
+    end
+
+    # @!endgroup
+
+    # @!group Conversion
+
+    # @return [Array] a 2D array of tiles.
+    def to_a
+      [0, 1, 2, 3].map { |each| row(each) }
     end
 
+    # @!endgroup
+
     private
 
-    def move_right
-      to_a.reduce([[], 0]) do |(board, score), each|
-        row, row_score = each.rmerge
-        [board << row, score + row_score]
-      end
+    def flip_horizontal(&block)
+      board = flipped_board.instance_eval(&block)
+      new_board(board.to_a.map(&:reverse), board.score)
+    end
+
+    def flipped_board
+      new_board(to_a.map(&:reverse), @score)
+    end
+
+    def transpose(&block)
+      board = transposed_board.instance_eval(&block)
+      new_board(board.to_a.transpose, board.score)
+    end
+
+    def transposed_board
+      new_board(to_a.transpose, @score)
+    end
+
+    def zero_tiles
+      @all_tiles.select { |_key, each| each.to_i == 0 }
     end
 
-    def transpose(direction)
-      klass = self.class
-      board = klass.new(to_a.transpose, @score).__send__(direction)
-      klass.new board.to_a.transpose, board.score
+    def sample_zero_tile
+      fail if zero_tiles.empty?
+      zero_tiles.keys.shuffle.first
     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
+    def new_board(tiles, score)
+      self.class.new(tiles, score)
     end
 
     def find_tiles(status)
-      @tiles.select { |_key, each| each.status == status }.keys
+      @all_tiles.select { |_key, each| each.status == status }.keys
     end
 
     def row(index)
-      [index].product([0, 1, 2, 3]).map { |each| @tiles[each] }
+      [index].product([0, 1, 2, 3]).map { |each| @all_tiles[each] }
     end
   end
 end

data/lib/text2048/curses_view.rb

@@ -1,65 +1,34 @@
 # encoding: utf-8
 
 require 'curses'
-require 'text2048/curses_tile'
+require 'forwardable'
+require 'text2048/curses_view/colorize'
+require 'text2048/curses_view/keyboard'
+require 'text2048/curses_view/tile'
+require 'text2048/curses_view/tile_effects'
 
 # This module smells of :reek:UncommunicativeModuleName
 module Text2048
   # Curses UI
   class CursesView
-    # Curses tile effects
-    module TileEffects
-      def pop_tiles(list)
-        [:pop, :draw_box].each do |each|
-          list_do each, list
-          refresh
-          sleep 0.1
-        end
-      end
-
-      def zoom_tiles(list)
-        [:fill_black, :draw_number, :show].each do |each|
-          list_do each, list
-          refresh
-          sleep 0.05
-        end
-      end
-
-      private
-
-      def list_do(name, list)
-        list.each { |each| @tiles[each].__send__ name }
-      end
-    end
-
+    include Colorize
     include Curses
     include TileEffects
+    extend Forwardable
 
-    COLORS = {
-      0 => COLOR_BLACK,
-      2 => COLOR_WHITE,
-      4 => COLOR_GREEN,
-      8 => COLOR_GREEN,
-      16 => COLOR_CYAN,
-      32 => COLOR_CYAN,
-      64 => COLOR_BLUE,
-      128 => COLOR_BLUE,
-      256 => COLOR_YELLOW,
-      512 => COLOR_YELLOW,
-      1024 => COLOR_MAGENTA,
-      2048 => COLOR_RED
-    }
-
-    DEFAULT_WIDTH = (CursesTile::DEFAULT_WIDTH + 1) * 4 + 1
-    DEFAULT_HEIGHT = (CursesTile::DEFAULT_HEIGHT + 1) * 4 + 2
+    DEFAULT_WIDTH = (Tile::DEFAULT_WIDTH + 1) * 4 + 1
+    DEFAULT_HEIGHT = (Tile::DEFAULT_HEIGHT + 1) * 4 + 2
 
     def initialize
       @tiles = {}
       @scale = 2
       @scale_min = 1
       @scale_step = 0.5
+      @keyboard = Keyboard.new
     end
 
+    def_delegator :@keyboard, :read, :command
+
     def update(board)
       maybe_init_curses
       draw_score(board.score)
@@ -68,11 +37,11 @@ module Text2048
     end
 
     def height
-      (CursesTile.height(@scale) + 1) * 4 + 1
+      (Tile.height(@scale) + 1) * 4 + 1
     end
 
     def width
-      (CursesTile.width(@scale) + 1) * 4 + 1
+      (Tile.width(@scale) + 1) * 4 + 1
     end
 
     def larger(board)
@@ -89,12 +58,12 @@ module Text2048
 
     def win
       setpos(rows_center, cols_center - 1)
-      attron(color_pair(COLOR_RED)) { addstr('WIN!') }
+      colorize(COLOR_RED) { addstr('WIN!') }
     end
 
     def game_over
       setpos(rows_center, cols_center - 4)
-      attron(color_pair(COLOR_RED)) { addstr('GAME OVER') }
+      colorize(COLOR_RED) { addstr('GAME OVER') }
     end
 
     private
@@ -115,20 +84,15 @@ module Text2048
     end
 
     def maybe_init_curses
-      @curses_initialized || init_curses
-      @curses_initialized = true
+      return if @initialized
+      init_curses
+      @initialized = true
     end
 
     def init_curses
-      start_color
-      init_color_pairs
-    end
-
-    def init_color_pairs
-      COLORS.each_pair do |_key, value|
-        init_pair value, COLOR_BLACK, value
-        init_pair value + 100, value, value
-      end
+      init_screen
+      curs_set(0)
+      at_exit { close_screen }
     end
 
     def draw_score(score)
@@ -140,7 +104,7 @@ module Text2048
       [0, 1, 2, 3].product([0, 1, 2, 3]).each do |row, col|
         tile = tiles[row][col]
         @tiles[[row, col]] =
-          CursesTile.new(tile, row, col, COLORS[tile.to_i], @scale).show
+          Tile.new(tile, row, col, color(tile.to_i), @scale).show
         refresh
       end
     end