Congratulations on buying RPG Maker VX Ace. Its a great program for making games. Though it is technically slated for RPG games only, you can make it very different by using scripts. This guide will not be an in-depth guide to scripting. Though I will attempt to teach you the basics, this will also be for useful tips and tricks, as well as common problems that I've encountered during my time doing scripts.

So on with the basics. It would help greatly if you knew the Ruby programming language. RGSS3 is based off of Ruby. There are many great places you can learn Ruby, such as Ruby Monk[www.rubymonk.com] or Learn Code the Hard Way[ruby.learncodethehardway.com]. These will each step you through the ruby language bit by bit, but I find that ruby monk is much more fast paced, and learn code the hard way is much more repetitive. I will try to make this as basic and informative as possible, but I cannot guarantee that I will explain everything.

What we have so far:

• Variables
  
• Switches
  
• Assingment Operators
  
• Attribute Accessors.
  
• Classes and Modules

To do:

• Adding configuration to your script

Variables are crucial to the game. They can hold many differnet kinds of numbers, such as the number of tiles walked, the amount of money you have, or how many battles you've won or lost. There are three types of variables that will be explained in this guide,

• Local Variables
  
• Global Variables
  
• Game Variables

Local Variables

Local variables are used in scripting to store values. They are used strictly by the script that created them. they store values that they are told to by the programmer. Local variables are usually used to determine math within a script so that it knows what to change in the game.

Creating a local variable is very easy.

Thats all you need to do. Variable is the name you want to give it. You use its name to refer to it later in your script. Value is what you want your variable to store.

Ruby variables are very flexible. If you're familiar with most other kinds of languages, you'd know that you need to specify what kind of data you want your variable to store. For example, in C++, you need to be very specific and say which type of variable (integer, float, etc). However, Ruby is very flexible. You don't need to say what kind of variable you are making. It can store anything, and it can be changed to anything, unlike most others.

Now that we've created our variable, we want to give it something to store for us. As you've seen in the examples above, we put a value to our variable by doing
The '=' puts the Variable_value into our lovely little variable, Variable_name. Variables can be changed at any point in the script. You cna give them a value when you first make them, you can change it 10 lines later, you can change it 10,000 lines later, it doesn't matter. You can always change the variable.




Now, we learned that local variables are used by the programmer to store values that the program will use later, whether for decisions or to have them put into a game variable (We cover game variables next! scroll down a little ;) ). Now, if you've opened the script editor in RPG Maker, then you've got a 115% chance of noticing that there are many more than just one script in there.

As you can see, there are a great number of scripts in the editor. When you make a script, you can give it a name, just like the ones in the image to the right. You then write your script. The variables that the section above showed you were local variables, meaning that they only exist to the script that made them. Well alright, what does that mean?

Well lets make an example:

We'll have:

• Two Scripts
  
• Variables
  
• An advanced thing or two that I'll explain later.

The first script will multiply two numbers, the other will print out the product.

Multiplyer Script:
Printer Script:

These wouldn't work. The game would tell you that there is a reference to an unknown method or variable. So how do we fix this? We make the variable number3 a global variable.

Global variables can be seen, copied, and editted from any script no matter if they made it or not. Editting a global variable in one script will change it for all other scripts as well.


So how do we make a variable global? We put a dollar sign ($) in front of the name. So the local variable 'number3' becomes the global variable '$number3'.

Multiplyer Script:
Printer Script:

Remember to put the $ when using the variable, and becareful about editing it.


Finally we get to the game variables. By now you've probably used the game variables by using the Control Variables event command. But now, how do we change the game's variables in a script? It has to be done somehow, since the default system does it, though through an interface that is easy to use.

Well, there is (obviously)! Its also very easy to use. The game variables are stored in an array, which is essentially just a spreadsheet full of values, if you've ever used Microsoft Excel, or any other spreadsheet application. This array stores the values of the variables. To make sure that the values change across every script, since there are so many that would use them, it is a global array.

Whats the difference between a global array and a global variable? None at all, an array is a variable.

So how do we access the game variables? Simple! All you have to do is the name of the array, which conveniently happens to be $game_variables. Make sure to include the $! Now, although arrays are variables, we use these a little bit differently. Recall how I said that an array is like a spreadsheet about five seconds ago? (The game variables are stored in an array, which is essentially just a spreadsheet full of values) We have to let the program know which value inside the array we are going to change.

So which one will we change? Well it depends on the situation. In the screen show in the picture above, you can name your variables (This does not change them at all, it just organizes that screen a bit). Again, naming them just makes it more organized and so that you know what variables are for what so you don't accidentally overwrite them. I'd recommend you name them in the Control Variables screen so that you're sure you're using an unused variable.

So for our example, we'll just change the very first game variable. The first one thats in the variable window (and the highlighted on in the picture).

So now, accessing values in an array. You take the array name, $game_variables, you take square brackets ( [ ], usually near the Enter key) and you put the number of the variable you want to change. So to change variable #1, you would use


Now comes a bit of an experimental part. Although the Control Variables window only allows you to set integer values, you can set them to strings or possibly even more arrays (have not tested arrays, but strings work). However, a normal conditional branch won't work if the value is not a number. You need to go to the 4th page and make a script, somethin similar to:


Set the variable to something that isn't a number...

Check if the first variable is equal to 'apple'


Now comes the weird part: If you add, subtract, modulous (mod, %), divide, or set the variable in the Control Variables window, then the variable will be set to 0. Using multiply on a string will use Ruby's built-in command and it will set the variable to the text it had, multiplied x times. for example:

Multiply the variable by.. lets say 5, then it will be equal to: appleappleappleappleapple

Multiply is the only function with an effect that doesn't change the variable back to 0, but rather multiples the number of times the string is saved.

This section is much simpler than the variable one, if you found that a little difficult :p

Switches, much like variables, are very important to a game. If you've ever done any program, even very basic programming, then you've probably worked with something called a boolean variable. A boolean variable is simple a variable that holds one of two possible values, True, or False. An example of something being true is 1 == 1. If 1 is equal to 1, then it is true.

Switches are a separate set of variables that only hold a true or false value. So how do we use these? In a game made with RPG maker, switches are used to say whether a condition is met, true, or if it isn't, false. Switches are often used when a cutscene is beginning (or ending), after starting and completing a quest, or after getting to a certain point in the map.

In a script, switches are controlled just like a normal variable, except with in-game switches we edit them just like the game variables, with the global variable $game_switches[]. You put the number of the switch inside the square brackets, [ ].

So why would we use these in a script? You can use this to check whether or not a switch is on to decide if you should run a bit of code. These are really only used in conditional branches, or statements that check conditions. If 1 == 1 is an example of a true conditional statement.

You can also use this in a script to change a switch. Instead of explicitly calling it in an event, you can use the script line
to change the value. Replace the number 3 with whatever switch you want to change.

Now, lets talk about assigning values to variables, and also comparing those values. We already know that we can set a variable equal to a value by using the equals sign, just like

Now thats great and all, but what if we want to change that value? Yes, we could do it the same way, using a definite value, or even variables for a little variety, but what if we want to add or subtract a set amount? Well, this would work, wouldn't it?

Yes, that would work just fine. But there's another way to do this. It's faster to type, and it looks cleaner. It doesn't really matter which way you do it, as they both provide the same result, but the following way looks nicer than the former.

So now what did we just do here? We took the variable 'one' and we set it to add 2 to the current value. It looks much cleaner, and it'll take less time to type since there's less to type.

Now that's great and all, but can we do anything other than add? Yes, you can do all the operations!

Ok, cool, that'll work. But, what's that percent sign doing there? In programming, division will only give you the whole number. 5 / 2 will give you 2, because 2 goes into 5 one time completely. Modulous, the percent sign, will give you the remainder. 5 % 2 will give you 1, because 2 goes into 5 two times, with one left over.





So now that you've figured out how to assign variables values in a few different ways, lets look into how we can compare them. Comparing values is a huge part of programming. If statements, a crucial part to programs, is just a comparison. If 1 is equal to 1, run this bit of code after me.

So how many ways can we compare our variables and values? There's a lot of them, so stay focused.

So I've mentioned it before, to see if a variable is EXACTLY equal to a value, you would use

Now, that's one way, but how else can we do this? What if we want to see if the variable is greater or lesser than a value? Easy!

And that's all you need to do. But wait! That is only checking if the value is greater or lesser than another! what if we want to see if it is greater/lesser OR equal to? well, then we'll just take the above code and turn it into

By putting the equal sign after the > or <, you're telling the game to see if the first value is greater/lesser than or equal to the second value.

Now that we've gone over that, let's go into multiple comparisons. It's great that we can compare one thing to another, but what if I want to compare multiple things at one time? Sure, I can make a whole set of if statements to test each condition before I let the code bit run, but why do it that way? We can just use the AND or OR operators.

In Ruby, AND and OR can be represented in two different ways. You can use the words and/or, or you can use the symbols that other programming languages use. The AND symbol you could probably guess, it's a double ampersand (&&), but what about the OR symbol? The OR symbol is a double pipe (||). Now why do we need to use these symbols twice? There mustbe two symbols when using them for comparison.

So lets use this in an example:

In the previous example, the text "True" would be printed to a console window because all the conditions were true. Be careful when using AND and OR, however. With AND conditions, if a single condition anywhere in the if statement is not true, the code will not execute. With OR conditions, if a single condition is true, then the code will be run.



Things I didn't explain in this guide (you can google them, and perhaps later I'll add them):

• ^=
  
• |=
  
• !=

When programming your scripts for RPG Maker VX Ace, you've probably ran into a situation similar to something like this:



Well why does this break? I have the variable fruit in there, and I'm trying to change it with an object of that class, so why does it say no method? Well, in Ruby, if you're going to try to change a variable within a different class, or with an object, you need to do one of two things, the easy way or the "hard" way.

The "hard" way is to make a method for what you're trying to do.


The "hard" way is to make a function for it. fruit= will let you change the the name of the variable, and fruit? will give you the value of fruit. Well why do they have names like that? Fruit= and fruit? ? This is because you're telling ruby you have a method to change the value of the variable fruit, which is fruit=, and then also one to read the value of fruit, fruit?.

Now let's look at the easy way.


And you're done. What have we added? Just that little line at the top, attr_accessor :fruit. What this does is, in simple terms, create the methods for you. This is a shortcut to making those two methods for changing that variable. It's ok if you make the methods yourself, but it's faster and easier to do it this way, especially when you want to be able to change more and more variables.



attr_reader

As the name implies, attr_reader will let you see the value of a variable. It will not let you touch it, only looking. With attr_reader you can ensure that you won't break your game by changing the variable outside of the class. The methods in the class can still change it, because it is defined and exists there, but attr_reader will not let any outside method at it, they'll break the game, saying that you're trying to change the value of a read-only variable.

attr_writer
The names are just so cryptic. Attr_writer is the opposite of attr_reader, you can change the variable as much as you want, but you can't look at it. You may never know the value of the variable until you change it, since this won't let you see what it is at any point int the program's life.


But what If I want to do both read and write to a variable? Well, you can easily include both in your class. It won't break anything, but it'll get to be bigger and bigger. Or, you could do as we've done above and use attr_accessor

attr_accessor
Attr_accessor does both read and write for you. It is just a more compressed way to do it. It's a good idea to use this if you want to be able to read and write to the variable.



At the top of the class definition, just put what kind of accessor you want, followed by a symbol of the variable. In Ruby, a symbol is any string preceded by a :, so in the example fruit script above, our symbol would be :fruit.

Just make sure your symbol is the same as your variable name, and make sure the first letter is lowercase for both the symbol and the variable. Uppercase will note the variable as a constant, which cannot be changed at any point in the program, it is a constant value that can only be changed when the program is stopped.

Classes and modules in Ruby are very basic building blocks. In RGSS, nearly everything is in a class or a module. So what do classes and modules do? In simple terms, they hold things.


Classes are used with objects. An object is, after all, the 'pet' of a class. What you use in programming with Ruby is all based on an object. Integers are technically objects of the Integer class, for example. But what does an object mean in terms of a class? The object of a class is kind of like a house pet. It gets to use everything that it's owner has. If you define the class animal like so:

**Note: Class and module names must begin with a capital letter, otherwise you will receive an error about them not being constant. Constants in Ruby begin with a capital letter. Constants don't change during runtime. Ever.


And then we make a new Animal object, pet:


Then the variable 'pet' has become an object. It has access to all the methods we defined in the class Animal. So now we can freely do something like this:


The pet object can use any of the methods we put in the Animal class because it is an object of that class. Creating an object is usually done by using an instance variable. These variables are the same as normal variables, but their name is preceded by an '@' sign. So in the case of the example above, our object would be


But why do we use instance variables? Why not a normal variables, won't they work the same? Yes, they will work the same way. However, there are benefits to using instance variables. In the example above, the program worked fine because the variables were defined outside any methods, making them available to the whole class. However, if we had something like this:


and we then call the methods:


You will see that there's an issue on the line pet.spots. It makes use of the variable 'color' that was made using the method call above it. However, color was defined within a method, making it only available to that method. You can probably guess now that an instance variable is available to the whole class, no matter where it was defined. Instance variables can hold any kind of data, not just objects. Instance variables are global to your class.

So why do we use these when making objects of classes? Because chances are you're not just making an object that you will only control with a single method. In same cases this is true, where you will not need an instance variable, but in most of the time you want to make it in one place and use it elsewhere in your program. Just remember that they only available to the class. Even further, they are, as the name implies, only existent to each copy of the class. For example:


'@one.get_name' will return the letter D because it was changed for it. '@two.get_name', however, returns the letter A because it was not changed. Instance variables are only changed in their object.

So there's no way to keep an instance variable the same through all objects of a class? Not even ones used ever time? Wrong! There is a way, but this is yet another type of variable. There are a lot of variable types in any programming language, and Ruby is no different. In C, C++, C#, Java, and many more programming languages, you may know something like this as the 'static' modifier. When used to define a variable in a class, static means that no matter how many different objects there are of that class, each one has the same variable pointing to the exact same value. Changing it in one object would change them all. Instead of 'static', ruby uses '@@'.

Very similar to instance variables are what, in Ruby, are called class variables. Class variables are static, and exist in every object. Change it one object and it's changed for all of them. I find that examples are easier to understand than paragraphs of text, so here's an example:


Both variables had the value of 'apples' changed because it is consistent between every single object of the class.

So are we done with classes now? Nope! We still have to go over one very important detail with classes. What if we want to set some values when the object is first created? What do we do then? By default, when you create a new object, the class' 'initialize' method is called. This will be run before the next line of code is run. For example:


You can even specify a number of arguments that the class takes by default. Just change the definition of initialize to something that suits your needs.


Just be sure now that when you define the object you pass in the arguments like you would to a normal method





So what's different about modules? If they both hold things why would there be two. The difference between modules and classes is actually fairly large. They both hold variables and methods, but classes can have instances(objects), and modules cannot. A class is, however, able to include and use what is in a module. It's similar to how a family works. The child doesn't really own the TV, or even 'their' room, but they use it. Modules and classes are similar. The module is the parent, because it owns things, and the class would be the child because it doesn't own everything itself, but it uses them. You declare a module just like a class, but instead of 'class', use 'module'.

So how do I include what is in a module into my class? Ruby has a built-in function for that. All you need to do is, at the top of your class, 'include' it.


And now your class USB can use anything inside of Electronic. Nice, simple, and a great way to use a template (module) for multiple different classes.

But wait, there's more! With your order of Free RGSS Learning, learn that modules can't have objects. They will not work, you will get an error, and it will break. Trying to do something like


will not work. you can not make an object with a module. You can make an object of USB, which then has access to Electronic, but you can't directly make an object of Electronic.

Remember when we went over variables? Yea, we went over three kinds, but there are more!

Right now we're going to go over Instance Variables and Class Variables.

____________________________________________________________________________

Instance variables are tied to an instance (hence the name) of the class. But why use them? What makes them soooo special? Well, just like a local variable, they hold a value. They're a type of variable, what else would you expect them to do if they can't hold a value? But now is when they get extra useful! They're sort of like global variables in the sense of where they can be used. We already know that local variables are tied to the method that created them, and global variables can be used in any class in any method and at any time. Instance variables, though, are not global nor local. They're pretty much both. They are global to the entire class/module that it was created in, but in another class, it doesn't exist. Consider the following:


They're really convenient, and they're not difficult to reference, their names simply have an '@' in the front.

Now, instance variables are also tied to the instance of the class, meaning they won't be the same for each object. For example:


These are used very often in RPG Maker since different variables are used in a lot of different methods and need to get there somehow.


____________________________________________________________________________

Class variables are even more like global variables. They're really an upgraded instance variable. Like instance variables, they can be used anywhere in the class(they're still tied to the class that made them), but now they keep the same value across EVERY object of that class. They're names are also nearly identical to instance variables. With instance variables you put an '@' in front of the variable name, well with class variables why not just slap a second one on there for a grand total of @@variable_name.


These are really useful if you have multiple instances of the same class and they all need to have the same value for one or more variables. Be careful when changing them, though, it changes it for every one!