Ruby Beginner - Accessing Another Class Object - ruby

Question

I'm trying to create a simple turn-based battle in Ruby, but I keep getting stuck when it comes to classes. I tried to do this by starting with basic code and building it up around that. I was able to make it work simply enough by using regular variables and basic attack code:
player = "goodguy"
player_health = 15
player_damage = 5
enemy = "badguy"
enemy_health = 15
enemy_damage = 5
puts "#{player} attacks #{enemy} and does #{player_damage} damage."
enemy_health -= player_damage
puts "#{enemy} has #{enemy_health} remaining."
Then, I turned the attack into a function (I had to make the variables global so the function could see them):
$player = "goodguy"
$player_health = 15
$player_damage = 5
$enemy = "badguy"
$enemy_health = 15
$enemy_damage = 5
def player_attack
puts "#{$player} attacks #{$enemy} and does #{$player_damage} damage."
$enemy_health -= $player_damage
puts "#{$enemy} has #{$enemy_health} health remaining."
if $enemy_health <= 0
puts "#{$enemy} died!"
end
end
player_attack()
Next, I turned Player into a class:
class Player
attr_accessor :name; :hp; :damage
def initialize(name, hp, damage)
#name = name
#hp = hp
#damage = damage
end
def attack
puts "#{self.name} attacks #{$enemy}!"
$enemy_health -= #damage
puts $enemy_health
end
end
$enemy = "badguy"
$enemy_health = 15
$enemy_damage = 5
me = Player.new("goodguy", 15, 5)
me.attack
This is where I get stuck. When I turn Enemy into a class (basically modeled exactly after the Player class), I can't figure out how to make the two objects interact with each other. This code doesn't work, but here's the last of what I tried. The #{} variables are more to show what I'm trying to make happen than anything else:
class Player
attr_accessor :name; :hp; :damage
def initialize(name, hp, damage)
#name = name
#hp = hp
#damage = damage
end
def attack
puts "#{self.name} attacks #{badguy.name}!"
badguy.hp -= #damage
puts badguy.hp
end
end
class Enemy
attr_accessor :name; :hp; :damage
def initialize(name, hp, damage)
#name = name
#hp = hp
#damage = damage
end
def attack
puts "#{self.name} attacks #{goodguy.name}!"
player.hp -= #damage
puts player.hp
end
end
goodguy = Player.new("Nicehero", 15, 5)
badguy = Enemy.new("Eviljerk", 15, 5)
me.attack
Basically, what I want to do is make it so that the Player object can interact with the Enemy object. I can't seem to get this working when I try to make 2 classes interact with each other; Also, the #{variable.name} isn't the only thing I've tried for getting the functions to report those values, but I can't seem to find how to actually reference that object.
Obviously there's something I'm missing about how objects interact or what my code is doing vs what I think it should be doing. I would appreciate any suggestions on getting these two classes to interact or how this should be rewritten so that it functions as intended.

Answer 1

As alluded to by #JacobM, the problem you are encountering has to do with the inability of your classes to know about other instances of each other without you explicitly passing them as an argument. Although your initial workaround of using global variables to hold references to the enemy and the player will work, this practice is strongly discouraged because it "leaks" the logic of your program throughout the entire body of your game, which is generally undesirable (see Global Variables are Bad for a detailed explanation of why to avoid them).
By removing the $ from your code, player becomes a local variable when defined in the attack method:
def attack
puts "#{self.name} attacks #{goodguy.name}!"
player.hp -= #damage
puts player.hp
end
In this construction, the player variable that you want to reference as an instance of the Player class is actually an undefined local variable that you have declared within the method body. Because the code of your Player and Enemy classes is the same, I would recommend that you create a superclass to hold this logic:
class Piece
attr_accessor :name, :hp, :damage
def initialize(name, hp, damage)
#name = name
#hp = hp
#damage = damage
end
def attack(opponent)
opponent.hp -= #damage
puts "#{#name} attacks #{opponent.name}!"
puts "#{opponent.name}'s HP: #{opponent.hp}"
end
end
and then create subclasses for the Player and the Enemy:
class Player < Piece
end
class Enemy < Piece
end
With this construction, you can create any number of enemies and pieces and have them all interact with each other separately:
> hero = Player.new("Zeus", 1000, 100)
=> #<Player:0x007fbd33958498 #name="Zeus", #hp=1000, #damage=100>
> goul = Enemy.new("Pariah", 400, 50)
=> #<Enemy:0x007fbd33949b78 #name="Pariah", #hp=400, #damage=50>
> ghost = Enemy.new("Bane", 600, 75)
=> #<Enemy:0x007fbd33937680 #name="Bane", #hp=600, #damage=75>
> hero.attack(goul)
Zeus attacks Pariah!
Pariah's HP: 300
=> nil

Answer 2

As all of the code of Player and Enemy is same, I can model them in a parent class (giving it a dumb name Man, you can give it some fancy name :D) removing all the code duplicity, and than inheriting from the common class.
There can be various ways to interact between two objects. I have taken the simplest by passing the other object in attack function and start interacting with it.
I will change this code in following way:
class Man
attr_accessor :name, :hp, :damage
def initialize(name, hp, damage)
#name = name
#hp = hp
#damage = damage
end
def attack opposite_team_man
puts "#{self.name} attacks #{opposite_team_man.name}!"
opposite_team_man.hp -= #damage
puts opposite_team_man.hp
end
end
class Player < Man
end
class Enemy < Man
end
goodguy = Player.new("Nicehero", 15, 5)
badguy = Enemy.new("Eviljerk", 15, 5)
goodguy.attack badguy