J'ai fait un blackjack avec Ruby (j'ai essayé d'utiliser minitest)

J'ai fait un blackjack avec Ruby (j'ai essayé d'utiliser minitest)

Ce à quoi je pensais quand j'ai écrit la structure du fichier et le code

• ** card.rb (classe de carte) **

• J'ai utilisé attr_reader pour que les données de chaque carte ne puissent pas être réécrites (afin que les données ne soient pas corrompues).

• ** deck.rb (classe de pont) ** --Au stade de l'instanciation, je me suis assuré que le deck était mélangé et l'ai testé.

• J'ai écrit la génération de deck de manière aussi concise que possible en utilisant chaque déclaration.

• En utilisant des variables de classe, lorsque vous piochez une carte, il compte maintenant le nombre de cartes de votre deck qui sont tirées.

• ** player.rb (classe de joueur) ** --Commun aux joueurs et aux concessionnaires, afin d'utiliser le même deck, j'ai assigné une instance du deck à la variable de classe et utilisé le deck.

• ** juge.rb (classe de jugement) ** ――La classe pour juger, par souci de clarté, j'ai osé utiliser un module séparément du lecteur.

• ** test.rb (test de contrôle de fonctionnement) ** --minitest est * "Introduction à Ruby pour ceux qui veulent devenir un professionnel" *, et je ne l'ai pas utilisé depuis que je l'ai écrit, donc je l'ai utilisé pour approfondir ma compréhension.

• ** main.rb (fichier principal qui exécute le blackjack) **

• Pour plus de clarté, je n'ai d'abord écrit que le flux global du jeu À partir de là, j'ai pensé aux classes et méthodes nécessaires et les ai ajoutées.

règle

--Pas de lit. (Prévu pour être mis en œuvre à une date ultérieure)

• "A" est reconnu comme "1" (sera converti en 10 à une date ultérieure)
• Frapper ou se tenir debout seulement ―― Celui avec le score total le plus élevé gagne

card.rb (classe de carte)

card.rb

class Card 
    attr_reader :mark, :number
    def initialize(mark, number)
        @mark   = mark.freeze
        @number = number.freeze
    end

    def convert
        if @number == 'J' || @number == 'Q' || @number == 'K'
            10
        elsif @number == 'A'
            1
        else
            @number.to_i
        end
    end
end

deck.rb (classe de pont)

deck.rb

require './card'

class Deck
    attr_accessor :cards
    @@draw_count = 0

    def initialize
        @cards = []
        create
        @cards = @cards.shuffle
    end

    def create
        nums = ['A', 2, 3, 4, 5, 6, 7, 8, 9, 10, 'J', 'Q', 'K']
        mark = ['❤︎', '♦︎', '♤', '♧']
        mark.each do |m|
            nums.each do |n|
                @cards << Card.new(m, n)
            end
        end
    end

    def draw
        cards[@@draw_count]
    end

    def draw_count
        @@draw_count += 1
    end

    #Méthode de référence de la carte pour les tests
    def show
        52.times do |n|
            puts "[ #{cards[n].mark} #{cards[n].number} ]"
        end
    end
end

player.rb (classe de joueur)

player.rb

require './deck'
require './judge'


class Player
    include Judge
    attr_accessor :hands, :total_score, :name
    @@deck = Deck.new
    def initialize(name: "joueur")
        @hands = []
        @total_score = 0
        @name = name
    end

    def draw
        self.hands << @@deck.draw
        self.total_score += @@deck.draw.convert
        @@deck.draw_count
    end

    
    def show
        puts "#{self.name}Est dans ta main"
        self.hands.each do |hand|
            puts "[ #{hand.mark} #{hand.number} ]"
        end
        puts "[Score total#{@total_score} ]"
    end

    #Méthode d'essai

    def test
        puts "Test --------"
    end

    def total_score_calc
        self.hands.each do |hand|
            @total_score += hand.convert
        end
        #puts "total"#{@total_score}」" 
    end

    def reset
        self.hands = []
        self.total_score = 0
    end

    def in_blackjack
        self.hands << Card.new("♦︎", "J")
        self.hands << Card.new("♦︎", "A")
    end
end

juge.rb (classe de jugement)

judge.rb

module Judge
    # def game_judge(target)
    #     if self.total_score > target.total_score
    #         puts "Votre score total[ #{self.total_score} ]"
    #         puts "Score total du concessionnaire[ #{target.total_score} ]"
    #         puts 'Vous gagnez'
    #     elsif self.total_score == target.total_score
    #         puts "Votre score total[ #{self.total_score} ]"
    #         puts "Score total du concessionnaire[ #{target.total_score} ]"
    #         puts 'C'est un tirage au sort'
    #     else
    #         puts "Votre score total[ #{self.total_score} ]"
    #         puts "Score total du concessionnaire[ #{target.total_score} ]"
    #         puts 'Tu as perdu'
    #     end
    # end

    def blackjack?
        if self.hands[1].number == "A" || self.hands[0].number == "A" 
            if  self.hands[0].number == "J" || self.hands[0].number == "Q"|| self.hands[0].number == "K" || \
                self.hands[1].number == "J" || self.hands[1].number == "Q"|| self.hands[1].number == "K"
                self.total_score = "Jack noir"
                true
            else
                false
            end
        else
            false
        end
    end

    def burst?
        if self.total_score > 21
            true
        else
            false
        end
    end
end

test.rb (test de contrôle de fonctionnement)

test.rb

require 'minitest/autorun'
require './player'
class BlackJackTest < Minitest::Test
    #La marque sur la carte de test est unifiée avec "♦ ︎"
    @@test_J      = Card.new('♦︎', 'J')
    @@test_Q      = Card.new('♦︎', 'Q')
    @@test_K      = Card.new('♦︎', 'K')
    @@test_A      = Card.new('♦︎', 'A')
    @@test_5      = Card.new('♦︎', 5)
    @@test_10     = Card.new('♦︎', 10)
    @@test_player = Player.new

    def test_blackjack?
        blackjack_player = Player.new
        blackjack_player.hands << @@test_A
        blackjack_player.hands << @@test_J
        assert blackjack_player.blackjack?

        blackjack_player.reset
        blackjack_player.hands << @@test_J
        blackjack_player.hands << @@test_A
        assert blackjack_player.blackjack?

        blackjack_player.reset
        blackjack_player.hands << @@test_Q
        blackjack_player.hands << @@test_A
        assert blackjack_player.blackjack?

        blackjack_player.reset
        blackjack_player.hands << @@test_A
        blackjack_player.hands << @@test_Q
        assert blackjack_player.blackjack?

        blackjack_player.reset
        blackjack_player.hands << @@test_A
        blackjack_player.hands << @@test_K
        assert blackjack_player.blackjack?

        blackjack_player.reset
        blackjack_player.hands << @@test_K
        blackjack_player.hands << @@test_A
        assert blackjack_player.blackjack?

        #faux motif
        # blackjack_player.reset
        # blackjack_player.hands << @@test_A
        # blackjack_player.hands << @@test_10
        # assert blackjack_player.blackjack?

        # blackjack_player.reset
        # blackjack_player.hands << @@test_5
        # blackjack_player.hands << @@test_5
        # assert blackjack_player.blackjack?

        # blackjack_player.reset
        # blackjack_player.hands << @@test_J
        # blackjack_player.hands << @@test_Q
        # assert blackjack_player.blackjack?
        

    end

    def test_burst?
        burst_player = Player.new
        burst_player.hands << @@test_J
        burst_player.hands << @@test_J
        burst_player.hands << @@test_5
        burst_player.total_score_calc
        burst_player.total_score
        assert burst_player.burst?
        # false
        # burst_player.reset
        # burst_player.hands << @@test_10
        # burst_player.total_score
        # assert burst_player.burst?
    end

    def test_total_score_calc
        total_score_calc_player = Player.new
        total_score_calc_player.hands << @@test_10
        total_score_calc_player.hands << @@test_5
        total_score_calc_player.total_score_calc
        assert_equal 15, total_score_calc_player.total_score
        # false
        #assert_equal 10, total_score_calc_player.total_score
    end

    def test_convert
        assert_equal 10, @@test_J.convert
        assert_equal 10, @@test_Q.convert
        assert_equal 10, @@test_K.convert
        assert_equal 1, @@test_A.convert
        assert_equal 5, @@test_5.convert
    end

    def test_draw_count
        deck = Deck.new
        assert_equal 1, @@test_player.draw
        assert_equal 2, @@test_player.draw
        assert_equal 3, @@test_player.draw
    end
end

main.rb (fichier principal qui exécute le blackjack)

main.rb

require './player'

lose_message =<<~TEXT
Tu as perdu
TEXT
win_message =<<~TEXT
Vous gagnez
TEXT
game_draw_message =<<~TEXT
C'est un tirage au sort
TEXT
error_message = "Caractère non valide. Tapez à nouveau"


class Play
    attr_accessor :player, :dealer

    def initialize
        @player = Player.new
        @dealer = Player.new(name: "Marchand")
    end

    def test
        @player.draw
        @player.draw
        @player.show
    end
end

while true #Traitement en boucle pour la relecture
    #Traitement au premier tour
    player = Player.new
    dealer = Player.new(name: "Marchand")
    puts "Bienvenue au Blackjack"
    puts "Distribuer des cartes"
    player.draw
    player.draw
    dealer.draw  
    dealer.show
    #Test de Blackjack
    # dealer.reset
    # dealer.in_blackjac 
    # dealer.show
    # player.reset
    # player.in_blackjack
    # player.show

    #Traitement pour confirmer que le joueur n'est pas un blackjack
    if player.blackjack?
            puts "Jack noir!"
            player.show
    else
        player.show
        puts h_or_s_message =<<~TEXT
Veuillez sélectionner
        Push「h」,frappé
        Push「s」,supporter
        TEXT
    end

    #Hit, traitement de stand (tour du joueur)
    while true
        #Dans le cas du blackjack, le processus de force
        if player.blackjack?
            command = 's'
        else
            command = gets.chomp #Choisissez hit ou stand
        end
        #Traitement en cas de hit
        if command == "h"
            while true
                player.draw
                if player.burst? #Vérifiez s'il y a une rafale
                    player.show
                    puts "éclater! !!"
                    puts lose_message
                    break
                end
                #Confirmation du score total après tirage au sort
                player.show
                #Dans le cas de la valeur maximale (21), le support est traité de force.
                if player.total_score == 21
                    puts 'Le score total a atteint le maximum'
                    command = 's'
                    break
                end
                #Si ce n'est pas la valeur maximale, appuyez à nouveau ou procédez
                puts "Souhaitez-vous le retirer à nouveau?"
                puts h_or_s_message
                while true
                    command = gets.chomp #Encore une fois, frappez ou tenez la sélection
                    if command == 'h'
                        break
                    elsif command == 's'
                        break
                    else
                        puts error_message
                        redo
                    end
                end
                #Manipulation de coup ou de stand
                if command == 'h' 
                    redo
                elsif command == 's'
                    break
                end
            end
            #Traitement de terminaison forcée au moment de la rafale
            if player.burst?
                break
            end
        else
            # h,Traitement lorsqu'une valeur autre que s est entrée
            puts error_message
            redo
        end
        #Traitement au stand (au tour du concessionnaire)
        if command == 's'
            #Manipulation du croupier lorsque le joueur est au blackjack
            if player.blackjack?
                dealer.draw
                dealer.show
                if !dealer.blackjack?
                    puts win_message
                    break
                else
                    puts game_draw_message
                    break
                end
            end
            #Le processus que le croupier continue de frapper jusqu'à ce que le joueur gagne
            while player.total_score > dealer.total_score
                dealer.draw
                dealer.show
                if dealer.burst?
                    puts 'éclater!'
                    puts win_message
                    break
                elsif dealer.total_score == 21 && player.total_score == 21
                    break
                end
            end
            if dealer.burst? #S'il y a une rafale, le traitement se termine
                break
            elsif dealer.total_score == 21 && player.total_score == 21 #Vérifiez si l'un et l'autre n'ont pas atteint la valeur maximale
                puts game_draw_message
                break
            else
                puts lose_message
                break
            end
        end
    end
    #Traitement de la relecture
    puts <<~TEXT
Voulez-vous rejouer?
Veuillez sélectionner
    Push「h」,Oui
    Push「s」,Non
    TEXT
    while true
        command = gets.chomp #Choisissez de rejouer
        if command == "h"
            command = nil
            break
        elsif command == "s"
            break
        else
            puts error_message
            redo
        end
    end
    #Traitement de la relecture
    if command == nil
        redo
    else
        break
    end
end

Ce que j'ai appris

• Dans "Introduction à Ruby pour les professionnels" * "Pourquoi fais-tu cela?" «Quand est-ce que je vais utiliser ça? Je savais exactement quand l'utiliser.

Au début, j'ai utilisé "p" au lieu de minitest, mais J'ai compris que le travail serait plus rapide si je l'utilisais.

Si vous ne mettez pas "test" dans le premier mot du nom de méthode du minitest J'ai complètement oublié de ne pas le tester et j'étais inquiet 2 jours mais lol

Vous approfondirez votre compréhension si vous utilisez activement des choses que vous n'avez jamais utilisées.

Il y a encore de nombreux endroits qui peuvent être refactorisés, J'étais presque fatigué de le faire, alors j'ai écrit Qiita une fois.