cardlike 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*~
+.*.s[a-w][a-z]

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Payton Swick
+
+MIT License
+
+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,278 @@
+# Cardlike
+
+A DSL to design and test card games.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cardlike'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cardlike
+
+Include the gem in your code to use it.
+
+    require 'cardlike'
+
+## Summary
+
+Cardlike provides a [DSL](http://en.wikipedia.org/wiki/Domain-specific_language)
+for creating a card game. It's a layer of abstraction for making Cards (with
+various properties), putting them into Decks, dealing them into Hands, and then
+taking turns while keeping a running score. 
+
+Cardlike is agnostic about what kind of game you want to create (it may not have
+turns or a score) and how you want to interact with the game. Here's a few
+possibilities for how you could use it:
+
+* Write tests for a physical card game to see if it will work.
+* Write a text-based card game.
+* Use as a backend for a web card game (backbone.js, anyone?).
+* Use as a backend for a native app card game.
+
+## Usage
+
+There are various ways to use the methods in Cardlike. Probably the easiest is
+to define your whole game in a `Cardlike.game` block.
+
+    Cardlike.game do
+      card "Ace of Diamonds"
+      card "Ace of Hearts"
+      card "Ace of Spades"
+      card "Ace of Clubs"
+
+      deck "My Deck" do
+        copy_card "Ace of Diamonds"
+        copy_card "Ace of Hearts"
+        copy_card "Ace of Clubs"
+        copy_card "Ace of Spades"
+      end
+
+      the_deck("My Deck").shuffle!
+
+      hand "Player 1"
+
+      puts "Find the Ace of Spades!"
+
+      the_deck("My Deck").draw_into(the_hand("Player 1"))
+
+      if the_hand("Player 1").first.name == "Ace of Spades"
+        puts "Congratulations, you win!"
+      else
+        puts "Oh, well, try again."
+      end
+    end
+
+You can also prefix the class methods with Cardlike.
+
+    Cardlike.type_of_card :playing_card do
+      has :suit
+    end
+    
+    Cardlike.new_playing_card "Six of Spades" do
+      suit 'spades'
+    end
+
+    @deck = Cardlike.deck "My Deck" do
+      include_card "Six of Spades"
+    end
+
+    puts "Drawing #{@deck.draw}" # @deck.draw == Cardlike.the_deck("My Deck").draw
+
+### Creating Cards
+
+The `card` method can be used to create a new Card object. Created cards are
+stored globally and can be accessed with `the_card` and the card's name.
+
+    Cardlike.card "Draw one Play one" # => creates (and returns) a new Card object
+    Cardlike.the_card "Draw one Play one" # => the Card object created above (NOT a copy)
+
+A block passed to the `card` method will be executed in the new Card's context.
+Card objects can have properties, but it's best to create a custom type of card
+to do this.
+
+    Cardlike.type_of_card :action_card do
+      has :power_level
+      has :color
+    end
+
+    Cardlike.new_action_card "Magic Spell" do
+      power_level 5
+      color :red
+    end # => new Card object (actually a new ActionCard object)
+
+    Cardlike.the_card("Magic Spell")[:color] # => :red
+    Cardlike.the_card("Magic Spell")[:power_level] # => 5
+
+The `type_of_card` method creates a new subclass of Card. Use the `has` method in
+a `card` block to add a property. A new card creation method is added to the DSL
+with the type of card prefixed by `new_`. 
+
+To assign a property to a new card in the card block, use a method of the same
+name as the property. To retrieve that property, treat the card as a hash and
+reference the property name as the key.
+
+### Creating Decks
+
+But what you really want to do is create a Deck of cards.
+
+    Cardlike.game do
+      
+      type_of_card :action_card do
+        has :power_level
+        has :cost
+      end
+
+      deck "Action Deck" do
+
+        new_action_card "Magic Spell" do
+          power_level 5
+          cost 3
+        end
+
+        new_action_card "Subtle Strike" do
+          power_level 2
+          cost 2
+        end
+
+        new_action_card "Wide Swing" do
+          power_level 1
+          cost 1
+        end
+
+        3.times { copy_card "Magic Spell" }
+        3.times { copy_card "Subtle Strike" }
+        3.times { copy_card "Wide Swing" }
+
+      end
+
+    end
+
+You can use the `deck` method to name a new deck and pass it a block which will
+be evauluated in the context of the Deck. In this case, we put a bunch of `card`
+creation methods in the block, or more specifically, `new_action_card` (the
+method that was created by `type_of_card`). 
+
+Cards defined within the `deck` method will automatically be added to the Deck.
+You can also add cards by treating the Deck as an Array (which it is).
+
+    Cardlike.game do
+      type_of_card :action_card
+      @card1 = new_action_card "Magic Spell"
+      @deck = deck "Action Deck"
+
+      @deck << @card1
+    end
+
+Decks can be accessed using `the_deck` method, which takes the name of a Deck.
+The cards within are inside an Array, so most Array methods will work
+(particularly `Deck#shuffle!`).
+
+    Cardlike.game do
+      ...
+      the_deck("Action Deck").shuffle!
+      the_deck("Action Deck").first.name # => could be "Magic Spell"
+    end
+
+### Drawing into Hands
+
+Often you probably want to draw the top card of the deck. Cardlike Decks have a
+`draw` method and a `draw_into` method. Both remove and return the top Card from
+that Deck. `draw_into` takes an additional argument which should be an Array,
+Deck, or Hand (or something that responds to `<<`).
+
+A Hand is a subclass of a Deck with some additional methods. Creating a Hand is
+easiest with the `hand` method (which works like the `Deck` method).
+
+    Cardlike.game do
+      type_of_card :action_card
+      @card1 = new_action_card "Magic Spell"
+      @deck = deck "Action Deck" do
+        2.times { copy_card "Magic Spell" }
+      end
+
+      the_deck("Action Deck").draw # => <Card, :name => 'Magic Spell'>
+
+      @player1 = hand "Player 1"
+
+      the_deck("Action Deck").draw_into @player1 # => <Card, :name => 'Magic Spell'>
+    end
+
+Hands can be accessed by `the_hand`, just like the other Cardlike objects.
+
+    Cardlike.game do
+      ...
+      hand "Player 1"
+      the_deck("Action Deck").draw_into the_hand("Player 1")
+      the_hand("Player 1").size # => 1
+    end
+
+### Defining a Turn
+
+As most games have turns, you can define a block of code as a turn using the
+`define_turn` method and then call it using `begin_new_turn`. Any number of
+arguments can be passed to the block.
+
+    Cardlike.game do
+      ...
+
+      define_turn do |current_hand|
+        the_deck("Action Deck").draw_into current_hand # Draw a card
+        puts "#{current_hand.name}'s Hand: #{current_hand}"
+      end
+
+      hands = []
+      hands << hand "Player 2"
+      hands << hand "Player 1"
+
+      begin
+        hands.rotate!
+        begin_new_turn(hands.first)
+      end while victory == false
+    end
+
+### Keeping Score
+
+Chances are there's scoring in your game too. You can use the `score` method to
+add a score to a particular key. The key can be anything, so players can have
+several scores or the game could keep score of several objects at once.
+
+You can retrieve the score using `the_score` followed by the key or get a Hash
+of all the scores with `scores`. 
+
+If you need to decrement the score or set it to a particular number, use
+`set_score`.
+
+    Cardlike.game do
+      ...
+      score "Player 1" # sets the score to 1
+      score "Player 2" # sets the score to 1
+      score "Player 1" # sets the score to 2
+
+      the_score "Player 1" # => 2
+
+      scores # => {"Player 1" => 2, "Player 2" => 1}
+
+      set_score "Player 2", 5
+
+      scores # => {"Player 1" => 2, "Player 2" => 5}
+
+    end
+
+### Examples
+
+See the examples in the `examples/` directory for some more good ideas.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')

data/cardlike.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cardlike/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "cardlike"
+  gem.version       = Cardlike::VERSION
+  gem.authors       = ["Payton Swick"]
+  gem.email         = ["payton@foolord.com"]
+  gem.summary       = 'A library for developing and testing card games.'
+  gem.homepage      = "https://github.com/sirbrillig/cardlike"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'rspec'
+  gem.add_dependency 'activesupport'
+end

data/examples/go_fish.rb

@@ -0,0 +1,120 @@
+require 'cardlike'
+require 'highline/import'
+
+Cardlike.game do
+  puts "Setting up..."
+
+  type_of_card :playing_card do
+    has :face
+    has :value
+    has :suit
+  end
+
+  deck "Go Fish" do
+    ['Spades', 'Clubs', 'Diamonds', 'Hearts'].each do |card_suit|
+      ['Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight', 'Nine', 'Jack', 'Queen', 'King', 'Ace'].each_with_index do |name, index|
+        new_playing_card("#{name} of #{card_suit}") do
+          value index
+          face name
+          suit card_suit
+        end
+      end
+    end
+
+    shuffle!
+  end
+  
+  players = []
+  players << hand("Player 1")
+  players << hand("Player 2")
+
+  players.each do |player|
+    7.times { the_deck("Go Fish").draw_into player }
+  end
+
+  current_player = players.first
+
+  define_turn do
+    target_player = players.last
+    if players.size > 2
+      target_name = choose do |menu|
+        menu.prompt = "#{current_player.name}, who are you asking? "
+        menu.choices(*players.map { |p| p.name })
+      end
+      target_player = players.select { |p| p.name == target_name }.first
+    end
+
+    target_card_name = choose do |menu|
+      menu.prompt = "#{current_player.name}, what are you looking for? "
+      menu.choices(*current_player.map {|c| c.name })
+    end
+    target_card = current_player.select { |c| c.name == target_card_name }.first
+    puts "#{target_player.name}, do you have any #{target_card[:face]}s?\n"
+
+    another_turn = false
+    removed = target_player.remove_card_if { |c| c[:value] == target_card[:value] }
+    unless removed.empty?
+      current_player += removed
+      puts "Got one! Yes indeed, #{target_player.name} had #{removed.size} #{removed.first[:face]}#{removed.size == 1 ? '' : 's'}."
+      puts "You get another turn."
+      another_turn = true
+
+      # Check for matches.
+      matching_sets = current_player.group_by { |c| c[:value] }.select { |k, v| v.size >= 4 }
+      matching_sets.each do |matching_value, cards|
+        matching_card = cards.first
+        puts "You have a matching set of #{matching_card[:face]}s!"
+        current_player.remove_card_if { |c| c[:value] == matching_value }
+        score current_player.name
+      end
+
+    else
+      puts "Go Fish!\n"
+      drawn = the_deck("Go Fish").draw_into current_player
+      puts "You drew a #{drawn.name}."
+
+      # Check for matches.
+      matching_sets = current_player.group_by { |c| c[:value] }.select { |k, v| v.size >= 4 }
+      matching_sets.each do |matching_value, cards|
+        matching_card = cards.first
+        puts "Good fortune! You have a matching set of #{matching_card[:face]}s!"
+        puts "You get another turn."
+        another_turn = true
+        current_player.remove_card_if { |c| c[:value] == matching_value }
+        score current_player.name
+      end
+
+    end
+
+    another_turn
+  end
+
+  begin
+    puts "\nBeginning a new turn!"
+
+    begin
+      another_turn = begin_new_turn 
+
+      if the_deck("Go Fish").empty?
+        puts "\nThe deck is empty!\n"
+        break
+      end
+      break if current_player.empty?
+
+    end while another_turn
+    players.rotate!
+    current_player = players.first
+
+    if the_deck("Go Fish").empty?
+      break
+    end
+    break if current_player.empty?
+
+  end until players.any? { |p| p.size < 1 }
+
+  puts "\n\nThe game has ended!"
+
+  winner = scores.max_by { |p, s| s }.first
+  puts "#{winner} is the winner!"
+
+end

data/lib/cardlike/card.rb

@@ -0,0 +1,73 @@
+#
+# Represents a game card. Best used with the Card and Deck DSL. See Cardlike.
+#
+class Cardlike::Card
+  attr_accessor :name, :text
+
+  #
+  # Create an instance of a Card. Arguments are a hash that should include
+  # +:name+ at a minimum.  Optionally all cards have a +text+ accessor that can
+  # be set in the constructor by including the option +:text+. Perhaps a better
+  # idea is to use Card.create or Cardlike.card.
+  #
+  def initialize(options={})
+    self.name = options[:name]
+    self.text = options[:text]
+    @properties = {}
+  end
+
+  # 
+  # Factory method to create an instance of a Card. This sets the name of the
+  # card and its properties using the Card DSL in the corresponding block. You
+  # can also use Cardlike.card, which does the same thing. Probably more useful
+  # is to create custom card types using Cardlike.type_of_card and create them
+  # using the +new_+ methods.
+  #
+  #   Card.create "Big Monster" do
+  #     text "Spend 1 Mana to Attack"
+  #   end
+  #
+  # Preferred over Card.new.
+  #
+  def self.create(name, &block)
+    c = self.new(name: name)
+    c.instance_eval(&block) if block_given?
+    c
+  end
+
+  # 
+  # DSL method for setting the card text. Still works as a getter if no args are
+  # passed.
+  #
+  def text(card_text=nil)
+    return @text unless card_text
+    @text = card_text
+  end
+
+  # 
+  # Return custom properties of this Card. Custom properties can be set using
+  # the Card.has method, ideally inside a Cardlike.type_of_card block.
+  #
+  #   @king_of_diamonds[:suit] # => 'Diamonds'
+  #
+  def [](prop)
+    @properties[prop]
+  end
+
+  #
+  # Class DSL method for setting custom properties for a Card. See
+  # Cardlike.type_of_card.
+  #
+  def self.has(prop)
+    define_method(prop, lambda { |arg| raise "Cards are immutable." if @properties.has_key? prop; @properties[prop] = arg })
+  end
+
+  def to_s
+    t = []
+    t << "Name: #{name}"
+    t << "Text: #{text}" if text
+    @properties.each { |p,v| t << "#{p}: #{v}" } 
+    t.join("\n")
+  end
+
+end

data/lib/cardlike/deck.rb

@@ -0,0 +1,103 @@
+#
+# Represents a game deck. Best used with the Card and Deck DSL. See Cardlike.
+#
+class Cardlike::Deck < Array
+  attr_accessor :name
+
+  #
+  # Create a new Deck. Options should always include +:name+ and may optionally
+  # include +:cards+, which is an array of Card objects (ideally) to keep in
+  # this deck. It's better to use Cardlike.deck to create decks, though.
+  #
+  def initialize(options={})
+    self.name = options[:name]
+    options[:cards].each { |c| self << c } if options[:cards]
+  end
+
+  # 
+  # Draw the top card from this deck and return it.
+  #
+  def draw
+    self.pop
+  end
+
+  #
+  # Shuffle this deck and return a copy Deck. Probably more useful is
+  # Deck#shuffle!  which will shuffle this deck in place.
+  #
+  def shuffle
+    self.dup.shuffle!
+  end
+
+  # 
+  # Append an array (or Deck) of cards to this Deck.
+  #
+  def +(ary)
+    ary.each { |a| self << a }
+    self
+  end
+
+  #
+  # DSL method to add a pre-defined card to this Deck. This inserts the unique
+  # card into the deck. If you want to put a copy into the deck (or several
+  # copies), use Deck#copy_card instead.
+  #
+  #   Cardlike.game do
+  #     card "Super Strike"
+  #
+  #     deck "My Deck" do
+  #       include_card "Super Strike"
+  #     end
+  #   end
+  #
+  def include_card(name)
+    raise "Card '#{name}' not found." unless card = Cardlike.the_card(name)
+    self << card
+  end
+
+  #
+  # DSL method to add a duplicate of a pre-defined card to this Deck.
+  #
+  #   Cardlike.game do
+  #     card "Super Strike"
+  #
+  #     deck "My Deck" do
+  #       4.times { copy_card "Super Strike" }
+  #     end
+  #   end
+  #
+  def copy_card(name)
+    raise "Card '#{name}' not found." unless card = Cardlike.the_card(name)
+    copy = card.dup
+    self << copy
+  end
+
+  # 
+  # DSL method to create a new card inside this deck. Also check out the +new_+
+  # methods created by Cardlike.type_of_card. This works just like Cardlike.card
+  # except that it automatically adds the card to this deck.
+  #
+  #   Cardlike.deck "Options Deck" do
+  #     card "Magic Spell"
+  #     card "Arcane Mark"
+  #     card "Simple Attack"
+  #   end
+  #
+  def card(name, &block)
+    c = Cardlike.card(name, &block)
+    self << c
+    c
+  end
+
+  # 
+  # Like Deck#draw except that it draws a card and then adds it to a Deck or
+  # Hand. Also returns the card drawn.
+  #
+  #   Cardlike.the_deck("Poker Deck").draw_into(Cardlike.the_hand("Player 1"))
+  #
+  def draw_into(deck)
+    card = draw
+    deck << card
+    card
+  end
+end

data/lib/cardlike/hand.rb

@@ -0,0 +1,28 @@
+#
+# Represents a game hand. Best used with the Card and Deck DSL. See Cardlike and
+# Cardlike::Deck, from which this inherits.
+#
+class Cardlike::Hand < Cardlike::Deck
+  #
+  # Remove and return a Card from this hand by name.
+  #
+  def remove_card(card_name)
+    self.delete(self.select { |card| card.name == card_name }.first)
+  end
+
+  #
+  # Remove cards for which the block evaluates to true, returning removed cards
+  # in an Array. If no cards are found, returns an empty array.
+  #
+  def remove_card_if(&block)
+    matches = self.select { |card| yield(card) }
+    matches.collect { |match| self.delete(match) }
+  end
+  
+  def to_s
+    puts "Hand: #{name}"
+    self.each do |card|
+      puts "-> #{card}\n"
+    end
+  end
+end