Machen wir Draw Poker mit Ruby-Preparation- ↓ Machen wir Draw Poker mit Ruby-Test-Unit-Vorbereitung- ↓ Machen wir Draw Poker mit Ruby-Implementierung 1 (Karte) -
Gefolgt von.
Quelle: https://github.com/rytkmt/ruby_poker
Dieses Mal werden wir die Rolle implementieren.
Lassen Sie uns die Anforderungen neu organisieren.
Es ist also Zeit zu implementieren.
Erstellen Sie zunächst eine normale Datei
ruby_poker/hand.rb
module RubyPoker
class Hand
def intialize(cards:)
end
end
end
ruby_poker.rb
require "ruby_poker/hand"
Wenn Sie eine "Rollen" -Klasse generieren, sollten Sie zu diesem Zeitpunkt ein Urteil fällen. ..
Verwenden Sie daher zum Zeitpunkt der Generierung die Beurteilungsmethode und legen Sie die Vergleichskarte für den Typ und dieselbe Rolle fest.
ruby_poker/hand.rb
attr_reader :hand_type, :comparison_card
def intialize(cards:)
raise(ArgumentError) if cards.size != 5
@hand_type, @comparison_card = judge(cards: cards)
end
private
def judge(cards:)
end
Machen Sie es nicht zu einer Instanzvariablen, da Sie es nicht einfach behalten müssen, indem Sie Karten verwenden, um die Rolle zu beurteilen.
So implementieren Sie ein Rollenurteil ...
Da es viele Rollen gibt, habe ich das Gefühl, dass ich sie nicht durch die Vorbereitung von Methoden nacheinander trennen konnte. .. Lassen Sie es uns also als Beurteilungsmodul herausschneiden.
Dann sollte das Urteil in der Reihenfolge der Stärke getroffen werden, und das am Anfang übereinstimmende sollte festgelegt werden. Definieren Sie es zunächst wie für die Karte.
Siehe hier für englische Namen ... lol https://en.wikipedia.org/wiki/List_of_poker_hands
ruby_poker.rb
HAND_TYPES = %i[
royal_straight_flush
straight_flush
four_of_a_kind
full_house
flush
straight
three_of_a_kind
two_pair
one_pair
high_card
].reverse.freeze
Ich möchte die Modulklasse dynamisch erhalten, also möchte ich von Schlangenfall zu Kamelfall konvertieren und sie mit const_get erhalten. ..
Verwenden wir also das Juwel "active_support" für die Wortkonvertierung
(Wenn ich normalerweise Schienen berühre, ist es praktisch, den juckenden Ort hier zu erreichen, und ich möchte ihn verwenden.)
Gemfile
gem "activesupport"
$ bundle install
Damit ist die Installation abgeschlossen
ruby_poker.rb
require "active_support/all"
Vergiss nicht zu lesen
ruby_poker/hand.rb
Dir[__dir__ + "/hand/hand_type_judgers/*.rb"].each { |p| require p }
module RubyPoker
class Hand
ruby_poker/hand.rb
private
def judge(cards:)
matched_cards = nil
matched_type = RubyPoker::HAND_TYPES.find do |type|
judger = RubyPoker::Hand::HandTypeJudgers.const_get(type.to_s.classify) # <=Aktiv für hier_support
matched_cards = judger.judge(cards: cards)
end
[matched_type, matched_cards.max]
end
Ich dachte, dass es in der Verantwortung der Hand liegt, die interne Verarbeitung der Hand zu trennen, also werde ich es als inneres Modul der Hand implementieren Judgers ".judge" gibt immer die Karte zurück, die das Ziel derselben Rollenbeurteilung ist, wenn sie übereinstimmt, und gibt null zurück, wenn sie nicht übereinstimmt
ruby_poker/lib/ruby_poker/hand/hand_type_judgers/royal_straight_flush.rb
module RubyPoker
class Hand
module HandTypeJudgers
module RoyalStraightFlush
def self.judge(cards:)
return nil unless cards.map(&:suit).uniq.size == 1
return nil unless cards.sort.map(&:number) == [10, 11, 12, 13, 1]
cards
end
end
end
end
end
ruby_poker/lib/ruby_poker/hand/hand_type_judgers/straight_flush.rb
module RubyPoker
class Hand
module HandTypeJudgers
module StraightFlush
def self.judge(cards:)
return nil unless cards.map(&:suit).uniq.size == 1
min_number_level = cards.min.number_level
expected = [*min_number_level..min_number_level + 4]
return nil unless cards.sort.map(&:number_level) == expected
cards
end
end
end
end
end
ruby_poker/lib/ruby_poker/hand/hand_type_judgers/four_of_a_kind.rb
module RubyPoker
class Hand
module HandTypeJudgers
module FourOfAKind
def self.judge(cards:)
cards.group_by(&:number).detect { |k, v| v.size == 4 }&.second
end
end
end
end
end
ruby_poker/lib/ruby_poker/hand/hand_type_judgers/full_house.rb
module RubyPoker
class Hand
module HandTypeJudgers
module FullHouse
def self.judge(cards:)
grouped_number_cards = cards.group_by(&:number)
three_card_number, three_cards = grouped_number_cards.detect { |k, v| v.size == 3 }
return nil unless three_card_number
grouped_number_cards.delete(three_card_number)
return nil unless grouped_number_cards.detect { |k, v| v.size == 2 }
three_cards
end
end
end
end
end
ruby_poker/lib/ruby_poker/hand/hand_type_judgers/flush.rb
module RubyPoker
class Hand
module HandTypeJudgers
module Flush
def self.judge(cards:)
return nil unless cards.map(&:suit).uniq.size == 1
cards
end
end
end
end
end
ruby_poker/lib/ruby_poker/hand/hand_type_judgers/straight.rb
module RubyPoker
class Hand
module HandTypeJudgers
module Straight
def self.judge(cards:)
min_number_level = cards.min.number_level
expected = [*min_number_level..min_number_level + 4]
return nil unless cards.sort.map(&:number_level) == expected
cards
end
end
end
end
end
ruby_poker/lib/ruby_poker/hand/hand_type_judgers/three_of_a_kind.rb
module RubyPoker
class Hand
module HandTypeJudgers
module ThreeOfAKind
def self.judge(cards:)
cards.group_by(&:number).detect { |k, v| v.size == 3 }&.second
end
end
end
end
end
ruby_poker/lib/ruby_poker/hand/hand_type_judgers/two_pair.rb
module RubyPoker
class Hand
module HandTypeJudgers
module TwoPair
def self.judge(cards:)
pairs = cards.group_by(&:number_level).select { |k, v| v.size == 2 }
return nil unless pairs.size == 2
pairs.max.second
end
end
end
end
end
ruby_poker/lib/ruby_poker/hand/hand_type_judgers/one_pair.rb
module RubyPoker
class Hand
module HandTypeJudgers
module OnePair
def self.judge(cards:)
cards.group_by(&:number_level).detect { |k, v| v.size == 2 }&.second
end
end
end
end
end
ruby_poker/lib/ruby_poker/hand/hand_type_judgers/high_card.rb
module RubyPoker
class Hand
module HandTypeJudgers
module HighCard
def self.judge(cards:)
[cards.max]
end
end
end
end
end
Es war ein wenig schwierig, einschließlich der Testimplementierung, aber die Implementierung wurde abgeschlossen. Jetzt können Sie die Rollenbeurteilung durchführen und gleichzeitig die Beurteilungskarte zurückgeben.
ruby_poker/hand.rb
+ include Comparable
ruby_poker/hand.rb
def hand_level
RubyPoker::HAND_TYPES.reverse.index(@hand_type)
end
def <=>(other)
hand_comparison = hand_level <=> other.hand_level
hand_comparison.zero? ? @comparison_card <=> other.comparison_card : hand_comparison
end
Jetzt können Sie die Gewinne und Verluste von Rollen mit > usw. vergleichen.
Mit diesem Inhalt denke ich, dass alle wichtigen Verarbeitungen für das Spiel wie Karten und Rollen abgeschlossen sind. Das nächste Mal möchte ich Spieler erstellen, die diese und den Spielfortschritt nutzen.
↓ Machen wir Draw Poker mit Ruby-Implementierung 3 (Spieler) -
Recommended Posts