RPG RPG Revolution

# he keyword class defines a class class Hero # attr_accessor allows us to change # the values of the instance variables. attr_accessor :hp attr_accessor :mp attr_accessor :str # Initialize is the method called when # you first create the object. def initialize @hp = 0 @mp = 0 @str = 0 end # You can normally define other methods. def equip(sword) p "Hero has equipped #{sword}"!" end # Another method~ def learn_skill(skill) p "Hero has learned #{skill}!" end # This 'end' belongs to the class block end

class Healing_Item # The instance variables: attr_accessor :name # The item's name attr_accessor :hp_increment #Amount of HP restored attr_accessor :mp_increment #Amount of MP restored # The methods: # initialize: Called when an item is created, #sets the values for the instance variables def initialize(item_name, hp_increase, mp_increase) @name = item_name @hp_increment = hp_increase @mp_increment = mp_increase end # use_item: 'Use' the item on player # player : a Hero object from the previous tutorial def use_item(player) # Increase player's HP by the value of @hp_increment player.hp += @hp_increment player.mp += @mp_increment # Increase MP too! end # print : Prints all the instance variables def print p "The item's name is: " + @name p "The amount of HP recovered when using a #{name} is: " + @hp_increment.to_s p "As for MP, the amount is: " + @mp_increment.to_s end end

# Create a new item called Potion, this item restores 100 HP potion = Healing_Item.new("Potion", 100, 0) potion.print# Print various useful information about potion # create a new hero with 200 HP and 100 MP alex = Hero.new(200,100) alex.hp = alex.hp - 150 # Decrease the hero's HP by 150 (now it's 50) # Use the potion on the hero, increasing his HP by 100 potion.use(alex) p Alex.hp# Print the hero's current HP (150)

class Shape attr_accessor :height attr_accessor :width def initialize(width, height) @width = width @height = height end def area p 'I'll be overwritten!' end def print_dimensions p "Height is #{@height}" p "Width is #{@width}" end end

class Triangle < Shape def initialize(base, height) super(base, height) end def area the_area = @width * @height / 2 p 'The area is: ' + the_area.to_s end def print_dimensions super p "AND THIS IS A TRIANGLE!!" end end

outer_var = 10 def lol(num) inner_var = num print "Printing outer_var inside the function lol: " + outer_var.to_s print "Printing inner_var inside the function lol: " + inner_var.to_s end lol(999) print "Printing outer_var outside the function lol: " + outer_var.to_s #print "Printing inner_var outside the function lol: " + inner_var.to_s

All the classes we've been creating so far contains 'instance methods', instance methods can only be called by an object. If you have a class called File which represents an open file (text file for example), and this class has an instance method called path, which returns the location of the file (eg. "my files\text\file1.txt"), you call the method like this:

class File

   def initialize(filename)
       @filepath = filename
       # some other initialization stuff
   end

   def path
       return @filepath
   end

end
my_file = File.new("my files\text\file1.txt")
print my_file.path

To call any instance method, you create an object (in this case my_file) and then call the method of that object. You can't do something like File.path because instance methods must be associated to an object. Why? Because every File object has its own path, so the path method must be different for all File objects.

Sometimes, however, you have methods that aren't really unique to each object. For example, your File class might have a method called rename which renames a file. You pass the original filename to the method, and the new name, and then it renames the file. Thing is, you don't need to open the file to rename it. Having this method as an instance method (as in, each File object has a copy of it) isn't that useful, because the same method can be applied on any file, open or not. One idea would be creating a 'global' (outside any class) method to do it, but then... renaming files is connected to the File class, it makes sense to have it as a method... if only we could call the method like this: File.rename("old.txt", "new.txt") instead of my_file.rename("old.txt", "new.txt). Maybe nothing seems wrong with the latter approach, but it's not a good way to design a class. An object has data and methods that operate on data. However, rename isn't operating on the object data; it could be used to rename any file, even if it wasn't the file represented by my_file.

Well, the best way to do it is use a class method, a method that isn't linked to a particular object. Something like:

class File

   def initialize(filename)
       @filepath = filename
       # some other initialization stuff
   end

   def path
       return @filepath
   end

   def File.rename(oldname, newname)
       # some complicated code to rename files~
       print "The file " + oldname + " has been successfully renamed to " + newname
   end

end
my_file = File.new("my files\text\file1.txt")
print my_file.path
File.rename("BigBoss.txt", "Snake.txt")

The only changes are adding the rename method to the class, and calling it to change BigBox.txt to Snake.txt. Notice the definition of the class method rename:

File.rename(oldname, newname)

Without the "File." part, the method will be treated as an instance method; each object will have its own copy of rename (like the path method). However, by prefixing the method name with the class name and then a dot (File.rename) you are stating that the rename method isn't linked to any particular object and that it can be invoked (called) directly from the class itself. As you can see, the rename method was called directly from File (File.rename("BigBoss.txt", "Snake.txt")). Cool, isn't it? 8)

Just a note: The File class is actually part of the built-in classes provided by Ruby. You don't have to write it yourself. I just used it as an example. Built-in classes and modules provide many useful methods that you can call right away. (Like the print method we've been using all along)

module Math PI = 3.141592654 def Math.square(n) return n * n end def Math.cube(n) return n * n * n end def Math.abs(n) if n >= 0 return n else return -n end end end print "The value of PI is: " print Math::PI print "The value of square(3) is: " print Math.square(3) print "The absolute value of -1 is: " print Math.abs(-1)

module Hello def hello_world print "Hello, World!" end end class A include Hello # whatever~ end class B include Hello # whatever~ end aaa = A.new bbb = B.new aaa.hello_word # outputs: "Hello, World!" bbb.hello_word # outputs: "Hello, World!"

class Hero include Comparable attr_accessor :hp attr_accessor :mp attr_accessor :str def initialize @hp = 0 @mp = 0 @str = 0 end def <=>(other_hero) if @hp > other_hero.hp return 1 elsif @hp == other_hero.hp return 0 else return -1 end end end hero1 = Hero.new hero1.hp = 10 hero2 = Hero.new hero2.hp = 5 if hero1 > hero2 print "hero1 has more hp than hero2!" end