Question

我想制作一个卡片游戏程序，用于比较分配给player_value和dealer_value的卡片的值。如果player_value大于dealer_value，则应显示"you win"。这是我的代码：

def get_card (card)
  type = case ((card-1)/13)
  when 0 then "of clubs"
  when 1 then "of diamonds"
  when 2 then "of hearts"
  when 3 then "of spades"
  end
  card = case (card%13)
  when 0 then "king #{type}"
  when 1 then "ace #{type}"                 
  when 11 then "jack #{type}"
  when 12 then "queen #{type}"
  else card%13
  end
  "#{card} #{type}"
end

def deal_cards
  total_cards = (1..52).to_a.shuffle
  player_value = [total_cards.pop, total_cards.pop]
  dealer_value = [total_cards.pop, total_cards.pop]
  puts "Your cards are #{get_card(player_value[0]).to_s} and #{get_card(player_value[1]).to_s}"
  puts "The dealer shows #{get_card(dealer_value[0])}"

  if(dealer_value > player_value)
    puts "You lose"
  else (player_value > dealer_value)
    puts "You win"
  end
  end  

deal_cards()

我不清楚为什么这不起作用，我将不胜感激任何帮助。

Answer 1

我真的不明白为什么要将数组分配给player_value和dealer_value，但您无法使用>或{{1}来比较数组}。

您必须从要比较的数组中检索元素，然后在< - if子句中使用它。

同样，else子句不会采用其他条件。如果之前的所有条件都失败，将使用else。在您的情况下，您应该使用else。

e.g：

elsif

Answer 2

让我为同样的问题提供这种面向对象的解决方案，因为这是Ruby真正发光的地方，并且看到它以程序方式使用真的让我感到烦恼。面向对象为脚手架添加了更多的线条，但在易读性，可重用性和概念清晰度方面增加了更多。

我们可以使用三个基本构建块来表示域。

首先，我们需要一个Card对象，能够保存一些关于自身的数据（等级和套装），以及将自己表示为字符串的能力：

class Card
  SUITS = [:clubs, :diamonds, :spades, :hearts]
  RANKS = [:ace, *2..10, :jack, :queen, :king]

  attr_reader :suit, :rank

  def initialize(n)
    @suit = (n - 1) / 13
    @rank = (n - 1) % 13
  end

  def to_s
    "#{ RANKS[@rank] } of #{ SUITS[@suit] }"
  end
end

接下来，我们需要一个Hand对象。基本上是一组卡片，可以将其力量与其他手牌进行比较，并将自己表现为一个字符串：

class Hand

  attr_reader :cards

  def initialize(cards)
    @cards = cards
  end

  def <=>(other_hand)
    @cards.strength <=> other_hand.strength
  end

  def to_s
    @cards.map(&:to_s).join(", ")
  end

  private

  def strength
    @cards.map(&:rank).inject(:+)
  end
end

从问题中不清楚手的力量是如何确定的。在这个原始实现中，它只是手中牌的等级的总和。

最后，我们需要一个Deck对象。我们可以从中得到卡片的东西。我们将使用标准的52张牌：

class Deck
  def initialize
    @cards = (1..52).map { |n| Card.new(n) }.shuffle
  end

  def draw(number_of_cards = 1)
    [*@cards.pop(number_of_cards)]
  end
end

现在我们已经设置了基本构建块，使用它们是微不足道的：

def deal_cards
  deck = Deck.new

  player_hand = Hand.new(deck.draw(2))
  dealer_hand = Hand.new(deck.draw(2))

  puts "Your have: #{ player_hand }"
  puts "The dealer has: #{ dealer_hand }"

  if(player_hand > dealer_hand)
    puts "You win!"
  elsif(dealer_hand < player_hand)
    puts "Aw. You lose."
  else
    puts "Woah! It's a tie!"
  end
end

值得注意的是，此解决方案缺少错误处理，例如将未知n传递给Card构造函数，或draw来自空白套牌，但可以轻松添加。< / p>

比较纸牌游戏中的值

2 个答案: