console-shogi 0.1.0 → 0.3.0

data/lib/console_shogi/piece.rb

@@ -2,10 +2,10 @@
 
 module ConsoleShogi
   class Piece
-    attr_reader :player
+    attr_accessor :teban
 
-    def initialize(player: nil)
-      @player = player
+    def initialize(teban: nil)
+      @teban = teban
     end
 
     def move
@@ -27,27 +27,19 @@ module ConsoleShogi
     end
 
     def image
-      if player.sente?
-        File.read("images/sente/#{self::class.name.split('::').last.downcase}.png")
-      else
-        File.read("images/gote/#{self::class.name.split('::').last.downcase}.png")
-      end
-    end
-
-    def none?
-      self::class == NonePiece
+      File.read("images/nomal/#{teban}/#{self::class.name.split('::').last.downcase}.png")
     end
 
-    def kaku?
-      self::class == Kaku
+    def active_image
+      File.read("images/active/#{teban}/#{self::class.name.split('::').last.downcase}.png")
     end
 
-    def hisha?
-      self::class == Hisha
+    def focused_image
+      File.read("images/focused/#{teban}/#{self::class.name.split('::').last.downcase}.png")
     end
 
-    def kyosha?
-      self::class == Kyosha
+    def none?
+      self::class == NonePiece
     end
 
     def fu?
@@ -57,7 +49,7 @@ module ConsoleShogi
     def moves
       ms = base_moves
 
-      if player.sente?
+      if teban == Teban::SENTE
         ms
       else
         ms.map {|m| m.transform_values {|v| v * -1 } }
@@ -67,6 +59,10 @@ module ConsoleShogi
     def change_player!(player)
       @player = player
     end
+
+    def can_move_long_distance?
+      [Kaku, Hisha, Kyosha, PromotedPiece::Uma, PromotedPiece::Ryu].include?(self::class)
+    end
   end
 
   class NonePiece < Piece
@@ -76,8 +72,16 @@ module ConsoleShogi
       []
     end
 
-    def player
-      NonPlayer.new
+    def image
+      File.read("images/nomal/nonepiece.png")
+    end
+
+    def active_image
+      File.read("images/active/nonepiece.png")
+    end
+
+    def focused_image
+      File.read("images/focused/nonepiece.png")
     end
 
     def can_promote?
@@ -249,13 +253,20 @@ module ConsoleShogi
   end
 
   class PromotedPiece < Piece
-    attr_reader :player, :original
+    attr_reader :original
 
     def initialize(original: nil)
-      @player = original.player
       @original = original
     end
 
+    def teban
+      original.teban
+    end
+
+    def teban=(val)
+      original.teban = val
+    end
+
     def can_promote?
       false
     end

data/lib/console_shogi/piece_movement_checker.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ConsoleShogi
+  class PieceMovementChecker
+    def initialize(board:, from:, to:)
+      @board = board
+      @from = from
+      @to = to
+    end
+
+    def can_move?
+      return false unless board.within_range?(x: to[:x], y: to[:y])
+
+      diff = {x: to[:x] - from[:x], y: to[:y] - from[:y]}
+
+      return false if from_piece.moves.none? {|m| m[:x] == diff[:x] && m[:y] == diff[:y] }
+
+      return false if from_piece.teban == to_piece.teban
+
+      return true unless from_piece.can_move_long_distance?
+
+      distance = (diff[:x].nonzero? || diff[:y]).abs
+      element = [diff[:x] / distance, diff[:y] / distance]
+
+      1.upto(distance - 1) do |d|
+        piece = board.fetch_piece(x: from[:x] + element[0] * d, y: from[:y] + element[1] * d)
+
+        return false unless piece.none?
+      end
+
+      true
+    end
+
+    private
+
+    attr_reader :board, :from, :to
+
+    def from_piece
+      @from_piece ||= board.fetch_piece(x: from[:x], y: from[:y])
+    end
+
+    def to_piece
+      @to_piece ||= board.fetch_piece(x: to[:x], y: to[:y])
+    end
+  end
+end

data/lib/console_shogi/piece_mover.rb

@@ -2,79 +2,62 @@
 
 module ConsoleShogi
   class PieceMover
-    def initialize(board:, from:)
+    def initialize(board:, player:, from:, to:)
       @board = board
-      @from_piece_index = from
+      @player = player
+      @from = from
+      @to = to
+      @moved_piece = false
     end
 
     def move!
-      return if target_piece.nil? || target_piece.none?
-
-      while key = STDIN.getch
-        if key == "\e" && STDIN.getch == "["
-          key = STDIN.getch
-
-          TerminalOperator.move_cursor(key)
-        elsif key == "\r"
-          to_piece_index = TerminalOperator.squares_index
-
-          return unless can_move?(piece: target_piece, to_piece_index: to_piece_index)
-
-          board.move_piece!(
-            from: {x: from_piece_index[:x], y: from_piece_index[:y]},
-            to: {x: to_piece_index[:x], y: to_piece_index[:y]}
-          )
-
-          # TODO とりあえずここに実装してしまっている。整理したい
-          piece = board.fetch_piece(x: to_piece_index[:x], y: to_piece_index[:y])
-          return unless can_promote?(piece, from_piece_index, to_piece_index)
-
-          board.promote_piece!(x: to_piece_index[:x], y: to_piece_index[:y]) if TerminalOperator.select_promotion
+      @moved_piece = move_piece!
+    end
 
-          return
-        end
-      end
+    def moved_piece?
+      @moved_piece
     end
 
-    def can_move?(piece:, to_piece_index:)
-      return false unless board.within_range?(x: to_piece_index[:x], y: to_piece_index[:y])
+    private
 
-      diff = {x: to_piece_index[:x] - from_piece_index[:x], y: to_piece_index[:y] - from_piece_index[:y]}
+    attr_reader :board, :player, :from, :to
 
-      return false if piece.moves.none? {|m| m[:x] == diff[:x] && m[:y] == diff[:y] }
+    def from_piece
+      @from_piece ||= board.fetch_piece(x: from[:x], y: from[:y])
+    end
 
-      to_piece = board.fetch_piece(x: to_piece_index[:x], y: to_piece_index[:y])
+    def move_piece!
+      return false if from_piece.nil? || from_piece.none?
+      return false if from_piece.teban != player.teban
 
-      return false if piece.player.teban == to_piece.player.teban
+      return false unless piece_movement_checker.can_move?
 
-      return true unless piece.kaku? || piece.hisha? || piece.kyosha?
+      to_piece = board.fetch_piece(x: to[:x], y: to[:y])
+      player.capture_piece!(to_piece) unless to_piece.none?
 
-      distance = (diff[:x].nonzero? || diff[:y]).abs
-      element = [diff[:x] / distance, diff[:y] / distance]
+      board.move_piece!(
+        from: {x: from[:x], y: from[:y]},
+        to: {x: to[:x], y: to[:y]}
+      )
 
-      1.upto(distance - 1) do |d|
-        piece = board.fetch_piece(x: from_piece_index[:x] + element[0] * d, y: from_piece_index[:y] + element[1] * d)
+      # TODO とりあえずここに実装してしまっている。整理したい
+      return true unless can_promote?(from_piece, from, to)
 
-        return false unless piece.none?
-      end
+      board.promote_piece!(x: to[:x], y: to[:y]) if Terminal::Operator.select_promotion
 
       true
     end
 
-    private
-
-    attr_reader :board, :from_piece_index
-
-    def target_piece
-      @target_piece ||= board.fetch_piece(x: from_piece_index[:x], y: from_piece_index[:y])
+    def piece_movement_checker
+      PieceMovementChecker.new(board: board, from: from, to: to)
     end
 
     def can_promote?(piece, from, to)
       return false unless piece.can_promote?
 
-      if piece.player.sente?
+      if piece.teban == Teban::SENTE
         from[:y].between?(0, 2) || to[:y].between?(0, 2)
-      elsif piece.player.gote?
+      elsif piece.teban == Teban::GOTE
         from[:y].between?(6, 8) || to[:y].between?(6, 8)
       end
     end

data/lib/console_shogi/piece_mover_on_komadai.rb

@@ -2,64 +2,58 @@
 
 module ConsoleShogi
   class PieceMoverOnKomadai
-    def initialize(board:, komadai:, from:)
+    def initialize(board:, komadai:, from:, to:)
       @board = board
       @komadai = komadai
       # 駒台の index に直す必要がある
-      @from_piece_index = from
+      @from = from
+      @to = to
+      @moved_piece = false
     end
 
-    def drop!
-      return if target_piece.nil? || target_piece.none?
+    def move!
+      @moved_piece = move_piece!
+    end
 
-      while key = STDIN.getch
-        if key == "\e" && STDIN.getch == "["
-          key = STDIN.getch
+    def moved_piece?
+      @moved_piece
+    end
 
-          TerminalOperator.move_cursor(key)
-        elsif key == "\r"
-          to_piece_index = TerminalOperator.squares_index
+    private
 
-          return if to_piece_index[:location] != :board
-          return unless can_drop?(piece: target_piece, to_piece_index: to_piece_index)
+    attr_reader :board, :komadai, :from, :to
 
-          komadai.pick_up_piece!(from: from_piece_index)
-          board.put_piece!(piece: target_piece, to: to_piece_index)
+    def move_piece!
+      return false if from_piece.nil? || from_piece.none?
 
-          return
-        end
-      end
-    end
+      # TODO ここで location の key もってるの期待してるの酷い、修正する
+      return false if to[:location] != :board
+      return false unless can_drop?(piece: from_piece, to: to)
 
-    private
+      komadai.pick_up_piece!(from: from)
+      board.put_piece!(piece: from_piece, to: to)
 
-    attr_reader :board, :komadai, :from_piece_index
+      true
+    end
 
-    def target_piece
-      @target_piece ||= komadai.fetch_piece(x: from_piece_index[:x], y: from_piece_index[:y])
+    def from_piece
+      @from_piece ||= komadai.fetch_piece(x: from[:x], y: from[:y])
     end
 
-    def can_drop?(piece:, to_piece_index:)
-      to_piece = board.fetch_piece(x: to_piece_index[:x], y: to_piece_index[:y])
+    def can_drop?(piece:, to:)
+      to_piece = board.fetch_piece(x: to[:x], y: to[:y])
 
       return false unless to_piece.none?
 
-      return false if nifu?(piece, to_piece_index)
-
-      can_move_next_turn?(piece, to_piece_index)
-    end
-
-    def can_move_next_turn?(piece, to_piece_index)
-      piece_mover = PieceMover.new(board: board, from: to_piece_index)
+      return false if nifu?(piece, to)
 
-      piece.moves.any? {|m|
-        piece_mover.can_move?(piece: piece, to_piece_index: {x: to_piece_index[:x] + m[:x], y: to_piece_index[:y] + m[:y]})
-      }
+      # TODO 動かせない場所に打つことはできないようにする
+      true
     end
 
-    def nifu?(piece, to_piece_index)
+    def nifu?(piece, to)
       piece.fu? &&
-        board.matrix.column(to_piece_index[:x]).any? {|p| p.fu? && piece.player == p.player }
+        board.matrix.column(to[:x]).any? {|p| p.fu? && piece.teban == p.teban }
     end
   end
 end

data/lib/console_shogi/player.rb

@@ -2,11 +2,6 @@
 
 module ConsoleShogi
   class Player
-    module Teban
-      SENTE = :sente
-      GOTE = :gote
-    end
-
     attr_reader :teban, :komadai
 
     def initialize(teban: nil)
@@ -27,16 +22,13 @@ module ConsoleShogi
       komadai.pieces.any? {|p| p.class == Ohsho }
     end
 
-    def capture_piece!(piece)
-      @komadai.expand! unless komadai.have_space?
-
-      piece = piece.original if piece.promoted?
+    def win_image
+      File.read("images/#{teban}_shori.png")
+    end
 
-      piece.change_player!(self)
+    def capture_piece!(piece)
+      piece.teban = teban
       komadai.put(piece: piece)
     end
   end
-
-  class NonPlayer < Player
-  end
 end

data/lib/console_shogi/teban.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module ConsoleShogi
+  module Teban
+    SENTE = :sente
+    GOTE = :gote
+  end
+end

data/lib/console_shogi/terminal/cursor.rb

@@ -0,0 +1,80 @@
+module ConsoleShogi
+  module Terminal
+    class Cursor
+      module Location
+        NONE = :none
+        BOARD = :board
+        SENTE_KOMADAI = :sente_komadai
+        GOTE_KOMADAI = :gote_komadai
+      end
+
+      TerminalPosition = Struct.new(:x, :y)
+      SquaresPosition = Struct.new(:x, :y, :location)
+
+      VERTICAL_DISTANCE = 1
+      HORIZONTAL_DISTANCE = 2
+      CURSOR_DIRECTIONS = %w(A B C D)
+
+      attr_reader :terminal_position, :squares_position
+
+      def initialize(terminal_index_x: 1, terminal_index_y: 1)
+        @terminal_position = TerminalPosition.new(x: 1, y: 1)
+        @squares_position = SquaresPosition.new(**calculate_squares_position)
+      end
+
+      def move(direction)
+        return unless CURSOR_DIRECTIONS.include?(direction)
+
+        distance =
+          case direction
+          when 'A', 'B'
+            VERTICAL_DISTANCE
+          when 'C', 'D'
+            HORIZONTAL_DISTANCE
+          end
+
+        print "\e[#{distance}#{direction}"
+
+        update_terminal_position!
+      end
+
+      private
+
+      def update_terminal_position!
+        positions = fetch_cursor_position_in_stdin
+
+        @terminal_position = TerminalPosition.new(x: positions[2].to_i, y: positions[1].to_i)
+        @squares_position = SquaresPosition.new(**calculate_squares_position)
+      end
+
+      def calculate_squares_position
+        case terminal_position.to_h
+        in x: 1..18, y: 1..9
+          {x: (terminal_position.x - 1) / HORIZONTAL_DISTANCE, y: terminal_position.y - 1, location: Location::BOARD}
+        in x: 21..38, y: 1..3
+          {x: (terminal_position.x - 21) / HORIZONTAL_DISTANCE, y: terminal_position.y - 1, location: Location::GOTE_KOMADAI}
+        in x: 21..38, y: 7..9
+          {x: (terminal_position.x - 21) / HORIZONTAL_DISTANCE, y: terminal_position.y - 7, location: Location::SENTE_KOMADAI}
+        else
+          {x: (terminal_position.x - 1) / HORIZONTAL_DISTANCE, y: terminal_position.y - 1, location: Location::NONE}
+        end
+      end
+
+      def fetch_cursor_position_in_stdin
+        stdout = ''
+
+        $stdin.raw do |stdin|
+          $stdout << "\e[6n"
+          $stdout.flush
+
+          # NOTE \e[n;mR という形式で現在位置が返ってくる
+          while (c = stdin.getc) != 'R'
+            stdout += c
+          end
+        end
+
+        stdout.match /(\d+);(\d+)/
+      end
+    end
+  end
+end

data/lib/console_shogi/terminal/display_area.rb

@@ -0,0 +1,30 @@
+module ConsoleShogi
+  module Terminal
+    module DisplayArea
+      module Board
+        START_INDEX = {x: 1, y: 1}
+        END_INDEX = {x: 18, y: 9}
+        RANGE = {x: Range.new(START_INDEX[:x], END_INDEX[:x]), y: Range.new(START_INDEX[:y], END_INDEX[:y])}
+      end
+
+      module Komadai
+        module Gote
+          START_INDEX = {x: 21, y: 1}
+          END_INDEX = {x: 38, y: 3}
+          RANGE = {x: Range.new(START_INDEX[:x], END_INDEX[:x]), y: Range.new(START_INDEX[:y], END_INDEX[:y])}
+        end
+
+        module Sente
+          START_INDEX = {x: 21, y: 7}
+          END_INDEX = {x: 38, y: 9}
+          RANGE = {x: Range.new(START_INDEX[:x], END_INDEX[:x]), y: Range.new(START_INDEX[:y], END_INDEX[:y])}
+        end
+      end
+
+      module OutSide
+        START_INDEX = {x: 10, y: 1}
+        RANGE = {x: Range.new(START_INDEX[:x], nil), y: Range.new(START_INDEX[:y], nil)}
+      end
+    end
+  end
+end