Lassen Sie uns mit Ruby Draw Poker machen ~ Implementierung 3 (Spieler) ~

Überblick

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) - ↓ Machen wir Draw Poker mit Ruby-Implementierung 2 (Rolle) -

Gefolgt von.

Quelle: https://github.com/rytkmt/ruby_poker

Dieses Mal möchte ich Spieler implementieren, die mit Karten und Rollen umgehen.

Player-Implementierung

Lassen Sie uns zunächst die Anforderungen klären.

――Erhalten Sie am Anfang 5 Karten

• Beurteilen Sie die Rolle
• Tauschen Sie eine beliebige Anzahl von Karten aus »Beurteilen Sie die Rolle erneut
• Beurteilen Sie den Sieg oder die Niederlage des Spielers ――In der Tat bestimmen Sie die Rolle des Spielers

Eine Datei erstellen

ruby_poker/player.rb

module RubyPoker
  class Player
    def initialize(cards:)
      @cards = cards
      @hand = Hand.new(cards: cards)
    end
  end
end

Dies geschah, bis die Rolle anhand der Karte beurteilt wurde, die ich erhalten hatte.

ruby_poker.rb

require "ruby_poker/version"
require "active_support/all"
-require "ruby_poker/card"
-require "ruby_poker/hand"
+Dir[__dir__ + "/ruby_poker/*.rb"].each { |p| require p }

module RubyPoker

Vergessen Sie nicht zu verlangen, aber ich wollte jeweils eine Datei hinzufügen, also habe ich sie geändert, um alle zu lesen.

Kartentausch

Implementieren Sie dann den Austausch einer beliebigen Karte.

• Verwerfen Sie unnötige Karten
• Holen Sie sich eine neue Karte
• Beurteilen Sie die Rolle erneut mit einer neuen Karte

Beim Kartenaustausch erhalte ich die Elementnummer und lösche sie. Zu diesem Zeitpunkt wird das Element um diesen Betrag falsch ausgerichtet, da es durch die Elementnummer gelöscht wird. Wenn Sie es von der kleinsten löschen, ist es seltsam. Daher müssen Sie aus der größten Anzahl löschen, also implementieren Sie es sorgfältig. Überprüfung)

x = %i[a b c d e]
# a & c & d    =>   [b, e]
indexes = [0, 2, 3]

indexes.each { |i| x.delete_at(i); p x }
# => [:b, :c, :d, :e]
# => [:b, :c, :e]
# => [:b, :c, :e]

x = %i[a b c d e]
indexes.sort.reverse_each { |i| x.delete_at(i); p x }
# => [:a, :b, :c, :e]
# => [:a, :b, :e]
# => [:b, :e]

Da die Karten vom Stapel bezogen werden müssen, dachte ich, dass sich der Verantwortungsbereich des Spielers verringern würde, wenn ich neue Karten für die Anzahl der zu verwerfenden Karten erhalten würde. Implementieren wir es also so (obwohl wir es später ändern können) k

ruby_poker/player.rb

    def change(indexes:, new_cards:)
      raise(ArgumentError) unless indexes.size == new_cards.size
      raise(ArgumentError) unless indexes.all? { |i| (0..4).include?(i) }

      indexes.sort.reverse_each { |i| @cards.delete_at(i) }
      @cards += new_cards
      @hand = Hand.new(cards: @cards)
    end

Gewinn / Verlust-Urteil des Spielers

Wir werden Comparable wieder verwenden. Am Ende wird es nach der Rolle beurteilt, also werde ich es delegieren.

~~ delegate ist active_support und Module hat eine delegate Methode als Erweiterung. ~~ ~~ Class ist eine Unterklasse von Module, daher können Sie auch delegate verwenden. ~~

ruby_poker/player.rb

    delegate :<=>, to: :@hand

↑ Es war nicht gut. .. Wenn der andere von <=> ein Delegierter ist, wird er an die Hand weitergegeben, sodass ich meine Hand mit der des anderen Spielers vergleiche.

ruby_poker/player.rb

    attr_reader :hand
    def <=>(other)
      @hand <=> other.hand
    end

Ich habe es leise und normal implementiert. ..

Das ist es. Es ist einfach

Am Ende

Dieses Mal haben wir nur die funktionale Verarbeitung implementiert, die sich auf das Gewinnen und Verlieren bezieht. In Anbetracht des Fortschritts des Spiels ist es von hier aus notwendig, die Konsolenausgabe zu implementieren, aber ich möchte sie zum Zeitpunkt der Prüfung des nächsten Fortschritts hinzufügen.

Fortsetzung

↓ Machen wir Draw Poker mit Ruby-Implementierung 4 (Deck) -