Ruby Scripting

[kyonides]

Some Oddities About new & initialize
And Should You Care About Types?

Ruby being an OOP has no specific operator for a new class alias a new copy of a class (its template). Instead it uses the new method that allows it to invoke that copy I was talking about.

Why don't we check for a moment how new works in another language like C++?

The new Operator!

Code:

CPP_Class *pointer = new CPP_Class;

operator new can be called explicitly as a regular function, but in C++, new is an operator with a very specific behavior: An expression with the new operator, first calls function operator new (i.e., this function) with the size of its type specifier as first argument, and if this is successful, it then automatically initializes or constructs the object (if needed). Finally, the expression evaluates as a pointer to the appropriate type.

Since Ruby works with objects mostly, it returns self instead after calling the initialize method.

 What's self? - A Reminder

self stands for the very own object. In this specific case it is the class being initialized or "constructed" there, if you prefer the C++ term instead. What this means is that in Ruby you can call initialize the constructor of Ruby classes during a conversation if you like. Many programmers would understand you in a timely fashion.

How that looks like in Ruby & CRuby?

Well, we already know the new and the initialize methods. new will invoke initialize by default, be it the internal implementation or a custom one you have provided in your script. Then initialize will return the final object, described here as self but representing pretty much any specific class depending on where does it belong to.

In CRuby you would call rb_class_new_instance which includes rb_obj_alloc (its allocator) before finally calling rb_obj_call_init (the function in charge of executing the initialize method of pretty much any Ruby class except for Array and Hash.)

So yes, there is some equivalent of the new operator in Ruby and initialize would be considered its constructor for being its very own variable creation handler.

 Now I wonder why Matz never called it construct or constructor instead being a C / C++ programmer himself. (The original documentation in Japanese has been translated to English so it might have got lost in translation. )

What's the advantanges of using new and initialize in Ruby?

 I guess I can come up with 3 reasons here. Its relatively easy to use by beginners and it can be customized by passing one or more arguments to its initialize method. Also its duck typing strategy makes you care more about what method you will call next than what type of object it actually is. If a given method does exist, Ruby will call it at once. You see, since it walks like a duck and quacks like a duck, it got to be a duck, right?

The problem is that it is not always the case!

Types & Custom Type Checks

RPG::Item and RPG::Weapon have both a method called name and another one named description. So you can call their name and descriptions methods and think for a moment that they are the same kind of object... but they are not!

And that is not really an issue at all.

You see, it comes handy for scripters to simply call an item's or a weapon's name method to display it on the window or sprite about to be drawn on screen.

What do we do if we need to get something like EVA in RPG::Armor ?
It does not exist in RPG::Weapon  and it could crash.

And it will crash indeed!

What you do in this case is to check for types or classes.

In C and C++ types are declared in several places, be it in a function's return value or as part of declaring the arguments it will accept and so on. As you can see in our previous example, the class name is the type we were looking for.

In  Ruby things are different. CRuby does include types but are not supposed to be used that often according to several opinions found online. Nonetheless, there is no limitation as to how many times you should invoke it. Just keep them to the bare minimum.

In pure Ruby you can check classes instead of types.

Or like VX ACE implemented that, it creates a common method like actor? and then places a true or false boolean return value as a quick battler's class identifier. Keep in mind that both Game_Actor and Game_Enemy are nothing but specialized Game_Battlers by default.

Check Classes

Code:

def reply(value)
  case value
  when String
    "SSShhh... tring!"
  when RPG::Weapon
    "It will ke'al!"
  when RPG::Item
    "Consume before: midnight"
  when Integer
    "I'm No. 1, you losers! :P"
  end
end

Type reply(1) in a script call and it will soon call you a loser.
Darn Number 1! You have got quite an ego!
At least the RPG::Weapon would sound like  Doug after testing a knife or machete or sword.

Here I used a case statement but it would also work with a typical if or unless conditional with their respective branches.

Just in case you did not know this, VX ACE runs this type of check whenever you try to retrieve or replace an actor's piece of equipment.