boardgame_engine 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9e57f58857092b8b08b48de9bafcf09a08297302fcbe695afde86125615d07f1
+  data.tar.gz: c7de6b02681a7b7def284e31186fc61281fe9ae41dfe75464dc0a5e83b5bde9a
+SHA512:
+  metadata.gz: 2155a5ca5a0c871e277a7a0e4beb9ea25b86a17ada30481d4f37b6104385c300095ef61cd694b860cadc72ab9230f6f7d199934a15c96de3278b22756174b07c
+  data.tar.gz: accc0b89071a919f466be01d1ecd68bc4f2fe3096817ff6340b161e731beabe1e05142399af352922cf7ac521ee95711fc6681068cf5b083c3e7ba9fb51ca02f

data/.rubocop.yml

@@ -0,0 +1,16 @@
+AllCops:
+  TargetRubyVersion: 3.1
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120
+
+Metrics/BlockLength:
+  AllowedMethods: ['describe', 'context']

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in boardgame_engine.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rubocop", "~> 1.21"

data/Gemfile.lock

@@ -0,0 +1,57 @@
+PATH
+  remote: .
+  specs:
+    boardgame_engine (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    diff-lcs (1.5.0)
+    json (2.6.2)
+    parallel (1.22.1)
+    parser (3.1.2.1)
+      ast (~> 2.4.1)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.6.0)
+    rexml (3.2.5)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.1)
+    rubocop (1.36.0)
+      json (~> 2.3)
+      parallel (~> 1.10)
+      parser (>= 3.1.2.1)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.20.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.21.0)
+      parser (>= 3.1.1.0)
+    ruby-progressbar (1.11.0)
+    unicode-display_width (2.3.0)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  boardgame_engine!
+  rake (~> 13.0)
+  rspec (~> 3.2)
+  rubocop (~> 1.21)
+
+BUNDLED WITH
+   2.3.22

data/README.md

@@ -0,0 +1,29 @@
+# BoardgameEngine
+
+A gem that provides a template for creating boardgames. It aims to streamline
+the process of making boardgames to be played on the terminal by providing a 
+variety of methods and classes.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add boardgame_engine
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install boardgame_engine
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Forthoney/boardgame_engine.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: :rubocop

data/boardgame_engine.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "lib/boardgame_engine/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "boardgame_engine"
+  spec.version = BoardgameEngine::VERSION
+  spec.authors = ["FortHoney"]
+  spec.email = ["castlehoneyjung@gmail.com"]
+
+  spec.summary = "A gem that makes digitizing/creating board games to be played on the terminal quick and easy."
+  spec.homepage = "https://github.com/Forthoney/boardgame_engine"
+  spec.required_ruby_version = ">= 2.7.0"
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to your gem server 'https://example.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/Forthoney/boardgame_engine"
+  spec.metadata["changelog_uri"] = "https://github.com/Forthoney/boardgame_engine/blob/main/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "rspec", "~> 3.2"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/boardgame_engine/boardgame.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+# All classes in this script are intended to be abstract, meaning they should
+# not be called on their own.
+
+# Class representing a physical board comprised of a grid in a board game. It
+# acts as both the View and Model if the project were to be compared to a MVC
+# model. It plays both roles as the board in a board game not only stores data,
+# but also IS the data that must be shown to the players.
+class Board
+  attr_reader :board
+
+  def initialize(row, col)
+    @board = Array.new(row) { Array.new(col) { nil } }
+  end
+
+  def display(show_row: false, show_col: false)
+    if show_row
+      @board.each_with_index { |row, idx| puts("#{idx} " + format_row(row)) }
+    else
+      @board.each { |row| puts format_row(row) }
+    end
+    return unless show_col
+
+    column_spacer = show_row ? "  " : ""
+    puts(@board[0].each_index.reduce(column_spacer) do |str, idx|
+      str + " #{idx} "
+    end)
+  end
+
+  def move_piece(start_row, start_col, end_row, end_col)
+    piece = @board[start_row][start_col]
+    @board[start_row][start_col] = nil
+    destination = @board[end_row][end_col]
+    @board[end_row][end_col] = piece
+
+    destination
+  end
+
+  private
+
+  def format_row(row)
+    row.map { |elem| "[#{elem.nil? ? " " : elem}]" }.join
+  end
+
+  def spot_playable?(piece, row, col)
+    piece.possible_moves.include? [row, col]
+  end
+end
+
+# Class representing a player in a game
+class Player
+  attr_reader :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def to_s
+    @name.to_s
+  end
+end
+
+# Class for running a board game.
+class Boardgame
+  EXIT_INSTRUCTIONS ||= "Try a sample input or input 'back' to leave the " \
+  "tutorial. Type in 'exit' anytime to exit the game fully"
+
+  def initialize(board, instructions, name1 = "Player 1", name2 = "Player 2")
+    @player1 = Player.new(name1)
+    @player2 = Player.new(name2)
+    @board = setup_board(board)
+    @instructions = instructions
+    @winner = nil
+  end
+
+  def self.play(do_onboarding: true)
+    puts "What is Player 1's name?"
+    player1 = gets.chomp
+    puts "What is Player 2's name?"
+    player2 = gets.chomp
+    @game = new(player1, player2)
+
+    puts "Welcome to #{@game}!"
+    @game.onboarding if do_onboarding
+    puts "Starting #{@game}..."
+    @game.start
+  end
+
+  def to_s(game_name = "boardgame")
+    "#{game_name} between #{@player1} and #{@player2}"
+  end
+
+  def onboarding
+    puts "Would you like a tutorial on how to play on this program? \n(y, n)"
+    case gets.chomp
+    when "y"
+      tutorial
+    when "n"
+      puts "Skipping tutorial"
+    else
+      puts 'Please answer either "y" or "n"'
+      onboarding
+    end
+  end
+
+  def tutorial
+    puts @instructions + Boardgame::EXIT_INSTRUCTIONS
+    input = gets.chomp
+    until input == "back"
+      exit if input == "exit"
+      puts valid_input?(input) ? "Valid input!" : "Invalid input"
+      input = gets.chomp
+    end
+  end
+
+  def start(turn = @player1)
+    @turn = turn
+    @board.display
+    until @winner
+      play_turn
+      @board.display
+    end
+    puts "#{@winner} wins!"
+  end
+
+  protected
+
+  def proper_format_input(special_commands = [])
+    input = gets.chomp
+    until valid_input?(input)
+      exit if input == "exit"
+      return input if special_commands.include?(input)
+
+      puts "Input is in the wrong format or out of bounds. Try again"
+      input = gets.chomp
+    end
+    input
+  end
+
+  def setup_board(board)
+    board.new
+  end
+end

data/lib/boardgame_engine/chess/chess.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "./lib/boardgame_engine"
+require "./lib/boardgame_engine/chess/chess_pieces"
+
+class ChessBoard < Board
+  attr_reader :board
+
+  def initialize(player1, player2)
+    super(8, 8)
+    setup(player1, player2)
+  end
+
+  def display
+    super(show_row: true, show_col: true)
+  end
+
+  private
+
+  def setup(player1, player2)
+    set_pawns(player1, player2)
+    set_non_pawns(player1, player2)
+  end
+
+  def set_pawns(player1, player2)
+    @board[1] = @board[1].map { Pawn.new(player1, 1) }
+    @board[-2] = @board[-2].map { Pawn.new(player2, -1) }
+  end
+
+  def set_non_pawns(player1, player2)
+    pieces = [Rook, Knight, Bishop, Queen, King, Bishop, Knight, Rook]
+    pieces.each_with_index do |piece, idx|
+      @board[0][idx] = piece.new(player1)
+      @board[7][7 - idx] = piece.new(player2)
+    end
+  end
+end
+
+class Chess < Boardgame
+  include TwoPlayers
+
+  def initialize(name1 = "Player 1", name2 = "Player 2")
+    @instructions = "You can select spots on the board by inputting the row " \
+    "and column with a comma in between. See example below\n1, 1\n"
+    super(ChessBoard, @instructions, name1, name2)
+  end
+
+  def to_s
+    super("chess")
+  end
+
+  private
+
+  def valid_input?(input)
+    coords = input.split(",")
+    coords.all? { |c| c.match?(/[[:digit:]]/) && c.to_i.between?(0, 7) }
+  end
+
+  def valid_piece?(piece)
+    !piece.nil? && piece.owner == @turn
+  end
+
+  def select_piece
+    input = proper_format_input
+    input.split(",").map(&:to_i) => [row, col]
+    if valid_piece? @board.board.dig(row, col)
+      [row, col]
+    else
+      puts "Invalid piece. Try again"
+      select_piece
+    end
+  end
+
+  def select_destination(piece, row, col)
+    input = proper_format_input(["back"])
+    return "back" if input == "back"
+
+    input.split(",").map(&:to_i) => [end_row, end_col]
+    if piece.valid_move?(row, col, end_row, end_col, @board.board)
+      [end_row, end_col]
+    else
+      puts "Invalid destination. Try again"
+      select_destination(piece, row, col)
+    end
+  end
+
+  def play_turn
+    puts "#{@turn}'s turn\nSelect your piece"
+    select_piece => [row, col]
+    piece = @board.board[row][col]
+    puts "Select where to move #{piece} to. Type back to reselect piece"
+    dest = select_destination(piece, row, col)
+    return if dest == "back"
+
+    killed = @board.move_piece(row, col, dest[0], dest[1])
+    @winner = piece.owner if killed.is_a?(King)
+    change_turn
+  end
+
+  def setup_board(board)
+    board.new(@player1, @player2)
+  end
+end

data/lib/boardgame_engine/chess/chess_pieces.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+class ChessPiece
+  attr_accessor :status
+  attr_reader :owner
+
+  def initialize(owner, name)
+    @kill_log = []
+    @status = "alive"
+    @owner = owner
+    @name = name
+  end
+
+  def kill(other)
+    @kill_log.push(other)
+    other.status = "dead"
+  end
+
+  def to_s
+    @name.to_s
+  end
+
+  protected
+
+  def valid_diag_move?(row, col, end_row, end_col, board)
+    ((end_row - row).abs == (end_col - col).abs) \
+    && clear_path?(row, col, end_row, end_col, board)
+  end
+
+  def valid_horz_move?(row, col, end_row, end_col, board)
+    (end_row == row) && clear_path?(row, col, end_row, end_col, board)
+  end
+
+  def valid_vert_move?(row, col, end_row, end_col, board)
+    (end_col == col) && clear_path?(row, col, end_row, end_col, board)
+  end
+
+  private
+
+  def next_cell(row, col, end_row, end_col)
+    row_move = 0
+    col_move = 0
+
+    col_move = (end_col - col) / (end_col - col).abs if end_col != col
+    row_move = (end_row - row) / (end_row - row).abs if end_row != row
+
+    [row + row_move, col + col_move]
+  end
+
+  def clear_path?(row, col, end_row, end_col, board)
+    current_tile = board.dig(row, col)
+    if (row == end_row) && (col == end_col)
+      current_tile.nil? || (current_tile.owner != @owner)
+    elsif current_tile.nil? || current_tile.equal?(self)
+      next_cell(row, col, end_row, end_col) => [next_row, next_col]
+      clear_path?(next_row, next_col, end_row, end_col, board)
+    else
+      false
+    end
+  end
+end
+
+class Pawn < ChessPiece
+  def initialize(owner, front)
+    super(owner, "p")
+    @first_move = true
+    @front = front
+  end
+
+  def valid_move?(row, col, end_row, end_col, board)
+    return false unless valid_forward_move?(row, end_row)
+
+    if col == end_col # only forward
+      valid_dest = board.dig(end_row, end_col).nil?
+      @first_move = false if valid_dest
+      return valid_dest
+    elsif (col - end_col).abs == 1 # diagonal movement
+      other_piece = board.dig(end_row, end_col)
+      return other_piece && (other_piece.owner != @owner)
+    end
+    false
+  end
+
+  private
+
+  def valid_forward_move?(row, end_row)
+    if @first_move
+      (row + @front * 2 == end_row) || (row + @front == end_row)
+    else
+      row + @front == end_row
+    end
+  end
+end
+
+class Queen < ChessPiece
+  def initialize(owner)
+    super(owner, "Q")
+  end
+
+  def valid_move?(row, col, end_row, end_col, board)
+    valid_diag_move?(row, col, end_row, end_col, board) \
+    || valid_horz_move?(row, col, end_row, end_col, board) \
+    || valid_vert_move?(row, col, end_row, end_col, board)
+  end
+end
+
+class Rook < ChessPiece
+  def initialize(owner)
+    super(owner, "R")
+  end
+
+  def valid_move?(row, col, end_row, end_col, board)
+    valid_horz_move?(row, col, end_row, end_col, board) \
+    || valid_vert_move?(row, col, end_row, end_col, board)
+  end
+end
+
+class Bishop < ChessPiece
+  def initialize(owner)
+    super(owner, "B")
+  end
+
+  def valid_move?(row, col, end_row, end_col, board)
+    valid_diag_move?(row, col, end_row, end_col, board)
+  end
+end
+
+class King < ChessPiece
+  def initialize(owner)
+    super(owner, "K")
+  end
+
+  def valid_move?(row, col, end_row, end_col, board)
+    return false unless (row - end_row).abs == 1 && (col - end_col).abs == 1
+
+    valid_diag_move?(row, col, end_row, end_col, board) \
+    || valid_horz_move?(row, col, end_row, end_col, board) \
+    || valid_vert_move?(row, col, end_row, end_col, board)
+  end
+end
+
+class Knight < ChessPiece
+  def initialize(owner)
+    # K was already taken by king, so I had to choose N
+    super(owner, "N")
+  end
+
+  def valid_move?(row, col, end_row, end_col, board)
+    within_movement(row, col, end_row, end_col) \
+    && not_occupied(end_row, end_col, board)
+  end
+
+  private
+
+  def within_movement(row, col, end_row, end_col)
+    ((row - end_row).abs == 2 and (col - end_col).abs == 1) \
+    || ((row - end_row).abs == 1 and (col - end_col).abs == 2)
+  end
+
+  def not_occupied(end_row, end_col, board)
+    spot = board.dig(end_row, end_col)
+    spot.nil? || spot.owner != @owner
+  end
+end

data/lib/boardgame_engine/connect4/connect4.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "./lib/boardgame_engine"
+
+class Connect4Board < Board
+  def initialize
+    super(6, 7)
+  end
+
+  def display
+    super(show_col: true)
+  end
+
+  def drop_chip(col, owner)
+    @board.reverse_each do |row|
+      if row[col].nil?
+        row[col] = owner
+        break
+      end
+    end
+  end
+end
+
+class Connect4 < Boardgame
+  include TwoPlayers
+
+  @instructions = "You can select which column to drop you chip into by" \
+  " typing in the row number."
+
+  def initialize(name1 = "Player 1", name2 = "Player 2")
+    super(Connect4Board, @instructions, name1, name2)
+  end
+
+  def to_s
+    super("connect-four")
+  end
+
+  private
+
+  def valid_input?(input)
+    input.match?(/[[:digit:]]/) && input.to_i.between?(0, 6)
+  end
+
+  def play_turn
+    puts "#{@turn}'s turn. Choose a column to drop your chip in"
+    col = proper_format_input.to_i
+    @board.drop_chip(col, @turn)
+    @winner = @turn if win?
+    change_turn
+  end
+
+  def win?
+    [@board.board,
+     @board.board.transpose,
+     align_diagonally(@board.board),
+     align_diagonally(@board.board.transpose)].each do |config|
+      config.each { |direction| return true if four_in_a_row? direction }
+    end
+    false
+  end
+
+  def four_in_a_row?(row)
+    counts = row.chunk { |x| x }.map { |x, xs| [x, xs.length] }
+    return true if counts.any? { |x, count| count > 3 && !x.nil? }
+  end
+
+  def align_diagonally(board)
+    board.map.with_index do |row, idx|
+      left_filler = Array.new(board.length - 1 - idx, nil)
+      right_filler = Array.new(idx, nil)
+      left_filler + row + right_filler
+    end
+  end
+end

data/lib/boardgame_engine/multiplayergame.rb

@@ -0,0 +1,5 @@
+module TwoPlayers
+  def change_turn
+    @turn = @turn == @player1 ? @player2 : @player1
+  end
+end

data/lib/boardgame_engine/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BoardgameEngine
+  VERSION = "0.1.0"
+end

data/lib/boardgame_engine.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "boardgame_engine/version"
+
+require_relative "boardgame_engine/boardgame"
+require_relative "boardgame_engine/multiplayergame"
+require_relative "boardgame_engine/chess/chess"
+require_relative "boardgame_engine/connect4/connect4"
+
+module BoardgameEngine
+  class Error < StandardError; end
+end

data/sig/boardgame_engine.rbs

@@ -0,0 +1,4 @@
+module BoardgameEngine
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: boardgame_engine
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- FortHoney
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-10-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description:
+email:
+- castlehoneyjung@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- boardgame_engine.gemspec
+- lib/boardgame_engine.rb
+- lib/boardgame_engine/boardgame.rb
+- lib/boardgame_engine/chess/chess.rb
+- lib/boardgame_engine/chess/chess_pieces.rb
+- lib/boardgame_engine/connect4/connect4.rb
+- lib/boardgame_engine/multiplayergame.rb
+- lib/boardgame_engine/version.rb
+- sig/boardgame_engine.rbs
+homepage: https://github.com/Forthoney/boardgame_engine
+licenses: []
+metadata:
+  homepage_uri: https://github.com/Forthoney/boardgame_engine
+  source_code_uri: https://github.com/Forthoney/boardgame_engine
+  changelog_uri: https://github.com/Forthoney/boardgame_engine/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: A gem that makes digitizing/creating board games to be played on the terminal
+  quick and easy.
+test_files: []