Class: SplendorGame::Game

Inherits:
Object show all
Defined in:
lib/splendor_game/game.rb,
lib/splendor_game/load_cards.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(user_options = nil) ⇒ Game

Returns a new instance of Game.



15
16
17
18
19
20
21
 
# File 'lib/splendor_game/game.rb', line 15

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

Instance Attribute Details

#bank ⇒ Object (readonly)

Returns the value of attribute bank.



14
15
16
 
# File 'lib/splendor_game/game.rb', line 14

def bank
  @bank
end

#deck ⇒ Object (readonly)

Returns the value of attribute deck.



14
15
16
 
# File 'lib/splendor_game/game.rb', line 14

def deck
  @deck
end

#display ⇒ Object (readonly)

Returns the value of attribute display.



14
15
16
 
# File 'lib/splendor_game/game.rb', line 14

def display
  @display
end

#nobles ⇒ Object (readonly)

Returns the value of attribute nobles.



14
15
16
 
# File 'lib/splendor_game/game.rb', line 14

def nobles
  @nobles
end

#options ⇒ Object (readonly)

Returns the value of attribute options.



14
15
16
 
# File 'lib/splendor_game/game.rb', line 14

def options
  @options
end

#players ⇒ Object (readonly)

Returns the value of attribute players.



14
15
16
 
# File 'lib/splendor_game/game.rb', line 14

def players
  @players
end

#turns ⇒ Object (readonly)

Returns the value of attribute turns.



14
15
16
 
# File 'lib/splendor_game/game.rb', line 14

def turns
  @turns
end

Instance Method Details

#add_player(player_name) ⇒ Object 



23
24
25
26
27
 
# File 'lib/splendor_game/game.rb', line 23

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

#all_displayed_cards ⇒ Object 



58
59
60
 
# File 'lib/splendor_game/game.rb', line 58

def all_displayed_cards
  @display.values.flatten
end

#game_over? ⇒ Boolean

Returns:

  • (Boolean) 


38
39
40
41
42
 
# File 'lib/splendor_game/game.rb', line 38

def game_over?
  return false if @players.map { |p| p.points }.max < @options[:winning_score]
  return true if @players[1] == @starting_player
  false
end

#load_cards ⇒ Object

Could read from an external file eventually, but this works just fine :)



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/splendor_game/load_cards.rb', line 4

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

#next_player ⇒ Object 



29
30
31
32
33
34
35
36
 
# File 'lib/splendor_game/game.rb', line 29

def next_player
  if !@turns.empty?
    @players.rotate!
    return @players.first
  end
  @players.shuffle!
  @starting_player = @players.first
end

#next_turn ⇒ Object 



51
52
53
54
55
56
 
# File 'lib/splendor_game/game.rb', line 51

def next_turn
  return false if game_over? || !defined? @display
  t = SplendorGame::Turn.new(self, next_player)
  @turns << t
  t
end

#noble_sample(number_of_cards_to_load) ⇒ Object 



111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/splendor_game/load_cards.rb', line 111

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

#start_game ⇒ Object 



44
45
46
47
48
49
 
# File 'lib/splendor_game/game.rb', line 44

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