just_xiangqi 0.1.0

data/lib/just_xiangqi/game_state.rb

@@ -0,0 +1,286 @@
+require 'just_xiangqi/errors/no_piece_error'
+require 'just_xiangqi/errors/not_players_turn_error'
+require 'just_xiangqi/errors/off_board_error'
+require 'just_xiangqi/errors/invalid_move_error'
+require 'just_xiangqi/errors/moved_into_check_error'
+require 'just_xiangqi/errors/piece_not_found_error'
+require 'just_xiangqi/errors/square_occupied_error'
+require 'just_xiangqi/errors/no_legal_moves_error'
+require 'just_xiangqi/square_set'
+
+module JustXiangqi
+
+  # = Game State
+  #
+  # Represents a game of Xiangqi in progress.
+  class GameState
+    def initialize(current_player_number: , squares: [])
+      @current_player_number = current_player_number
+      @squares = if squares.is_a?(SquareSet)
+                   squares
+                 else
+                   SquareSet.new(squares: squares)
+                 end
+    end
+
+    attr_reader :current_player_number, :squares, :errors
+
+    # Instantiates a new GameState object in the starting position.
+    #
+    # @return [GameState]
+    def self.default
+      new(
+        current_player_number: 1,
+        squares: [
+          { id: 'a10', x: 0, y: 0, piece: { id: 1, player_number: 2, type: 'ju' } },
+          { id: 'b10', x: 1, y: 0, piece: { id: 2, player_number: 2, type: 'ma' } },
+          { id: 'c10', x: 2, y: 0, piece: { id: 3, player_number: 2, type: 'xiang' } },
+          { id: 'd10', x: 3, y: 0, piece: { id: 4, player_number: 2, type: 'shi' } },
+          { id: 'e10', x: 4, y: 0, piece: { id: 5, player_number: 2, type: 'jiang' } },
+          { id: 'f10', x: 5, y: 0, piece: { id: 6, player_number: 2, type: 'shi' } },
+          { id: 'g10', x: 6, y: 0, piece: { id: 7, player_number: 2, type: 'xiang' } },
+          { id: 'h10', x: 7, y: 0, piece: { id: 8, player_number: 2, type: 'ma' } },
+          { id: 'i10', x: 8, y: 0, piece: { id: 9, player_number: 2, type: 'ju' } },
+
+          { id: 'a9', x: 0, y: 1, piece: nil },
+          { id: 'b9', x: 1, y: 1, piece: nil },
+          { id: 'c9', x: 2, y: 1, piece: nil },
+          { id: 'd9', x: 3, y: 1, piece: nil },
+          { id: 'e9', x: 4, y: 1, piece: nil },
+          { id: 'f9', x: 5, y: 1, piece: nil },
+          { id: 'g9', x: 6, y: 1, piece: nil },
+          { id: 'h9', x: 7, y: 1, piece: nil },
+          { id: 'i9', x: 8, y: 1, piece: nil },
+
+          { id: 'a8', x: 0, y: 2, piece: nil },
+          { id: 'b8', x: 1, y: 2, piece: { id: 10, player_number: 2, type: 'pao' } },
+          { id: 'c8', x: 2, y: 2, piece: nil },
+          { id: 'd8', x: 3, y: 2, piece: nil },
+          { id: 'e8', x: 4, y: 2, piece: nil },
+          { id: 'f8', x: 5, y: 2, piece: nil },
+          { id: 'g8', x: 6, y: 2, piece: nil },
+          { id: 'h8', x: 7, y: 2, piece: { id: 11, player_number: 2, type: 'pao' } },
+          { id: 'i8', x: 8, y: 2, piece: nil },
+
+          { id: 'a7', x: 0, y: 3, piece: { id: 12, player_number: 2, type: 'zu' } },
+          { id: 'b7', x: 1, y: 3, piece: nil },
+          { id: 'c7', x: 2, y: 3, piece: { id: 13, player_number: 2, type: 'zu' } },
+          { id: 'd7', x: 3, y: 3, piece: nil },
+          { id: 'e7', x: 4, y: 3, piece: { id: 14, player_number: 2, type: 'zu' } },
+          { id: 'f7', x: 5, y: 3, piece: nil },
+          { id: 'g7', x: 6, y: 3, piece: { id: 15, player_number: 2, type: 'zu' } },
+          { id: 'h7', x: 7, y: 3, piece: nil },
+          { id: 'i7', x: 8, y: 3, piece: { id: 16, player_number: 2, type: 'zu' } },
+
+          { id: 'a6', x: 0, y: 4, piece: nil },
+          { id: 'b6', x: 1, y: 4, piece: nil },
+          { id: 'c6', x: 2, y: 4, piece: nil },
+          { id: 'd6', x: 3, y: 4, piece: nil },
+          { id: 'e6', x: 4, y: 4, piece: nil },
+          { id: 'f6', x: 5, y: 4, piece: nil },
+          { id: 'g6', x: 6, y: 4, piece: nil },
+          { id: 'h6', x: 7, y: 4, piece: nil },
+          { id: 'i6', x: 8, y: 4, piece: nil },
+
+          { id: 'a5', x: 0, y: 5, piece: nil },
+          { id: 'b5', x: 1, y: 5, piece: nil },
+          { id: 'c5', x: 2, y: 5, piece: nil },
+          { id: 'd5', x: 3, y: 5, piece: nil },
+          { id: 'e5', x: 4, y: 5, piece: nil },
+          { id: 'f5', x: 5, y: 5, piece: nil },
+          { id: 'g5', x: 6, y: 5, piece: nil },
+          { id: 'h5', x: 7, y: 5, piece: nil },
+          { id: 'i5', x: 8, y: 5, piece: nil },
+
+          { id: 'a4', x: 0, y: 6, piece: { id: 17, player_number: 1, type: 'zu' } },
+          { id: 'b4', x: 1, y: 6, piece: nil },
+          { id: 'c4', x: 2, y: 6, piece: { id: 17, player_number: 1, type: 'zu' } },
+          { id: 'd4', x: 3, y: 6, piece: nil },
+          { id: 'e4', x: 4, y: 6, piece: { id: 17, player_number: 1, type: 'zu' } },
+          { id: 'f4', x: 5, y: 6, piece: nil },
+          { id: 'g4', x: 6, y: 6, piece: { id: 17, player_number: 1, type: 'zu' } },
+          { id: 'h4', x: 7, y: 6, piece: nil },
+          { id: 'i4', x: 8, y: 6, piece: { id: 17, player_number: 1, type: 'zu' } },
+
+          { id: 'a3', x: 0, y: 7, piece: nil },
+          { id: 'b3', x: 1, y: 7, piece: { id: 18, player_number: 1, type: 'pao' } },
+          { id: 'c3', x: 2, y: 7, piece: nil },
+          { id: 'd3', x: 3, y: 7, piece: nil },
+          { id: 'e3', x: 4, y: 7, piece: nil },
+          { id: 'f3', x: 5, y: 7, piece: nil },
+          { id: 'g3', x: 6, y: 7, piece: nil },
+          { id: 'h3', x: 7, y: 7, piece: { id: 19, player_number: 1, type: 'pao' } },
+          { id: 'i3', x: 8, y: 7, piece: nil },
+
+          { id: 'a2', x: 0, y: 8, piece: nil },
+          { id: 'b2', x: 1, y: 8, piece: nil },
+          { id: 'c2', x: 2, y: 8, piece: nil },
+          { id: 'd2', x: 3, y: 8, piece: nil },
+          { id: 'e2', x: 4, y: 8, piece: nil },
+          { id: 'f2', x: 5, y: 8, piece: nil },
+          { id: 'g2', x: 6, y: 8, piece: nil },
+          { id: 'h2', x: 7, y: 8, piece: nil },
+          { id: 'i2', x: 8, y: 8, piece: nil },
+
+          { id: 'a1', x: 0, y: 9, piece: { id: 20, player_number: 1, type: 'ju' } },
+          { id: 'b1', x: 1, y: 9, piece: { id: 21, player_number: 1, type: 'ma' } },
+          { id: 'c1', x: 2, y: 9, piece: { id: 22, player_number: 1, type: 'xiang' } },
+          { id: 'd1', x: 3, y: 9, piece: { id: 23, player_number: 1, type: 'shi' } },
+          { id: 'e1', x: 4, y: 9, piece: { id: 24, player_number: 1, type: 'jiang' } },
+          { id: 'f1', x: 5, y: 9, piece: { id: 25, player_number: 1, type: 'shi' } },
+          { id: 'g1', x: 6, y: 9, piece: { id: 26, player_number: 1, type: 'xiang' } },
+          { id: 'h1', x: 7, y: 9, piece: { id: 27, player_number: 1, type: 'ma' } },
+          { id: 'i1', x: 8, y: 9, piece: { id: 28, player_number: 1, type: 'ju' } }
+        ]
+      )
+    end
+
+    # serializes the game state as ahash
+    #
+    # @return [Hash]
+    def as_json
+      {
+        current_player_number: current_player_number,
+        squares: squares.as_json,
+      }
+    end
+
+    # deep clone of the game state
+    #
+    # @return [GameState]
+    def clone
+      self.class.new(**as_json)
+    end
+
+    # Moves a piece owned by the player, from one square, to another.
+    #
+    # It has an option to promote the moving piece.
+    # It moves the piece and returns true if the move is valid and it's the player's turn.
+    # It returns false otherwise.
+    #
+    # ==== Example:
+    #   # Moves a piece from a square to perform a move
+    #   game_state.move(1, '77', '78')
+    #
+    # @param [Fixnum] player_number
+    #   the player number, 1 or 2.
+    #
+    # @param [String] from_id
+    #   the id of the from square
+    #
+    # @param [String] to_id
+    #   the id of the to square
+    #
+    # @return [Boolean]
+    def move(player_number, from_id, to_id)
+      @errors = []
+
+      from = squares.find_by_id(from_id)
+      to = squares.find_by_id(to_id)
+
+      if current_player_number != player_number
+        @errors.push JustXiangqi::NotPlayersTurnError.new
+      elsif from.unoccupied?
+        @errors.push JustXiangqi::NoPieceError.new
+      elsif to.nil?
+        @errors.push JustXiangqi::OffBoardError.new
+      elsif from.piece.can_move?(from, to, self)
+
+        duplicate = self.clone
+        duplicate.perform_complete_move(player_number, from_id, to_id)
+
+        if duplicate.in_check?(current_player_number)
+          @errors.push JustXiangqi::MovedIntoCheckError.new
+        else
+          perform_complete_move(player_number, from_id, to_id)
+        end
+      else
+        @errors.push JustXiangqi::InvalidMoveError.new
+      end
+
+      @errors.empty?
+    end
+
+    # The player number of the winner. It returns nil if there is no winner.
+    #
+    # @return [Fixnum,NilClass]
+    def winner
+      case
+      when in_checkmate?(1)
+        2
+      when in_checkmate?(2)
+        1
+      else
+        nil
+      end
+    end
+
+    # Moves a piece owned by the player, from one square, to another, with the option to promote.
+    #
+    # It moves the piece and returns true if the move is valid and it's the player's turn.
+    # It returns false otherwise.
+    def perform_complete_move(player_number, from_id, to_id)
+      from = squares.find_by_id(from_id)
+      to = squares.find_by_id(to_id)
+
+      captured = to.occupied? ? to : nil
+
+      @last_change = { type: 'move', data: { player_number: player_number, from: from_id, to: to_id } }
+
+      perform_move(player_number, from, to, captured)
+
+      pass_turn
+    end
+
+    def in_check?(player_number)
+      jiang_square = squares.find_jiang_for_player(player_number)
+      threatened_by = squares.threatened_by(opposing_player_number(player_number), self)
+      threatened_by.include?(jiang_square)
+    end
+
+    def in_checkmate?(player_number)
+      (in_check?(player_number) || non_jiang_pieces_cannot_move?(player_number)) && jiang_cannot_move?(player_number)
+    end
+
+    private
+
+    def non_jiang_pieces_cannot_move?(player_number)
+      squares.occupied_by_player(player_number).excluding_piece(JustXiangqi::Jiang).all? { |s| s.piece.destinations(s, self).empty? }
+    end
+
+    def jiang_cannot_move?(player_number)
+      jiang_square = squares.find_jiang_for_player(player_number)
+      destinations = jiang_square.piece.destinations(jiang_square, self)
+      destinations.all? do |destination|
+        duplicate = self.clone
+        duplicate.perform_complete_move(player_number, jiang_square.id, destination.id)
+        duplicate.in_check?(player_number)
+      end
+    end
+
+    def pass_turn
+      @current_player_number = opposing_player_number
+    end
+
+    def opposing_player_number(player_number = nil)
+      if player_number
+        other_player_number(player_number)
+      else
+        other_player_number(@current_player_number)
+      end
+    end
+
+    def other_player_number(player_number)
+      (player_number == 1) ? 2 : 1
+    end
+
+    def perform_move(player_number, from, to, captured)
+      if captured
+        captured.piece = nil
+      end
+      to.piece = from.piece
+      from.piece = nil
+    end
+  end
+end
+

data/lib/just_xiangqi/piece_factory.rb

@@ -0,0 +1,71 @@
+require 'just_xiangqi/pieces/jiang'
+require 'just_xiangqi/pieces/ju'
+require 'just_xiangqi/pieces/ma'
+require 'just_xiangqi/pieces/pao'
+require 'just_xiangqi/pieces/shi'
+require 'just_xiangqi/pieces/xiang'
+require 'just_xiangqi/pieces/zu'
+
+module JustXiangqi
+
+  # = Piece Factory
+  #
+  # Generates pieces from a hash of arguments
+  class PieceFactory
+
+    # A mapping of type descriptions to classes.
+    CLASSES = {
+      'jiang' => Jiang,
+      'ju' => Ju,
+      'ma' => Ma,
+      'pao' => Pao,
+      'shi' => Shi,
+      'xiang' => Xiang,
+      'zu' => Zu 
+    }
+
+    # New objects can be instantiated by passing in a hash or the piece.
+    #
+    # @param [Hash,Piece] args
+    #   the initial attributes of the piece, hash requires type key
+    #
+    # ==== Example:
+    #   # Instantiates a new PieceFactory
+    #   JustXiangqi::PieceFactory.new({
+    #     type: 'zu',
+    #     id: 1,
+    #     player_number: 2
+    #   })
+    def initialize(args)
+      @args = args
+    end
+
+    # Returns a piece based on the initial arguments.
+    #
+    # @return [Piece]
+    def build
+      case @args
+      when Hash
+        build_from_hash
+      when Piece
+        @args
+      when nil
+        nil
+      else
+        raise ArgumentError, "piece must be Hash or NilClass"
+      end
+    end
+
+    private
+
+    def build_from_hash
+      klass = CLASSES[@args[:type]]
+      if klass
+        klass.new(**@args)
+      else
+        raise ArgumentError, "invalid piece type: #{@args[:type].to_s}"
+      end
+    end
+  end
+end
+

data/lib/just_xiangqi/pieces/jiang.rb

@@ -0,0 +1,31 @@
+require 'just_xiangqi/pieces/piece'
+
+module JustXiangqi
+  
+  # = Jiang
+  #
+  # The piece that can move 1 space orthogonally within the palace.
+  class Jiang < Piece
+    PALACE_X_COORDINATES = [3, 4, 5]
+    PALACE_Y_COORDINATES = [0, 1, 2, 7, 8, 9]
+
+    # All the squares that the piece can move to and/or capture.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [SquareSet]
+    def destinations(square, game_state)
+      palace_squares(game_state).orthogonal(square).at_range(square, 1).unoccupied_or_occupied_by_opponent(player_number)
+    end
+
+    private
+
+    def palace_squares(game_state)
+      game_state.squares.where(x: PALACE_X_COORDINATES, y: PALACE_Y_COORDINATES) 
+    end
+  end
+end

data/lib/just_xiangqi/pieces/ju.rb

@@ -0,0 +1,19 @@
+require 'just_xiangqi/pieces/piece'
+
+module JustXiangqi
+  # = Ju
+  #
+  # The piece that can move orthogonally.
+  class Ju < Piece
+    # All the squares that the piece can move to and/or capture.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    def destinations(square, game_state)
+      game_state.squares.orthogonal(square).unoccupied_or_occupied_by_opponent(player_number).unblocked(square, game_state.squares)
+    end
+  end
+end

data/lib/just_xiangqi/pieces/ma.rb

@@ -0,0 +1,60 @@
+require 'just_xiangqi/pieces/piece'
+
+module JustXiangqi
+  # = Ma 
+  #
+  # The piece that can move in an l shape, but can be blocked by adjacent pieces.
+  class Ma < Piece
+    MOVEMENT_MAP = {
+      [0,-1] => [[-1,-2], [1,-2]],
+      [1,0] => [[2,-1], [2,1]],
+      [0,1] => [[-1,2], [1,2]],
+      [-1,0] => [[-2,-1], [-2,1]]
+    }
+    # All the squares that the piece can move to and/or capture.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [SquareSet]
+    def destinations(square, game_state)
+      _squares = MOVEMENT_MAP.map do |adjacent_map, destinations_map|
+        adjacent = find_square_by_displacement(square, game_state, adjacent_map)
+        
+        if adjacent.nil? || adjacent.occupied?
+          nil
+        else
+          find_valid_destinations(square, game_state, destinations_map)
+        end
+      end.flatten.compact
+
+      SquareSet.new(squares: _squares)
+    end
+
+    private
+
+    def find_valid_destinations(square, game_state, destinations_map)
+      destinations_map.map do |destination_map|
+        find_valid_destination(square, game_state, destination_map)
+      end
+    end
+
+    def find_valid_destination(square, game_state, destination_map)
+      destination = find_square_by_displacement(square, game_state, destination_map)
+      if destination && (destination.unoccupied? || destination.occupied_by_opponent?(player_number))
+        destination
+      else
+        nil
+      end
+    end
+
+    def find_square_by_displacement(square, game_state, displacement)
+      x = square.x + displacement[0]
+      y = square.y + displacement[1]
+      game_state.squares.find_by_x_and_y(x, y)
+    end
+  end
+end

data/lib/just_xiangqi/pieces/pao.rb

@@ -0,0 +1,58 @@
+require 'just_xiangqi/pieces/piece'
+
+require 'board_game_grid'
+
+module JustXiangqi
+  # = Ju
+  #
+  # The piece that can move orthogonally and captures by jumping over
+  class Pao < Piece
+    MOVEMENT_VECTORS = [
+      BoardGameGrid::Point.new(0, -1),
+      BoardGameGrid::Point.new(1, 0),
+      BoardGameGrid::Point.new(0, 1),
+      BoardGameGrid::Point.new(-1, 0)
+    ]
+
+    # All the squares that the piece can move to and/or capture.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    def destinations(square, game_state)
+      move_squares(square, game_state) + capture_squares(square, game_state)
+    end
+
+    private
+
+    def move_squares(square, game_state)
+      game_state.squares.orthogonal(square).unoccupied.unblocked(square, game_state.squares)
+    end
+
+    def capture_squares(square, game_state)
+      squares = []
+      MOVEMENT_VECTORS.each do |vector|
+        current_point = square.point + vector 
+        current_square = game_state.squares.find_by_x_and_y(current_point.x, current_point.y)
+
+        # iterate through unoccupied square until end of board or occupied opponent square is reached
+        while !current_square.nil? && current_square.unoccupied?
+          current_point = current_square.point + vector
+          current_square = game_state.squares.find_by_x_and_y(current_point.x, current_point.y)
+        end
+
+        # find the next square after the occupied square
+        if current_square&.occupied_by_opponent?(player_number)
+          next_point = current_square.point + vector
+          next_square = game_state.squares.find_by_x_and_y(next_point.x, next_point.y)
+          # add the next square if it's unoccupied
+          squares.push(next_square) if !next_square.nil? && next_square.unoccupied?
+        end 
+      end
+
+      SquareSet.new(squares: squares)
+    end
+  end
+end

data/lib/just_xiangqi/pieces/piece.rb

@@ -0,0 +1,14 @@
+require 'board_game_grid'
+
+module JustXiangqi
+
+  # = Piece
+  #
+  # A piece that can move on a board
+  class Piece < BoardGameGrid::Piece
+    def initialize(id: , player_number: , type: nil)
+      @id = id
+      @player_number = player_number
+    end
+  end
+end

data/lib/just_xiangqi/pieces/shi.rb

@@ -0,0 +1,31 @@
+require 'just_xiangqi/pieces/piece'
+
+module JustXiangqi
+
+  # = Shi
+  #
+  # The piece that can move 1 space diagonally within the palace.
+  class Shi < Piece
+    PALACE_X_COORDINATES = [3, 4, 5]
+    PALACE_Y_COORDINATES = [0, 1, 2, 7, 8, 9]
+
+    # All the squares that the piece can move to and/or capture.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [SquareSet]
+    def destinations(square, game_state)
+      palace_squares(game_state).diagonal(square).at_range(square, 1).unoccupied_or_occupied_by_opponent(player_number)
+    end
+
+    private
+
+    def palace_squares(game_state)
+      game_state.squares.where(x: PALACE_X_COORDINATES, y: PALACE_Y_COORDINATES) 
+    end
+  end
+end

data/lib/just_xiangqi/pieces/xiang.rb

@@ -0,0 +1,29 @@
+require 'just_xiangqi/pieces/piece'
+
+module JustXiangqi
+
+  # = Xiang
+  #
+  # The piece that can move 2 spaces diagonally on its side of the river
+  class Xiang < Piece
+    # All the squares that the piece can move to and/or capture.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [SquareSet]
+    def destinations(square, game_state)
+      players_side_squares(game_state).diagonal(square).at_range(square, 2).unoccupied_or_occupied_by_opponent(player_number) 
+    end
+
+    private
+
+    def players_side_squares(game_state)
+      condition = player_number == 2 ? -> (y) { y <= 4 } : -> (y) { y >= 5 }
+      game_state.squares.where(y: condition)
+    end
+  end
+end

data/lib/just_xiangqi/pieces/zu.rb

@@ -0,0 +1,43 @@
+require 'just_xiangqi/pieces/piece'
+
+module JustXiangqi
+  # = Zu 
+  #
+  # The piece that can move one space forward and can also move one space horizontally when on the opposite side of the river. 
+  class Zu < Piece
+    # All the squares that the piece can move to and/or capture.
+    #
+    # @param [Square] square
+    #   the origin square.
+    #
+    # @param [GameState] game_state
+    #   the current game state.
+    #
+    # @return [SquareSet]
+    def destinations(square, game_state)
+      same_file_forwards_and_or_same_rank(square, game_state).in_range(square, 1).unoccupied_or_occupied_by_opponent(player_number)
+    end
+
+    private
+
+    def same_file_forwards_and_or_same_rank(square, game_state)
+      if on_players_side(square)
+        same_file_forwards(square, game_state) 
+      else
+        same_file_forwards(square, game_state) + same_rank(square, game_state)
+      end
+    end
+
+    def same_file_forwards(square, game_state)
+      game_state.squares.in_direction(square, forwards_direction).same_file(square)
+    end
+
+    def same_rank(square, game_state)
+      game_state.squares.same_rank(square)
+    end
+
+    def on_players_side(square)
+      (player_number == 2 && square.y <= 4) || (player_number == 1 && square.y >= 5) 
+    end
+  end
+end

data/lib/just_xiangqi/square.rb

@@ -0,0 +1,41 @@
+require 'just_xiangqi/piece_factory'
+require 'board_game_grid'
+
+module JustXiangqi
+
+  # = Square
+  #
+  # A Square on a shogi board.
+  class Square < BoardGameGrid::Square
+
+    # New object can be instantiated by passing in a hash with
+    #
+    # @param [String] id
+    #   the unique identifier of the square.
+    #
+    # @param [Fixnum] x
+    #   the x co-ordinate of the square.
+    #
+    # @param [Fixnum] y
+    #   the y co-ordinate of the square.
+    #
+    # @option [Piece,Hash,NilClass] piece
+    #   The piece on the square, can be a piece object or hash or nil.
+    #
+    # ==== Example:
+    #   # Instantiates a new Square
+    #   JustXiangqi::Square.new({
+    #     id: '91',
+    #     x: 0,
+    #     y: 0,
+    #     piece: { id: 1, player_number: 1, type: 'zu' }
+    #   })
+    def initialize(id: , x: , y: , piece: nil)
+      @id = id
+      @x = x
+      @y = y
+      @piece = PieceFactory.new(piece).build
+    end
+  end
+end
+