How can I access an array defined outside the function? I've tried adding $coins.length as I had read somewhere for global variable — it didn't work. The reason I define the array outside is because there are other functions below that will be pushing a new item into that same array.
coins = []
def start
puts "It's a sunny day. It's warm and you feel great."
puts "You've picked up your son from creche. He's in a good mood and you've got home no problem."
puts "This is when troubles start, and you know it."
puts "You go out of the elevator and before you reach the door... 'give me the keeys'!"
puts "Do you give him the keys? (Y/N)"
print "> "
while keys = gets.chomp.downcase
case keys
when "y"
puts "you are in, good job. And you get a coin"
coins.push("1")
puts "you now have #{coins.length} coins"
room
when "n"
cry("I wanted to dooooooo iiiiiiiit!")
else
again
end
end
end
Ruby is an object oriented language. Even more, Ruby appeared on the scene with a motto “everything is an object.” Even numbers and (sic!) nil in Ruby are objects:
▶ 42.class
#⇒ Fixnum < Integer
▶ nil.__id__
#⇒ 8
So, you are supposed to use objects for anything that is slightly more complicated than a one-liner. Objects have a lot of goodness out of the box: instance variables, lifecycle, etc.
class Game
def initialize
#coins = []
end
def add_coin(value)
#coins << value
end
def coins
#coins
end
def amount
#coins.size
end
end
Now you might create in instance of this class and while it’s alive, it will hold the value of #coins:
game = Game.new
game.add_coin("1")
puts game.coins
#⇒ ["1"]
puts game.amount
#⇒ 1
game.add_coin("1")
game.add_coin("2")
puts game.coins
#⇒ ["1", "1", "2"]
puts game.amount
#⇒ 3
instead of defining global variable, try to define a method which you can use everywhere, like:
def coins
#coins ||= []
end
def start
puts "It's a sunny day. It's warm and you feel great."
puts "You've picked up your son from creche. He's in a good mood and you've got home no problem."
puts "This is when troubles start, and you know it."
puts "You go out of the elevator and before you reach the door... 'give me the keeys'!"
puts "Do you give him the keys? (Y/N)"
print "> "
while keys = gets.chomp.downcase
case keys
when "y"
puts "you are in, good job. And you get a coin"
coins.push("1")
puts "you now have #{coins.length} coins"
room
when "n"
cry("I wanted to dooooooo iiiiiiiit!")
else
again
end
end
end
This way, the method will not be global and other methods can also access this method(coins) within the file.
Related
I've been trying to test a program that simulates an elevator for two days now with little success. Here's my elevator class, the program is still a work in progress and I've also commented out some methods that might not be essential to the test I'm having trouble with. I'll gladly show more code if you think it's needed
class Elevator
attr_accessor :current_floor
GROUND = 0
TOP = 15
def initialize
#floors = [] # list of floors to travel to
#pending = [] # store floors not in direction of travel
#current_floor = GROUND
#going_up = true # cannot travel downward from ground floor
#going_down = false
end
def get_input
gets.chomp
end
def run
enter_floors
sort_floors
move_to_floor
end
def enter_floors
# prompts the user for input and calls check_floor_numbers
end
def check_floor_numbers floors
# calls validate_floors to ensure user entered '2' instead of 'two'
# if proper floor numbers have been entered this method adds the number
# to #floors array other wise it calls floor_error_message
end
def floor_error_message
puts "Please enter numbers only."
enter_floors
end
def sort_floors
# if we are on the ground floor this method sorts #floors in ascending order
# if we are on the top floor it sorts #floors in descending order
# else it calls check_direction_of_travel
end
def move_to_floor
floor = #floors[0]
if #current_floor == floor
puts "You are already on floor #{floor}"
else
print_direction
(#current_floor..floor).each { |floor| puts "...#{floor}" }
#current_floor = floor # update current_floor
#floors.delete_at(0) # remove floor from list
end
check_for_more_passengers
end
def check_for_more_passengers
puts "Are there any more passengers? (Y/N)"
answer = (get_input).upcase
answer == 'Y' ? run : check_next_move
end
def check_next_move
if #floors.empty? && #pending.empty?
end_ride
else
move_to_floor
end
end
def check_direction_of_travel
# not implemented - add floor to appropriate array depending on dir
# of travel
end
def end_ride
puts "\n\nEND."
end
def print_direction
msg = " "
#going_up ? msg = "Going Up!" : msg = "Going Down!"
puts msg
end
end
I'm trying to test that the elevator can move to a specific floor. At first I was having trouble testing input from the console without running the program itself. I asked a question about this and was referred to this answer in a different question. The answer in question extract gets.chomp to a separate method then overrides the method in the tests. I ended up with something like this:
describe "it can move to a floor" do
before do
##moves = ["2", "N"]
def get_input; ##moves.next end
end
it "should move to floor 2" do
e = Elevator.new
e.run
assert_equal(e.current_floor, 2)
end
end
Problem: get_input was not properly overidden and running the test suit prompted the user for input so it was suggested that I open the Elevator class in the test itself to ensure that the method was properly overridden. Attempting to do so eventually led to a test like this:
describe "it can move to a floor" do
before do
class Elevator
attr_accessor :current_floor
##moves = ["2", "N"]
def get_input; ##moves.next end
def run; end
end
end
it "should move to floor 2" do
e = Elevator.new
e.run
assert_equal(e.current_floor, 2)
end
end
I had to override run and add an attr_accessor for current_floor because I was getting method missing errors.
Problem: This test gives the following error:
1) Failure: it can move to a floor#test_0001_should move to floor 2
[elevator_test.rb:24]: Expected: nil Actual: 2
I've tried to tidy up the Elevator class as much as possible and keep the methods as simple as I could given the parameters of the program.
Can anyone point me in the right direction towards getting this solved, with maybe pseudocode examples (if possible) to demonstrate how I should approach this problem if the answer is to refactor.
Please bear in mind that I'd also like to implement other tests like checking that the elevator class can maintain a list of floors, or that it can change direction, in the future when you answer.
Your test class ElevatorTest is redefining the Elevator to override method get_input, but it is not opening the class Elevator defined in elevator.rb, but instead it is sort of creating a new class Elevator which happens to be defined inside the class ElevatorTest. Remember every class is also a module, so now you have a new class ElevatorTest::Elevator.
To fix this issue, I have made some changes to elevator_test.rb which is shown below.
gem 'minitest', '>= 5.0.0'
require 'minitest/spec'
require 'minitest/autorun'
require_relative 'elevator'
class Elevator
##moves = ["2", "N"].each
def get_input; ##moves.next end
end
class ElevatorTest < MiniTest::Test
def test_working
assert_equal(1, 1)
end
describe "it can move to a floor" do
before do
end
it "should move to floor 2" do
e = Elevator.new
e.run
assert_equal(e.current_floor, 2)
end
end
end
Also, please remember to use .each while defining ##moves - it returns an enumerator. We can call .next only on an enumerator
I am very new to Ruby and I am trying to do an exercise on a book.
I have 3 classes, one is the menu that interacts with the user, the other one creates objects books, and the other one stores the books into array, the problem I am having is when I add a book and then ask the user if he wants to continue to the menu, then I ran Menu.new and it returns the user to the menu, when I select option 3 to show the arrays content, in this case the books I've stored, its not showing anything. What am i doing wrong?
book
class Book
attr_accessor :name
def initialize(name, author)
#name = name
#author = author
end
def to_s
"Book: #{#name} Autor: #{#author}"
end
end
bookshelf
class Bookshelf
def initialize
#array = []
end
def +(arg)
#array << arg
end
def -(arg)
#array.delete(arg)
end
def showAll
puts #array
end
def search(book)
#array.each do |x| if x == book
puts "book is here!"
else
puts "book is not here! "
end
end
end
menu
class Menu
def initialize
menu
end
def menu
puts "Menu
1. Add book
2. Delete book
3. Show All
4. Search book
5. Exit"
bookshelf = Bookshelf.new
answ = gets.chomp.to_i
case answ
when 1
answ = "yes"
while answ == "yes"
puts "Book:"
name_book = gets
puts "Author:"
name_author = gets
name_book = Book.new(name_book, name_author)
name_book = name_book.name
bookshelf+ name_book
puts "Add another book?"
answ= gets.chomp
end
puts "Return to menu?"
answer2 = gets.chomp
if answer2 == "yes"
bookshelf.showAll
Menu.new
else
puts "bye!"
bookshelf.showAll
end
when 2
puts "Book:"
book_delete = gets
bookshelf- book_delete
bookshelf.showAll
puts "Youve deleted: #{book_delete}"
puts "Return to menu?"
answer = gets.chomp
if answer == "yes"
Menu.new
else
puts "bye!"
end
when 3
puts "Here are all the books stored:"
bookshelf.showAll
puts "Return to menu?"
answer = gets
if answer == "yes"
Menu.new
else
puts "bye!"
end
end
end
Menu.new
end
There are a couple issues with your code. I'll cover them one at a time.
Your immediate issue is you are calling Menu.new from inside your while loop. This means you are getting a completely new menu, with a brand new bookshelf, each time the user wants to return to the menu and keys in "yes". You should probably just repeat the menu over and over (hence the while loop) instead of asking the user each time if they want to return to the menu since your menu has an exit option (though you haven't coded it yet).
Here's a quick example:
# ... display menu
# Let's say choice 5 is 'Exit'
choice = gets.chomp
until choice == "5"
# case statement that does something for options 1 - 4
end
# Then end the method which means once use picks "5", the menu closes
The main issue is you are calling Menu.new at the end of your Menu class definition. Remember that your definition of a class is just a blueprint for an actual instance of a class. When you make a blueprint for a house, the blueprint doesn't build the house. The builder builds the house.
Your code really should read something like:
class Menu
# code
end
myMenu = Menu.new
You can call the method menu from your initialize method but it is better Ruby practice to call it outside the method. Let the builder decide if he wants to build the wall or the floor first. So:
myMenu = Menu.new
myMenu.menu
This should help you sort out a few of your issues and help you get going in your further learning. I've tried to shorten this as much as possible since it has the opprotunity of being a very broad disscussion.
You should set the array member of bookshelf as global. That would solve your problem.
A better aproach is to set the Menu's member bookshelf (yes, the object) as a member of Menu, but if you use Menu.new you are creating a new instance and so destroying that bookshelf member. So here you have two options:
Do not destroy that menu nor initialize a new one when you whant the user to return to the menu and use the same menu all the time (singleton). What I would do.
set that bookshelf member also as global.
Can someone please explain me what is happening here? I know that this code is simple, but it is hard for me, I am ultimate beginner. I am stucked for many hours here, I cant figure it out..
When I run code, CentralCorridor class is run where we have basic gets.chomp prompt. All answers("shoot!", "dodge!", "tell a joke") for that prompt end program. I dont know how to enter to other scenes (class TheBridge, class EscapePod, class LaserWeaponArmory...). I really want to make my own game like this, but i cant figure it out..
Also, if someone can explain me this enter() method.
Please help :)
here is link: http://ruby.learncodethehardway.org/book/ex43.html
or code:
class Scene
def enter() # what this method do?
exit(1)
end
end
class Engine
def initialize(scene_map)
#scene_map = scene_map
end
def play()
current_scene = #scene_map.opening_scene()
last_scene = #scene_map.next_scene('finished')
while current_scene != last_scene
next_scene_name = current_scene.enter()
current_scene = #scene_map.next_scene(next_scene_name)
end
# be sure to print the last scene
current_scene.enter()
end
end
class Death < Scene
##quips = [
"You died. You kinda suck at this",
"Your mom would be proud...if she were smarter.",
"Such a luser.",
"I have a small puppy that's better at this."
]
def enter()
puts ##quips[rand(0..(##quips.length - 1))] # 2. what is this?
exit(1)
end
end
class CentralCorridor < Scene
def enter()
puts "The Gothons of Planet Percal #25 have invaded your ship and destroyed"
puts "your entire crew. You are the last surviving member and your last"
puts "mission is to get the neutron destruct bomb from the Weapons Armory,"
puts "put it in the bridge, and blow the ship up after getting into an "
puts "escape pod."
puts "\n"
puts "You're running down the central corridor to the Weapons Armory when"
puts "a Gothon jumps out, red scaly skin, dark grimy teeth, and evil clown costume"
puts "flowing around his hate filled body. He's blocking the door to the"
puts "Armory and about to pull a weapon to blast you."
print "> "
action = $stdin.gets.chomp
if action == "shoot!"
puts "Quick on the draw you yank out your blaster and fire it at the Gothon."
puts "His clown costume is flowing and moving around his body, which throws"
puts "off your aim. Your laser hits his costume but misses him entirely. This"
puts "completely ruins his brand new costume his mother bought him, which"
puts "makes him fly into an insane rage and blast you repeatedly in the face until"
puts "you are dead. Then he eats you."
return 'death'
elsif action == "dodge!"
puts "Like a world class boxer you dodge, weave, slip and slide right"
puts "as the Gothon's blaster cranks a laser past your head."
puts "In the middle of your artful dodge your foot slips and you"
puts "bang your head on the metal wall and pass out."
puts "You wake up shortly after only to die as the Gothon stomps on"
puts "your head and eats you."
return 'death'
elsif action == "tell a joke"
puts "Lucky for you they made you learn Gothon insults in the academy."
puts "You tell the one Gothon joke you know:"
puts "Lbhe zbgure vf fb sng, jura fur fvgf nebhaq gur ubhfr, fur fvgf nebhaq gur ubhfr."
puts "The Gothon stops, tries not to laugh, then busts out laughing and can't move."
puts "While he's laughing you run up and shoot him square in the head"
puts "putting him down, then jump through the Weapon Armory door."
return 'finished'
else
puts "DOES NOT COMPUTE!"
return 'central_corridor'
end
end
end
class LaserWeaponArmory < Scene
def enter()
puts "You do a dive roll into the Weapon Armory, crouch and scan the room"
puts "for more Gothons that might be hiding. It's dead quiet, too quiet."
puts "You stand up and run to the far side of the room and find the"
puts "neutron bomb in its container. There's a keypad lock on the box"
puts "and you need the code to get the bomb out. If you get the code"
puts "wrong 10 times then the lock closes forever and you can't"
puts "get the bomb. The code is 3 digits."
code = "#{rand(1..9)}#{rand(1..9)}#{rand(1..9)}"
print "[keypad]> "
guess = $stdin.gets.chomp
guesses = 0
while guess != code && guesses < 10
puts "BZZZZEDDD!"
guesses += 1
print "[keypad]> "
guess = $stdin.gets.chomp
end
if guess == code
puts "The container clicks open and the seal breaks, letting gas out."
puts "You grab the neutron bomb and run as fast as you can to the"
puts "bridge where you must place it in the right spot."
return 'the_bridge'
else
puts "The lock buzzes one last time and then you hear a sickening"
puts "melting sound as the mechanism is fused together."
puts "You decide to sit there, and finally the Gothons blow up the"
puts "ship from their ship and you die."
return 'death'
end
end
end
class TheBridge < Scene
def enter()
puts "You burst onto the Bridge with the netron destruct bomb"
puts "under your arm and surprise 5 Gothons who are trying to"
puts "take control of the ship. Each of them has an even uglier"
puts "clown costume than the last. They haven't pulled their"
puts "weapons out yet, as they see the active bomb under your"
puts "arm and don't want to set it off."
print "> "
action = $stdin.gets.chomp
if action == "throw the bomb"
puts "In a panic you throw the bomb at the group of Gothons"
puts "and make a leap for the door. Right as you drop it a"
puts "Gothon shoots you right in the back killing you."
puts "As you die you see another Gothon frantically try to disarm"
puts "the bomb. You die knowing they will probably blow up when"
puts "it goes off."
return 'death'
elsif action == "slowly place the bomb"
puts "You point your blaster at the bomb under your arm"
puts "and the Gothons put their hands up and start to sweat."
puts "You inch backward to the door, open it, and then carefully"
puts "place the bomb on the floor, pointing your blaster at it."
puts "You then jump back through the door, punch the close button"
puts "and blast the lock so the Gothons can't get out."
puts "Now that the bomb is placed you run to the escape pod to"
puts "get off this tin can."
return 'escape_pod'
else
puts "DOES NOT COMPUTE!"
return "the_bridge"
end
end
end
class EscapePod < Scene
def enter()
puts "You rush through the ship desperately trying to make it to"
puts "the escape pod before the whole ship explodes. It seems like"
puts "hardly any Gothons are on the ship, so your run is clear of"
puts "interference. You get to the chamber with the escape pods, and"
puts "now need to pick one to take. Some of them could be damaged"
puts "but you don't have time to look. There's 5 pods, which one"
puts "do you take?"
good_pod = rand(1..5)
print "[pod #]> "
guess = $stdin.gets.chomp.to_i
if guess != good_pod
puts "You jump into pod %s and hit the eject button." % guess
puts "The pod escapes out into the void of space, then"
puts "implodes as the hull ruptures, crushing your body"
puts "into jam jelly."
return 'death'
else
puts "You jump into pod %s and hit the eject button." % guess
puts "The pod easily slides out into space heading to"
puts "the planet below. As it flies to the planet, you look"
puts "back and see your ship implode then explode like a"
puts "bright star, taking out the Gothon ship at the same"
puts "time. You won!"
return 'finished'
end
end
end
class Finished < Scene
def enter()
puts "You won! Good job."
end
end
class Map
##scenes = {
'central_corridor' => CentralCorridor.new(),
'laser_weapon_armory' => LaserWeaponArmory.new(),
'the_bridge' => TheBridge.new(),
'escape_pod' => EscapePod.new(),
'death' => Death.new(),
'finished' => Finished.new(),
}
def initialize(start_scene)
#start_scene = start_scene
end
def next_scene(scene_name)
val = ##scenes[scene_name]
return val
end
def opening_scene()
return next_scene(#start_scene)
end
end
a_map = Map.new('central_corridor')
a_game = Engine.new(a_map)
a_laser = EscapePod.new()
a_game.play()
Aleksar
You have a game with a number of components:
The Engine - the main entry point to the game (you can tell because it has the play method)
You've got a Map object which is just a collection of the different scenes that can be played in the game. Each scene is just another scenario in the game with its own challenges. E.g. in on scene you are on the bridge in another you are in an escape pod. In another you have a weapon whatever.
All of scenes in the game inherit their behavior from the Scene class as in this example.
class EscapePod < Scene
#....
#Scene stuff
#...
end
The code above basically says create a class called EscapePod that can do everything that a Scene can do.
What is throwing you off is that the Scene class doesn't do much. It has only one behavior (this is a slight over simplification) which is it that it knows how to do something called enter which in this case just immediately exits. This Scene class is a template for all of the other scenes that are more interesting.
class Scene
def enter() # what this method do?
exit(1)
end
end
Each scene subclass overrides the enter method from the template to do something more interesting when enter is called rather than just exiting.
The next simplest scene is the Finish scene it is a little more interesting it tells you did a good job.
class Finished < Scene
def enter()
puts "You won! Good job."
end
end
One last thing. It is clear that intention is not to use Scene class directly but only the subclasses EscapePod, Finish etc. which must override the enter method.
If this were production code you might even see something like this:
class Scene
def enter() # what this method do?
raise "Scene 'enter' must not be used directly.Please subclass Scene and provide a meaningful implementation for the 'enter' method"
end
end
I hope this helps.
I'm working through Learn Ruby the Hard Way by Zed Shaw and I wanted to see if I was on track with the first extra credit. He asks you to explain how returning the first room works. I think I understand most of it except how the .call() works. This is what I came up with, can anyone tell me if I'm getting it or if I'm off base?
class Game
def initialize(start)
#quips = [
"You died. You kinda suck at this.",
"Nice job, you died...jackass.",
"Such a luser.",
"I have a small puppy that's better at this."
]
#start = start
end
def prompt()
print"> "
end
def play()
next_room = #start
# While next_room = #start (only in the beginning), room then gets
# defined as room = method(next_room)
# a method is a set of expressions that returns a value.
# with methods, you can organize code into subroutines that
# can be easily invoked from other areas of their program.
# so, this method sets room to next_room, and next_room is then
# set to room.call()
# room.call() is then set by what is returned at the end of the code.
#at every room, it returns either death or
# the name of the next room/function
while true
puts "\n---------"
room = method(next_room)
next_room = room.call()
end
end
def death()
puts #quips[rand(#quips.length())]
Process.exit(1)
end
def central_corridor()
puts "The Gothons of Planet Percal #25 have invaded your ship and destroyed"
puts "your entire crew. You are the last surviving member and your last"
puts "mission is to get the neutron destruct bomb from the Weapons Armory,"
puts "put it in the bridge, and blow the ship up after getting into an "
puts "escape pod."
puts "\n"
puts "You're running down the central corridor to the Weapons Armory when"
puts "a Gothon jumps our, red scaly skin, dark grimy teeth, and evil clown costume"
puts "flowing around his hate filled body. He's blocking the door to the"
puts "Armory and about to pull a weapon to blast you."
prompt()
action = gets.chomp()
if action == "shoot!"
puts "Quick on the draw you yank our yoru blaster and fire it at the Gothon."
puts "His clown costume is flowing and moving around his body, which throws"
puts "off your aim. Your laser hits his costume but misses him entirely. This"
puts "completely ruins his brand new costume his mother bought him, which"
puts "makes him fly into an insane rage and blas you repeatedly in the face until"
puts "you are dead. Then he eats you."
return :death
elsif action == "dodge!"
puts "Like a world class boxer you dodge, weave, slipe and slide right"
puts "as the Gothon's blaster cranks a laser past your head."
puts "In the middle of your artful dodge your foot slips and you"
puts "bang your head on the metal wall and pass out."
puts "You wake up shortly after only to die as the Gothon stomps on"
puts "your head and eats you."
return :death
elsif action == "tell a joke"
puts "Luck for you they made you learn Gothon incults in teh academy."
puts "You tell the one Gothon joke you know:"
puts "Lbhe zbgure vf fb sng, jura fur fvgf nebhaq gur ubhfr, fur fgvf nebhaq gur ubhfr."
puts "The GOthon stops, tries not to laugh, then busts our laughing and can't move."
puts "While he's laughing you run up and shoot him square in the head"
puts "putting him down, then jump through the Weapon Armory door."
return :laser_weapon_armory
else
puts "DOES NOT COMPUTE!"
return :central_corridor
end
end
it execute the literal passed to the method as if they were called as a function
Here is an example
def test
"Hello World"
end
p method(:test).call
#=>"Hello World"
p method("test").call
#=>"Hello World"
I had a previous question that I asked here: I (think) I'm getting objects returned when I expect my array to have just 2 properties available
that may give some background. Having received a solution for that, I immediately moved to showing each player hand. The below module is included in both the Dealer and Player classes.
module Hand
def show_hand
if self.class == Dealer
#Need to cover up 1 of the 2 cards here. Dealer doesn't show both!
print "The dealer is showing: "
print self.hand[0].show_card
puts ''
elsif self.class == Player
print "You have: "
self.hand.each do |item|
item.show_card
end
puts ''
else
puts "A Random person is showing their hand."
end
end
end
I know this customization defeats the purpose of the module, just using it to reinforce the concept of modules. The above solution worked fine for the Dealer portion. But when the Player portion was called it printed a blank block. On a .inspect of each "item" in the Player block it confirmed that the items were in fact Card objects as expected. Here was the previous show_card method:
def show_card
"[#{#card_type} of #{#suit}]"
end
So it just returned a string with the card_type and suit.
I was able to fix the problem for the Player object portion just by changing the method to this:
def show_card
print "[#{#card_type} of #{#suit}]"
end
Why was this happening? I'm assuming it has something to do with the call the "each" on the Player Hand. Really just curious what the difference was and why these Card objects wouldn't print without the explicit "print" in there vice returning via String object.
Hope I was descriptive enough. This one just baffles me and I'm really trying to grasp these little things since I know it will prevent future errors like this. Thanks!
In Ruby you must print with puts or print. Just returning the string doesn't print it. The reason your Dealer class prints is because you did a print, but in your Player class, as you noted, you had no print. You only returned the string without printing.
As you noted, you were able to fix it by including the print:
def show_card
print "[#{#card_type} of #{#suit}]"
end
You could do this instead:
def show_card
"[#{#card_type} of #{#suit}]"
end
...
module Hand
def show_hand
if self.class == Dealer
#Need to cover up 1 of the 2 cards here. Dealer doesn't show both!
print "The dealer is showing: "
puts self.hand[0].show_card # PRINT THE CARD
elsif self.class == Player
print "You have: "
self.hand.each do |item|
print item.show_card # PRINT THE CARD
end
puts ''
else
puts "A Random person is showing their hand."
end
end
end
Which would be a little more "symmetrical" and prints what you want.
A slightly more compact would be:
def show_card
"[#{#card_type} of #{#suit}]"
end
...
module Hand
def show_hand
if self.class == Dealer
#Need to cover up 1 of the 2 cards here. Dealer doesn't show both!
puts "The dealer is showing: #{self.hand[0].show_card}"
elsif self.class == Player
print "You have: "
self.hand.each { |item| print item.show_card }
puts ''
else
puts "A Random person is showing their hand."
end
end
end