Ruby Scripting

[kyonides]

Revisiting Strings & Symbols

Not long ago, a furry Wulfo noticed something about using strings and symbols in Ruby, either by running a vanilla RMXP game or my own custom engine HiddenChest. Without further delay, let's read his comments thoroughly.

Some Wulfo Once Said

For scripters of RUBY, I did a little bit of discovery.

Within RUBY... even available when using RPGMaker XP's RGSS... you have access to the OBJECT class. Not that you see it in the Scripts database. And the OBJECT class has a few methods. One of these methods is 'instance_variables' which would return an array listing all the variables specific for the class within.

Ergo, you would get instance variables representing the command window, the created sprite background, and a few others if used within "Scene_Title"

However, different versions of Ruby return this array differently.

With Ruby v 1.8.1 (used by both RPGMaker XP and VX at the very least), the names stored within the returned array are listed as strings:

EX: ["@sprite", "@continue_enabled", "@previous_scene", "@command_window"]

But at some point, RUBY had changed, and the current versions (used by HiddenChest) now return the instance variables as their 'symbols', and not by their names as strings.

EX: [:@sprite, :@continue_enabled, :@previous_scene, :@command_window]

Now, this is important as older scripts that utilize this method (such as the RMXP SDK) to retrieve the names in string format. And yep, that can cause problems.

BUT, I found that there's no issue just converting the 'symbol' name into a string.

Code:

Code:

object_name = (object_name).to_s unless object_name.is_a?(String)

This STOOPID thing works. And lets what I'm doing work between both new and old RUBY versions.

I know, its not 'proper' to change a variable itself from one type to another (like changing a float to an integer), and if a variable needs to be 'defined' as a particular fixed type this wouldn't exactly work... requiring a second variable defined soley for 'string names'. But for the current RUBY version, it works.

Honestly, that's old news to me.

And there's something I'd really like to add to his remarks there. Adding the condition to not convert a string into a string if it's already a string object is quite weird, to say the least.

"string".to_s by itself will simply return self, this means it will return "string" after processing that line. It won't transform anything. Instead, it will return its default value, the string itself!!

I suspect this change might have happened in Ruby version 1.9 or later.

Based on old comments online, it seems that the Ruby on Rails aka Rails community and base code pushed Ruby core developers into implementing more and more symbols in the default MRI code to reduce the amount of unfrozen strings that needed to be frozen at runtime.

The Advantage of Relying on Symbols Not Strings

Symbols are unique by definition. Once created, there'll be just a single copy of it for the rest of the code's execution. This is great if you need unique identifiers for very specific things in your custom script. I can give you my Terms module script as an example. By using a single language symbol like :eng or :deu or :spa you can make many different arrays or hashes of strings quickly change your game's graphical user interface or GUI in no time. You'd only need to change a single instance variable in Terms module and you're done!

Fine, you'd also need to refresh your windows or sprites right away or you'd never notice any changes on screen.