Lassen Sie uns mit Ruby Draw Poker machen ~ Implementierung 1 (Karte) ~

Überblick

Machen wir Draw Poker mit Ruby-Preparation- ↓ Machen wir Draw Poker mit Ruby-Test-Unit-Vorbereitung-

Gefolgt von.

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

Ab diesem Zeitpunkt werde ich endlich mit der Implementierung beginnen.

Kartenmontage

Ich denke, dass das einzige bewegliche Ende beim Poker eine Karte ist, also werde ich es von der Karte machen. Lassen Sie uns die Informationen organisieren.

--Nummer --Soothe (Symbol)

Zuallererst halten es alle Karten, also implementieren Sie dies.

Generieren

• Um alle Karten zu generieren, müssen Sie in diesem Fall die Nummer und den Ruß übergeben. Verwenden Sie sie daher als Argument für "Initialisieren"
• Obwohl Zahlen und Ruß von außen referenziert werden können, können sie nicht geändert werden.

ruby_poker/card.rb

module RubyPoker
  class Card
    attr_reader :suit, :number

    def initialize(suit:, number:)
      @suit = suit
      @number = number
    end
  end
end

Und lesen Sie für eine neue Datei

ruby_poker.rb

require "ruby_poker/card"

Ich denke, dies ist das Ende und denke darüber nach, wann ich die Karte das nächste Mal benutze.

Vergleich

Karten verwenden Zahlen und Ruß, um "Rollen" zu erstellen, und die Rolle wird beurteilt. Reicht es also aus, sich auf die Karte zu beziehen? Ich dachte auch, Wenn Sie die Erklärung der Rolle im Detail überprüfen, wird gesagt, dass es Stärken und Schwächen zwischen den Karten gibt, z. B. die Beurteilung anhand der Stärke der Karten, die in der Rolle bei derselben Rolle verwendet werden.

Zum Beispiel im Fall von "zwei Karten" ―― Je höher die Zahl, desto besser ――Wenn die Zahlen gleich sind, gewinnt derjenige mit dem stärkeren Ruß

Wie im Vorbereitungsabschnitt bestätigt, lautet die Reihenfolge wie folgt.

――Wenn zwei Spieler dieselbe Rolle spielen, gewinnt die stärkere Karte, aus der die Rolle besteht.

• Die starke Rangfolge der Karten ist A, K, Q, J, 10 ~ 2. ――Das starke Ranking von Ruß ist Spade Heart Diamond Clover

Da es anscheinend an der Elementnummer des Arrays gemessen werden kann, definieren Sie es (da die Definitionen in der Reihenfolge ihrer Stärke angeordnet sind, kehren Sie die Reihenfolge um, wenn Sie den Index verwenden).

ruby_poker.rb

module RubyPoker
  NUMBERS = ([1] + [*2..13].reverse).freeze
  SUITS = %i[spade heart diamond club].freeze
end

Da es eine große Sache ist, verwende ich es auch zur Argumentationsprüfung auf der Seite "card.rb"

ruby_poker/card.rb

    def initialize(suit:, number:)
+      raise(ArgumentError) unless RubyPoker::SUITS.include?(suit)
+      raise(ArgumentError) unless RubyPoker::NUMBERS.include?(number)

Als Anwendungsfall zur Beurteilung der Stärke des Elements wurde Folgendes berücksichtigt.

1. Welche der stärksten Karten in Ihrer Hand wurde verwendet (zum Beispiel beim Vergleich von Geraden)?
2. Vergleich zwischen den stärksten Karten im Vergleich zur Rolle des Feindes

In Bezug auf 1 möchte ich das stärkste von mehreren nehmen, also "max" In Bezug auf 2, großer und kleiner Vergleich > usw.

Daher kann es gelöst werden, indem "<=>" mit "Comparable" implementiert wird ("max" wird durch "<=>" Array # max bestimmt. ja / latest / method / Array / i / max.html))

Wenn Sie die Zahlen mit einfachen Zahlen vergleichen, ist "1" die schwächste. Vergleichen Sie also richtig anhand des "Index"

ruby_poker/card.rb

module RubyPoker
  class Card
+   include Comparable
    attr_reader :suit, :number

ruby_poker/card.rb

    def suit_level
      RubyPoker::SUITS.reverse.index(@suit)
    end

    def number_level
      RubyPoker::NUMBERS.reverse.index(@number)
    end

    def <=>(other)
      number_comparision = number_level <=> other.number_level
      number_comparision.zero? ? suit_level <=> other.suit_level : number_comparision
    end

Testfall

Testfälle einfach implementieren * Testeinheit ist das erste Mal. Bitte sagen Sie mir, ob es eine gute Möglichkeit gibt, dies zu beschreiben

require "test_helper"

module RubyPoker
  class CardTest < Test::Unit::TestCase
    sub_test_case "#initialize" do
      test "correct arguments" do
        assert_nothing_raised do
          Card.new(suit: :heart, number: 3)
        end
      end

      test "wrong suit" do
        assert_raise_kind_of(ArgumentError) do
          Card.new(suit: :test, number: 3)
        end
      end

      test "wrong number" do
        assert_raise_kind_of(ArgumentError) do
          Card.new(suite: :heart, number: 14)
        end
      end
    end

    sub_test_case "#<=>" do
      sub_test_case "compare number" do
        test "simple numbers" do
          a = Card.new(suit: :heart, number: 8)
          b = Card.new(suit: :heart, number: 2)
          assert(a > b)
        end

        test "compare ace" do
          a = Card.new(suit: :heart, number: 13)
          b = Card.new(suit: :heart, number: 1)
          assert(a < b)
        end

        test "max number" do
          cards = [*1..5]
            .shuffle
            .map { |i| Card.new(suit: :heart, number: i) }

          assert_equal(1, cards.max.number)
        end
      end

      sub_test_case "compare suit(same number)" do
        test "spade and heart" do
          a = Card.new(suit: :spade, number: 1)
          b = Card.new(suit: :heart, number: 1)
          assert(a > b)
        end

        test "heart and club" do
          a = Card.new(suit: :club, number: 1)
          b = Card.new(suit: :heart, number: 1)
          assert(a < b)
        end

        test "spade and diamond" do
          a = Card.new(suit: :spade, number: 1)
          b = Card.new(suit: :diamond, number: 1)
          assert(a > b)
        end
      end
    end
  end
end

Ist dies vorerst das Ende der Karte?

Fortsetzung

↓ Machen wir Draw Poker mit Ruby-Implementierung 2 (Rolle) -