terminal_chess 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 34fa5a38bd74510d2289f5fec7141397fb691f5f
-  data.tar.gz: f01641e3e28dbb1e3965a42a2a3da40078442d0c
+  metadata.gz: e6a657c0e4f1a9d9e7f1d0c9ee0c62b009f33fdc
+  data.tar.gz: e691068c1d7e0ba8c9f0a6e2092a8ac32e4c562b
 SHA512:
-  metadata.gz: a9b484ad6b6058cf21c2f0feda9d35bd41285ddea65d7d1926bcfde9ccf10d77d2c0f9d1239d7bf62f1d6a0b37eb13fc7c5a24a893ebbb1c4c90636b2c9dcb40
-  data.tar.gz: cb690106cc38935ac5528639d222e81d237367584b4c075abe848742ea11645fa35644334d6e38d98863bf1b79d6f63c344da344766aeff44f747b081427a003
+  metadata.gz: 27347b75a56f10cb3969257fac8295d948ced1e6002f545fd539a1890d5853c46d11b287c4721d8ca4d1385938b58d562280542f76222ce9e0f351f29e0d7de6
+  data.tar.gz: 65ce2d89d403db4310bd179b635b36a0a1d84cfc4ae513826ff17de30e1427bb546a06db39203d8152754398d7053a5ebe8c60b94228e120a9ea085d1c2fbee7

data/Gemfile.lock

@@ -0,0 +1,38 @@
+PATH
+  remote: .
+  specs:
+    terminal_chess (0.2.0)
+      colorize
+      em-websocket
+      eventmachine
+      faye-websocket
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    colorize (0.8.1)
+    em-websocket (0.5.1)
+      eventmachine (>= 0.12.9)
+      http_parser.rb (~> 0.6.0)
+    eventmachine (1.2.5)
+    faye-websocket (0.10.7)
+      eventmachine (>= 0.12.0)
+      websocket-driver (>= 0.5.1)
+    http_parser.rb (0.6.0)
+    minitest (5.8.4)
+    rake (10.5.0)
+    websocket-driver (0.7.0)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.7)
+  minitest
+  rake (~> 10.0)
+  terminal_chess!
+
+BUNDLED WITH
+   1.16.0

data/README.md

@@ -1,63 +1,87 @@
 Terminal-Chess
 ==============
 
-A two-player chess game for the Terminal, written in Ruby (output below is colorized when run in the terminal)
-<pre>
-					>> Welcome to Terminal Chess v0.1.0
-
-    _A__  _B__  _C__  _D__  _E__  _F__  _G__  _H__
-   |    ||    ||    ||    ||    ||    ||    ||    |
- 1 |    || KN || BI || QU || KI || BI || KN || RO | 1
-   |____||____||____||____||____||____||____||____|
-   |    ||    ||    ||    ||    ||    ||    ||    |
- 2 |    || PA || PA || PA || PA || PA || PA || PA | 2
-   |____||____||____||____||____||____||____||____|
-   |    ||    ||    ||    ||    ||    ||    ||    |
- 3 |    ||    ||    ||    || RO ||    ||    ||    | 3
-   |____||____||____||____||____||____||____||____|
-   |    ||    ||    ||    ||    ||    ||    ||    |
- 4 | PA ||    ||    ||    ||    ||    ||    ||    | 4
-   |____||____||____||____||____||____||____||____|
-   |    ||    ||    ||    ||    ||    ||    ||    |
- 5 | PA ||    ||    ||    ||    ||    ||    ||    | 5
-   |____||____||____||____||____||____||____||____|
-   |    ||    ||    ||    ||    ||    ||    ||    |
- 6 |    ||    ||    ||    ||    ||    ||    ||    | 6
-   |____||____||____||____||____||____||____||____|
-   |    ||    ||    ||    ||    ||    ||    ||    |
- 7 |    || PA || PA || PA || PA || PA || PA || PA | 7
-   |____||____||____||____||____||____||____||____|
-   |    ||    ||    ||    ||    ||    ||    ||    |
- 8 | RO || KN || BI || QU || KI || BI || KN || RO | 8
-   |____||____||____||____||____||____||____||____|
-     A     B     C     D     E     F     G     H
-
-Piece to Move: B8
-Valid destinations: C6, A6
-Location: c6
-
-</pre>
-
-![Screenshot](http://at1as.github.io/github_repo_assets/terminal_chess.jpg)
-
-### Requirements
-Requires the colorize Ruby gem (listed in .gemspec file)
-```bash
-$ sudo gem install colorize
-```
+A lightweight two-player chess game for the Terminal, written in Ruby
+
+![Screenshot](http://at1as.github.io/github_repo_assets/terminal_chess-2.png)
+
  
-### Usage
-The easiest way to use terminal_chess is to install it via the [Rubygem](https://rubygems.org/gems/terminal_chess). This is likely to be a few commits behind, but generally more stable.
+### Installing
+
+The easiest way to use terminal_chess is to install it via the [Rubygem](https://rubygems.org/gems/terminal_chess). Note that the Gem is *way* out of date when compared to the repo
 
 Otherwise, clone this repo directly and run:
-```bash 
+
+```bash
+# Download Repo
 $ git clone git@github.com:at1as/Terminal-Chess.git
 $ chmod +x lib/terminal_chess.rb
+
+# Install Dependencies. Only dependency is the colorize gem
+$ bundle install
+```
+
+### Running
+
+#### Local Gameplay
+
+In this mode, the game will launch in Terminal and allow the player to make moves for both sides of the board
+
+```
+# Run program in terminal
+
 $ ruby lib/terminal_chess.rb
 ```
 
-### Limitations
-* Built and tested on Terminal in OS 10.10
-* For now, checkmate will need to be verified manually
-* TODO: Code cleanup. Printer module is painful to read.
-* Niether player can be automated
+#### Multiplayer
+
+Terminal Chess can connect to an opponent using websockets over ngrok. The requires first starting the server:
+
+```
+# The webserver must be running either on one of the players machines
+# Or somewhere else. This will need to be running before either client can connect
+$ lib/server.rb 
+
+# The host running the server will need to tunnel the connection through ngrok
+# on the free plan the URL will change every time ngrok is launched
+# therefor the `9cf13f35` component will need to be passed to the clients in order
+# to connect
+$ ngrok http 4567
+ => http://9cf13f35.ngrok.io -> localhost:4567
+```
+
+And then the client can connect via the NGROK environment variable. if this environment variable is set, the client will attempt to start a session over the network. If the connection  
+
+```
+# Replace the NGROK enviroment variable with whatever URL the ngrok server returned
+$ NGROK=9cf13f5 ruby lib/terminal_chess.rb
+
+# => [:message, "INFO: Awaiting second player..."]
+```
+
+And once the second client connects, game on!
+
+```
+$ NGROK=9cf13f5 ruby lib/terminal_chess.rb
+
+# => [:message, "INFO: Connected to remote player"]
+# => [:message, "SETUP: You are player 2"]
+# => [:message, "INFO: Starting game!"]
+```
+
+Any subsequent clients that attempt to connect while the game is in session will have their connections dropped
+
+### Testing:
+
+```bash
+$ bundle exec rake test --trace
+```
+
+### Notes
+* Built and tested on macOS 10.11 with Ruby 2.4.0
+* Neither player can currently be automated
+
+### TODO:
+* Update Gem to reflect the last two years' repo changes...
+* Automate one of two players (note: tried this. Not easy to make it competent)
+* Switch written Chess pieces to unicode characters (note: tried this. Didn't look great)

data/lib/board.rb

@@ -0,0 +1,357 @@
+#!/usr/bin/env ruby
+
+load 'printer.rb'
+load 'move.rb'
+load 'terminal_chess/messages.rb'
+require 'colorize'
+
+class Board
+
+  include Printer
+  include Move
+
+  attr_reader :piece_locations, :checkmate, :player_turn
+  attr_reader :taken_pieces
+
+  alias piece_manifest piece_locations
+
+
+  def initialize
+    @piece_locations_buffer = Hash.new
+    @piece_locations = Hash.new
+    @row_mappings    = Hash[("A".."H").zip(1..8)]
+    @taken_pieces    = Array.new
+    @player_turn     = :black
+    @checkmate       = false
+
+    setup_board
+  end
+
+  # Game logic
+  def move(p1, p2)
+
+    manifest = piece_manifest()
+
+    p1 = get_index_from_rowcol(p1.to_s)
+    p2 = get_index_from_rowcol(p2.to_s)
+
+    # Find valid positions and subtract king current position as nobody can directly take king piece
+    valid_positions = possible_moves(p1, manifest, true)
+    valid_positions -= king_positions
+
+    # If player is moving out of turn, display message
+    # `return p ...` is so we print value and return it from the function
+    #  this is so the unit tests can get the value directly. There are better ways to do this
+    unless @player_turn == @piece_locations[p1][:color]
+      return p "It is #{@player_turn}'s turn. Please move a #{@player_turn} piece."
+    end
+
+    return p "Please select a valid destination." unless valid_positions.include?(p2)
+
+    create_board_after_piece_moved(p1, p2)
+
+    # If player is in check with the new proposed board, disallow the movement
+    if check?(@player_turn, @piece_locations_buffer)
+      return p "Please move #{@player_turn} king out of check to continue"
+    end
+
+    # At this point, the move appears to be valid
+    @taken_pieces << @piece_locations[p2] unless @piece_locations[p2][:type].nil?
+
+    # Check for Pawn Promotion (if pawn reaches end of the board, promote it)
+    if @piece_locations_buffer[p2][:type] == :pawn
+      if p2 < 9 && @piece_locations_buffer[p2][:color] == :red
+        promote(p2)
+      elsif p2 > 56 && @piece_locations_buffer[p2][:color] == :black
+        promote(p2)
+      end
+    end
+
+    # Check for Castling - https://en.m.wikipedia.org/wiki/Castling
+    if @piece_locations_buffer[p2][:type] == :king && (p2 - p1).abs == 2
+
+      p2 < 9 ? y_offset = 0 : y_offset = 56
+
+      if p2 > p1
+        @piece_locations_buffer[6+y_offset] = @piece_locations_buffer[8+y_offset]
+        @piece_locations_buffer[8+y_offset] = {
+          :type   => nil,
+          :number => nil,
+          :color  => nil
+        }
+      else
+        @piece_locations_buffer[4+y_offset] = @piece_locations_buffer[1+y_offset]
+        @piece_locations_buffer[1+y_offset] = {
+          :type   => nil,
+          :number => nil,
+          :color  => nil
+        }
+      end
+    end
+
+    commit_board_piece_movement
+
+    if (winner = player_in_checkmate(@piece_locations))
+      return p Messages.black_winner if winner == :black
+      return p Messages.red_winner   if winner == :red
+    end
+
+    return p Messages.piece_moved
+  end
+
+
+  def commit_board_piece_movement
+    @piece_locations = @piece_locations_buffer
+    @player_turn = opposing_color(@player_turn)
+    display_board
+  end
+
+
+  def create_board_after_piece_moved(p1, p2)
+    # Store state of board after proposed move in @piece_locations_buffer
+    @piece_locations_buffer = @piece_locations.clone
+    @piece_locations_buffer[p2] = @piece_locations_buffer[p1]
+    @piece_locations_buffer[p2][:moved] = true
+    @piece_locations_buffer[p1] = {
+      :type   => nil,
+      :number => nil,
+      :color  => nil
+    }
+  end
+
+
+  # Return the valid positions for piece at current_pos to move in readable format [A-H][1-8]
+  def valid_destinations(current_pos)
+    readable_positions = []
+    manifest = piece_manifest
+    p1 = get_index_from_rowcol(current_pos.to_s)
+
+    valid_positions = possible_moves(p1, manifest, true)
+
+    valid_positions.each do |pos|
+      grid_pos = get_rowcol_from_index(pos)
+      # Map first string character 1-8 to [A-H], for column, and then add second string character as [1-8]
+      readable_positions << (@row_mappings.key(grid_pos[0].to_i) + grid_pos[1].to_s)
+    end
+
+    readable_positions.sort
+  end
+
+
+  # Search piece manifest for kings. Remove them from the list of positions returned
+  # from the Move module (so that players cannot take the "king" type piece)
+  def king_positions
+    king_locations = []
+
+    @piece_locations.each do |piece, details|
+      king_locations << piece if details.fetch(:type) == :king
+    end
+
+    king_locations
+  end
+
+
+  # Once a pawn reaches the end, this method is called to swap the pawn
+  # for another piece (from the list below)
+  def promote(p1)
+    puts "Promote to: [Q]ueen, [K]night, [R]ook, [B]ishop"
+
+    loop do
+      promo_piece = gets.chomp.downcase
+
+      if promo_piece == "q" || promo_piece == :queen
+        @piece_locations_buffer[p1][:type] = :queen
+        break
+
+      elsif promo_piece == "k" || promo_piece == :knight
+        @piece_locations_buffer[p1][:type] = :knight
+        break
+
+      elsif promo_piece == "r" || promo_piece == :rook
+        @piece_locations_buffer[p1][:type] = :rook
+        break
+
+      elsif promo_piece == "b" || promo_piece == :bishop
+        @piece_locations_buffer[p1][:type] = :bishop
+        break
+
+      else
+        puts "Please enter one of: [Q]ueen, [K]night, [R]ook, [B]ishop"
+      end
+    end
+  end
+
+  private :promote
+
+
+  def player_in_checkmate(manifest = @piece_locations)
+    return :red   if checkmate?(:black, manifest)
+    return :black if checkmate?(:red,   manifest)
+  end
+
+  def checkmate?(color, manifest)
+    check?(color, manifest, recurse_for_checkmate=true) && @checkmate
+  end
+
+  # Return whether the player of a specified color has their king currently in check
+  # by checking the attack vectors of all the opponents players against the king location
+  # Also, check whether king currently in check, has all of their valid moves within
+  # their opponents attack vectors, and therefore are in checkmate (@checkmate)
+  def check?(color, proposed_manifest = @piece_locations, recurse_for_checkmate = false)
+
+    enemy_attack_vectors  = {}
+    player_attack_vectors = {}
+
+    king_loc    = []
+    enemy_color = opposing_color(color)
+
+    proposed_manifest.each do |piece, details|
+
+      if details[:color] == enemy_color
+        enemy_attack_vectors[piece] = possible_moves(piece, proposed_manifest)
+
+      elsif details[:color] == color
+        begin
+          player_attack_vectors[piece] = possible_moves(piece, proposed_manifest)
+        rescue
+          # TODO: Fix possible_moves() so it doesn't throw exceptions
+          # This happens because it is searching board for where pieces
+          # will be, as as a result some pieces are nil
+        end
+      end
+
+      king_loc = piece if details[:color] == color && details[:type] == :king
+    end
+
+    danger_vector  = enemy_attack_vectors.values.flatten.uniq
+    defence_vector = player_attack_vectors.values.flatten.uniq
+    king_positions = possible_moves(king_loc, proposed_manifest)
+
+    # The King is in the attackable locations by the opposing player
+    return false unless danger_vector.include? king_loc
+
+    # If all the positions the king piece can move to is also attackable by the opposing player
+    if recurse_for_checkmate && ((king_positions - danger_vector).length == 0)
+
+      is_in_check = []
+      player_attack_vectors.each do |piece_index, piece_valid_moves|
+        piece_valid_moves.each do |possible_new_location|
+
+          # Check if board is still in check after piece moves to its new location
+          @new_piece_locations = @piece_locations.clone
+          @new_piece_locations[possible_new_location] = @new_piece_locations[piece_index]
+          @new_piece_locations[piece_index] = {
+            :type   => nil,
+            :number => nil,
+            :color  => nil
+          }
+
+          is_in_check << check?(color, @new_piece_locations)
+        end
+      end
+
+      if is_in_check.include?(false)
+        return false
+      else
+        @checkmate = true
+      end
+    end
+
+    true
+  end
+
+
+  def opposing_color(player_color)
+    ([:black, :red] - [player_color]).first
+  end
+
+  # Board spaces that are attackable by opposing pieces
+  #  TODO: check? method should use this function
+  def attack_vectors(color = @player_turn, proposed_manifest = @piece_locations)
+    enemy_color = opposing_color(color)
+    kill_zone = Array.new
+
+    proposed_manifest.each do |piece, details|
+      kill_zone << possible_moves(piece, proposed_manifest) if details.fetch(:color) == enemy_color
+    end
+
+    kill_zone.flatten.uniq
+  end
+
+
+  # Reprint the board. Called after every valid piece move
+  def display_board
+    print_board @piece_locations
+  end
+
+
+  # Convert index [A-H][1-8] => (1 - 64)
+  def get_index_from_rowcol(row_col)
+    (row_col[1].to_i - 1) * 8 + @row_mappings.fetch(row_col[0]).to_i
+  end
+
+
+  # Convert index (1 - 64) => [A-H][1-8]
+  def get_rowcol_from_index(index)
+    letter = get_col_from_index(index)
+    number = get_row_from_index(index)
+
+    "#{letter}#{number}"
+  end
+
+
+  def setup_board
+    # Intial setup of board. Put pieces into the expected locations
+    setup_empty_tiles
+    place_player_pieces(:black)
+    place_player_pieces(:red)
+  end
+
+
+  def setup_empty_tiles
+    # Initialize chess board tiles without any pieces
+    (1..64).each do |tile_num|
+      @piece_locations[tile_num] = {
+        :type   => nil,
+        :number => nil,
+        :color  => nil
+      }
+    end
+  end
+
+
+  def place_player_pieces(color)
+    # Place pieces on chess board
+    place_first_row(color)
+    place_pawns(color)
+  end
+
+
+  def place_pawns(color)
+    offset = color == :black ? 8 : 48
+
+    (1..8).each do |piece_num|
+      @piece_locations[piece_num + offset] = {
+        :type   => :pawn,
+        :number => piece_num,
+        :color  => color,
+        :moved  => false
+      }
+    end
+  end
+
+
+  def place_first_row(color)
+    row_offset = color == :black ? 0 : 56
+
+    @piece_locations[row_offset + 1] = {:type => :rook,   :number => 1, :color => color, :moved => false}
+    @piece_locations[row_offset + 2] = {:type => :knight, :number => 1, :color => color, :moved => false}
+    @piece_locations[row_offset + 3] = {:type => :bishop, :number => 1, :color => color, :moved => false}
+    @piece_locations[row_offset + 4] = {:type => :queen,  :number => 1, :color => color, :moved => false}
+    @piece_locations[row_offset + 5] = {:type => :king,   :number => 1, :color => color, :moved => false}
+    @piece_locations[row_offset + 6] = {:type => :bishop, :number => 2, :color => color, :moved => false}
+    @piece_locations[row_offset + 7] = {:type => :knight, :number => 2, :color => color, :moved => false}
+    @piece_locations[row_offset + 8] = {:type => :rook,   :number => 2, :color => color, :moved => false}
+  end
+
+end