[Series][Scripting]LegacyX's Ruby/RGSS Tutorial Series, Part 1: Ruby Basics Options

[Legacy]

LegacyX's Ruby/RGSS Tutorials Part 1: Ruby Basics

Author: LegacyX
Date Created: 10-01-2010
Date Revised: 13-01-2010

If you want to try any Ruby code out whilst you go through my tutorial, i recommend that you'd go to http://tryruby.org/ and work from within your browser. This is also a good way to retain the information you have learnt form this tutorial. Typing it out 1 time isn't good enough, the best way to remember is to type it out at least 16 times. This is how i learnt and remembered Ruby. just though i would give you a personal piece of advice.

1.1 Information

So what is Ruby? Well, Ruby is an interpreted, object-oriented scripting language. And is the backbone of RGSS (Ruby Game Scripting System)that is used in RPG Maker XP.

Ruby goes to great lengths to be a purely object oriented language. Every value in Ruby is an object, even the most primitive things: strings, numbers and even true and false. Every object has a class and every class has one
superclass. At the root of the class hierarchy is the class Object, from which all other classes inherit. Every class has a set of methods which can be called on objects of that class. Methods are always called on an object there are no Å“class methods as there are in many other languages (though Ruby does a great job of faking them). Every object has a set of instance variables which hold the state of the object. Instance variables are created and accessed from within methods called on the object. Instance variables are completely private to an object. No other object can see them, not even other objects of the same class, or the class itself. All communication between Ruby objects happens through methods.

In addition to classes, Ruby has modules. A module has methods, just like a class, but it has no instances. Instead, a module can be included, or mixed in, to a class, which adds the methods of that module to the class. This is very
much like inheritance but far more flexible because a class can include many different modules. By building individual features into separate modules, functionality can be combined in elaborate ways and code easily reused.
Mix-ins help keep Ruby code free of complicated and restrictive class hierarchies.

Variables in Ruby are dynamically typed, which means that any variable can hold any type of object. When you call a method on an object, Ruby looks up the method by name alone it doesn't care about the type of the object. This is called duck typing and it lets you make classes that can pretend to be other classes, just by implementing the same methods.

So this means that having some knowledge of Ruby will help you understand RGSS a lot easier. So, well get right into learning the basics of Ruby.

1.2 Basics Of Ruby

Comments

Comments are an important aspect in Programming, it doesn't matter what language it is, commenting is important because it allows you to revisit your code and understand what it all does (if you commented it well) There are two different types of comments, line and Block. some examples are bellow.

Like Perl, Bash, and C Shell, Ruby uses the hash symbol (also called Pound Sign, number sign, Square, or octothorpe) for comments. Everything from the hash to the end of the line is ignored when the program is run by Ruby. Here are some sample comments.

Line Comments

CODE

# My first Comment
line_of_code

You can append a comment to the end of a line of code, as well. Everything before the hash is treated as normal Ruby code.

CODE

line_of_code # a line_of_code

Block Comments

You can also comment several lines at a time:

CODE

=begin
my first
block comment
=end

line_of_code

Although block comments can start on the same line as =begin, the =end must have its own line. You cannot insert block comments in the middle of a line of code as you can in C, C++, and Java, although you can have non-comment code on the same line as the =end.

CODE

=begin my first
block comment
=end line_of_code

Reserved Words

Ruby has a set of Reserved rules, just like many other programming languages, these cannot be changed or used for something else like a
variable. Most of these words are listed bellow.

CODE

alias   and     BEGIN   begin   break   case    class   def     defined?
do      else    elsif   END     end     ensure  false   for     if
in      module  next    nil     not     or      redo    rescue  retry
return  self    super   then    true    undef   unless  until   when
while   yield

Classes and objects

Classes and objects are obviously central to Ruby, but at first sight they can seem a little confusing. There seem to be a lot of concepts: classes, objects, class objects, instance methods, class methods, and singleton classes. In reality, however, Ruby has just a single underlying class and object structure, which well discuss in this chapter. In fact, the basic model is so simple, we can describe it in a single paragraph.

A Ruby object has three components these are a set of flags, some instance variables, and an associated class. A Ruby class is an object of Class, which contains all the object things plus a list of methods and a reference to a superclass (which is itself another class).

All method calls in Ruby nominate a receiver (which is by default self, the current object). Ruby finds the method to invoke by looking at the list of methods in the receivers class. If it doesn't find the method there, it looks in the superclass, and then in the superclass superclass, and so on. If the method cannot be found in the receivers class or any of its ancestors, Ruby invokes the method method_missing on the original receiver.

Creating Classes

Classes represent a type of an object, such as a book, a whale, a grape, or chocolate. Everybody likes chocolate, so lets make a chocolate class:

CODE

class Chocolate
  def eat
    puts "That tasted great!"
  end
end

Lets take a look at what we've just done. Classes are created via the class keyword. After that comes the name of the class. All class names must start with a Capital Letter. By convention, we use CamelCase for class name. So we would create classes like PieceOfChocolate, but not like Piece_of_Chocolate.

The next section defines a class method. A class method is a method that is defined for a particular class. For example, the String class has the length method:

CODE

# outputs 5
puts hello.length

To call the eat method of an instance of the Chocolate class, we would use this code:

CODE

my_chocolate = Chocolate.new
my_chocolate.eat # outputs "That tasted great!"

Defining Methods

Methods are defined using the keyword def followed by the method_name. Method parameters are specified between parentheses following the method name. The method body is enclosed by this definition on the top and the word end on the bottom. By convention method names that consist of multiple words have each word separated by an underscore. Some programmers find the Methods defined in Ruby very similar to those in Python.

CODE

def method_name(value)
  puts value
end

To define a method that doesn't need to take in any values don't add any parameters after the method_name

CODE

def method_name
  puts "hello"
end

If multiple variables need to be used in the method, they can be separated with a comma.

CODE

class SomeClass

  def initialize(msg, person)
    print "Hi, my name is " + person + ". Some information about myself" + msg
  end

end

How to call this method:

CODE

instance = SomeClass.new("im 17","LegACy")

Output:

im 17 is the msg string and LegacyX is the person string

hi my name is LegACy. Some information about myself: im 17

Any object can be passed through using methods

CODE

def myMethod(myObject)
#Check to see if it defined as an Object that we created
#You will learn how to define Objects in a later section
  if(myObject.is_a?(Integer))
    puts "Your Object is an Integer"
  end
end

The return keyword can be used to specify that you will be returning a value from the method defined

CODE

def myMethod
  return "Hello"
end

Superclass(Inheritance)

A class can inherit functionality and variables from a superclass, sometimes referred to as a parent class or base class. Ruby does not support multiple inheritance and so a class in Ruby can have only one superclass. The syntax is
as follows:

CODE

class ParentClass
  def a_method
    puts 'b'
  end
end

class SomeClass <  ParentClass # " < " means inherit (or "extends" if you are from Java background)
  def another_method
    puts 'a'
  end
end

How to call this:

CODE

instance = SomeClass.new
instance.another_method
instance.a_method

Output:

a
b

All non-private variables and functions are inherited by the child class from the superclass. If your class overrides a method from parent class (superclass), you still can access the parents method by using the super keyword.

CODE

class ParentClass

  def a_method
    puts 'b'
  end

end

class SomeClass <  ParentClass

  def a_method
    super
    puts 'a'
  end

end

how to call this:

CODE

instance = SomeClass.new
instance.a_method

Output:

b
a

Operators


Assignment

Assignment in Ruby is done using the equal operator =. This is both for variables and objects, but since strings, floats, and integers are actually objects in Ruby, you're always assigning objects.
Examples:

CODE

myvar = 'myvar is now this string'
var = 321
dbconn = Mysql::new('localhost','root','password')

Self assignment

CODE

x = 1 #=>;1
x += x #=>; 2
x -= x #=>; 0
x += 4 #=>; x was 0 so x= + 4 # x is positive 4
x *= x #=>; 16
x **= x #=>; 18446744073709551616 # Raise to the power
x /= x #=>;1

A frequent question from C and C++ types is How do you increment a variable? Where are ++ and -- operators? In Ruby, you should use x+=1 and x-=1 to increment or decrement a variable.

CODE

x = 'a'
x.succ! #=>; "b" : succ! method is defined for String, but not for Integer types

Multiple assignments

Examples:

CODE

var1, var2, var3 = 10, 20, 30
puts var1 #=>; var1 is now 10
puts var2 #=>; var2 is now 20,var3...etc

Control Structures

Ruby can control the execution of code using Conditional branches. A conditional Branch takes the result of a test expression and executes a block of code depending whether the test expression is true or false. If the test expression evaluates to the constant false or nil, the test is false; otherwise, it is true. Note that the number zero is considered true, whereas many other programming languages consider it false.

In many popular programming languages, conditional branches are statements. They can affect which code is executed, but they do not result in values themselves. In Ruby, however, conditional branches are expressions. They evaluate to values, just like other expressions do. An if expression, for example, not only determines whether a subordinate block of code will execute, but also results in a value itself.

if expression:

CODE

a = 5
if a == 4
a = 7
end
print a # prints 5 since the if-block isn't executed

You can also put the test expression and code block on the same line if you use then:

CODE

if a == 4 then a = 7 end
#or
if a == 4: a = 7 end

if-elsif-else expression

The elsif (note that its elsif and not elseif) and else blocks give you further control of your scripts by providing the option to accommodate additional tests. The elsif and else blocks are considered only if the if test is false. You can have any number of elsif blocks but only one if and one else block.

Syntax:

CODE

if   #expression
#...code block...
elsif   #another expression
#...code block...
elsif   #another expression
#...code block...
else
#...code block...
end

Variables and Constants

A variable in Ruby can be distinguished by the characters at the start of its name. There's no restriction to the length of a variables name (with the exception of the heap size).

Local Variables

A variable whose name begins with a lowercase letter (a-z) or underscore (_) is a local variable or method invocation. A local variable is only accessible from within the block of its initialization.

Example:

CODE

foobar

Instance Variables

Instance variables are created for each class instance and are accessible only within that instance or through the methods provided by that instance. They are accessed using the @ operator.

Example:

CODE

@foobar

A variable whose name begins with @ is an instance variable of self. An instance variable belongs to the object itself. Uninitialized instance variables have a value of nil.

Class Variables

Class variables are accessed using the @@ operator. These variables are associated with the class rather than any object instance of the class and are the same across all object instances. (These are the same as class static
variables in Java or C++).

Example:

CODE

@@foobar

Global Variables

A variable whose name begins with $ has a global scope; meaning it can be accessed from anywhere within the program during runtime.

Example:

CODE

$foobar

Constants

A variable whose name begins with an uppercase letter (A-Z) is a constant. A constant can be reassigned a value after its initialization, but doing so will generate a warning. Every class is a constant. Trying to substitute the value of a constant or trying to access an uninitialized constant raises the NameError exception.

Usage:

CODE

FOOBAR

Pseudo Variables

CODE

self

Execution context of the current method.

CODE

nil

The sole-instance of the NilClass class. Expresses nothing.

CODE

true

The sole-instance of the TrueClass class. Expresses true.

CODE

false

The sole-instance of the FalseClass class. Expresses false. (nil also is considered to be false, and every other
value is considered to be true in Ruby.)
The value of a pseudo variable cannot be changed. Substitution to a pseudo variable causes an exception to be raised.

1.3 Intermediate Ruby

Arrays & Hashes

An array is a collection of objects indexed by a non-negative integer. You can create an array object by writing Array.new, by writing an optional comma-separated list of values inside square brackets.

CODE

array_one = Array.new
array_two = [] # shorthand for Array.new
array_three = ["a", "b", "c"] # array_three contains "a" , "b" and "c"

array_three[0] # =>; "a"
array_three[2] # =>; "c"

Negative indices are counted back from the end

CODE

array_four[-2] # =>; "b"

[start, count] indexing returns an array of count objects beginning at index start

CODE

array_four[1,2] # =>; ["b", "c"]

Using ranges. The end position is included with two periods but not with three, well learn more about ranges later.

CODE

array_four[0..1] # =>; ["a", "b"]

array_four[0...1] # =>; ["a"]

Hashes are basically the same as arrays, except that a hash not only contains values, but also keys pointing to those values. Each key can occur only once in a hash. A hash object is created by writing Hash.new or by writing an optional list of comma-separated key => value pairs inside curly braces.

CODE

hash_one = Hash.new
hash_two = {} # shorthand for Hash.new
hash_three = {"a" =>; 1, "b" =>; 2, "c" =>; 3} #=>; {"a"=>; 1,"b"=>; 2, "c"=>; 3}

Ranges

A range represents a subset of all possible values of a type, to be more precise, all possible values between a start value and an end value.

This may be:

All integers between 0 and 5.
0..5
All numbers (including non-integers) between 0 and 1, excluding 1.
0.01.0
All characters between t and y.
t..y

Therefore, ranges consist of a start value, an end value, and whether the end value is included or not (in this short syntax, using two .. for including, and three ... for excluding). A range represents a set of values, not a sequence. Therefore,

CODE

5..0

though syntactically correct, produces a range of length zero.

Ranges can only be formed from instances of the same class or subclasses of a common parent, which must be Comparable (implementing <=>). Ranges are instances of the Range class, and have certain methods, for example, to determine whether a value is

inside a range:

CODE

r = 0..5
puts r === 4 # =>; true
puts r === 7 # =>; false

Method Calls

Methods are called using the following syntax:

method_name(parameter1, parameter2,

If the method has no parameters the parentheses can usually be omitted as in the following:

CODE

method_name

If you don't have code that needs to use method result immediately, Ruby allows to specify parameters omitting
parentheses:

CODE

results = method_name parameter1, parameter2 # calling method, not using parentheses

You need to use parentheses if you want to work with the result immediately. e.g., if a method returns an array and we want to reverse element

order:

CODE

results = method_name(parameter1, parameter2).reverse

Return Values

Methods return the value of the last statement executed. The following code returns the value x+y.

CODE

def calculate_value(x,y)
x + y
end

An explicit return statement can also be used to return from function with a value, prior to the end of the function declaration. This is useful when you want to terminate a loop or return from a function as the result of a conditional expression.

Note, if you use return within a block, you actually will jump out from the function, probably not what you want.

To terminate block, use break. You can pass a value to break which will be returned as the result of the block:

CODE

six = (1..10).each {|i| break i if i>; 5}

In this case, six will have the value 6.

Class Definition

Classes are the basic template from which object instances are created. A class is made up of a collection of variables representing internal state and methods providing behaviours that operate on that state.

Classes are defined in Ruby using the class keyword followed by a name. The name must begin with a capital letter and by convention names that contain more than one word are run together with each word capitalized and no
separating characters (CamelCase). The class definition may contain method, class variable, and instance variable declarations as well as calls to methods that execute in the class context, such as attr_accessor. The class declaration
is terminated by the end keyword.

Example:

CODE

class MyClass
  def some_method
     #code goes here
  end
end

If you have any questions please feel free to ask, and i will answer them to the best of my ability.

[koira92]

Wow, took me a while to read this! But I must say this is a really nice help for beginners & a bit over beginner lvl!
+Rep

[Legacy]

Thank you, i put allot of effort into this, although it is for beggineres i added a few things that begginers will come accross in RGSS such as the hash and arrays.

I tried to explian as simply as possible, and as well as possible.

Part 2 is getting writen as we speak

[MagitekElite]

Part 2?

This is the best tut I've seen for RPG XP, for anything. It gives great detail ^^
Although, I'm not sure if these "�€�" are something important I can't see and need to know...

Anyway, I'm halfway through this -- taking in as much as I can -- and I'd love to see part 2 come out so I may continue.

[Legacy]

those ""�€�" are uni code characters, ill have to sort that out. Sorry about that and thank you for noticing.

Yeah part 2 should be out really soon, im working on it right now^^

This post has been edited by LegacyX: Feb 16 2010, 02:24 AM

[redyugi]

Very helpful. I would like to point out that this tutorial also helps for RGSS2, because it is based on Ruby.

[Legacy]

I will be doing a RGSS and RGSS2 orientated Tutorial. And yes, they are both Ruby orientated, so this will help allot. (which is why i did this one first )

[MagitekElite]

those ""�€�" are uni code characters, ill have to sort that out. Sorry about that and thak you for noticing.

Yeah part 2 should be out really soon, im working on it as we speak ^^

I can't wait! I'm gonna read the rest now ^^

[Legacy]

Thanks for the intrest. I shall hopefully be finished with Part2 in a few hours, maybe a few days ... or a week if i dont get the BSOD again like last time :'(

Well anyway you can always check my sig to see if it's posted yet.

[MagitekElite]

Alright then, I'll keep an eye out ^^

[vincevince]

wow, this is great! i read the first few and tripled my knowledge about RGSS haha, im what the cool kids call a "noob" at xp scrips, but not for long

[Legacy]

Sorry about the long wait for the second part to this tutorial. Just its taking longer than expected and i have other things to do as well. im still writing it in my spare time, don't worry it will deffinetly be worth the wait.

[poisonshift]

LegACy, this is amazing. I've wanted to learn to script, and this is so easy of a tutorial I just might be able to do it now. Thanks a ton!

[Rukiri]

I may be excellent with just about any C syntaxed language but wanted to branch off to something different.
This is a grade A tutorial my friend!

You might want to include RGSS/2 tutorials as well.

[Legacy]

I may be excellent with just about any C syntaxed language but wanted to branch off to something different.
This is a grade A tutorial my friend!

You might want to include RGSS/2 tutorials as well.

RGSS/2 tutorials are already planned. RGSS windows, scenes and just the basics are included in the next part, after which will follow the same but in RGSS2 and covering all the new features and functions in the third part.

[Zackwell]

I've read this a few times now. It's a great tutorial Regashi. ^^
If a bit heavy to try to digest all at once, it's helped me with my own scripting attempts. X3

[Ratty524]

Greigh, the last post is at least two months old.

Please, do not necropost.