ttr 1.0.0

data/lib/ttr.rb

@@ -0,0 +1,7 @@
+# encoding: UTF-8
+# 
+# Copyright © 2010-2011 Jesse Sielaff
+# 
+
+Dir[File.expand_path("../ttr/objects/*.rb", __FILE__)].sort.each {|f| require f }
+Dir[File.expand_path("../ttr/entities/*.rb", __FILE__)].sort.each {|f| require f }

data/lib/ttr/entities/city.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class City < Entity
+  # Returns true if the two Cities are connected by a single direct Route, false
+  # otherwise.
+  # 
+  def connected? (city)
+    @obj.connected?(City.object(city))
+  end
+  
+  # Returns an Array of Cities connected to the City by a single direct Route.
+  # 
+  def connected_cities
+    City.entities(@obj.connected_city_objs)
+  end
+  
+  # Returns the name of the City as a Symbol.
+  # 
+  def name
+    @obj.name
+  end
+  
+  # Returns an Array of Routes leading into and out of the City.
+  # 
+  def routes
+    Route.entities(@obj.route_objs)
+  end
+  
+  # Returns an Array of Routes leading into and out of the City that are not
+  # claimed by any Player.
+  # 
+  def unclaimed_routes
+    Route.entities(@obj.route_objs.reject {|obj| obj.player_obj })
+  end
+end

data/lib/ttr/entities/game.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class Game < Entity
+  # Returns an Array of the colors of the Cards available for selection.
+  # 
+  def available_colors
+    @obj.deck.available_colors
+  end
+  
+  # Returns an Array of all Cities in the Game.
+  # 
+  def cities
+    City.entities(@obj.city_objs)
+  end
+  
+  # Returns an Array of all Routes in the Game.
+  # 
+  def routes
+    Route.entities(@obj.route_objs)
+  end
+  
+  # Returns an Array of all unclaimed Routes in the Game.
+  # 
+  def unclaimed_routes
+    Route.entities(@obj.route_objs.reject {|obj| obj.player_obj })
+  end
+end

data/lib/ttr/entities/opponent.rb

@@ -0,0 +1,43 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class Opponent < Entity
+  # Returns the number of Cards held by the Opponent.
+  # 
+  def cards
+    @obj.cards.values.flatten.length
+  end
+  
+  # Returns an Array of the Routes claimed by the Opponent.
+  # 
+  def claimed_routes
+    Route.entities(@obj.claimed_route_objs)
+  end
+  
+  # Returns the current score of the Opponent.
+  # 
+  def score
+    @obj.score
+  end
+  
+  # Returns an Array of the color of the last n Cards selected by the Opponent.
+  # Cards drawn at random are represented as :grey.
+  # 
+  def selections (n)
+    @obj.selections.first(n)
+  end
+  
+  # Returns the number of Tickets held by the Player.
+  # 
+  def tickets
+    @obj.kept_ticket_objs.length
+  end
+  
+  # Returns the number of unplayed trains held by the Player.
+  # 
+  def trains
+    @obj.trains
+  end
+end

data/lib/ttr/entities/player.rb

@@ -0,0 +1,213 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class Player < Entity
+  # Returns an Array of the Tickets currently available for the Player to choose
+  # to keep or discard.
+  # 
+  def candidate_tickets
+    Ticket.entities(@obj.candidate_ticket_objs)
+  end
+  
+  # Returns the number of Cards of the given color held by the Player.
+  # 
+  def cards (color)
+    @obj.cards[color].length
+  end
+  
+  # Claims the given Route using Cards of the given color and the minimum number
+  # of wild Cards needed, then returns an Array of the Routes claimed by the
+  # Player. If the Player is unable to claim the Route with the given color,
+  # returns nil.
+  # 
+  def claim (route, color)
+    return if @obj.action_begun
+    return if route.claimed?
+    return unless route.match?(color)
+    return if route.length > @obj.trains
+    return if (twin = Route.object(route).twin) && (twin.player_obj == Player.object(self))
+    return if (twin) && (opponents.length < 2) && (twin.player_obj)
+    return unless card_objs = @obj.set_of(route.length, color, wilds)
+    
+    @obj.discard card_objs
+    @obj.claim Route.object(route)
+  end
+  
+  # Claims the given Route using all the Player's wild Cards and as many Cards
+  # of the given color as needed, then returns an Array of the Routes claimed by
+  # the Player. If the Player is unable to claim the Route with the given color,
+  # returns nil.
+  # 
+  def claim_max_wild (route, color)
+    return if @obj.action_begun
+    return if route.claimed?
+    return unless route.match?(color)
+    return if route.length > @obj.trains
+    return if (twin = Route.object(route).twin) && (twin.player_obj == Player.object(self))
+    return if (twin) && (opponents.length < 2) && (twin.player_obj)
+    return unless card_objs = @obj.set_of(route.length, color, wilds, true)
+    
+    @obj.discard card_objs
+    @obj.claim Route.object(route)
+  end
+  
+  # Claims the given Route using the given number of wild Cards and as many
+  # Cards of the given color as needed, then returns an Array of the Routes
+  # claimed by the Player. If the Player is unable to claim the Route with the
+  # given color, returns nil.
+  # 
+  def claim_n_wild (route, color, n)
+    return if @obj.action_begun
+    return if route.claimed?
+    return unless route.match?(color)
+    return if route.length > @obj.trains
+    return if (twin = Route.object(route).twin) && (twin.player_obj == Player.object(self))
+    return if (twin) && (opponents.length < 2) && (twin.player_obj)
+    return unless card_objs = @obj.set_of(route.length, color, n, true)
+    
+    @obj.discard card_objs
+    @obj.claim Route.object(route)
+  end
+  
+  # Claims the given Route using only Cards of the given color (no wild Cards),
+  # then returns an Array of the Routes claimed by the Player. If the Player is
+  # unable to claim the Route with the given color, returns nil.
+  # 
+  def claim_no_wild (route, color)
+    return if @obj.action_begun
+    return if route.claimed?
+    return unless route.match?(color)
+    return if route.length > @obj.trains
+    return if (twin = Route.object(route).twin) && (twin.player_obj == Player.object(self))
+    return if (twin) && (opponents.length < 2) && (twin.player_obj)
+    return unless card_objs = @obj.set_of(route.length, color, 0)
+    
+    @obj.discard card_objs
+    @obj.claim Route.object(route)
+  end
+  
+  # Returns an Array of the Routes claimed by the Player.
+  # 
+  def claimed_routes
+    Route.entities(@obj.claimed_route_objs)
+  end
+  
+  # Removes all candidate Tickets from the Player, marks the Player's turn as
+  # complete, and returns true. If the Player is unable to discard Tickets,
+  # returns nil.
+  # 
+  def discard_tickets
+    return if @obj.kept_ticket_objs.length < 2
+    return if [0,3].include?(@obj.candidate_ticket_objs.length)
+    
+    @obj.clear_ticket_objs
+  end
+  
+  # Adds one Card to the Player and returns the color of that Card. If the
+  # Player is unable to draw a Card, returns nil.
+  # 
+  def draw_random
+    return if @obj.draws_remaining < 1
+    return unless card = @obj.deck.draw
+    
+    @obj.cards[card.color] << card
+    @obj.selections.unshift(:grey)
+    @obj.register_draw(1)
+    
+    card.color
+  end
+  
+  # Adds three candidate Tickets to the Player and returns an Array of the
+  # Tickets. Disallows the Player from claiming Routes, drawing Tickets, and
+  # drawing Cards for the remainder of the turn. Returns nil if the Player is
+  # unable to draw Tickets.
+  # 
+  def draw_tickets
+    return if @obj.action_begun
+    return if @obj.remaining_ticket_objs.length < 3
+    
+    Ticket.entities(@obj.add_tickets)
+  end
+  
+  # Marks the given Ticket as kept by the Player. If all candidate Tickets have
+  # been kept, marks the Player's turn as complete and returns true. Returns
+  # false if some candidate Tickets remain, or nil if the Ticket was not a
+  # candidate Ticket. 
+  # 
+  def keep_ticket (ticket)
+    ticket_obj = Ticket.object(ticket)
+    return unless @obj.candidate_ticket_objs.delete(ticket_obj)
+    
+    @obj.keep_ticket_obj(ticket_obj) || false
+  end
+  
+  # Returns an Array of the Tickets kept by the Player.
+  # 
+  def kept_tickets
+    Ticket.entities(@obj.kept_ticket_objs)
+  end
+  
+  # Returns an Array of the Player's Opponents.
+  # 
+  def opponents
+    Opponent.entities(@obj.all_player_objs - [@obj])
+  end
+  
+  # Returns the current score of the Player.
+  # 
+  def score
+    @obj.score
+  end
+  
+  # Moves one Card of the given Color from the selection to the Player and
+  # returns the number of Cards of that color held by the Player. If the Player
+  # is not currently allowed to draw a Card of the given color, returns nil.
+  # 
+  def select_card (color)
+    return select_wild if color == :wild
+    
+    return if @obj.draws_remaining < 1
+    return unless card = @obj.deck.select(color)
+    
+    @obj.cards[color] << card
+    @obj.selections.unshift(card.color)
+    @obj.register_draw(1)
+    
+    cards(color)
+  end
+  
+  # Moves one wild Card from the selection to the Player and returns the number
+  # of wild Cards held by the Player. If the Player is not currently allowed to
+  # draw a wild Card, returns nil.
+  # 
+  def select_wild
+    return if @obj.draws_remaining < 2
+    return unless card = @obj.deck.select(:wild)
+    
+    @obj.cards[:wild] << card
+    @obj.selections.unshift(:wild)
+    @obj.register_draw(2)
+    
+    wilds
+  end
+  
+  # Returns the number of unplayed trains held by the Player.
+  # 
+  def trains
+    @obj.trains
+  end
+  
+  # Returns true if the Player has completed the current turn.
+  # 
+  def turn_completed?
+    @obj.turn_completed
+  end
+  
+  # Returns the number of wild Cards held by the Player.
+  # 
+  def wilds
+    cards(:wild)
+  end
+end

data/lib/ttr/entities/route.rb

@@ -0,0 +1,74 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class Route < Entity
+  # Returns an Array of the two Cities at either end of the Route.
+  # 
+  def cities
+    City.entities(@obj.city_objs)
+  end
+  
+  # Returns true if any Player has claimed the Route, false otherwise.
+  # 
+  def claimed?
+    @obj.player_obj != nil
+  end
+  
+  # Returns true if the given Player has claimed the route, false otherwise.
+  # 
+  def claimed_by_player? (player)
+    @obj.player_obj == Player.object(player)
+  end
+  
+  # Returns the color of the Route as a Symbol.
+  # 
+  def color
+    @obj.color
+  end
+  
+  # Returns false if the color of the Route is :grey, true otherwise.
+  # 
+  def color?
+    @obj.color != :grey
+  end
+  
+  # Returns true if the Route is the exact same color as the given color, false
+  # otherwise.
+  # 
+  def exact_match? (color)
+    @obj.color == color
+  end
+  
+  # Returns true if the color of the Route is :grey, false otherwise.
+  # 
+  def grey?
+    @obj.color == :grey
+  end
+  
+  # Returns the length of the Route.
+  # 
+  def length
+    @obj.length
+  end
+  
+  # Returns true if the given color represents a color match with the Route,
+  # false otherwise. The color :grey matches every color.
+  # 
+  def match? (color)
+    [color, :grey].include?(@obj.color)
+  end
+  
+  # Returns the point value of the Route.
+  # 
+  def points
+    @obj.points
+  end
+  
+  # Returns true if the Route is unclaimed, false otherwise.
+  # 
+  def unclaimed?
+    @obj.player_obj == nil
+  end
+end

data/lib/ttr/entities/ticket.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class Ticket < Entity
+  # Returns an Array of the Cities on the Ticket.
+  # 
+  def cities
+    City.entities(@obj.city_objs)
+  end
+  
+  # Returns the point value of the Ticket.
+  # 
+  def points
+    @obj.points
+  end
+end

data/lib/ttr/objects/card.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+require_relative 'colorful'
+
+class CardObject
+  def initialize (color)
+    @color = color.to_sym
+  end
+  
+  include Colorful
+end

data/lib/ttr/objects/city.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class CityObject
+  def initialize (name)
+    @name = name
+    @route_objs = []
+    @connected_city_objs = []
+  end
+  
+  attr_reader :connected_city_objs, :name, :route_objs
+  
+  # Adds the given Route to the City's Routes.
+  # 
+  def add_route_obj (route_obj)
+    @route_objs << route_obj
+    @connected_city_objs |= (route_obj.city_objs - [self])
+  end
+  
+  # Returns true if the two Cities are connected by a single direct Route, false
+  # otherwise.
+  # 
+  def connected? (city_obj)
+    @connected_city_objs.include?(city_obj)
+  end
+  
+  # Returns true if the two Cities are connected using any combination of the
+  # given Routes.
+  # 
+  def connected_using? (city_obj, route_objs)
+    valid_routes = route_objs & @route_objs
+    return false if valid_routes.empty?
+    
+    valid_routes.any? do |obj|
+      return true if obj.connects?(self, city_obj)
+      
+      obj.city_objs.any? do |c_obj|
+        next if c_obj == self
+        c_obj.connected_using?(city_obj, route_objs - valid_routes)
+      end
+    end
+  end
+  
+  # Returns an Array of the Routes directly connecting the two Cities.
+  # 
+  def routes_to (city_obj)
+    @route_objs.select {|obj| obj.connects?(self, city_obj) }
+  end
+end

data/lib/ttr/objects/colorful.rb

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+module Colorful
+  attr_reader :color
+  
+  # Returns true if the given Symbol or Colorful object represents the exact
+  # same color as the receiver, false otherwise. Returns nil if the given object
+  # is neither a Symbol nor Colorful.
+  # 
+  def exact_match? (c)
+    case c
+      when Symbol then @color == c
+      when Colorful then exact_match? c.color
+    end
+  end
+  
+  # Returns true if the given Symbol or Colorful object represents a color match
+  # with the receiver, false otherwise. The colors :wild and :grey match every
+  # color. Returns nil if the given object is neither a Symbol nor Colorful.
+  # 
+  def match? (c)
+    case c
+      when Symbol then [:grey, :wild, @color].include? c
+      when Colorful then match? c.color
+    end
+  end
+end

data/lib/ttr/objects/deck.rb

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class DeckObject
+  def initialize
+    @draw_pile = []
+    @selection = []
+    @discard_pile = 14.times.map { CardObject.new(:wild) }
+    
+    %w:black blue green orange pink red white yellow:.each do |color|
+      @discard_pile.concat(12.times.map { CardObject.new(color.to_sym) })
+    end
+  end
+  
+  # Returns an Array of the colors of the Cards in the selection.
+  # 
+  def available_colors
+    @selection.map {|card| card.color }
+  end
+  
+  # Moves the given Card to the discard pile.
+  # 
+  def discard (card)
+    @discard_pile << card
+  end
+  
+  # Returns the top Card of the Deck, shuffling first if necessary. If there are
+  # no Cards left in the Deck, returns nil.
+  # 
+  def draw
+    if @draw_pile.empty?
+      @draw_pile.replace(@discard_pile.shuffle)
+      @discard_pile.clear
+    end
+    
+    @draw_pile.pop
+  end
+  
+  # Returns true if there are no Cards remaining in the Deck, false otherwise.
+  # 
+  def empty?
+    (@draw_pile + @discard_pile + @selection).empty?
+  end
+  
+  # Moves Cards from the draw pile to the selection (shuffling when necessary)
+  # until the selection contains 5 Cards, or as many Cards as are left in the
+  # Deck. If there are ever 3 wild Cards showing (and at least 3 non-wild cards
+  # left in the Deck), moves the selection Cards to the discard pile and
+  # attempts to fill the selection again.
+  # 
+  def fill_selection
+    until @selection.length > 4
+      return unless card = draw
+      @selection << card
+      
+      if (@selection.count {|card| card.color == :wild } >= 3) && ((@draw_pile + @discard_pile + @selection).count {|card| card.color != :wild } > 2)
+        @selection.each {|card| discard(card) }
+        @selection.clear
+      end
+    end
+  end
+  
+  # Removes a Card of the given color from the selection, refills the selection,
+  # then returns the Card. If no Card of the given color is found, returns nil.
+  # 
+  def select (color)
+    if index = @selection.index {|card| card.exact_match?(color) }
+      card = @selection.delete_at(index)
+      fill_selection
+      card
+    end
+  end
+  
+  # Returns true if the deck is empty except for wild Cards in the selection.
+  # 
+  def wilds_only?
+    (@draw_pile + @discard_pile).empty? && @selection.all? {|card| card.color == :wild }
+  end
+end

data/lib/ttr/objects/entity.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class Entity
+  def Entity.inherited (klass)
+    klass.define_singleton_method(:object) {|obj| obj.instance_variable_get(:@obj) }
+    klass.define_singleton_method(:entities) {|ary| ary.map {|obj| klass.new(obj) } }
+  end
+  
+  def initialize (obj)
+    @obj = obj
+  end
+end

data/lib/ttr/objects/game.rb

@@ -0,0 +1,44 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class GameObject
+  def initialize (script_names, city_objs, route_objs, ticket_objs)
+    n = script_names.length
+    raise(NumberOfPlayers, "#{n} player#{"s" if n != 1} given, 2..5 players expected") unless n.between?(2,5)
+    
+    @deck = DeckObject.new
+    
+    @city_objs = city_objs
+    @route_objs = route_objs
+    @ticket_objs = ticket_objs
+    
+    @player_objs = []
+    
+    script_names.each do |script_name|
+      script = Script.method(script_name).to_proc.curry[Game.new(self)]
+      @player_objs << PlayerObject.new(@deck, @player_objs, @route_objs, script, @ticket_objs)
+    end
+    
+    @deck.fill_selection
+  end
+  
+  NumberOfPlayers = Class.new(Exception)
+  UnfinishedTurn = Class.new(Exception)
+  
+  attr_reader :deck, :route_objs
+  
+  # Causes Players to take turns until every Player has played a turn in which
+  # at least one Player has fewer than 3 trains, then scores the Tickets held by
+  # each Player.
+  # 
+  def play
+    @player_objs.cycle do |obj|
+      obj.take_a_turn
+      break if @player_objs.all? {|obj| obj.played_final_round? }
+    end
+    
+    @player_objs.map {|obj| obj.score_tickets; obj.score }
+  end
+end

data/lib/ttr/objects/map.rb

@@ -0,0 +1,49 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class MapObject
+  def MapObject.inherited (subclass)
+    subclass.define_singleton_method(:play_game) do |*script_names|
+      subclass.new.new_game(*script_names).play
+    end
+  end
+  
+  def initialize
+    @city_objs = []
+    @route_objs = []
+    @ticket_objs = []
+    
+    build
+  end
+  
+  # Creates and returns a new City on the Map.
+  # 
+  def city (name)
+    @city_objs[0...0] = CityObject.new(name.to_sym)
+  end
+  
+  # Returns a new Game played using the Map, using Players running the named
+  # Scripts.
+  # 
+  def new_game (*script_names)
+    GameObject.new(script_names, @city_objs, @route_objs.each {|r| r.player_obj = nil }, @ticket_objs.shuffle)
+  end
+  
+  # Creates and returns a new Route between the given Cities, with the given
+  # length and color.
+  # 
+  def route (*city_objs, length, color)
+    route_obj = RouteObject.new(city_objs, length, color)
+    city_objs.each {|obj| obj.add_route_obj(route_obj) }
+    @route_objs[0...0] = route_obj
+  end
+  
+  # Creates and returns a new Ticket for the given Cities, with the given point
+  # value.
+  # 
+  def ticket (points, *city_objs)
+    @ticket_objs[0...0] = TicketObject.new(points, city_objs)
+  end
+end

data/lib/ttr/objects/player.rb

@@ -0,0 +1,170 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class PlayerObject
+  def initialize (deck_obj, player_objs, route_objs, script, ticket_objs)
+    @deck = deck_obj
+    @script = script
+    
+    @all_player_objs = player_objs
+    @all_route_objs = route_objs
+    @remaining_ticket_objs = ticket_objs
+    
+    @candidate_ticket_objs = []
+    @kept_ticket_objs = []
+    @claimed_route_objs = []
+    
+    @score = 0
+    @trains = 45
+    
+    @selections = []
+    @cards = { wild:[], black:[], blue:[], green:[], orange:[], pink:[], red:[], white:[], yellow:[] }
+    
+    4.times do
+      card = @deck.draw
+      @cards[card.color] << card
+    end
+    
+    @action_begun = false
+    @turn_completed = false
+    @draws_remaining = 0
+  end
+  
+  attr_reader :action_begun, :all_player_objs, :candidate_ticket_objs, :cards,
+              :claimed_route_objs, :deck, :draws_remaining, :kept_ticket_objs,
+              :remaining_ticket_objs, :score, :selections, :trains,
+              :turn_completed
+  
+  # Moves three candidate Tickets from the remaining Tickets to the Player and
+  # returns an Array of the Tickets. Disallows the Player from claiming Routes,
+  # drawing Tickets, and drawing Cards for the remainder of the turn.
+  # 
+  def add_tickets
+    @action_begun = true
+    @draws_remaining = 0
+    
+    @candidate_ticket_objs.replace(@remaining_ticket_objs.pop(3))
+  end
+  
+  # Marks the given Route as claimed by the Player. Increments the Player's
+  # score by the point value of the Route. Decrements the Player's trains by the
+  # length of the Route. Disallows claiming Routes, drawing Tickets, and drawing
+  # Cards for the remainder of the turn and marks the Player's turn as complete.
+  # 
+  def claim (route_obj)
+    route_obj.player_obj = self
+    
+    @claimed_route_objs << route_obj
+    @trains -= route_obj.length
+    @score += route_obj.points
+    
+    @action_begun = true
+    @turn_completed = true
+    @draws_remaining = 0
+  end
+  
+  # Removes all candidate Tickets from the Player, marks the Player's turn as
+  # complete, and returns true.
+  # 
+  def clear_ticket_objs
+    @candidate_ticket_objs.clear
+    @turn_completed = true
+  end
+  
+  # Moves the given Cards from the Player to the Deck's discard pile.
+  # 
+  def discard (card_objs)
+    card_objs.each do |obj|
+      @cards.each {|k,v| v.delete(obj) }
+      @deck.discard(obj)
+    end
+  end
+  
+  # Marks the given Ticket as kept by the Player. If all candidate Tickets have
+  # been kept, marks the Player's turn as complete and returns true, otherwise
+  # returns nil.
+  # 
+  def keep_ticket_obj (ticket_obj)
+    @kept_ticket_objs << ticket_obj
+    @turn_completed = true if @candidate_ticket_objs.empty?
+  end
+  
+  # Returns true if the Player has taken a turn during the final round, false
+  # otherwise.
+  # 
+  def played_final_round?
+    @final_round
+  end
+  
+  # Returns true if the Player will be able to draw Cards, claim a Route, or
+  # draw Tickets during this turn, false otherwise.
+  # 
+  def possible_to_play?
+    return true unless @deck.empty?
+    return true unless @remaining_ticket_objs.length < 3
+    
+    max_route = @cards.keys.each_with_object({}) do |color, h|
+      next if color == :wild
+      h[color] = @cards[color].length + @cards[:wild].length
+    end
+    
+    max_route[:grey] = max_route.values.max
+    
+    @all_route_objs.any? do |obj|
+      next if obj.player_obj
+      next if obj.length > @trains
+      next if obj.length > max_route[obj.color]
+      next if (twin = obj.twin) && (twin.player_obj == self)
+      next if (twin) && (@all_player_objs.length < 3) && (twin.player_obj)
+      true
+    end
+  end
+  
+  # Decrements the number of Cards left to draw by 1 and disallows the Player
+  # from drawing Tickets and claiming Routes for the remainder of this turn. If
+  # the number of Cards left to draw reaches 0, also disallows the Player from
+  # drawing more Cards this turn, and marks the Player's turn as complete.
+  # 
+  def register_draw (n)
+    @action_begun = true
+    @draws_remaining -= n
+    
+    if (@draws_remaining < 1) || @deck.empty? || @deck.wilds_only?
+      @turn_completed = true
+    end
+  end
+  
+  def score_tickets
+    @kept_ticket_objs.each {|obj| @score += (obj.completed? @claimed_route_objs) ? obj.points : -obj.points }
+  end
+  
+  # Returns an Array of Cards of the given size. If force_wilds is false, will
+  # attempt to fill the Array first with Cards of the given color, then with the
+  # given number of wild Cards (if necessary). If force_wilds is true, will
+  # attempt to fill the Array first with the given number of wild Cards, then
+  # with Cards of the given color (if necessary). If the Array is not filled to
+  # the required size, returns nil.
+  # 
+  def set_of (size, color, wilds, force_wilds = false)
+    c, w = @cards[color], @cards[:wild].take(wilds)
+    
+    set = (force_wilds) ? (w + c) : (c + w)
+    set.take(size) unless set.length < size
+  end
+  
+  # 
+  # 
+  def take_a_turn
+    if possible_to_play?
+      @script[Player.new(self)]
+      raise Game::UnfinishedTurn unless @turn_completed
+    end
+    
+    @final_round = @all_player_objs.any? {|obj| obj.trains < 3 }
+    @draws_remaining = 2
+    @action_begun = false
+    @turn_completed = false
+  end
+end

data/lib/ttr/objects/route.rb

@@ -0,0 +1,40 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class RouteObject
+  def initialize (city_objs, length, color)
+    @city_objs = city_objs
+    @color = color
+    @length = length
+    @player_obj = nil
+    
+    x = length.to_f
+    @points = (Math.sin(4*x/3)*x*x*x/250 + 23*x*x/78 + 7*x/13).round
+  end
+  
+  include Colorful
+  
+  attr_accessor :player_obj
+  attr_reader :city_objs, :length, :points
+  
+  # Returns true if the Route connects the given Cities, false otherwise.
+  # 
+  def connects? (*city_objs)
+    (@city_objs & city_objs).length == 2
+  end
+  
+  # Returns true if the Route connects to the given City, false otherwise.
+  # 
+  def into? (city_obj)
+    @city_objs.include?(city_obj)
+  end
+  
+  # If there are two Routes connecting the two Cities at the end of this Route,
+  # returns the other Route. Otherwise, returns nil.
+  # 
+  def twin
+    (@city_objs[0].routes_to(@city_objs[1]) - [self])[0]
+  end
+end

data/lib/ttr/objects/ticket.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class TicketObject
+  def initialize (points, city_objs)
+    @city_objs = city_objs
+    @points = points
+  end
+  
+  attr_reader :city_objs, :points
+  
+  # Returns true if the Ticket is completed by any combination of the given
+  # Routes, false otherwise.
+  # 
+  def completed? (route_objs)
+    c1, c2 = city_objs
+    return false unless route_objs.any? {|obj| obj.into?(c1) }
+    return false unless route_objs.any? {|obj| obj.into?(c2) }
+    
+    c1.connected_using?(c2, route_objs)
+  end
+end

data/lib/ttr/objects/usa_map.rb

@@ -0,0 +1,177 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class UsaMap < MapObject
+  def build
+    atlanta, boston, calgary, charleston, chicago, dallas, denver, duluth,
+      el_paso, helena, houston, kansas_city, las_vegas, little_rock,
+      los_angeles, miami, montreal, nashville, new_orleans, new_york,
+      oklahoma_city, omaha, phoenix, pittsburgh, portland, raleigh, st_louis,
+      salt_lake_city, san_francisco, santa_fe, sault_ste_marie, seattle,
+      toronto, vancouver, washington, winnipeg = %w:
+    Atlanta  Boston  Calgary  Charleston  Chicago  Dallas  Denver  Duluth
+      El\ Paso  Helena  Houston  Kansas\ City  Las\ Vegas  Little\ Rock
+      Los\ Angeles  Miami  Montreal  Nashville  New\ Orleans  New\ York
+      Oklahoma\ City  Omaha  Phoenix  Pittsburgh  Portland  Raleigh  St\ Louis
+      Salt\ Lake\ City  San\ Francisco  Santa\ Fe  Sault\ Ste\ Marie  Seattle
+      Toronto  Vancouver  Washington  Winnipeg
+    :.map {|name| city(name) }
+    
+    ticket(4, denver, el_paso)
+    ticket(5, kansas_city, houston)
+    ticket(6, new_york, atlanta)
+    ticket(7, calgary, salt_lake_city)
+    ticket(7, chicago, new_orleans)
+    ticket(8, duluth, houston)
+    ticket(8, helena, los_angeles)
+    ticket(8, sault_ste_marie, nashville)
+    ticket(9, sault_ste_marie, oklahoma_city)
+    ticket(9, montreal, atlanta)
+    ticket(9, seattle, los_angeles)
+    ticket(9, chicago, santa_fe)
+    ticket(10, toronto, miami)
+    ticket(10, duluth, el_paso)
+    ticket(11, winnipeg, little_rock)
+    ticket(11, dallas, new_york)
+    ticket(11, portland, phoenix)
+    ticket(11, denver, pittsburgh)
+    ticket(12, boston, miami)
+    ticket(12, winnipeg, houston)
+    ticket(13, montreal, new_orleans)
+    ticket(13, calgary, phoenix)
+    ticket(13, vancouver, santa_fe)
+    ticket(16, los_angeles, chicago)
+    ticket(17, san_francisco, atlanta)
+    ticket(17, portland, nashville)
+    ticket(20, los_angeles, miami)
+    ticket(20, vancouver, montreal)
+    ticket(21, los_angeles, new_york)
+    ticket(22, seattle, new_york)
+    
+    route(denver, helena, 4, :green)
+    route(denver, kansas_city, 4, :black)
+    route(denver, kansas_city, 4, :orange)
+    route(denver, omaha, 4, :pink)
+    route(denver, oklahoma_city, 4, :red)
+    route(denver, phoenix, 5, :white)
+    route(denver, santa_fe, 2, :grey)
+    route(denver, salt_lake_city, 3, :red)
+    route(denver, salt_lake_city, 3, :yellow)
+    
+    route(pittsburgh, chicago, 3, :orange)
+    route(pittsburgh, chicago, 3, :black)
+    route(pittsburgh, new_york, 2, :white)
+    route(pittsburgh, new_york, 2, :green)
+    route(pittsburgh, nashville, 4, :yellow)
+    route(pittsburgh, raleigh, 2, :grey)
+    route(pittsburgh, st_louis, 5, :green)
+    route(pittsburgh, toronto, 2, :grey)
+    route(pittsburgh, washington, 2, :grey)
+    
+    route(atlanta, charleston, 2, :grey)
+    route(atlanta, miami, 5, :blue)
+    route(atlanta, nashville, 1, :grey)
+    route(atlanta, new_orleans, 4, :yellow)
+    route(atlanta, new_orleans, 4, :orange)
+    route(atlanta, raleigh, 2, :grey)
+    route(atlanta, raleigh, 2, :grey)
+    
+    route(duluth, chicago, 3, :red)
+    route(duluth, helena, 6, :orange)
+    route(duluth, omaha, 2, :grey)
+    route(duluth, omaha, 2, :grey)
+    route(duluth, sault_ste_marie, 3, :grey)
+    route(duluth, toronto, 6, :pink)
+    route(duluth, winnipeg, 4, :black)
+    
+    route(dallas, el_paso, 4, :red)
+    route(dallas, houston, 1, :grey)
+    route(dallas, houston, 1, :grey)
+    route(dallas, little_rock, 2, :grey)
+    route(dallas, oklahoma_city, 2, :grey)
+    route(dallas, oklahoma_city, 2, :grey)
+    
+    route(kansas_city, omaha, 1, :grey)
+    route(kansas_city, omaha, 1, :grey)
+    route(kansas_city, oklahoma_city, 2, :grey)
+    route(kansas_city, oklahoma_city, 2, :grey)
+    route(kansas_city, st_louis, 2, :blue)
+    route(kansas_city, st_louis, 2, :pink)
+    
+    route(san_francisco, los_angeles, 3, :yellow)
+    route(san_francisco, los_angeles, 3, :pink)
+    route(san_francisco, salt_lake_city, 5, :white)
+    route(san_francisco, salt_lake_city, 5, :orange)
+    route(san_francisco, portland, 5, :pink)
+    route(san_francisco, portland, 5, :green)
+    
+    route(seattle, calgary, 4, :grey)
+    route(seattle, helena, 6, :yellow)
+    route(seattle, portland, 1, :grey)
+    route(seattle, portland, 1, :grey)
+    route(seattle, vancouver, 1, :grey)
+    route(seattle, vancouver, 1, :grey)
+    
+    route(el_paso, houston, 6, :green)
+    route(el_paso, los_angeles, 6, :black)
+    route(el_paso, oklahoma_city, 5, :yellow)
+    route(el_paso, phoenix, 3, :grey)
+    route(el_paso, santa_fe, 2, :grey)
+    
+    route(montreal, boston, 2, :grey)
+    route(montreal, boston, 2, :grey)
+    route(montreal, new_york, 3, :blue)
+    route(montreal, sault_ste_marie, 5, :black)
+    route(montreal, toronto, 3, :grey)
+    
+    route(chicago, omaha, 4, :blue)
+    route(chicago, st_louis, 2, :green)
+    route(chicago, st_louis, 2, :white)
+    route(chicago, toronto, 4, :white)
+    
+    route(helena, calgary, 4, :grey)
+    route(helena, omaha, 5, :red)
+    route(helena, salt_lake_city, 3, :pink)
+    route(helena, winnipeg, 4, :blue)
+    
+    route(little_rock, nashville, 3, :white)
+    route(little_rock, new_orleans, 3, :green)
+    route(little_rock, oklahoma_city, 2, :grey)
+    route(little_rock, st_louis, 2, :grey)
+    
+    route(new_york, boston, 2, :yellow)
+    route(new_york, boston, 2, :red)
+    route(new_york, washington, 2, :black)
+    route(new_york, washington, 2, :orange)
+    
+    route(raleigh, charleston, 2, :grey)
+    route(raleigh, nashville, 3, :black)
+    route(raleigh, washington, 2, :grey)
+    route(raleigh, washington, 2, :grey)
+    
+    route(calgary, vancouver, 3, :grey)
+    route(calgary, winnipeg, 6, :white)
+    
+    route(las_vegas, los_angeles, 2, :grey)
+    route(las_vegas, salt_lake_city, 3, :orange)
+    
+    route(miami, charleston, 4, :pink)
+    route(miami, new_orleans, 6, :red)
+    
+    route(phoenix, los_angeles, 3, :grey)
+    route(phoenix, santa_fe, 3, :grey)
+    
+    route(sault_ste_marie, toronto, 2, :grey)
+    route(sault_ste_marie, winnipeg, 6, :grey)
+    
+    route(houston, new_orleans, 2, :grey)
+    
+    route(nashville, st_louis, 2, :grey)
+    
+    route(oklahoma_city, santa_fe, 3, :blue)
+    
+    route(portland, salt_lake_city, 6, :blue)
+  end
+end

data/lib/ttr/sample/script.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+# 
+# Copyright © 2011 Jesse Sielaff
+# 
+
+class Script
+  def Script.sample (game, player)
+    until player.turn_completed?
+      case rand
+        when 0...0.01
+          player.draw_tickets
+          a, b, c = player.candidate_tickets
+          player.keep_ticket(a)
+          player.keep_ticket(b) if rand < 0.1
+          player.keep_ticket(c) if rand < 0.1
+          player.discard_tickets
+        
+        when 0.01...0.1
+          game.unclaimed_routes.shuffle.any? do |route|
+            %w:black blue green orange pink red white yellow:.shuffle.any? do |color|
+              player.claim_n_wild(route, color.to_sym, rand(7))
+            end
+          end
+        
+        when 0.1...0.2
+          player.select_card(game.available_colors.sample)
+        
+        else
+          player.draw_random
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: ttr
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Jesse Sielaff
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-26 00:00:00 Z
+dependencies: []
+
+description: .
+email: jesse.sielaff@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/ttr/entities/city.rb
+- lib/ttr/entities/game.rb
+- lib/ttr/entities/opponent.rb
+- lib/ttr/entities/player.rb
+- lib/ttr/entities/route.rb
+- lib/ttr/entities/ticket.rb
+- lib/ttr/objects/card.rb
+- lib/ttr/objects/city.rb
+- lib/ttr/objects/colorful.rb
+- lib/ttr/objects/deck.rb
+- lib/ttr/objects/entity.rb
+- lib/ttr/objects/game.rb
+- lib/ttr/objects/map.rb
+- lib/ttr/objects/player.rb
+- lib/ttr/objects/route.rb
+- lib/ttr/objects/ticket.rb
+- lib/ttr/objects/usa_map.rb
+- lib/ttr/sample/script.rb
+- lib/ttr.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: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.8
+signing_key: 
+specification_version: 3
+summary: A simulator for AI scripts to play the popular train board game.
+test_files: []
+