cardgame 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/README.md

@@ -0,0 +1,4 @@
+Uno Card Game
+=============
+
+This is a programming exercise created for my son. It models some card games and their rules, especially Uno.

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.test_files = FileList['test/**/test_*.rb']
+end
+
+task :default => :test

data/TODO.md

@@ -0,0 +1,6 @@
+* Extract the playing engine
+* Finish the retry-mode after a player violated the rules
+* Build a rules engine that enforces the game rules and prevents cheating (e.g. it must not be possible to add new cards to the deck)
+* Implement swapping of cards when a zero was played
+* Implement reverse order if Reverse card was played
+* Can we detect the endless loop that occasionally occurs?

data/bin/game

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'cardgame'
+include CardGame
+
+class RuleViolation < StandardError; end
+
+#
+# Ensure that everyone follows the rules
+#
+def matches_rules(played, pile)
+  true
+end
+
+class UnoUno < StandardError
+  attr_reader :player, :card
+  def initialize(player, card)
+    @player, @card = player, card
+  end
+end
+
+players = []
+('A'..'C').each{|i| players << Player.new(i)}
+
+stack = Uno.new.deal
+
+Array.class_eval do
+  def replenish(pile)
+    concat(pile)
+    pile.clear
+    pile.push(pop) # the last card stays on the pile
+    sort_by!{rand}
+  end
+end
+
+# deal out cards to the players
+7.times{
+  players.each{|player|
+    player << stack.pop
+  }
+}
+
+# init the game
+pile = []
+
+begin
+  pile.push(stack.pop)
+end while !pile.first && pile.first.trump? # do not allow trumps (jokers) as initial card
+
+# puts "Starting the game with #{players.size} players"
+rounds = 0
+
+# main game loop - ask each player to play
+loop do
+  begin
+    rounds += 1
+    players.each{|player|
+      begin
+        played = player.play(pile.last)
+      
+        if played && matches_rules(played, pile.last)
+          pile.push(played)
+        else
+          stack.replenish(pile) if stack.empty? # replenish stack from pile
+          player << stack.pop # draw a card from the stack
+        end
+      rescue RuleViolation => v
+        puts v.message
+        player << played # Push the offending card back to the player
+        retry
+      end
+    }
+  rescue UnoUno => u
+    puts "#{u.player} wins with #{u.card} after #{rounds} rounds."
+    exit
+  end
+end

data/cardgame.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cardgame/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cardgame"
+  s.version     = CardGame::VERSION
+  s.authors     = ["Nicholas E. Rabenau"]
+  s.email       = ["nerab@gmx.net"]
+  s.homepage    = ""
+  s.summary     = %q{Models card games, e.g. Uno}
+  s.description = %q{This gem is a small exercise in OO modeling. It models card games, especially Uno.}
+
+  s.rubyforge_project = "cardgame"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+  s.add_runtime_dependency 'activesupport', '~> 3.2'
+end

data/lib/cardgame.rb

@@ -0,0 +1,6 @@
+require 'cardgame/version'
+require 'cardgame/deck'
+require 'cardgame/card'
+require 'cardgame/player'
+require 'cardgame/uno'
+require 'cardgame/french'

data/lib/cardgame/card.rb

@@ -0,0 +1,43 @@
+module CardGame
+  class BaseCard
+    attr_reader :rank
+    
+    def initialize(rank)
+      @rank = rank
+    end
+  
+    def to_s
+      @rank
+    end
+    
+    def trump?
+      false
+    end
+  end
+  
+  class Trump < BaseCard
+    # When playing a trump card, the player can set which suit it has so that the next player has to follow it
+    attr_accessor :suit
+    
+    def trump?
+      true
+    end
+
+    def to_s
+      "#{super} requiring #{@suit}"
+    end
+  end
+  
+  class Card < BaseCard
+    attr_reader :suit
+    
+    def initialize(rank, suit)
+      super(rank)
+      @suit = suit
+    end
+
+    def to_s
+      "#{@suit} #{super}"
+    end
+  end
+end

data/lib/cardgame/deck.rb

@@ -0,0 +1,45 @@
+require 'forwardable'
+
+module CardGame
+  class Deck
+    class << self
+      def ranks
+        []
+      end
+
+      def trumps
+        []
+      end
+
+      def suits
+        []
+      end
+    end
+    
+    extend Forwardable
+    
+    def initialize
+      @cards = []
+      
+      self.class.ranks.each{|name|
+        self.class.suits.each{|color|
+          push Card.new(name, color)
+        }
+      }
+      
+      self.class.trumps.each{|j| push Trump.new(j)}
+    end
+    
+    #
+    # Deal out a shuffled deck
+    #
+    def deal
+      @cards.sort_by{rand}
+    end
+    
+    def_delegator :@cards, :size
+    
+    private
+    def_delegator :@cards, :push
+  end
+end

data/lib/cardgame/french.rb

@@ -0,0 +1,17 @@
+module CardGame
+  class French < Deck
+    class << self
+      def ranks
+        %w{Ace 2 3 4 5 6 7 8 9 10 Knave Queen King}
+      end
+    
+      def trumps
+        []
+      end
+    
+      def suits
+        %w{Clubs Spades Hearts Diamonds}
+      end
+    end
+  end
+end

data/lib/cardgame/player.rb

@@ -0,0 +1,57 @@
+require 'forwardable'
+
+module CardGame
+  class Player
+    extend Forwardable
+    attr_reader :name
+    
+    def initialize(name)
+      @name = name
+      @hand = []
+    end
+    
+    def to_s
+      "Player #{@name}"
+    end
+    
+    #
+    # Select one or more of our cards (according to our playing strategy)
+    #
+    # Note the the player has no further knowledge about the state of the game except the topmost card of the pile that is passed.
+    # If a player wants to implement more advanced strategies (e.g. by observing and counting the cards already played),
+    # we need to implement a notification mechanism that tells every player which card the current player played.
+    #
+    # TODO Need to obey if top_card is a trump, unless we can trump that one
+    # TODO If the game system allows it, return two identical cards
+    #
+    def play(top_card)
+      raise "There must be a card on the pile" if top_card.nil?
+      
+#      puts
+#      puts "#{self} plays:"
+#      puts "#{@hand.size} in hand and sees the top card #{top_card}"
+      
+      candidates = @hand.select{|card| top_card.rank == card.rank || top_card.suit == card.suit  || card.trump?}
+      
+      selected = candidates.sort_by{rand}.pop
+      
+      if selected.nil?
+#        puts "Decided NOT to play"
+      else
+        selected.suit = Uno.suits.sample if selected.trump? #  TODO Improve suit selection to take our current hand into account
+#        puts "Decided to play #{selected}"
+        @hand.delete_if{|card| selected == card}
+#        puts "Has #{@hand.size} left in hand."
+      end
+      
+      # raise Uno.new(selected) if 1 == @hand.size
+      raise UnoUno.new(self, selected) if 0 == @hand.size
+      
+      selected
+    end
+    
+    def_delegator :@hand, :size
+    def_delegator :@hand, :<<
+    def_delegator :@hand, :empty?
+  end
+end

data/lib/cardgame/uno.rb

@@ -0,0 +1,17 @@
+module CardGame
+  class Uno < Deck
+    class << self
+      def ranks
+        ['0'].concat(%w{1 2 3 4 5 6 7 8 9 Reverse Skip} * 2).concat(['Draw 2'] * 2)
+      end
+    
+      def trumps
+        ["Wild Draw 4"] * 4 + ["Wild"] * 4
+      end
+    
+      def suits
+        %w{Blue Green Red Yellow}
+      end
+    end
+  end
+end

data/lib/cardgame/version.rb

@@ -0,0 +1,3 @@
+module CardGame
+  VERSION = "0.0.1"
+end

data/test/fixtures/french.json

@@ -0,0 +1,24 @@
+{
+  "trumps": [],
+  "ranks": [
+    "Ace",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "10",
+    "Knave",
+    "Queen",
+    "King"
+  ],
+  "suits": [
+    "Clubs",
+    "Spades",
+    "Hearts",
+    "Diamonds"
+  ]
+}

data/test/fixtures/uno.yaml

@@ -0,0 +1,41 @@
+---
+:ranks:
+- '0'
+- '1'
+- '2'
+- '3'
+- '4'
+- '5'
+- '6'
+- '7'
+- '8'
+- '9'
+- Reverse
+- Skip
+- '1'
+- '2'
+- '3'
+- '4'
+- '5'
+- '6'
+- '7'
+- '8'
+- '9'
+- Reverse
+- Skip
+- Draw 2
+- Draw 2
+:trumps:
+- Wild Draw 4
+- Wild Draw 4
+- Wild Draw 4
+- Wild Draw 4
+- Wild
+- Wild
+- Wild
+- Wild
+:suits:
+- Blue
+- Green
+- Red
+- Yellow

data/test/helper.rb

@@ -0,0 +1,50 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'test/unit'
+require 'cardgame'
+require 'yaml'
+require 'json'
+require 'active_support/core_ext/string'
+
+class Test::Unit::TestCase
+end
+
+module CardGameTest
+  class TestCase < Test::Unit::TestCase
+    FIXTURES_DIR = File.join(File.dirname(__FILE__), 'fixtures')
+
+    def fixture(name = self.class.name.underscore.match(/test_(.*)/)[1])
+      file_name = nil
+      
+      %w{.yaml .yml .json}.each{|ext| 
+        file_name = File.join(FIXTURES_DIR, "#{name}#{ext}")
+        break if File.exist?(file_name)
+      }
+
+      raw = File.read(file_name)
+
+      case File.extname(file_name)
+      when '.yaml'
+        YAML.load(raw)
+      when '.json'
+        JSON.parse(raw, :symbolize_names => true)
+      else
+        raw
+      end
+    end
+  end
+
+  module DeckTests
+    def test_suits
+      assert_equal(fixture[:suits], @deck.class.suits)
+    end
+
+    def test_trumps
+      assert_equal(fixture[:trumps], @deck.class.trumps)
+    end
+
+    def test_ranks
+      assert_equal(fixture[:ranks], @deck.class.ranks)
+    end
+  end
+end

data/test/unit/test_card.rb

@@ -0,0 +1,11 @@
+require 'helper'
+
+class TestCard < CardGameTest::TestCase
+  def setup
+    @card = CardGame::Card.new('foo', 'bar')
+  end
+  
+  def test_to_s
+    assert_equal('bar foo', @card.to_s)
+  end
+end

data/test/unit/test_french.rb

@@ -0,0 +1,13 @@
+require 'helper'
+
+class TestFrench < CardGameTest::TestCase
+  include CardGameTest::DeckTests
+  
+  def setup
+    @deck = CardGame::French.new
+  end
+  
+  def test_size
+    assert_equal(52, @deck.size)
+  end
+end

data/test/unit/test_uno.rb

@@ -0,0 +1,15 @@
+require 'helper'
+require 'awesome_print'
+
+class TestUno < CardGameTest::TestCase
+  include CardGame
+  include CardGameTest::DeckTests
+  
+  def setup
+    @deck = Uno.new
+  end
+  
+  def test_size
+    assert_equal(108, @deck.size)
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: cardgame
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Nicholas E. Rabenau
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2152230380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2152230380
+description: This gem is a small exercise in OO modeling. It models card games, especially
+  Uno.
+email:
+- nerab@gmx.net
+executables:
+- game
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- TODO.md
+- bin/game
+- cardgame.gemspec
+- lib/cardgame.rb
+- lib/cardgame/card.rb
+- lib/cardgame/deck.rb
+- lib/cardgame/french.rb
+- lib/cardgame/player.rb
+- lib/cardgame/uno.rb
+- lib/cardgame/version.rb
+- test/fixtures/french.json
+- test/fixtures/uno.yaml
+- test/helper.rb
+- test/unit/test_card.rb
+- test/unit/test_french.rb
+- test/unit/test_uno.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: cardgame
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Models card games, e.g. Uno
+test_files:
+- test/fixtures/french.json
+- test/fixtures/uno.yaml
+- test/helper.rb
+- test/unit/test_card.rb
+- test/unit/test_french.rb
+- test/unit/test_uno.rb