Faisons tirer le poker avec ruby ~ Implémentation 1 (carte) ~

Aperçu

Faisons dessiner au poker avec ruby-Preparation- ↓ Faisons dessiner du poker avec la préparation de ruby-test-unit-

Suivi par.

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

À partir de ce moment, je vais enfin commencer à l'implémenter.

Montage de la carte

Je pense que l'extrémité mobile la plus simple au poker est une carte, donc je vais la faire à partir de la carte. Organisons les informations.

--Nombre --Soothe (symbole)

Tout d'abord, toutes les cartes le contiennent, alors implémentez ceci.

produire

Afin de générer toutes les cartes, dans ce cas, assurez-vous de passer des nombres et de la suie, utilisez donc ʻinitialize` comme argument. --Bien que les nombres et les suies puissent être référencés de l'extérieur, ils ne peuvent pas être modifiés.

`ruby_poker/card.rb`


module RubyPoker
  class Card
    attr_reader :suit, :number

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

Et lisez pour un nouveau fichier

`ruby_poker.rb`


require "ruby_poker/card"

Je pense que c'est la fin et pense à la prochaine fois que j'utiliserai la carte.

Comparaison

Les cartes utilisent des nombres et de la suie pour créer des «rôles», et le rôle est jugé, alors suffit-il de se référer à la carte? J'ai aussi pensé, Si vous vérifiez l'explication du rôle en détail, il est dit qu'il y a des forces et des faiblesses entre les cartes, comme le jugement en fonction de la force des cartes utilisées dans le rôle dans le cas du même rôle.

Par exemple, dans le cas de «deux cartes» --Plus le nombre est élevé mieux c'est ――Si les chiffres sont les mêmes, celui avec la suie la plus forte l'emporte

Comme confirmé dans la section préparation, l'ordre est le suivant.

――Si deux joueurs jouent le même rôle, la carte la plus forte qui compose le rôle l'emporte.

Le classement fort des cartes est A, K, Q, J, 10 ~ 2. ――Le classement fort de Soot est Spade Heart Diamond Clover

Puisqu'il semble qu'il puisse être jugé par le numéro d'élément du tableau, définissez-le (puisque les définitions sont disposées par ordre de force, inversez l'ordre lors de la prise d'index)

`ruby_poker.rb`


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

De plus, comme c'est un gros problème, je l'utilise également pour la vérification des arguments du côté card.rb

`ruby_poker/card.rb`


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

En outre, comme cas d'utilisation pour juger de la force de l'élément, les éléments suivants ont été pris en compte.

Laquelle des cartes les plus fortes de votre main a été utilisée (par exemple, lors de la comparaison de quintes)
Comparaison entre les cartes les plus fortes en comparaison avec le rôle de l'ennemi

Concernant 1, je veux prendre le plus fort parmi plusieurs, donc max En ce qui concerne 2, grande et petite comparaison > etc.

Donc, si vous utilisez Comparable et implémentez <=>, il sera résolu (max est jugé par<=>Array # max ja / dernier / method / Array / i / max.html))

Si vous comparez des nombres avec des nombres simples, «1» sera le plus faible, alors comparez correctement en fonction de «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

cas de test

Implémentez facilement des cas de test * test-unit est la première fois, alors dites-moi s'il existe une bonne façon de le décrire

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

Est-ce la fin de la carte pour le moment?

A continué

↓ Faisons tirer le poker avec ruby-Implementation 2 (rôle) -