127 lines
3.7 KiB
Ruby
127 lines
3.7 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
module ClashDeckGenerator2
|
|
module Services
|
|
class DeckGenerator
|
|
DEFAULT_RULES = {
|
|
deck_size: 8,
|
|
min_spells: 1,
|
|
min_troops: 1,
|
|
max_buildings: 2,
|
|
min_avg_elixir: 2.5,
|
|
max_avg_elixir: 5.0
|
|
}.freeze
|
|
|
|
SPECIAL_COMBINATIONS = [
|
|
{ evolutions: 1, specials: 2 },
|
|
{ evolutions: 2, specials: 1 }
|
|
].freeze
|
|
|
|
def initialize(cards_repo: ClashDeckGenerator2::Repos::CardsRepo.new, rules: {})
|
|
@cards_repo = cards_repo
|
|
@rules = DEFAULT_RULES.merge(rules)
|
|
end
|
|
|
|
def call
|
|
cards = unwrap_cards(@cards_repo.all)
|
|
|
|
raise "No cards found in DB" if cards.empty?
|
|
raise "Not enough cards to build a deck" if cards.size < @rules[:deck_size]
|
|
|
|
evolution_cards = cards.select { |card| card.rarity == "evolution" }
|
|
special_cards = cards.select { |card| %w[hero champion].include?(card.rarity) }
|
|
regular_cards = cards.reject { |card| ["evolution", "hero", "champion"].include?(card.rarity) }
|
|
|
|
def enough_win_conditions?(deck)
|
|
deck.count { |card| has_role?(card, "win_condition") } >= 1
|
|
end
|
|
|
|
def enough_anti_air?(deck)
|
|
deck.count { |card| has_role?(card, "anti_air") } >= 1
|
|
end
|
|
|
|
def has_role?(card, role)
|
|
@roles_repo.has_role?(card.name, role)
|
|
end
|
|
|
|
attempts = 1000
|
|
|
|
attempts.times do
|
|
combo = SPECIAL_COMBINATIONS.sample
|
|
|
|
next if evolution_cards.size < combo[:evolutions]
|
|
next if special_cards.size < combo[:specials]
|
|
|
|
chosen_evolutions = evolution_cards.sample(combo[:evolutions])
|
|
chosen_specials = special_cards.sample(combo[:specials])
|
|
|
|
used_names = (chosen_evolutions + chosen_specials).map(&:name)
|
|
|
|
remaining_pool = regular_cards.reject { |card| used_names.include?(card.name) }
|
|
remaining_needed = @rules[:deck_size] - chosen_evolutions.size - chosen_specials.size
|
|
|
|
next if remaining_pool.size < remaining_needed
|
|
|
|
chosen_regulars = remaining_pool.sample(remaining_needed)
|
|
|
|
deck = chosen_evolutions + chosen_specials + chosen_regulars
|
|
next unless valid_deck?(deck)
|
|
|
|
return deck.shuffle
|
|
end
|
|
|
|
raise "Failed to generate a valid deck after #{attempts} attempts"
|
|
end
|
|
|
|
private
|
|
|
|
def unwrap_cards(result)
|
|
if result.is_a?(Array) && result.first == :cards
|
|
result.last
|
|
else
|
|
result
|
|
end
|
|
end
|
|
|
|
def valid_deck?(deck)
|
|
return false unless deck.size == @rules[:deck_size]
|
|
return false unless unique_cards?(deck)
|
|
return false unless enough_spells?(deck)
|
|
return false unless enough_troops?(deck)
|
|
return false unless buildings_limit_ok?(deck)
|
|
return false unless avg_elixir_ok?(deck)
|
|
return false unless special_slots_ok?(deck)
|
|
|
|
true
|
|
end
|
|
|
|
def unique_cards?(deck)
|
|
deck.map(&:name).uniq.size == deck.size
|
|
end
|
|
|
|
def enough_spells?(deck)
|
|
deck.count { |card| card.type == "spell" } >= @rules[:min_spells]
|
|
end
|
|
|
|
def enough_troops?(deck)
|
|
deck.count { |card| card.type == "troop" } >= @rules[:min_troops]
|
|
end
|
|
|
|
def buildings_limit_ok?(deck)
|
|
deck.count { |card| card.type == "building" } <= @rules[:max_buildings]
|
|
end
|
|
|
|
def avg_elixir_ok?(deck)
|
|
avg = deck.sum(&:elixir_cost).to_f / deck.size
|
|
avg >= @rules[:min_avg_elixir] && avg <= @rules[:max_avg_elixir]
|
|
end
|
|
|
|
def special_slots_ok?(deck)
|
|
evolutions_count = deck.count { |card| card.rarity == "evolution" }
|
|
special_count = deck.count { |card| %w[hero champion].include?(card.rarity) }
|
|
|
|
[[1, 2], [2, 1]].include?([evolutions_count, special_count])
|
|
end
|
|
end
|
|
end
|
|
end |