splendor_game 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 547dab96b270b9680b85697dcfdebf09fac4f8db
+  data.tar.gz: 9fbdd1e06feb465f45e47b43018fc0b497a913b0
+SHA512:
+  metadata.gz: e63c1ad7284bafc6844d171967b9eeada48d1cc973b0de224531e31a4a9981f14cf22db2d06a16bcc36f190304440b840bdd1b437952432d2fa368b61f8c29a7
+  data.tar.gz: 2675112afc9482cb891145bb3a88e32ef96dfe26de643d4ecaba1fd1cb179ae6e3163fbaf9c1091cdf8524268baa23b95d58110234797d2dbe37f74b00e761e1

data/.codeclimate.yml

@@ -0,0 +1,27 @@
+---
+engines:
+  duplication:
+    enabled: true
+    config:
+      languages:
+        ruby:
+          mass_threshold: 22
+        javascript:
+        python:
+        php:
+  fixme:
+    enabled: true
+  rubocop:
+    enabled: true
+ratings:
+  paths:
+  - "**.inc"
+  - "**.js"
+  - "**.jsx"
+  - "**.module"
+  - "**.php"
+  - "**.py"
+  - "**.rb"
+exclude_paths:
+- spec/
+- lib/splendor_game/load_cards.rb

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.5
+before_install: gem install bundler -v 1.13.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in splendor_game.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 reedstonefood
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+# Splendor_game
+
+[![Code Climate](https://codeclimate.com/github/reedstonefood/splendor_game/badges/gpa.svg)](https://codeclimate.com/github/reedstonefood/splendor_game)
+
+A Ruby implementation of the board game Splendor. 
+
+Find out more about the game at [BoardGameGeek](https://boardgamegeek.com/boardgame/148228/splendor).
+
+## Installation
+
+Not yet ready for use - still in development.
+
+## Usage
+
+There is a simple CLI you can use. Simply run the following in irb or put in a .rb file and run it.
+
+```ruby
+require 'splendor_game'
+SplendorGame::CLI.new
+```
+
+Or, hook this up to any front end you might desire to use.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/reedstonefood/splendor_game.
+
+## With thanks...
+
+Whoever typed up a list of all the cards in the board game into this spreadsheet... https://drive.google.com/file/d/0B4yyYVH10iE5VlBFME9QelBVUnc/edit
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "splendor_game"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/splendor_game.rb

@@ -0,0 +1,23 @@
+require "splendor_game/version"
+require "splendor_game/options"
+require "splendor_game/coloured_object"
+require "splendor_game/card"
+require "splendor_game/noble"
+require "splendor_game/tableau"
+require "splendor_game/player"
+require "splendor_game/turn"
+require "splendor_game/load_cards"
+require "splendor_game/game"
+require "splendor_game/cli"
+
+module SplendorGame
+  # This is to validate when loading cards
+  VALID_COLOUR_LIST = ["RED", "BLUE", "BLACK", "GREEN", "WHITE"]
+  # This is used to validate certain calls
+  VALID_COLOUR_SYMBOLS = VALID_COLOUR_LIST.map { |x| x.downcase.to_sym }
+  # Note gold is a special colour so shouldn't be in VALID_COLOUR_LIST
+  VALID_COLOUR_SYMBOLS << :gold
+  
+  MAX_PLAYER_COUNT = 4
+  MIN_PLAYER_COUNT = 2
+end

data/lib/splendor_game/card.rb

@@ -0,0 +1,24 @@
+module SplendorGame
+  
+  class Card < ColouredObject
+    attr_reader :level, :points, :colour, :cost
+  
+    def initialize(level, colour, cost, points = 0)
+      @level = level
+      @points = points
+      @colour = colour
+      @cost, @cost_error = Hash.new(), Hash.new()
+      # if the colour is valid, load it, if not, put it in an error hash
+      cost.each do |key, value|
+        new_key_name = validate_colour(key)
+        if new_key_name==false
+          @cost_error[key] = value
+        else
+          @cost[new_key_name] = value
+        end
+      end
+    end
+    
+  end
+
+end

data/lib/splendor_game/cli.rb

@@ -0,0 +1,255 @@
+require 'highline'
+
+module SplendorGame
+  
+  class CLI
+    @@cli = HighLine.new
+    attr_reader :level, :points, :colour, :cost
+  
+    def initialize
+      @g = SplendorGame::Game.new Hash[*ARGV]
+      choose_players
+      main
+    end
+    
+    def choose_players
+      count = 1 
+      @@cli.say "Name all the players. Input 'done' when you are done."
+      loop do
+        pname = @@cli.ask("Enter name of player #{count} > ") do |q| 
+          q.validate = lambda { |a| a.length >= 1 && a.length <= 19 }
+        end
+        if pname.downcase == 'done'
+          break if count > MIN_PLAYER_COUNT
+          @@cli.say "You need to input at least 2 players!"
+        elsif @g.add_player(pname)== true
+          count += 1
+          @@cli.say "*** #{pname} successfully added"
+        else
+          @@cli.say "*** Sorry, there was a problem adding player #{pname}"
+        end
+        break if count > MAX_PLAYER_COUNT
+      end
+      @@cli.say "Succesfully added #{count-1} players. Game is ready to start."
+    end
+    
+    def puts_help
+      @@cli.say "************************ HELP! ************************"
+      @@cli.say "<%= color('(b)uy', BOLD) %> = Buy a card"
+      @@cli.say "<%= color('(r)eserve', BOLD) %> = Reserve a card"
+      @@cli.say "<%= color('(t)okens', BOLD) %> = Pick up tokens from the bank"
+      @@cli.say "<%= color('(n)obles', BOLD) %> = Look at the available nobles"
+      @@cli.say "<%= color('(h)elp', BOLD) %> = This help page"
+      @@cli.say "<%= color('e(x)it', BOLD) %> = Exit the program"
+    end
+    
+    def full_display
+      @g.display.each do |row, deck|
+        @@cli.say "ROW #{row}"
+        deck.each do |card| 
+          @@cli.say card_display(card)
+        end
+      end
+    end
+    
+    #practicing using args rather than fixed list of parameters
+    def purchase_card(args)
+      #if args[:turn].player.tableau.reserved_cards.include?(args[:card])
+      #  args[:turn].reserve_card
+      if args[:turn].purchase_card(args[:card])
+        true
+      else
+        @@cli.say "Oops, you can't afford that"
+      end
+    end
+    
+    def reserve_card(args)
+      if args[:card].is_a?(SplendorGame::Card) && args[:turn].reserve_displayed_card(args[:card])
+        true
+      elsif args[:card].is_a?(Integer) && args[:turn].reserve_random_card(args[:card])
+        true
+      else
+        @@cli.say "Sorry, you can't reserve that (maybe you have reserved too many cards)"
+      end
+    end
+    
+    def do_turn(turn)
+      while turn.action_done == false
+        output_all_player_details(turn.player)
+        input = @@cli.ask "What do you want to do, <%= color('#{turn.player.name}', BOLD) %>? "
+        command_result = process_command(input.downcase, turn)
+        if !command_result
+          @@cli.say "Sorry, I did not understand that. Press h for help"
+        elsif command_result==:exit
+          break
+        end
+      end
+      consider_nobles(turn)
+      turn.end_turn
+      @@cli.say "*** END OF TURN***"
+      command_result==:exit ? false : true
+    end
+    
+    def process_command(input, turn)
+      case
+      when input[0]=='b'
+        card = choose_card(:buy, turn.player)
+        purchase_card(:card => card, :turn => turn) if card
+      when input[0]=='r'
+        card = choose_card(:reserve, turn.player)
+        reserve_card(:card => card, :turn => turn) if card
+      when input[0]=='h'
+        puts_help
+      when input[0]=='n'
+        display_nobles
+      when input[0]=='t'
+        @@cli.say bank_details + " "
+        take_tokens(turn)
+      when input[0]=='x'
+        return :exit
+      else
+        return false
+      end
+      true
+    end
+    
+    
+    def card_display(card)
+      text = "#{card.points}pts "
+      text << "(#{card.colour}) => " if card.instance_variable_defined?(:@colour)
+      card.cost.each do |k,v|
+        text << "#{v} x #{k}, "
+      end
+      text[0..-3]
+    end
+    
+    def output_all_player_details(highlighted_player=nil)
+      @g.players.each do |p|
+        if p==highlighted_player
+          str = "<%= color('"
+          str << player_details(p)
+          str << "', BOLD) %>"
+        else
+          str = player_details(p)
+        end
+        @@cli.say str
+      end
+    end
+    
+    def player_details(player)
+      str = "#{player.name.ljust(19)}: #{player.points.to_s.ljust(2)}pts. "
+      reserved_card_count = player.tableau.reserved_cards.count
+      str << "(#{reserved_card_count}R) " if reserved_card_count > 0
+      str << "Cards (#{player.tableau.cards.count}): "
+      player.tableau.all_colours_on_cards.sort.to_h.each do |colour, count|
+        str << "#{colour}=#{count} " if count > 0
+      end
+      str << "Tokens: "
+      player.tableau.tokens.sort.to_h.each do |colour,count|
+        str << "#{colour}=#{count} " if count > 0
+      end
+      str[0..-2]
+    end
+    
+    def bank_details
+      str = "Bank tokens = "
+      @g.bank.tokens.sort.to_h.each do |colour, count|
+        str << "#{colour}=#{count} " if count > 0
+      end
+      str
+    end
+    
+    def choose_card(mode, player = nil)
+      displayed_cards_list = @g.all_displayed_cards.collect { |c| [card_display(c),c] }.to_h
+      if mode==:reserve
+        (1..3).each { |i| displayed_cards_list["Reserve mystery level #{i} card"]= i }
+      end
+      if mode==:buy
+        player.tableau.reserved_cards.each_with_index do |card, index| 
+          displayed_cards_list["R#{index+1} - #{card_display(card)}"]= card
+        end
+      end
+      @@cli.choose do |menu|
+        menu.prompt = "Which card do you want to #{mode}? "
+        menu.choices(*displayed_cards_list.keys) do |chosen|
+          @@cli.say "Nice, you chose #{chosen}."
+          displayed_cards_list[chosen]
+        end
+        menu.choice(:cancel) { return false }
+      end
+    end
+    
+    #def validate_token_choice(t)
+    #  return false if [2,3].include?(t.count)
+    #  t.each { |c| return false if !VALID_COLOUR_SYMBOLS.include?(c.upcase) || c==:gold}
+    #  return false if t.count==2 && t[0] != t[1]
+    #  true
+    #end
+    
+    def take_tokens(turn)
+      input = @@cli.ask "Which tokens would you like (CSV format)? "
+      requested_tokens = input.split(",")
+      #return false if !validate_token_choice(requested_tokens)
+      if requested_tokens.count==2
+        response = turn.take_two_tokens_same_colour(requested_tokens[0])
+      elsif requested_tokens.count==3
+        response = turn.take_different_tokens(requested_tokens)
+      end
+      @@cli.say "Oops, that's not a valid selection" if !response
+    end
+    
+    def consider_nobles(turn)
+      possibles = turn.claimable_nobles
+      return false if possibles.empty?
+      return assign_only_valid_noble(turn, possibles) if possibles.count==1
+      displayed_nobles_list = possibles.collect { |c| [card_display(c),c] }.to_h
+      @@cli.choose do |menu|
+        menu.prompt = "You qualify for multiple nobles! Pick one... "
+        menu.choices(*displayed_nobles_list.keys) do |chosen|
+          turn.claim_noble(displayed_nobles_list[chosen])
+          @@cli.say "Nice, you chose #{chosen}."
+        end
+      end
+      
+    end
+    
+    def display_nobles
+      @g.nobles.each do |noble|
+        @@cli.say "NOBLE - #{card_display(noble)}"
+      end
+    end
+    
+    def end_game_detail
+      @@cli.say "The game consisted of #{@g.turns.count} turns"
+      @@cli.ask "It's the end of the game. Press enter to end the program."
+      @@cli.say "Goodbye!"
+    end
+    
+    
+    def main
+      @g.start_game
+      catch :exit do
+        loop do
+          turn = @g.next_turn
+          throw :exit if turn===false # or @exit_flag==true ??
+          throw :exit if !do_turn(turn) 
+        end #end of the game - only reachable by throwing an :exit
+      end
+      end_game_detail
+    end
+    
+    private
+    def assign_only_valid_noble(turn,noble_array)
+      the_noble = noble_array.first
+      if !turn.claim_noble(the_noble)
+        @@cli.say "Looks like you qualify for a noble, but it didn't work"
+        return false
+      else
+        @@cli.say "You have been given a noble! #{the_noble.points} points"
+        return true
+      end
+    end
+    
+  end
+
+end

data/lib/splendor_game/coloured_object.rb

@@ -0,0 +1,17 @@
+module SplendorGame
+  
+  class ColouredObject
+    private
+    # format any inputted colours to the downcase symbol version
+    # return false if an invalid input is passed in
+    def validate_colour(input)
+      if VALID_COLOUR_LIST.include?(input.to_s.upcase)
+        input.downcase.to_sym
+      else 
+        false
+      end
+    end
+    
+  end
+
+end

data/lib/splendor_game/game.rb

@@ -0,0 +1,64 @@
+class Object
+  def is_natural_number?
+    return false if !self.is_a?(Numeric)
+    return false if self < 0
+    return false if self != self.abs
+    true
+  end
+end
+
+module SplendorGame
+
+
+  class Game
+    attr_reader :deck, :bank, :players, :nobles, :options, :display, :turns
+    def initialize(user_options = nil)
+      @options = Options.new(user_options).give_options
+      load_cards # puts all the cards into shuffled decks... a hash of arrays of cards. @deck[level]
+      @bank = Tableau.new(0) # 0 means no limit on token capacity
+      @players = Array.new()
+      @turns = Array.new()
+    end
+    
+    def add_player(player_name)
+      return false if @players.count >= MAX_PLAYER_COUNT
+      @players << Player.new(player_name, @players.count+1,@options[:player_token_limit])
+      true
+    end
+    
+    def next_player
+      if !@turns.empty?
+        @players.rotate!
+        return @players.first
+      end
+      @players.shuffle!
+      @starting_player = @players.first
+    end
+    
+    def game_over?
+      return false if @players.map { |p| p.points }.max < @options[:winning_score]
+      return true if @players[1] == @starting_player
+      false
+    end
+    
+    def start_game
+      @bank.seed_bank({:options=> @options, :player_count => @players.count})
+      @nobles = noble_sample(@options[:nobles_available][@players.count])
+      @display = Hash.new()
+      @deck.each { |level, subdeck| @display[level] = subdeck.pop(@options[:display_cards_per_row]) }
+    end
+    
+    def next_turn
+      return false if game_over? || !defined? @display
+      t = SplendorGame::Turn.new(self, next_player)
+      @turns << t
+      t
+    end
+    
+    def all_displayed_cards
+      @display.values.flatten
+    end
+    
+  end
+ 
+end

data/lib/splendor_game/load_cards.rb

@@ -0,0 +1,126 @@
+module SplendorGame
+  class Game
+    #Could read from an external file eventually, but this works just fine :) 
+    def load_cards
+      all_cards = Array.new()
+      all_cards << Card.new(1, :white, {:blue => 3})
+      all_cards << Card.new(1, :white, {:red => 2, :black => 1})
+      all_cards << Card.new(1, :white, {:blue => 1, :green => 1, :red => 1, :black => 1})
+      all_cards << Card.new(1, :white, {:blue => 2, :black => 2})
+      all_cards << Card.new(1, :white, {:green => 4}, 1)
+      all_cards << Card.new(1, :white, {:blue => 1, :green => 2, :red => 1, :black => 1})
+      all_cards << Card.new(1, :white, {:blue => 2, :green => 2, :black => 1})
+      all_cards << Card.new(1, :white, {:white => 3, :blue => 1, :black => 1})
+      all_cards << Card.new(1, :blue, {:white => 1, :black => 2})
+      all_cards << Card.new(1, :blue, {:black => 3})
+      all_cards << Card.new(1, :blue, {:white => 1, :green => 1, :red => 1, :black => 1})
+      all_cards << Card.new(1, :blue, {:green => 2, :black => 2})
+      all_cards << Card.new(1, :blue, {:red => 4}, 1)
+      all_cards << Card.new(1, :blue, {:white => 1, :green => 1, :red => 2, :black => 1})
+      all_cards << Card.new(1, :blue, {:white => 1, :green => 2, :red => 2})
+      all_cards << Card.new(1, :blue, {:blue => 1, :green => 3, :red => 1})
+      all_cards << Card.new(1, :green, {:white => 2, :blue => 1})
+      all_cards << Card.new(1, :green, {:red => 3})
+      all_cards << Card.new(1, :green, {:white => 1, :blue => 1, :red => 1, :black => 1})
+      all_cards << Card.new(1, :green, {:blue => 2, :red => 2})
+      all_cards << Card.new(1, :green, {:black => 4}, 1)
+      all_cards << Card.new(1, :green, {:white => 1, :blue => 1, :red => 1, :black => 2})
+      all_cards << Card.new(1, :green, {:blue => 1, :red => 2, :black => 2})
+      all_cards << Card.new(1, :green, {:white => 1, :blue => 3, :green => 1})
+      all_cards << Card.new(1, :red, {:blue => 2, :green => 1})
+      all_cards << Card.new(1, :red, {:white => 3})
+      all_cards << Card.new(1, :red, {:white => 1, :blue => 1, :green => 1, :black => 1})
+      all_cards << Card.new(1, :red, {:white => 2, :red => 2})
+      all_cards << Card.new(1, :red, {:white => 4}, 1)
+      all_cards << Card.new(1, :red, {:white => 2, :blue => 1, :green => 1, :black => 1})
+      all_cards << Card.new(1, :red, {:white => 2, :green => 1, :black => 2})
+      all_cards << Card.new(1, :red, {:white => 1, :red => 1, :black => 3})
+      all_cards << Card.new(1, :black, {:green => 2, :red => 1})
+      all_cards << Card.new(1, :black, {:green => 3})
+      all_cards << Card.new(1, :black, {:white => 1, :blue => 1, :green => 1, :red => 1})
+      all_cards << Card.new(1, :black, {:white => 2, :green => 2})
+      all_cards << Card.new(1, :black, {:blue => 4}, 1)
+      all_cards << Card.new(1, :black, {:white => 1, :blue => 2, :green => 1, :red => 1})
+      all_cards << Card.new(1, :black, {:white => 2, :blue => 2, :red => 1})
+      all_cards << Card.new(1, :black, {:green => 1, :red => 3, :black => 1})
+      
+      all_cards << Card.new(2, :white, {:red => 5}, 2)
+      all_cards << Card.new(2, :white, {:white => 6}, 3)
+      all_cards << Card.new(2, :white, {:green => 3, :red => 2, :black => 2}, 1)
+      all_cards << Card.new(2, :white, {:green => 1, :red => 4, :black => 2}, 2)
+      all_cards << Card.new(2, :white, {:white => 2, :blue => 3, :red => 3}, 1)
+      all_cards << Card.new(2, :white, {:red => 5, :black => 3}, 2)
+      all_cards << Card.new(2, :blue, {:blue => 5}, 2)
+      all_cards << Card.new(2, :blue, {:blue => 6}, 3)
+      all_cards << Card.new(2, :blue, {:blue => 2, :green => 2, :red => 3}, 1)
+      all_cards << Card.new(2, :blue, {:white => 2, :red => 1, :black => 4}, 2)
+      all_cards << Card.new(2, :blue, {:blue => 2, :green => 3, :black => 3}, 1)
+      all_cards << Card.new(2, :blue, {:white => 5, :blue => 3}, 2)
+      all_cards << Card.new(2, :green, {:green => 5}, 2)
+      all_cards << Card.new(2, :green, {:green => 6}, 3)
+      all_cards << Card.new(2, :green, {:white => 2, :blue => 3, :black => 2}, 1)
+      all_cards << Card.new(2, :green, {:white => 3, :green => 2, :red => 3}, 1)
+      all_cards << Card.new(2, :green, {:white => 4, :blue => 2, :black => 1}, 2)
+      all_cards << Card.new(2, :green, {:blue => 5, :green => 3}, 2)
+      all_cards << Card.new(2, :red, {:black => 5}, 2)
+      all_cards << Card.new(2, :red, {:red => 6}, 3)
+      all_cards << Card.new(2, :red, {:white => 2, :red => 2, :black => 3}, 1)
+      all_cards << Card.new(2, :red, {:white => 1, :blue => 4, :green => 2}, 2)
+      all_cards << Card.new(2, :red, {:blue => 3, :red => 2, :black => 3}, 1)
+      all_cards << Card.new(2, :red, {:white => 3, :black => 5}, 2)
+      all_cards << Card.new(2, :black, {:white => 5}, 2)
+      all_cards << Card.new(2, :black, {:black => 6}, 3)
+      all_cards << Card.new(2, :black, {:white => 3, :blue => 2, :green => 2}, 1)
+      all_cards << Card.new(2, :black, {:blue => 1, :green => 4, :red => 2}, 2)
+      all_cards << Card.new(2, :black, {:white => 3, :green => 3, :black => 2}, 1)
+      all_cards << Card.new(2, :black, {:green => 5, :red => 3}, 2)
+      
+      all_cards << Card.new(3, :white, {:black => 7}, 4)
+      all_cards << Card.new(3, :white, {:white => 3, :black => 7}, 5)
+      all_cards << Card.new(3, :white, {:white => 3, :red => 3, :black => 6}, 4)
+      all_cards << Card.new(3, :white, {:blue => 3, :green => 3, :red => 5, :black => 3}, 3)
+      all_cards << Card.new(3, :blue, {:white => 7}, 4)
+      all_cards << Card.new(3, :blue, {:white => 7, :blue => 3}, 5)
+      all_cards << Card.new(3, :blue, {:white => 6, :blue => 3, :black => 3}, 4)
+      all_cards << Card.new(3, :blue, {:white => 3, :green => 3, :red => 3, :black => 5}, 3)
+      all_cards << Card.new(3, :green, {:blue => 7}, 4)
+      all_cards << Card.new(3, :green, {:blue => 7, :green => 3}, 5)
+      all_cards << Card.new(3, :green, {:white => 3, :blue => 6, :green => 3}, 4)
+      all_cards << Card.new(3, :green, {:white => 5, :blue => 3, :red => 3, :black => 3}, 3)
+      all_cards << Card.new(3, :red, {:green => 7}, 4)
+      all_cards << Card.new(3, :red, {:green => 7, :red => 3}, 5)
+      all_cards << Card.new(3, :red, {:blue => 3, :green => 6, :red => 3}, 4)
+      all_cards << Card.new(3, :red, {:white => 3, :blue => 5, :green => 3, :black => 3}, 3)
+      all_cards << Card.new(3, :black, {:red => 7}, 4)
+      all_cards << Card.new(3, :black, {:red => 7, :black => 3}, 5)
+      all_cards << Card.new(3, :black, {:green => 3, :red => 6, :black => 3}, 4)
+      all_cards << Card.new(3, :black, {:white => 3, :blue => 3, :green => 5, :red => 3}, 3)
+
+
+    
+      # Now all cards are in all_cards, distribute them into all_cards
+      @deck = Hash.new()
+      all_cards.each do |card|
+        @deck[card.level] = Array.new() if !@deck.include?(card.level)
+        @deck[card.level] << card
+      end
+      # shuffle them
+      @deck.each { |_deck_num, smaller_deck| smaller_deck.shuffle! }
+    end
+    
+    def noble_sample(number_of_cards_to_load)
+      all_nobles = Array.new()
+      all_nobles << Noble.new({:white => 3, :blue => 3, :black => 3}, 3)
+      all_nobles << Noble.new({:blue => 3, :green => 3, :red => 3}, 3)
+      all_nobles << Noble.new({:white => 3, :red => 3, :black => 3}, 3)
+      all_nobles << Noble.new({:white => 3, :blue => 3, :green => 3}, 3)
+      all_nobles << Noble.new({:green => 3, :red => 3, :black => 3}, 3)
+      all_nobles << Noble.new({:green => 4, :red => 4}, 3)
+      all_nobles << Noble.new({:blue => 4, :green => 4}, 3)
+      all_nobles << Noble.new({:red => 4, :black => 4}, 3)
+      all_nobles << Noble.new({:white => 4, :black => 4}, 3)
+      all_nobles << Noble.new({:white => 4, :blue => 4}, 3)
+      all_nobles.shuffle!.first(number_of_cards_to_load)
+    end
+  end
+end

data/lib/splendor_game/noble.rb

@@ -0,0 +1,22 @@
+module SplendorGame
+  
+  #Players become eligible for Nobles when they have cards that meet the cost (NOT tokens)
+  class Noble < ColouredObject
+    attr_reader :cost, :points
+  
+    def initialize(cost, points = 0)
+      @points = points
+      @cost, @cost_error = Hash.new(), Hash.new()
+      # if the colour is valid, load it, if not, put it in an error hash
+      cost.each do |key, value|
+        new_key_name = validate_colour(key)
+        if new_key_name==false
+          @cost_error[key] = value
+        else
+          @cost[new_key_name] = value
+        end
+      end
+    end
+  end
+
+end

data/lib/splendor_game/options.rb

@@ -0,0 +1,48 @@
+module SplendorGame
+
+  class Options
+    NOBLES_AVAILABLE = { 2 => 3, 3 => 4, 4 => 5}
+    STARTING_GOLD_TOKENS = 5
+    STARTING_NON_GOLD_TOKENS = { 2 => 4, 3 => 5, 4 => 7}
+    DISPLAY_CARDS_PER_ROW = 4
+    WINNING_SCORE = 15
+    MIN_TO_TAKE_TWO = 4
+    PLAYER_TOKEN_LIMIT = 10
+    attr_reader :deck, :bank, :players, :nobles, :options, :display
+    def initialize(user_options = nil)
+      if user_options.is_a?(Hash)
+        @user_options = user_options 
+      else
+        @user_options = Hash.new()
+      end
+    end
+    
+    def clean_user_options
+      [:starting_non_gold_tokens, :nobles_available].each do |key|
+        if @user_options[key].respond_to?(:keys)
+          @user_options.delete(key) if !([2,3,4] - @user_options[key].keys).empty?
+        end
+      end
+    end
+    
+    def default_options
+      output = Hash.new()
+      output[:display_cards_per_row] = DISPLAY_CARDS_PER_ROW
+      output[:winning_score] = WINNING_SCORE
+      output[:min_to_take_two] = MIN_TO_TAKE_TWO
+      output[:starting_gold_tokens] = STARTING_GOLD_TOKENS
+      output[:starting_non_gold_tokens] = STARTING_NON_GOLD_TOKENS
+      output[:nobles_available] = NOBLES_AVAILABLE
+      output[:player_token_limit] = PLAYER_TOKEN_LIMIT
+      output
+    end
+    
+    #Take the user values if they are valid, else use defaults
+    def give_options
+      clean_user_options
+      @user_options.merge(default_options)
+    end
+    
+  end
+ 
+end

data/lib/splendor_game/player.rb

@@ -0,0 +1,33 @@
+module SplendorGame
+  
+  class Player
+
+    attr_reader :name, :turn_order, :tableau, :nobles
+  
+    def initialize(name, turn_order, token_limit)
+      @name = name
+      @turn_order = turn_order
+      @tableau = Tableau.new(token_limit)
+      @nobles = Array.new()
+    end
+
+    def points
+      card_points = @tableau.cards.inject(0) { |sum,c| sum + c.points }
+      card_points + @nobles.inject(0) { |sum,c| sum + c.points }
+    end
+    
+    def can_afford_noble?(noble)
+      noble.cost.each do |k, v|
+        return false if @tableau.colours_on_cards(k) < v 
+      end
+      true
+    end
+    
+    def claim_noble(noble)
+      return false if !can_afford_noble?(noble)
+      @nobles << noble
+      true
+    end
+  end
+ 
+end

data/lib/splendor_game/tableau.rb

@@ -0,0 +1,128 @@
+module SplendorGame
+  
+ 
+  class Tableau
+    @@max_reserved_cards = 3
+    attr_reader :cards, :tokens, :reserved_cards
+    
+    def initialize(token_limit)
+      @cards = Array.new()
+      @tokens = Hash.new(0)
+      @unlimited = token_limit <= 0 ? true : false
+      @token_limit = token_limit
+      @reserved_cards = Array.new()
+    end
+    
+    def seed_bank(args)
+      seed_bank_non_gold(args[:options][:starting_non_gold_tokens][args[:player_count]])
+      seed_bank_gold(args[:options][:starting_gold_tokens])
+    end
+    
+    ### add tokens, remove tokens, counting tokens
+    
+    def add_token(token_colour)
+      return false if !VALID_COLOUR_SYMBOLS.include?(token_colour)
+      return false if !@unlimited && token_count >= @token_limit
+      if @tokens.include?(token_colour)
+        @tokens[token_colour] += 1
+      else
+        @tokens[token_colour] = 1
+      end
+      true
+    end
+    
+    def remove_token(token_colour)
+      return false if !@tokens.key?(token_colour)
+      return false if @tokens[token_colour] <= 0
+      @tokens[token_colour] -= 1
+      true
+    end
+    
+    def token_count
+      @tokens.inject(0) { |sum,(_k,v)| sum + v }
+    end
+    
+    def token_space_remaining
+      return nil if @unlimited == true #meaning, undefined
+      @token_limit - token_count
+    end
+    
+    def distinct_token_colour_count
+      @tokens.count { |_k,v| v >0 }
+    end
+    
+    #### reserving cards
+    
+    def can_reserve_card?
+      return false if @reserved_cards.size >= @@max_reserved_cards
+      true
+    end
+
+    def reserve_card(card)
+      return false if !can_reserve_card?
+      @reserved_cards << card
+    end    
+    
+    def play_reserved_card(card)
+      return false if tokens_required(card) == false
+      return false unless @reserved_cards.include?(card)
+      @cards << card
+      @reserved_cards.delete(card)
+    end
+    
+    ### related to purchasing cards
+      
+    def purchase_card(card)
+      return false if tokens_required(card) == false
+      @cards << card
+    end
+    
+    # Returns a Hash of the tokens required to buy the card
+    # If the tableau does not have sufficient cards/tokens, it returns false
+    def tokens_required(card)
+      answer = Hash.new(0)
+      card.cost.each do |colour, col_cost|
+        theoretical_tokens = col_cost - colours_on_cards(colour)
+        if theoretical_tokens <= @tokens[colour]
+          answer[colour] = theoretical_tokens if theoretical_tokens > 0
+        else
+          answer[colour] = @tokens[colour]
+          answer[:gold] += theoretical_tokens - @tokens[colour]
+        end
+      end
+      return false if answer[:gold] > @tokens[:gold]
+      answer
+    end
+    
+    def all_colours_on_cards
+      output = Hash.new()
+      VALID_COLOUR_SYMBOLS.each { |c| output[c] = colours_on_cards(c) if colours_on_cards(c) > 0 }
+      output
+    end
+    
+    def colours_on_cards(colour)
+      @cards.inject(0) { |sum,card| card.colour == colour ? sum+1 : sum }.to_i
+    end
+    
+    ### Other
+    
+    def is_empty?
+      @cards.size==0 && @tokens.size==0 ? true : false
+    end
+    
+    ### setup
+    private
+    
+    def seed_bank_non_gold(token_count)
+      VALID_COLOUR_SYMBOLS.each do |colour|
+        @tokens[colour] = token_count if colour != :gold
+      end
+    end
+    
+    def seed_bank_gold(token_count)
+      @tokens[:gold] = token_count
+    end
+    
+  end
+ 
+end

data/lib/splendor_game/turn.rb

@@ -0,0 +1,144 @@
+module SplendorGame
+  
+  class Turn
+    attr_reader :player, :action_done
+  
+    def initialize(game, player)
+      @game = game
+      @player = player
+      @action_done = false
+      @noble_claimed = false
+    end
+    
+    #from the 12 cards on display plus up to 3 reserved ones, return the ones affordable, in an Array
+    def affordable_cards
+      answer = Array.new()
+      (@game.all_displayed_cards + @player.tableau.reserved_cards).each do |card|
+        @cost = @player.tableau.tokens_required(card)
+        answer << card if !@cost==false
+      end
+      answer
+    end
+    
+    def purchase_card(card) # do the requisite card/token changes, if the card is in affordable_cards
+      return false if @action_done
+      return false if !affordable_cards.include?(card)
+      cost_to_player = @player.tableau.tokens_required(card)
+      if @player.tableau.reserved_cards.include?(card)
+        @player.tableau.play_reserved_card(card)
+      else
+        @player.tableau.purchase_card(card)
+      end
+      cost_to_player.each do |colour, val|
+        val.times { @player.tableau.remove_token(colour) }
+        val.times { @game.bank.add_token(colour) }
+      end
+      display_row = @game.display[card.level]
+      display_row.delete_at(display_row.index(card) || display_row.length)
+      @action_done = true
+    end
+    
+    def reserve_card_checks?
+      return false if @action_done
+      return false if !@player.tableau.can_reserve_card?
+      true
+    end
+    
+    def give_gold_token
+      if @game.bank.tokens[:gold] > 0 && @player.tableau.token_space_remaining > 0
+        @game.bank.remove_token(:gold)
+        @player.tableau.add_token(:gold)
+      end
+    end
+    
+    def reserve_displayed_card(card) # put cards in to player's reserved set. Remove card from display
+      return false if !reserve_card_checks?
+      return false if !@game.display.flatten(2).include?(card)
+      @player.tableau.reserve_card(card)
+      display_row = @game.display[card.level]
+      display_row.delete_at(display_row.index(card) || display_row.length)
+      give_gold_token
+      @action_done = true
+    end
+    
+    def reserve_random_card(deck_number)
+      return false if !reserve_card_checks?
+      return false if @game.deck[deck_number].nil?
+      return false if @game.deck[deck_number].count==0
+      card = @game.deck[deck_number].pop
+      @player.tableau.reserve_card(card)
+      give_gold_token
+      @action_done = true
+    end
+    
+    def validate_token_pickup?(colour)
+      return false if @action_done
+      return false if Array(colour).include?(:gold)
+      true
+    end
+    
+    def take_two_tokens_same_colour(colour)
+      colour = colour.to_sym
+      return false if !validate_token_pickup?(colour)
+      return false if @game.bank.tokens[colour] < @game.options[:min_to_take_two]
+      return false if @player.tableau.token_space_remaining < 2
+      2.times { @player.tableau.add_token(colour) }
+      2.times { @game.bank.remove_token(colour) }
+      @action_done = true
+    end
+  
+    def take_different_tokens(colours)
+      colours.map!{|c| c.to_sym}
+      return false if !validate_token_pickup?(colours)
+      return false if colours.count != 3
+      return false if colours.uniq.length != colours.length
+      return false if colours.select { |c| @game.bank.tokens[c]==0}.length > 0
+      return false if @player.tableau.token_space_remaining < 3
+      colours.each do |c|
+        @player.tableau.add_token(c)
+        @game.bank.remove_token(c)
+      end
+      @action_done = true
+    end
+  
+    # in order to claim tokens you may need to return tokens, eg pick up a gold when 
+    # you have 10, or you have 8 and want to take 3 different. 
+    
+    def action_return_token(colour)
+      return false if !@player.tableau.tokens.include?(colour) 
+      return false if @player.tableau.tokens[colour] <= 0
+      @player.tableau.remove_token(colour)
+      @game.bank.add_token(colour)
+    end
+  
+    def claim_noble(noble) # Move noble from bank to player, assuming it's affordable
+      return false if @noble_claimed # you can only claim 1 per turn
+      return false if !noble_affordable?(noble)
+      @game.nobles.delete_at(@game.nobles.index(noble) || display_row.length)
+      @player.nobles << noble
+      @noble_claimed = true
+    end
+  
+    def claimable_nobles
+      @game.nobles.find_all { |noble| noble_affordable?(noble) }
+    end
+    
+    def noble_affordable?(noble)
+      noble.cost.each do |colour, cost|
+        return false if @player.tableau.colours_on_cards(colour) < cost
+      end
+      true
+    end
+  
+    def end_turn # make sure there are 4 cards showing from each deck, assuming there are any left
+      #assumption : max 1 card is missing from each row
+      nonfull_rows = @game.display.select { |_level, subdeck| subdeck.count < @game.options[:display_cards_per_row] }
+      nonfull_rows.each do |row_num, display_row|
+        relevant_deck = @game.deck[row_num]
+        display_row << relevant_deck.pop if relevant_deck.count > 0
+      end
+    end
+    
+  end
+
+end

data/lib/splendor_game/version.rb

@@ -0,0 +1,3 @@
+module SplendorGame
+  VERSION = "0.1.0"
+end

data/splendor_game.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'splendor_game/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "splendor_game"
+  spec.version       = SplendorGame::VERSION
+  spec.authors       = ["reedstonefood"]
+  spec.email         = ["reedstonefood@users.noreply.github.com"]
+
+  spec.summary       = %q{An implementation of the board game, Splendor.}
+  spec.homepage      = "https://github.com/reedstonefood/splendor_game"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  
+  spec.add_dependency "highline", "~> 1.7"
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: splendor_game
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- reedstonefood
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-08-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: 
+email:
+- reedstonefood@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".codeclimate.yml"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/splendor_game.rb
+- lib/splendor_game/card.rb
+- lib/splendor_game/cli.rb
+- lib/splendor_game/coloured_object.rb
+- lib/splendor_game/game.rb
+- lib/splendor_game/load_cards.rb
+- lib/splendor_game/noble.rb
+- lib/splendor_game/options.rb
+- lib/splendor_game/player.rb
+- lib/splendor_game/tableau.rb
+- lib/splendor_game/turn.rb
+- lib/splendor_game/version.rb
+- splendor_game.gemspec
+homepage: https://github.com/reedstonefood/splendor_game
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.6
+signing_key: 
+specification_version: 4
+summary: An implementation of the board game, Splendor.
+test_files: []