Faisons tirer le poker avec ruby ~ Implémentation 3 (joueur) ~

Aperçu

Faisons dessiner du poker avec ruby-Preparation- ↓ Faisons dessiner du poker avec la préparation de ruby-test-unit- ↓ Faisons tirer le poker avec ruby-Implementation 1 (carte) - ↓ Faisons tirer le poker avec ruby-Implementation 2 (rôle) -

Suivi par.

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

Cette fois, j'aimerais commencer à implémenter des joueurs qui gèrent les cartes et les rôles.

Implémentation du joueur

Tout d'abord, trions les exigences.

―― Obtenez 5 cartes au début

• Juger le rôle
• Échangez n'importe quel nombre de cartes ――Jugez à nouveau le rôle
• Juger la victoire ou la défaite du joueur ――En effet, déterminez le rôle du joueur

Créer un fichier

ruby_poker/player.rb

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

Cela a été fait jusqu'à ce que le rôle soit jugé par la carte que j'ai reçue.

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

N'oubliez pas d'exiger, mais j'avais envie d'ajouter un fichier à la fois, alors je l'ai changé pour tout lire.

Échange de cartes

Mettez ensuite en œuvre le remplacement de n'importe quelle carte.

--Jeter les cartes inutiles

• Obtenez une nouvelle carte
• Juger à nouveau le rôle avec une nouvelle carte

Lors de l'échange de cartes, j'obtiendrai le numéro d'élément et je le supprimerai. À ce stade, comme il est supprimé par le numéro d'élément, si vous supprimez du plus petit, l'élément sera désaligné de ce montant et ce sera étrange. Par conséquent, vous devez supprimer du plus grand nombre, alors implémentez-le soigneusement. Vérification)

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]

Puisque les cartes doivent être obtenues à partir du paquet, j'ai pensé que la gamme de responsabilités du joueur serait réduite si j'avais de nouvelles cartes autant que le nombre de cartes à défausser. Alors implémentons-le de cette façon (bien que nous puissions le changer plus tard) 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

Jugement de victoire / perte du joueur

Nous utiliserons à nouveau «Comparable». En fin de compte, il sera jugé par le rôle, donc je vais le déléguer.

~~ delegate a la méthode delegate étendue à Module dans ʻactive_support. ~~ ~~ Class est une sous-classe de Module, vous pouvez donc également utiliser delegate`. ~~

ruby_poker/player.rb

    delegate :<=>, to: :@hand

↑ Ce n'était pas bon. .. Si l'autre de <=> est un délégué tel quel, il sera passé à la main, donc je comparerai ma main avec l'autre joueur.

ruby_poker/player.rb

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

Je l'ai implémenté tranquillement et normalement. ..

C'est tout. C'est facile

À la fin

Cette fois, nous n'avons implémenté que le traitement fonctionnel lié au gain et à la défaite. À partir de là, compte tenu de la progression du jeu, il est nécessaire de l'implémenter autour de la sortie de la console, mais je voudrais l'ajouter au moment de considérer la prochaine progression.

A continué

↓ Faisons tirer le poker avec ruby-Implementation 4 (Deck) -