Help RPGmaker

RGSS Reference Manual RGSS (Ruby Game Scripting System) uses the object-oriented scripting language Ruby to develop 2D games for the Windows® platform.

Contents

RGSS Specifications Ruby Syntax

Syntax and Expressions Variables and Constants Literals Operator Expressions Control Structures Method Calls Class and Method Definitions

Standard Library Built-in Functions Built-in Variables Built-in Classes Built-in Modules Built-in Exception Classes

Game Library RGSS Built-in Functions RGSS Built-in Classes RGSS Built-in Modules RPGVX Data Structure

Appendix Regular Expressions sprintf Format

About This Document

This document presents a selection of entries from the Ruby reference manual, the bare minimum needed for using RGSS. It has been edited to include explanations of RGSS's unique specifications as well. Aimed at RGSS users, we've greatly scaled back on those areas that aren't important for game programming and updated each entry. This means that some portions might not be strictly accurate; as a Ruby reference, it's no more than a quick-and-dirty guide and should be treated as such.

The original Ruby language, as well as the source for this document, can be found at the official Ruby homepage: http://www.ruby-lang.org/. Check it out if you need more detailed Ruby information.

User Support

Enterbrain provides no user support for creating games with the script editor or any problems that may arise from the game-creation process. Furthermore, neither Enterbrain nor Yukihiro Matsumoto assume any responsibility to provide

of 172RGSS Reference Manual

12/13/2010file://C:\Documents and Settings\Admin\Local Settings\Temp\~hh3715.htm

Ruby script support. Be sure you have a thorough understanding of RGSS's functions when attempting to edit a script.

Be a responsible programmer--make sure to check these pages, the Ruby homepage, any other Ruby information and support sites, and similar resources before approaching a site administrator for assistance.

RGSS Specifications Differences from the Previous Version Starting a Game Game.ini RGSS-RTP

Installation Data Encrypted Archives Other

Character Set Frame Rate Properties

Differences from the Previous Version (RGSS2)

RGSS2, which is incorporated into RPG Maker VX, has a number of differences from RGSS1, which was included with RPG Maker XP. The main differences are listed below.

The default resolution has been changed from 640×480 to 544×416 and the default frame rate has been changed from 40 to 60. Smooth Mode has been removed. Double buffering is now used for drawing in Full Screen mode. If your computer meets the recommended specifications, scrolling should be very smooth. The function that would assume that the program had hung up if the screen had not been refreshed for a long period of time and automatically perform a force quit has been removed. Even if the screen is not refreshed, Windows messages will still be processed normally, so in most cases you can force quit by using Alt+F4 as usual. It is now possible to easily perform a fade-in or fade-out of the screen. To do this, you use the Graphics.fadeout and Graphics.fadein methods. It is now possible to get a bitmap image of the current game screen. To do this, you use the Graphics.snap_to_bitmap method. The tilemap (Tilemap) class has been significantly changed to match the RPGVX map specifications. It is now possible to use effects such as Blur or Radial Blur with bitmaps (Bitmap). For sprites (Sprite), a wave effect (similar to a raster scroll effect) is now supported. By placing font files in the Fonts folder inside the game folder, it is now possible to directly use fonts that are not installed on the system. Shadow text is now supported for the Font class (Font). A number of the default values were also changed. It is now possible to change viewport (Viewport) associations after the fact. Sprites and other elements associated with viewports will no longer be automatically freed. The timing with which the BGM restarts after ME playback has been improved (Audio.me_play).

In addition to the above, a number of other minor changes have been made.

In this manual, functions or specifications that have been changed for RGSS2 will be marked with a (RGSS2) symbol.



Starting a Game

Normally, you launch RGSS by double-clicking the icon for the game file, Game.exe (or Game if the Windows option "Hide extensions for known file types" has been turned on). The folder that contains this file is called the game folder.

In-progress games can be started up by selecting [Playtest] from the menu or [Battle Test] from the Troop database. When this is done, the global variable $TEST will be set to true. When performing a Battle Test, the $BTEST variable will also be set to true. With RGSS1, the value of the Ruby built-in variable $DEBUG was changed but this was removed because differences in behavior could lead to problems in rare cases. (RGSS2)

Game operation is specified in Game.ini, the configuration file.

Game.ini

The Game.ini file is automatically created and updated by RPGVX. It can also be edited manually with Notepad or another text editor.

Example:

[Game] RTP=RPGVX Library=RGSS200E.dll Scripts=Data\Scripts.rvdata Title=RubyQuest

RTP

The title of the RGSS-RTP the game is using. Usually "RPGVX".

If the specified RTP isn't installed, an error message will be displayed.

Library

The name of the RGSS DLL. This file is usually installed in the RTP folder.

If there's a DLL specified in the game folder, it will be given precedence.

Scripts

The data file in which scripts are stored, specified with a path relative to the game folder.

Ruby's scripts usually take the form of text files with the extension .rb, but RGSS uses one proprietary packaged file. This file cannot usually be edited without using RPGVX's script editor. The data is comprised of multiple sections and is executed in the listed order, as displayed.

Title

The game title, displayed in the game window's title bar.

RGSS-RTP

Game



RTP (Run-Time Package) is a mechanism that reduces game data size for distribution. RTP contains standard graphics and audio files used across many different games. Installing these resources as a common file before playing a game eliminates the need to download duplicate files over and over.

RTP files can use the following methods from the built-in game library to access files as though they were in the game folder. The extensions can be left off the file names that are passed to the methods below--their file types (such as .png or .mid) are identified automatically.

Bitmap.new, Audio.bgm_play, Audio.bgs_play, Audio.me_play, Audio.se_play, Graphics.transition

Installation Data

The standard RTP for RPG Maker VX is just "RPGVX" but it is now possible to use RTPs with different structures. If you know how to make an installer, follow these steps to create a unique RTP at the user level. However, using common names for RTP titles, such as "Extension", is not recommended; they might conflict with the names of new, official RTPs in the future.

By default, RTP is installed in the following folder: (RGSS2)

[CommonFilesFolder]\Enterbrain\RGSS2\[RTPName]

Here, [CommonFilesFolder] is the location of the Windows "Common Files" folder, while [RTPName] is the name of the RTP. Here's an example:

C:\Program Files\Common Files\Enterbrain\RGSS2\RPGVX

The RTP installer creates a string value containing the RTP name in the "HKEY_LOCAL_MACHINE\SOFTWARE\Enterbrain\RGSS2\RTP" registry key and uses it to set the path. RGSS recognizes the string specified in this key as the RTP. (RGSS2)

Encrypted Archives

Encrypted archives make it difficult for others to analyze and/or rebuild the game contents. Normally all data and graphic files (not audio and font files) are stored in Game.rgss2a. You can create an encrypted archive by checking the [Create encrypted archive] box when compressing the game data.

The files within the encrypted archive can use the following methods from the built-in game library to access files as though they were in the game folder:

load_data, Bitmap.new, Graphics.transition

When there is an encrypted archive in the game folder, the script data (normally Data\Scripts.rvdata) defined in the Scripts line of Game.ini will always be read from the archive. This is a limitation that prevents files within the archive from being read by an external script.

Due to its nature, the encrypted archive's internal format has not, and will not, been released to the public. Please refrain from analyzing it.

Other



Character Set

RGSS uses the UTF-8 character set. UTF-8 is a way of encoding Unicode, a character set that can display letters and characters from all the world's languages.

Ruby's built-in variable $KCODE (not included in this reference) is set to "UTF8" by default. RPGVX's script data and all other string data are also in UTF-8, so you don't have to worry about any encoding conflicts as you build your game.

Frame Rate

The standard frame rate for RGSS2 games is 60 frames per second. With RGSS1, it was possible to turn the Smooth Mode option off and skip drawing some frames, thereby making games run at half frame rate, but this has been eliminated with RGSS2.(RGSS2)

You can change the framerate with Graphics.frame_rate.

Properties

The term "property" is used in the game library overview. This is not a concept in Ruby's specifications, but rather a term unique to RGSS.

For example, this is how to obtain and set a sprite's x-coordinate (Sprite#x):

x = sprite1.x # obtain sprite2.x = x + 32 # set

For the sake of convenience, methods that are defined to both obtain (read) and set (write) via assignment operators in this way are called "properties".

When objects such as the Color class, the Tone class, or the Rect class are defined as properties, a reference to the object itself is returned to the caller, rather than a copy. Therefore, it is possible to change the color of a font by using this format:

color = font1.color color.set(255, 0, 0)

Ruby Syntax Syntax and Expressions

Identifiers Comments Reserved Words Expressions

Variables and Constants Local Variables Instance Variables Class Variables Global Variables Constants Pseudo Variables



Literals Number Literals String Literals

Backslash Notation Formula Development

Array Expressions Hash Expressions Range Expressions Symbols

Operational Forms Assignment

Self-assignment Multiple Assignment

and or not Conditional Operators

Control Structures Conditional Branching

if if Modifier unless unless Modifier case

Looping while while Modifier until until Modifier for break next

Exception Handling raise begin rescue Modifiers

Method Ending return

Calling Methods super Iterators yield

Defining Classes and Methods Class Definition Module Definition Method Definition

Method Evaluation



Unique Method Definition Class Method Definition Definition Controls

alias

Syntax and Expressions Identifiers Comments Reserved Words Expressions

Ruby is a case-sensitive language. Apart from within identifiers and some literals, blank space and comments may be placed anywhere as needed. Line breaks are treated as blank space only when used to clearly show a line is continuing; otherwise, they are treated as phrase delimiters.

Identifiers

Example:

foobar ruby_is_simple

An identifier in Ruby begins with an alphabetic character or underscore (_) and consists of alphanumeric characters or underscores (_). There is no limit on length.

Comments

Example:

# this is a comment line

Strings beginning with # are considered comments.

Reserved Words

The following are reserved words:

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

Reserved words cannot be used for names of classes, variables, or the like. However, words prefixed by $ or @ are not considered reserved. Furthermore, these words can be used as method names after def, after a method-call period, and in other cases where it is clear that the word is acting as a method name.

Expressions



Example

true (1+2)*3 foo() if test then ok else ng end

The term "expressions" encompasses everything from variables and literals to operational forms and control structures.

A collection of these expressions makes up a Ruby program. Expressions are separated from one another with semicolons (;) or line breaks. However, a line break following a backslash is not considered a new expression boundary; instead, the expression continues on the next line.

Expressions can be grouped with parentheses.

Variables and Constants Local Variables Instance Variables Class Variables Global Variables Pseudo Variables Constants

The type of variable or constant in Ruby--local variables, instance variables, class variables, global variables, and constants--can be determined from its initial character. Normally a variable has an alphanumeric name (outside of its first character) which can include an underscore, but some built-in variables begin with '$' + one character (see Built-In Variables).

Variables and constants point to specified objects. Assigning objects to variables and constants simply makes them point to new objects; it does not create new copies of objects.

Local Variables

Example:

foobar

Identifiers beginning with a lowercase letter or '_' are local variables or method calls.

Within a local variable's scope (classes, modules, method definitions), the initial assignment to an identifier beginning with lowercase letters is the declaration of that scope's local variable. Referencing undeclared identifiers is considered a call to a method with no arguments.

Instance Variables

Example:

@foobar



Variables beginning with '@' are instance variables and belong to specific objects. Instance variables can be referenced from any method of their class or subclass. When referenced, the value of an uninitialized instance variable is nil.

Class Variables

Example:

class Foo @@foo = 1 def bar puts @@foo end end

Variables beginning with @@ are class variables. Class variables are defined within the class definition and can be referenced/assigned from class-unique methods, instance methods, etc.

The differences between class variables and constants are as follows.

They may be reassigned (constants will give a warning if this is done). They cannot be directly referenced from outside the class (they may be referenced/assigned from an inherited class).

Global Variables

Example:

$foobar

Variables beginning with '$' are global variables and can be referenced from anywhere in the program (thus requiring some caution when using). Global variables do not need declarations. When referenced, the value of an uninitialized global variable is nil.

Pseudo Variables

Apart from the usual variables, there are also special variables known as pseudo variables.

self

The current method's execution constituent.

nil

The only instance of the NilClass class. Signifies NIL.

true

The only instance of the TrueClass class. Signifies TRUE.

false

The only instance of the FalseClass class. Signifies FALSE.



The value of a pseudo variable cannot be changed. Assigning values to pseudo variables will result in a syntax error.

Constants

Example:

FOOBAR

Identifiers beginning with an uppercase letter are constants. The definition of a constant (and its initialization) depends on its assignment; constants cannot be defined with a method. Accessing an undefined constant throws a NameError exception.

Within the class or module in which a constant is defined, the constant can be referenced by inheriting classes, classes that include modules, and modules. To reference constants externally, use the '::' operator.

class Foo FOO = 'FOO' end class Bar < Foo p FOO # => "FOO" end p Foo::FOO # => "FOO"

The names of classes and modules are handled as constants.

Literals Numeric Literals String Literals

Backslash Notation Expression Substitution

Regular Expressions Array Expressions Hash Expressions Range Expressions Symbols

Values that can be expressed directly in Ruby programs, such as the number 1 or the string "hello world", are called literals.

Numeric Literals

123 0d123

integer

-123



integer (signed)

123.45

floating point number

Floating point numbers beginning with a decimal point, like .1, are not allowed. They must be written with a leading zero (0.1).

1.2e-3

floating point number

0xffff

hexadecimal integer

0b1011

binary integer

0377 0o377

octal integer

Numeric literals can contain an underscore. The Ruby interpreter simply ignores these underscores and does not interpret them in a special way. This can be useful as a thousands separator for large values. However, placing an underscore before and after a literal or connecting literals with an underscore will result in an error.

1_000_000_000 # => 1000000000 0xffff_ffff # => 0xffffffff

String Literals

Example:

"this is a string expression\n" 'this is a string expression'

String expressions begin and end with double or single quote marks.

Double-quoted string expressions are subject to backslash notation and expression substitution. Single-quoted strings are not (except for \' and \\).

String literals with white space on either side are treated as a single string literal.

p "foo" "bar" # => "foobar"

Backslash Notation

\t

tab (0x09)



\n

newline (0x0a)

\r

carriage return (0x0d)

\f

form feed (0x0c)

\s

whitespace (0x20)

\nnn

character at octal value nnn (n = 0-7)

\xnn

character at hexadecimal value nn (n = 0-9, a-f)

Expression Substitution

In double-quoted strings and regular expressions, the form "#{expression}" can be extended to the (string of the) contents of that expression. If the expressions are variables beginning with either $ or @, the surrounding braces may be omitted and the variable can be expressed as a #variable. The character # is interpreted literally if it is not followed by the characters {, $, or @. To explicitly prevent expression substitution, place a backslash in front of the #.

$ruby = "RUBY" p "my name is #{$ruby}" # => "my name is RUBY" p 'my name is #{$ruby}' # => "my name is #{$ruby}"

Regular Expressions

Example:

/^Ruby the OOPL/ /Ruby/i /my name is #{myname}/

Strings delimited by slashes are regular expressions, which are instances of the Regexp class.

Refer to Regular Expressions for more information on which metacharacters are interpreted as regular expressions.

The characters immediately following the final slash denotes a regular expression option:

i

Regular expression matching is case insensitive.



m

Multiple run mode. Newlines are treated as normal characters (matching with the . character).

Ruby correctly handles multibyte characters (such as Chinese and Japanese) in regular expressions.

Backslash notation and expression substitution are available in regular expressions, as in strings.

If a regular expression does not include expression substitution, it will return the same regular expression object every time it is evaluated. If expression substitution is included, the regular expression will be compiled with every evaluation (based on the expression substitution results) and a new regular expression object will be created.

Array Expressions

Example:

[1, 2, 3]

Syntax:

'[' expr ',' ... ']'

Returns an array containing the result of each expression. Arrays are instances of the class Array.

Array expressions spawn a new array object every time they are evaluated.

Hash Expressions

Example:

{1=>2, 2=>4, 3=>6}

Syntax:

'{' expr '=>' expr ',' ... '}' '{' expr ',' expr ',' ... '}'

Returns a new hash object that maps each resulting value to a key. Hashes are instances of the class Hash.

A hash (also called an associative array) can associate one object of an arbitrary type with another.

Hash expressions spawn a new hash object every time they are evaluated.

Range Expressions

Example:

1 .. 20

Syntax:

expr1 '..' expr2 expr1 '...' expr2



If a range expression appears anywhere but a conditional expression, returns the range object from expression 1 to expression 2. Range objects are instances of the class Range.

Range objects spawned by .. operators include the final expression, while those spawned by ... operators do not.

If both ends of a range expression are numeric literals, the expression will return the same object every time it is evaluated. Otherwise, the expression will return a new range object every time it is evaluated.

Symbols

Example:

:class :lvar :method :$gvar :@ivar :+

Syntax:

':' identifier ':' variable name ':' operator

Returns symbols that have a one-to-one correspondence with arbitrary strings. Symbols are an instance of the Symbol class.

Symbols are unique objects that return the same object every time they are evaluated.

Operator Expressions Assignment

Self-Assignment Multiple Assignment

and or not Conditional Operators

Example:

1+2*3/4

Some method calls and control structures take the form of operators for ease in programming. Ruby contains the following operators:

high :: [] ** -(unary) +(unary) ! ~ * / % + - << >> & | ^ > >= < <=



<=> == === != =~ !~ && || .. ... ?:(conditional operator) =(+=, -= ... ) not low and or

"High" and "low" signify the operators' priority level. For example, "&&" has a higher priority than "||", so it would be interpreted in the following way:

a && b || c # => (a && b) || c a || b && c # => a || (b && c)

Most operators are method calls in special form, but some are built into the language and cannot be redefined.

Redefinable operators (methods)

+@ and -@ represent the unary operators + and -. This notation is used in method definitions and the like.

| ^ & <=> == === =~ > >= < <= << >> + - * / % ** ~ +@ -@ [] []= `

Nonredefinable operators (control structures)

Combination operators (i.e., self-assignment operators, !=, and !~) cannot be redefined.

= ?: .. ... ! not && and || or ::

Assignment

Example:

foo = bar foo[0] = bar foo.bar = baz

Syntax:

variable '=' expr constant '=' expr expr '['expr..']' '=' expr expr '.' identifier '=' expr

Assignment expressions are used to assign values to variables and the like. Assignments can also be used as declarations for local variables or constants. The left side of an assignment expression must be one of the following:

a variable

variable '=' expr

If there is a variable on the left side, the value of the expression is assigned to the variable.

an array reference

expr1 '[' expr2 ... ']' '=' exprN

For the object obtained by evaluating expr1, this form is converted into a []= method call with expr2 through



exprN as arguments.

class C def initialize @ary = [0,1,2,3,4,5,6,7] end def [](i) @ary[i * 2] end def []=( i, v ) @ary[i * 2] = v end end c = C.new p c[3] # converted to c.[]( 3 ); result is 6 p c[3] = 1 # converted to c.[]=(3,1); result is 1

an attribute reference

expr1 '.' identifier '=' expr2

For the object obtained by evaluating expr1, calls the identifier= method with expr2 as an argument.

class C def foo @foo end def foo=( v ) @foo = v end end c = C.new c.foo = 5 # converted to c.foo=( 5 ) p c.foo # => 5

Attributes can be defined with attr_accessor in the same way:

class C attr_accessor :foo end c = C.new c.foo = 5 # converted to c.foo=( 5 ) p c.foo # => 5

Self-Assignment

Example:

foo += 12 # foo = foo + 12 foo *= 3 # foo = foo * 3

Syntax:

expr1 op= expr2 # expr1 is part of the right-hand assignment

op is one of the following. There can be no space between the operator and =.

+, -, *, /, %, **, &, |, ^, <<, >>, &&, ||

In this assignment format, most cases are evaluated as:

expr1 = expr1 op expr2

Multiple Assignment



Example:

foo, bar, baz = 1, 2, 3 foo, = list() foo, *rest = list2()

Syntax:

expr [',' [ expr ',' ... ] ['*' [ expr ]]] = expr [, expr ... ]['*' expr ] '*' [ expr ] = expr [, expr ... ]['*' expr ]

Multiple assignment performs assignments from multiple expressions or arrays. Each expression on the left must be assignable. If there is only one expression on the right, its value will be converted into an array whose elements will be assigned to the expressions on the left. If there are more elements in the array than on the left, the extra elements are ignored. If there are too few elements in the array, nil will be assigned to the extra elements on the left.

Prepend * to the final expression on the left to assign all extra lefthand elements to that expression as an array. If there are no extra elements, an empty array will be assigned.

foo, bar = [1, 2] # foo = 1; bar = 2 foo, bar = 1, 2 # foo = 1; bar = 2 foo, bar = 1 # foo = 1; bar = nil foo, bar = 1, 2, 3 # foo = 1; bar = 2 foo = 1, 2, 3 # foo = [1, 2, 3] *foo = 1, 2, 3 # foo = [1, 2, 3] foo, *bar = 1, 2, 3 # foo = 1; bar = [2, 3]

and

Example:

test && set test and set

Syntax:

expr '&&' expr expr and expr

First evaluates the left side; if the result is true, evaluates the right side. and does the same as &&, but is a lower priority operator.

or

Example:

demo || die demo or die

Syntax:

expr '||' expr expr or expr

First evaluates the left side; if the result is false, evaluates the right side. or does the same as ||, but is a lower priority operator.



not

Example:

! me not me i != you

Syntax:

'!' expr not expr

If the value of the expression is true, returns FALSE; if the value is false, returns TRUE.

The following notation is also possible:

expr '!=' expr # same as !(expr == expr) expr '=~' expr # same as !(expr =~ expr)

Conditional Operators

Example:

obj == 1 ? foo : bar

Syntax:

expr1 ? expr2 : expr3

Returns expr2 or expr3 depending on the results of expr1. This is identical to:

if expr1 then expr2 else expr3 end

Control Structures Conditional Branching

if if Modifier unless unless Modifier case

Looping while while Modifier until until Modifier for break next

Exception Handling raise



begin rescue Modifier

Method Exit return

Unlike in C, control structures in Ruby are expressions that return some value.

Ruby carries over some control structures from C and Perl, but also features a loop abstraction feature called iterators. Iterators are user-definable looping control structures.

Conditional Branching

if

Examples:

if age >= 12 then print "adult fee\n" else print "child fee\n" end gender = if foo.gender == "male" then "male" else "female" end

Syntax:

if expr [then] expr ... [elsif expr [then] expr ... ] ... [else expr ... ] end

If a conditional expression is evaluated as true, evaluates the expression beginning with then. If the if expression is false, evaluates the elsif condition. Multiple elsif clauses can be specified; when all if or elsif conditional expressions are false, the else clause expression, if any, is evaluated.

if returns the value of the last evaluated expression in the conditional expression clause (or else clause). If there is no else clause and no conditional expressions in effect, returns nil.

The values false and nil are false; everything else, including zero and empty text strings, is true.

Note that Ruby uses elsif after if, not else if and not elif.

if Modifier

Example:

print "debug\n" if $DEBUG

Syntax:

expr if expr

Evaluates and returns the result of the expression on the left if the condition on the right is true. If the condition is



not in effect, returns nil.

unless

Example:

unless baby? feed_meat else feed_milk end

Syntax:

unless expr [then] expr ... [else expr ... ] end

unless is the reverse of if; if the conditional expression is false, evaluates the expression beginning with then. elsif cannot be specified with unless.

unless Modifier

Example:

print "stop\n" unless valid(passwd)

Syntax:

expr unless expr

Evaluates and returns the result of the expression on the left if the condition on the right is false. If the condition is not in effect, returns nil.

case

Example:

case $age when 0 .. 2 "baby" when 3 .. 6 "little child" when 7 .. 12 "child" when 13 .. 18 "youth" else "adult" end

Syntax:

case expr [when expr [, expr] ... [then] expr ..].. [else expr ..] end



case expressions execute branching for a single expression via matching. Comparisons of values specified in a when clause to the evaluated result of the first expression are performed by the === operator. When the values match, evaluates the contents of the when clause.

case returns the result of the last evaluated expression in a conditional when (or else) clause. If neither condition is in effect, returns nil.

Looping

while

Example:

ary = [0,2,4,8,16,32,64,128,256,512,1024] i = 0 while i < ary.length print ary[i] i += 1 end

Syntax:

while expr [do] ... end

Executes the contents of an expression as long as the expression remains true.

while returns nil. Alternatively, the while return value can also be the value of an argument to a break.

while Modifier

Example:

sleep(60) while io_not_ready?

Syntax:

expr while expr

Repeatedly executes the expression on the left as long as the expression on the right is evaluated as true. If the expression on the left is begin, while evaluates it first before looping.

The while modifier returns nil. Alternatively, the while modifier return value can also be the value of an argument to a break.

until

Example:

until f.eof? print f.gets end

Syntax:

until expr [do]



... end

Repeatedly executes the expression until it is evaluated as true.

until returns nil. Alternatively, the until return value can also be the value of an argument to a break.

until Modifier

Example:

print(f.gets) until f.eof?

Syntax:

expr until expr

Repeatedly executes the expression on the left until the expression on the right is evaluated as true. If the expression on the left is begin, the until modifier evaluates it first before looping.

The until modifier returns nil. Alternatively, the until modifier return value can also be the value of an argument to a break.

for

Example:

for i in [1, 2, 3] print i*2, "\n" end

Syntax:

for lhs ... in expr [do] expr .. end

Repeatedly executes the contents for each evaluated object element. Approximately identical to the following:

(expr).each '{' '|' lhs..'|' expr .. '}'

It is only approximately identical because while blocks defined by do ... end or by { } introduce a new block scope for local variables, for has no effect on the scope of local variables.

for returns the return value of the each method for the objects specified in in.

break

Example:

i = 0 while i < 3 print i, "\n" break end

Syntax:



break [expr]

break escapes from the innermost loop. A "loop" is one of the following:

while until for an iterator

Unlike in C, break can only escape from loops. It does not exit from case.

for or an iterator that has escaped from a loop via break returns nil. However, if an argument is specified, the loop's return value will become that argument.

next

Example:

str.each_line do |line| next if line.empty? print line end

Syntax:

next [expr]

next jumps to the next iteration of the innermost loop. In an iterator, next is an escape for a yield call.

A yield that has escaped via next returns nil. However, if an argument is specified, yield's return value will become that argument.

Exception Handling

raise

Examples:

raise raise "you lose" raise SyntaxError.new("invalid syntax") raise SyntaxError, "invalid syntax"

Syntax:

raise raise message raise exception raise error_type, message

Throws an exception. In the first format, throws the last exception again. In the second format, given a string argument, throws a RuntimeError exception with the given string as a message. In the third format, throws the exception if the argument is an exception object. In the last format, throws the exception specified in the first argument with the message given in the second argument.

Thrown exceptions can be trapped with a rescue clause in begin.



raise is not a reserved word in Ruby, but rather an built-in function.

begin

Example:

begin do_something rescue recover ensure must_do end

Syntax::

begin expr .. [rescue [error_type,..] [then] expr ..].. [ensure expr ..] end

If an exception is thrown while begin is being executed, a rescue clause can trap the exception; multiple clauses can be specified. If a rescue clause with a matching exception type exists, it is executed. The thrown exception can be referenced with the built-in variable $!.

When error_type is omitted, it traps all exceptions in the StandardError subclasses, of which most built-in exceptions in Ruby are members. See Built-in Exception Classes.

In rescue clauses, error_type is evaluated in the same way as an argument. If any value matches, the clause will be executed. If the value of error_type is not a class or a module, rescue throws a TypeError exception.

If there is an ensure clause, its contents are always evaluated immediately before a begin expression exits.

begin returns the result of the final argument evaluated in either its contents or in the rescue clause.

rescue Modifier

Example:

File.open("file") rescue print "can't open\n"

Syntax:

expr1 rescue expr2

When an exception is thrown in the first expression, evaluates the second expression. You cannot specify the exception class(es) to be trapped; in other words, you can only trap the subclasses of the StandardError exception class.

Expressions associated with the rescue modifier return expr1 if no exception is thrown and expr2 if an exception is thrown.

Method Exit



return

Example:

return return 12 return 1,2,3

Syntax:

return [expr[',' expr ... ]]

Exits from a method with the return value. If two or more expressions are provided, the method's return value will consist of an array containing these values. If the expression is omitted, the return value will be nil.

Method Calls super Iterators yield

Example:

foo.bar() foo.bar bar() print "hello world\n" print

Syntax:

[expr '.'] identifier ['(' expr ... ['*' [expr]] ')']

Method calls invoke the method of the receiver (the value of the expression to the left of the dot). If no receiver is specified, calls the method of self.

Method names can be normal identifiers or identifiers followed by the character ? or !. Customarily, ? is used for predicates (methods returning true/false values), while ! is used for methods that are more destructive than their !-less counterparts (tr versus tr!).

If the last argument is preceded by *, the value of that expression is expanded to its arguments:

foo(*[1,2,3]) # same as foo(1,2,3)

super

Example:

super super(1,2,3)

Syntax:

super super(expr , ... )



super calls the method that is being overridden by the current method. If the parentheses and arguments are omitted, the current method's arguments are passed to super as is. To call the overridden method without passing any arguments, indicate the parentheses as in super().

class Foo def foo(arg=nil) p arg end end class Bar < Foo def foo(arg) super(5) # called with 5 as an argument super(arg) # called with 5 as an argument super # called with 5 as an argument; abbreviation of super(arg) arg = 1 super # called with 1 as an argument; abbreviation of super(arg) super() # called with no argument end end Bar.new.foo 5

Iterators

Example:

[1,2,3].each do |i| print i*2, "\n" end [1,2,3].each {|i| print i*2, "\n" }

Syntax:

method(arg1, arg2, ...) do ['|' expr ... '|'] expr ... end method(arg1, arg2, ...) '{' ['|' expr ... '|'] expr ... '}'

Iterators are methods used for abstracting control structures (especially loops). If you call a method that is followed by a code segment enclosed by do ... end or by { ... } (called a block), the method can evaluate the block from within. Methods that call these kinds of blocks are called iterators. Block calls from iterators use yield. The value passed to yield is assigned to the variable between the two pipes ( | ).

{ ... } binds more strongly than a do ... end block.

foobar a, b do .. end # foobar is called as an iterator foobar a, b { .. } # b is called as an iterator

Local variables that are first assigned (declared) in a block are only valid within that block.

foobar { i = 20 # local variable 'i' is declared ... } # 'i' is undefined here foobar a, b do i = 11 # declaration of a totally different variable 'i' ... end

Like most methods, an iterator's return value is nil if it is interrupted by break from within a block. When break has an argument, that value will become the iterator's return value.

yield



Example:

yield data

Syntax:

yield '(' [ expr [',' expr ... ]] ')' yield [ expr [',' expr ... ]]

Passes the argument(s) as the block's argument(s) and evaluates the block. yield is used within MethodDefinition to define iterators.

def foo yield(1,2) end foo {|a,b| p [a,b]}

Assignment of the block argument(s) is carried out according to the rules of multiple assignment. If no block is supplied to the method that executed yield (i.e., it is not an iterator), throws a LocalJumpError exception.

yield returns the result of the block's last evaluated expression. If block execution has been interrupted by next, returns nil. When next has an argument, that value will become yield's return value.

Class and Method Definitions Class Definitions Module Definitions Method Definitions

Method Evaluation Singleton-Method Definitions Class Method Definitions Definition Operations

alias

Class Definitions

Example:

class Foo < Super def test : end : end

Syntax:

class identifier ['<' superclass ] expr .. end

Defines a class. Class names are identifiers beginning with an uppercase letter.

Class definitions assign a class to a constant specified by an identifier (in Ruby, classes and objects together are one instance of the Class class.)



When a class is already defined, writing a class definition with the same class name will add to the existing class definition.

class Foo < Array def foo end end class Foo def bar end end

In a class definition, self is that class itself; otherwise, it is no different than a top-level definition. Class definitions can contain arbitrary expressions that will be executed when the class is defined.

Class definitions can operate as nests. In the following example, there is absolutely no functional relationship (such as inheritance) between the outer class Foo and the inner class Bar, other than the fact that the constant Bar is Foo's inner constant Foo::Bar. Class nests group together semantically related classes into the outer class or module, and can be used to express an inclusion relationship.

class Foo class Bar end end

Class definitions return the result of the last evaluated expression. If that expression does not return a value, the class definition returns nil.

Module Definitions

Example:

module Foo def test : end : end

Syntax:

module identifier expr .. end

Defines a module. Module names are identifiers beginning with an uppercase letter.

Module definitions assign a module to a constant specified by an identifier. In Ruby, classes and objects together are one instance of the Class class.)

When a module is already defined, writing a module definition with the same module name will add to the existing module definition.

Module definitions return the result of the last evaluated expression. If that expression does not return a value, the module definition returns nil.

Method Definitions



Example:

def fact(n) if n == 1 then 1 else n * fact(n-1) end end

Syntax:

def methodname ['(' [arg ['=' default]] ... [',' '*' arg] ')'] expr .. [rescue [error_type,..] [then] expr ..].. [ensure expr ..] end

Defines a method. In other words, defines the method of a class or module if within the definition of that class or module. If top-level, defines methods that can be called from anywhere. This kind of method can be used like functions are in other scripting languages.

Method names can be normal identifiers or redefinable operators (==, +, -, and so on; see Operator Expressions.

When a default expression has been provided to a dummy argument, it becomes the default value when the actual argument is omitted through a method call. The default expression is evaluated at the time of the call and in the context of the method definition.

When the last dummy argument has a * immediately before it, the remaining actual arguments are all stored in this argument as an array.

Example:

# method with no argument. end omitted below def foo end # method with arguments def foo(arg, arg2) # method with default argument def foo(arg = nil) # with everything def foo(arg, arg2, arg3 = nil, *rest) # operator format def ==(other) def +(other) def *(other)

For method definition, each type of dummy argument can only be specified according to the following sequence. Any of these types of arguments can be omitted.

arguments without default expressions (can specify multiple arguments) arguments with default expressions (can specify multiple arguments) arguments with * (can specify only one)

These method definitions have special formats:



# unary plus/minus def +@ def -@ # element substitution def foo=(value) # obj.foo = value # [] and []= def [](key) # obj[key] def []=(key, value) # obj[key] = value def []=(key, key2, value) # obj[key, key2] = value

Furthermore, a begin expression as well as rescue and/or ensure clauses can be specified to trap exceptions when executing a method.

Method definition returns nil.

Method Evaluation

When a method is called, its expressions are evaluated in the following order:

Default expressions in arguments (when specified) The method itself The method's rescue or else clauses (when specified), depending on whether an exception has been thrown The ensure clause (when specified)

Everything is evaluated in the method's context, including the argument's default expression.

The method's return value is the value passed to return. When return is not called, returns the value of the last evaluated expression in the method, before any ensure clause is executed.

Methods cannot be called before they are defined. For example:

foo def foo print "foo\n" end

Calling an undefined method throws a NameError exception.

Singleton-Method Definitions

Example:

def foo.test print "this is foo\n" end

Syntax:

def expr '.' identifier ['(' [ argument ['=' default]] ... [',' '*' argument ]')'] expr .. [rescue [error_type,..] [then] expr ..].. [else expr ..] [ensure expr ..] end



A singleton method belongs to a certain object and not to a class. Singleton-method definitions can be nested.

The singleton methods of a class carry over to its subclasses. In other words, they act like the class methods in other object-oriented languages.

Singleton-method definitions return nil.

Class Method Definitions

In Ruby, class methods are the methods specific to a class. Classes are also objects, so these specific methods can be defined like regular objects.

Therefore, when a method in a class object is defined in some way, that object becomes a class method. Specifically, these methods can be defined in the following way (as can modules):

# singleton method class Hoge def Hoge.foo end end # can use outside class definition, too def Hoge.bar end # even if the class name changes, you don't have to change the method class Hoge def self.baz end end

Definition Operations

alias

Example:

alias foo bar alias :foo :bar

Syntax:

alias newmethod oldmethod

Assigns an alias to a method or global variable. Specifies an identifier or a Symbol as the method name (expressions like obj.method are not permitted). alias's argument performs no evaluation of method calls or the like.

An aliased method carries over that method definition, retaining it even if the original method is redefined. This can be used when you want to change the actions of a given method, then use the result of the original method in the redefined method.

# defining method "foo" def foo "foo" end # setting alias (retracting method definition) alias :_orig_foo :foo



# "foo" redefined (using the old definition) def foo _orig_foo * 2 end p foo # => "foofoo"

alias returns nil.

Standard Library Built-in Functions Built-in Variables Built-in Classes

Object Array Exception FalseClass Hash IO

File MatchData Module

Class NilClass Numeric

Integer Bignum Fixnum

Float Proc Range Regexp String Symbol Time TrueClass

Built-in Modules Comparable Enumerable Errno FileTest GC Kernel Marshal Math

Built-in Exception Classes



Built-in Functions Strictly speaking, they aren't functions in Ruby, but since methods defined in the Kernel module can be called from anywhere, they can be used like functions are in other languages. Carefully consider the repercussions of redefining the methods here.

block_given?

Returns true when the method has been supplied with a block; otherwise, returns false. See Iterator for details.

catch(tag) {|tag| .... }

Executes the block and returns its value. If a throw with the same name as tag takes place while the block is running, the return value will be that throw's second argument.

break cannot break out all nested loops at once. Use catch in these circumstances.

catch(:loop1) { for i in 1..2 for j in 1..2 throw :loop1, j end end }

eval(expr)

Evaluate the string expr as a Ruby program and returns the result.

exit

Exits a running Ruby program.

exit throws a SystemExit exception to terminate the program, so it can be trapped by a rescue clause where necessary.

loop { ... }

Evaluates a block in an infinite loop (until explicitly terminated).

open(file[, mode]) open(file[, mode]) {|io| ... }

Opens file and returns a File object. mode specifies one of the following strings. When mode is omitted, the default is "r".

"r": Opens file in read mode. "w": Opens file in write mode. If a file already exists when file is opened, the previous file's contents will be deleted. "a": Opens file in write mode. Output will always be appended to the end of the file.

Using "+" opens the file in read-write mode (RDWR):



"r+": Sets the read-write position to the beginning of the file. "w+": The same as "r+", but if a file already exists when file is opened, the previous file's contents will be deleted. "a+": The same as "r+", but if a file already exists when file is opened, the read-write position will be set to the end of the file.

The "b" flag can also be added to any of these (in the format "r+b") to open the file in binary mode.

When open is called along with a block, it opens the file, executes the block, then closes the file when execution is complete. In this case, returns the result of the block evaluation. That is:

open(path, mode) do |f| ... end # almost identical to the above f = open(path, mode) begin ... ensure f.close end

p(obj, [obj2, ...])

Outputs obj in a human-readable format. Identical to the following code (see Object#inspect):

print obj.inspect, "\n", obj2.inspect, "\n", ...

In Ruby, the usual output destination would be standard output. This method is redefined in RGSS to output to a Windows message box.

Returns nil.

print(arg[, ...])

Prints the arguments in order. If a non-string object has been supplied as an argument, it will be converted into a string with to_s and printed. However, if the argument is nil, it will print the string "nil".

In Ruby, the usual output destination would be standard output. This method is redefined in RGSS to output to a Windows message box.

Returns nil.

raise raise(message) raise(exception) raise(error_type, message)

Throws an exception. See raise for details.

rand(max)

Creates a random integer in the range 0 ≤ integer < max. Automatically calls srand if it hasn't already been called.



If max is nil or 0, uses Float to return a random number in the range 0 ≤ real number < 1.

sprintf(format[, arg[, ...]])

Interprets the string format as does C's sprintf, returning a string of formatted arguments.

See sprintf Format for details.

srand([seed])

Sets the rand random number seed and returns the old initial value. If seed is omitted, uses the current time (or a similar value) as the seed.

throw(tag[, value])

Escapes (across methods) to the end of a catch block with the same tag. If there is no catch with the same tag, the thread terminates with NameError. value will be the return value of the catch.

Built-in Variables Built-in variables are a type of global variable, but their values are not only used globally.

The following are examples of built-in variables divided up by their scope.

Local Scope

$~

The information about the last match in the current scope (MatchData object). Setting this variable changes the values of $&, $1 ... $9, etc.

Identical to Regexp.last_match.

$&

The string matched by the last successful pattern match in this scope, or nil if the last pattern match failed.

Identical to Regexp.last_match[0]

$1 $2 $3 ...

Contains the subpattern from the corresponding set of parentheses in the last successful pattern matched, or nil if the last pattern match failed.

Identical to Regexp.last_match[1], Regexp.last_match[2], ...

Global Scope



$!

Information on the latest exception. Set with raise.

$DEBUG

The debug mode flag. RGSS sets this flag during playtesting.

There are some differences in exception behavior, etc., while in Ruby's debug mode, but you need not be concerned about them in RGSS.

Built-in Classes Object

Array Exception FalseClass Hash IO

File MatchData Module

Class NilClass Numeric

Integer Bignum Fixnum

Float Proc Range Regexp String Symbol Time TrueClass

Object The superclass of all classes. Defines the general behavior of objects.

Included Modules

Kernel

Methods



self == other

Checks if self and other are equal. By default, has the same effect as equal?.

This method must be redefined with respect to each class's properties.

self === other

This method is mostly used for comparison within case statements. By default, acts like Object#==, but this behavior can be redefined in the subclass to implement an ownership check.

class

Returns the receiver class.

clone dup

Creates a copy of the object. clone returns a complete clone of the original object, including freeze status and singleton methods, while dup duplicates the object contents only.

Note that clone and dup perform only a shallow copy. They duplicate the object itself, but nothing it points to (such as array elements).

For duplicated objects,

obj.equal?(obj.clone)

generally does not hold, while

obj == obj.clone

is correct in most cases.

Attempting to duplicate true, false, nil, Numeric objects, Symbol objects, and the like result in TypeError exceptions.

equal?(other)

When other is self, returns true. This method must not be redefined.

freeze

Prohibits an object's contents from being modified. Modifying a frozen object throws a TypeError exception.

frozen?

Returns true when the object's contents are prohibited from being modified.

inspect

Returns the object in a human-readable string format.

instance_of?(klass)



Returns true when self is a direct instance of the class klass. When obj.instance_of?(c) is true, obj.kind_of?(c) is always true as well.

is_a?(mod) kind_of?(mod)

Returns true when self is the class mod (or its subclass). or a class (or its subclass) that includes the module mod.

module M end class C < Object include M end class S < C end obj = S.new p obj.is_a? S # true p obj.is_a? M # true p obj.is_a? C # true p obj.is_a? Object # true p obj.is_a? Hash # false

nil?

Checks if the receiver is nil.

object_id

Returns a unique integer for each object. The integers are assigned to objects arbitrarily.

to_ary

Called internally when an object's implicit conversion to an array is required.

to_hash

Called internally when an object's implicit conversion to a hash is required.

to_int

Called internally when an object's implicit conversion to an integer is required.

to_s

Returns the string representation of the object. This method is used internally by print and sprintf.

When non-string objects are passed to arguments in print and sprintf, use this method to convert the objects to strings.

to_str

Called when an object's implicit conversion to a string is required.

Private Method



initialize

The initialization method for user-defined classes. This method is called from Class#new to initialize a newly created object. The default behavior is to do nothing; it is assumed that this method will be redefined in the subclass as needed. The argument given to Class#new will be passed to initialize as is.

Array The array class. The elements of an array are arbitrary Ruby objects. See Array Expressions for more information.

Superclass

Object

Included Modules

Enumerable

Methods

self[nth]

Retrieves the nth item from an array. The index starts from zero. If the nth value is negative, counts backward from the end of the array (the index of the last element is -1). If the nth element does not exist in the array, returns nil.

self[start, length]

Returns an array containing length items from start. If the start value is negative, counts backward from the end of the array (the index of the last element is -1).If length is longer than the length of the array from start, the length of the overlong portion is ignored. Returns nil if length is negative.

self[nth]=val

Changes the nth element of the array into val. If nth is outside the array range, the array will automatically be extended. The extended region will be initialized by nil.

Returns val.

self[start, length]=val

Replace the length items from index start with the contents of val. If val is not an array, the items will be replaced by the contents of val.to_ary or [val]. Returns val .

ary = [0, 1, 2, 3] ary[1, 2] = ["a", "b", "c"] p ary # => [0, "a", "b", "c", 3] ary[2, 1] = 99 p ary # => [0, "a", 99, "c", 3] ary[1, 0] = ["inserted"] p ary # => [0, "inserted", "a", 99, "c", 3]



self + other

Returns a new array with the concatenated contents of self and other. If other is not an array, uses the return value of other.to_ary. If that return value is not an array, throws a TypeError exception.

a = [1, 2] b = [8, 9] p a + b # => [1, 2, 8, 9] p a # => [1, 2] (no change) p b # => [8, 9] (no change here, either)

self - other

The set subtraction operation. Returns a new array containing self without the elements of other.

self & other

The set intersection operation. Returns a new array containing elements belonging to both arrays. Duplicate elements will be removed.

self | other

The set union operation. Returns a new array containing all elements belonging to either array. Duplicate elements will be removed.

self <=> other

Compares each element with <=> and returns 1 if self is greater than, 0 if equal to, or -1 if less than other. If the end of one array is reached with each element being equal, the shorter array will be treated as being the lesser of the two.

self == other

Compares each element with == and returns TRUE if all elements are equal.

clear

Deletes all elements of an array, making it empty. Returns self.

ary = [1, 2] ary.clear p ary # => []

clone dup

Returns a new array with the same contents as the receiver. clone returns a complete clone of the original array, including freeze status and singleton methods, while dup duplicates the object contents only. Neither method copies the methods or elements themselves.

compact compact!

compact returns a new array consisting of self without any nil elements. compact! performs a destructive update; if modified, returns self, if not modified, returns nil.



ary = [1, nil, 2, nil, 3, nil] p ary.compact # => [1, 2, 3] p ary # => [1, nil, 2, nil, 3, nil] ary.compact! p ary # => [1, 2, 3] p ary.compact! # => nil

concat(other)

Appends (destructively) the other array to the end of self. Returns self.

array = [1, 2] a = [3, 4] array.concat a p array # => [1, 2, 3, 4] p a # => [3, 4] # this doesn't change

delete(val) delete(val) { ... }

Delete all elements equal to val (via ==). When elements equal to val are found, returns val.

If there are no elements equal to val, returns nil. However, if a block has been specified, it will be evaluated and the result returned.

array = [1, 2, 3, 2, 1] p array.delete(2) # => 2 p array # => [1, 3, 1] # if the argument is nil and there's no block, there's no way # to determine from the return value whether it was deleted ary = [nil,nil,nil] p ary.delete(nil) # => nil p ary # => [] p ary.delete(nil) # => nil

delete_at(pos)

Removes the element at the position specified by pos and returns the removed element. If pos is out of range, returns nil.

array = [0, 1, 2, 3, 4] array.delete_at 2 p array # => [0, 1, 3, 4]

each {|item| .... }

Evaluates a block against each element. Returns self.

# 1, 2, 3 are displayed in order [1, 2, 3].each do |i| puts i end

each_index {|index| .... }

Evaluates a block against each element's index. Identical to the following:

(0 ... ary.size).each {|index| .... }

Returns self.



empty?

Returns TRUE if the number of elements in the array is zero.

include?(val)

Returns TRUE if the array contains an element equal to val (using ==).

index(val)

Returns the position of the first element equal to val (using ==). If no such element is found, returns nil.

insert(nth, [val[, val2 ...]])

Inserts the value of the second or more arguments immediately before the nth element. Returns self. Defined as below:

class Array def insert( n, *vals ) self[n, 0] = vals self end end

ary = ["foo", "bar", "baz"] ary.insert 2, 'a', 'b' p ary # => ["foo", "bar", "a", "b", "baz"]

If no argument val is specified, does nothing.

length size

Returns the length of the array. If the array is empty, returns zero.

nitems

Returns the number of non-nil elements.

pop

Removes the last element and returns it. If the array is empty, returns nil.

array = [1, [2, 3], 4] p array.pop # => 4 p array.pop # => [2, 3] p array # => [1] p array.pop # => 1 p array.pop # => nil p array # => []

push(obj1[, obj2 ...])

Appends obj1, obj2 ... to the end of the array, in order.

Returns self.

array = [1, 2, 3]



array.push 4 array.push [5, 6] array.push 7, 8 p array # => [1, 2, 3, 4, [5, 6], 7, 8]

reverse reverse!

reverse returns a new array of all elements in reverse order. reverse! destructively updates the elements in the array.

reverse always returns a new array, while reverse! returns self.

shift

Removes the first element of the array and returns it. The remaining elements are moved up to fill the gap. If the array is empty, returns nil.

sort sort! sort {|a, b| ... } sort! {|a, b| ... }

Sorts the contents of the array. If called with a block, it passes two arguments to the block, then uses the result to compare. Without a block, it compares elements with the operator <=>. sort! destructively updates the elements in the array.

sort returns a new, sorted array, while sort! always returns self.

uniq uniq!

uniq returns a new array by removing duplicate elements. The remaining elements will then be shifted forward to fill the gaps. uniq! performs destructive deletion and returns self if deletion was performed and nil if it was not.

unshift(obj1[, obj2 ...])

Inserts obj1, obj2 ... to the start of the array, in order.

Returns self.

Exception The ancestor class of all exceptions.

Refer to Built-in Exception Classes for information on its subclasses.

Superclass

Object



Class Method

Exception.new([error_message])

Creates and returns a new exception object. A string indicating an error message can be supplied as an argument. This message will become the value of the message attribute (below) and will be displayed by the default exception handler.

Methods

exception([error_message])

Returns self when no argument is specified. Otherwise, creates a copy of itself with the message attribute as error_message and returns it.

raise actually calls the Exception object's exception method.

backtrace

Returns backtrace information as a String array in the follow formats:

"#{sourcefile}:#{sourceline}:in '#{method}'"

(within methods)

"#{sourcefile}:#{sourceline}"

(at the top level)

message

Returns the error message string.

FalseClass The false class. false is the only instance of the FalseClass class. false, like nil, denotes a FALSE condition, while all other objects are TRUE.

Superclass

Object

Methods

self & other

Normally returns FALSE.

self | other



self ^ other

If other is TRUE, returns TRUE. If FALSE, returns FALSE.

Hash The hash class. See Hash Expressions for more information.

Superclass

Object

Included Modules

Enumerable

Methods

self[key]

Returns the value mapped to key. If the corresponding key is not registered, returns the default value (or nil if not specified).

self[key]=value

Maps value to key. Returns value.

clear

Clears the hash contents. Returns self.

clone dup

Returns a new hash with the same contents as the receiver. Using clone on a frozen hash will return a similarly frozen hash, but dup returns an unfrozen hash with identical contents.

Returns value.

delete(key) delete(key) {|key| ... }

Deletes the mapping from key. Returns the removed value, or nil if there is no value corresponding to key.

When the method has been supplied with a block, it will be evaluated and the results returned if there is no match for key.

each {|key, value| ... } each_pair {|key, value| ... }



Evaluates a block with key and value as arguments. Returns self.

each_key {|key| ... }

Evaluates a block with key as the argument. Returns self.

each_value {|value| ... }

Evaluates a block with value as the argument. Returns self.

empty?

Returns true when the hash is empty.

has_key?(key) include?(key)

Returns true when the hash includes key as a key.

has_value?(value)

Returns true when the hash includes value as a value as determined by ==.

index(val)

Returns the key corresponding to val. If there is no corresponding element, returns nil.

If there are multiple corresponding keys, arbitrarily returns one of them.

keys

Returns an array of all keys.

length size

Returns the number of elements in the hash.

values

Returns an array of all values in the hash.

IO The IO class provides basic IO functions.

Superclass

Object

Included Modules



Enumerable

Methods

binmode

Converts the stream into binary mode. The only way to revert to normal mode is to reopen the stream.

Returns self.

close

Closes the IO port. An Errno::EXXX exception is thrown if close fails.

Returns nil.

each_line {|line| ... }

Reads from the IO port line by line.

Returns self.

each_byte {|ch| ... }

Reads from the IO port byte by byte.

Returns self.

eof?

Returns true when the stream reaches the end of the file.

pos

Returns the current position of the file pointer.

pos=n

Moves the file pointer to the indicated position.

read([length])

Reads length bytes and returns the string. If length is omitted, reads all data until the end of the file.

If the IO has already reached the end of the file, returns nil.

Throws an Errno::EXXX exception if the data read fails and an ArgumentError exception if length is negative.

readlines([rs])

Reads all the data and returns an array whose elements consist of the lines read. If the IO has already reached the end of the file, returns the empty array [].



Lines are separated by the string indicated in the argument rs, whose default value is "\n".

Specify nil for rs and the lines will not be separated. Specify the empty string "" and consecutive linefeeds willbe treated as line separators (paragraph mode).

write(str)

Outputs str to the IO port. If str is not a string, tries converting it to a string with to_s.

Returns the actual number of bytes written. Throws an Errno::EXXX exception if the output action fails.

File The file access class, normally created by open or File.open.

Open file objects that cannot be referenced will be closed and discarded by the next garbage collection.

Superclass

IO

Class Methods

File.mtime(filename)

Returns the file's last modified time (Time object).

If time retrieval fails, throws an Errno::EXXX exception.

File.basename(filename[, suffix])

Returns the final slash-delimited component of filename. If suffix is supplied and is identical to the end of filename, filename is returned without the suffix.

p File.basename("ruby/ruby.c") # => "ruby.c" p File.basename("ruby/ruby.c", ".c") # => "ruby" p File.basename("ruby/ruby.c", ".*") # => "ruby" p File.basename("ruby/ruby.exe", ".*") # => "ruby"

See also File.dirname and File.extname.

File.delete(filename ... )

Deletes a file or files and returns the number of files deleted. If deletion fails, throws an Errno::EXXX exception.

This method is for file deletion and cannot delete directories.

File.dirname(filename)

Returns all but the final slash-delimited component of filename. Returns "." (the current directory) for a filename that does not include a slash.



p File.dirname("dir/file.ext") # => "dir" p File.dirname("file.ext") # => "." p File.dirname("foo/bar/") # => "foo" p File.dirname("foo//bar") # => "foo"

See also File.basename and File.extname.

File.expand_path(path[, default_dir])

Returns a string containing path's expanded absolute path. If path is relative, sets default_dir as the base directory. If default_dir is nil or missing, uses the current directory.

p File.expand_path("..") # => "/home/matz/work" p File.expand_path("..", "/tmp") # => "/"

File.extname(filename)

Returns filename's extension (the string after the final dot). Dots in directory names or at the start of filenames are not considered to be denoting extensions. If filename contains no extension, returns an empty string.

p File.extname("foo/foo.txt") # => ".txt" p File.extname("foo/foo.tar.gz") # => ".gz" p File.extname("foo/bar") # => "" p File.extname("foo/.bar") # => "" p File.extname("foo.txt/bar") # => "" p File.extname(".foo") # => ""

See also File.basename and File.dirname.

File.open(path[, mode]) File.open(path[, mode]) {|file| ... }

Opens the file specified by path and returns the file object. If file opening fails, throws an Errno::EXXX exception.

The mode argument is identical to the built-in function open.

Blocks can be specified for open(). When called with a block, executes the block with the given file object. The file will be closed automatically after executing the block.

When a block is specified, the return value of this method is the result of the block's evaluation. File.rename(from, to)

Renames file, moving it to a different directory as required. If a file already exists at the destination, it is overwritten.

Returns 0 when file movement is successful; when it fails, throws an Errno::EXXX exception.

Methods

mtime

Returns the file's last modified time (Time object).

If time retrieval fails, throws an Errno::EXXX exception.



path

Returns the path of the opened file.

MatchData The class handling regular expression match data. Instances of this class can be obtained via

Regexp.last_match, Regexp#match, and $~.

Superclass

Object

Methods

self[n]

Returns the nth substring. 0 signifies the entire matching string. When the value of n is negative, it is treated as a backwards index (the final element being in the position -1). When the nth element does not exist, returns nil.

/(foo)(bar)(BAZ)?/ =~ "foobarbaz" p $~.to_a # => ["foobar", "foo", "bar", nil] p $~[0] # => "foobar" p $~[1] # => "foo" p $~[2] # => "bar" p $~[3] # => nil (doesn't match) p $~[4] # => nil (out of range) p $~[-2] # => "bar"

post_match

Returns the string after the matching portion.

pre_match

Returns the string before the matching portion.

to_a

Returns an array containing $&, $1, $2, ...

to_s

Returns the entire matching string.

Module



The module class.

Superclass

Object

Method

self === obj

This method is mostly used for comparison within case statements. Returns true if obj has an Object#kind_of? relationship with self. In other words, case can be used to check the owner relationship of classes and modules.

str = String.new case str when String # evaluates String === str p true # => true end

Private Methods

attr_accessor(name ... )

Defines both the read and write methods for the attribute name, where name is specified by Symbol or a string.

The definition of the method defined by attr_accessor is as follows:

def name @name end def name=(val) @name = val end

attr_reader(name ... )

Defines the read method for the attribute name, where name is specified by Symbol or a string.

The definition of the method defined by attr_reader is as follows:

def name @name end

attr_writer(name ... )

Defines the writer method for the specified attribute(s).

Defines the write method for the attribute name (name=), where name is specified by Symbol or a string.

The definition of the method defined by attr_writer is as follows:

def name=(val) @name = val



end

include(module ... )

Includes the specified modules' properties (methods and constants). Returns self. include is used to implement a mix-in in place of a multiple inheritance.

class C include FileTest include Math end

Module capabilities are included by inserting modules into a class inheritance. Therefore, when searching for methods, included modules will be given priority over superclasses.

If the same module is included two or more times, the second and later instances will be ignored. Furthermore, executing an include that results in a recursive module inheritance will throw an ArgumentErrorexception.

Class The class of classes. More accurately speaking, each class has its own unnamed "metaclass", and Class is the class of these metaclasses. This relationship is a little complicated, but it is not especially important to keep in mind while using Ruby.

Compared to modules, classes

can create instances and cannot perform mix-in using include

Otherwise, nearly all of its capabilities are inherited from Module.

Superclass

Module

Method

new( ... )

Creates a class instance and returns it. This method's arguments, including block arguments, are passed to initialize.

NilClass The nil class of nil. nil is the sole instance of this class, signifying FALSE along with the false object. All other objects are true.

Superclass



Object

Methods

self & other

Always returns false.

self | other self ^ other

If other is true, returns true; if false, returns false.

nil?

Always returns true.

to_a

Returns the empty array [].

to_f

Returns 0.0.

to_i

Returns 0.

to_s

Returns the empty string "".

Numeric Numeric is the abstract class for numbers. In Ruby, operations are possible among different numerical classes.

Operations and comparison methods (+, -, *, /, <=>), etc. are defined in a subclass. For increased efficiency, methods identical to the Numeric method may also be redefined in a subclass.

Superclass

Object

Included Modules

Comparable

Methods



+ self

Returns self.

- self

Returns self, negated.

This method is defined by the binary operator - in 0 - self.

abs

Returns the absolute value of self.

ceil

Returns the smallest integer equal to or greater than self (i.e., the ceiling).

floor

Returns the largest integer that does not exceed self (i.e., the floor).

integer?

Returs true when self is an integer.

round

Returns the integer closest to self.

truncate

Discards the decimal point and all digits after it.

Integer The abstract class for integers. Its subclasses are Fixnum and Bignum. These two types of integers are automatically converted into one another according to their values. Integers can be treated as infinite bit strings for bit operations.

Superclass

Numeric

Methods

self[nth]

Returns 1 if the nth bit of the integer is set (with the LSB, or least significant bit, at position 0), otherwise returns 0.



self[nth]=bit is not an Integer method because the associated Numeric class is immutable.

self + other self - other self * other self / other self % other self ** other

Arithmetic operators. Compute the sum, difference, product, quotient, remainder, and exponent respectively.

self <=> other

Compares self with other; returns a positive integer if self is larger, 0 if the two are equal, and a negative integer if self is smaller.

self == other self < other self <= other self > other self >= other

Relational operators.

~ self self | other self & other self ^ other

Bit operators. Compute bitwise negation, logical OR, logical AND, and logical XOR respectively.

self << bits self >> bits

Shift operators. Shift only bits to the right or left.

The signed bit (MSB or most significant bit) is retained in a right shift.

chr

Returns a 1-byte string corresponding to the numeric position in the character set. For example, 65.chr returns "A".

The integer must be within the range of 0 to 255. Calling this method with an out-of-range integer will throw a RangeError exception.

downto(min) {|n| ... }

Iterates from self to min, decrementing by 1. If self < min, does nothing.

See also upto, step, and times.



next succ

Returns the "next" value of an integer.

step(limit, step) {|n| ... }

Iteratively evaluates a block from self, incrementing by step, until limit is about to be surpassed. step can also be a negative number.

When step is set to 0, throws an ArgumentError exception.

Returns self.

See also upto, downto, and times.

times {|n| ... }

Iterates self number of times, from 0 to self-1. If self is negative, does nothing.

Returns self.

See also upto, downto, and step.

to_f

Converts a value to a floating point integer (Float).

to_s([base])

Converts an integer to a base-10 string expression.

If an argument is specified, it will be used as the base number for conversion. If a base outside the range of 2-36 is specified, an ArgumentError exception will be thrown.

p 10.to_s(2) # => "1010" p 10.to_s(8) # => "12" p 10.to_s(16) # => "a" p 35.to_s(36) # => "z"

upto(max) {|n| ... }

Iterates from self to max, incrementing by 1. If self > max, does nothing.

Returns self.

See also downto, step, and times.

Bignum The class for long integers, limited only by memory size. The result of an operation is automatically converted into a Fixnum if its value is within range; conversely, if the value is out of Fixnum range, it is extended into a Bignum. For bit operations, Bignum can be considered to be an infinite 2's complement bit string. Negative numbers in



particular can operate as a string of 1 bits extending indefinitely to the left. Mixing Bignum with Float can result in digit cancellation errors upon conversion.

Superclass

Integer

Fixnum The class for fixed-length integers that fit into the machine's pointer, which is usually 31 bits long. If the result of an operation is out of Fixnum range, it is automatically extended into a Bignum.

Superclass

Integer

Methods

id2name

Returns the string corresponding to a Symbol integer (obtained with Symbol#to_i). If there is no symbol that corresponds to the integer, returns nil.

to_sym

Returns the Symbol object corresponding to the integer value of the object's self. If there is no symbol that corresponds to the integer, returns nil.

Float The floating point value class. The implementation of Float is the same as in C.

Superclass

Numeric

Methods

self + other self - other self * other self / other self % other self ** other

Arithmetic operator. Computes the sum, difference, product, quotient, remainder, and exponent.



self <=> other

Compares other with self; returns a positive integer if self is larger, 0 if the two are equal, and a negative integer if self is smaller.

self == other self < other self <= other self > other self >= other

Relational operator.

finite?

Returns TRUE even if the value is infinite, unless it is also NaN.

infinite?

Returns 1 when a value is positive and infinite; returns -1 when a value is negative and infinite. Otherwise, returns nil. The floating point zero ensures infinite division.

inf = 1.0/0 p inf p inf.infinite? => Infinity 1 inf = -1.0/0 p inf p inf.infinite? => -Infinity -1

nan?

Returns TRUE when a value is NaN (not a number). The floating point zero ensures the result of division by 0 is NaN.

nan = 0.0/0.0 p nan p nan.nan? => NaN true

Range The range object class. See Range Expressions for more information.

Superclass

Object



Included Module

Enumerable

Methods

self === other

This method is mostly used for comparison within case statements. Returns true if other is within range.

begin first

Returns the initial element.

each {|item| ... }

Iterates over each element within the range.

end last

Returns the end point, regardless of whether the range object is inclusive of the end point.

p (1..5).end # => 5 p (1...5).end # => 5

exclude_end?

Returns true if the range object is exclusive of the end point.

Proc Proc is a procedure object in which both a block and its context (local variable scope and stack frame) have been encapsulated as an object. Proc can be used like an unnamed function, except that it does not have its own local variable scope.

We can see that Proc retains a local variable scope, however, by observing that the variable var can be referenced, as in the example below:

var = 1 $foo = Proc.new { var } var = 2 def foo $foo.call end p foo # => 2

Superclass

Object



Class Method

Proc.new Proc.new { ... }

Encapsulates a block, along with its context, into an object and returns it.

If no block is specified, but the method that called Proc.new contains a block, that block will be created as a Proc object and returned.

Method

call(arg ... )

Executes a procedure object and returns the result. Arguments are assigned to block parameters as is (according to the rules of multiple assignation).

Regexp The regular expression class. See Regular Expressions for details.

Superclass

Object

Class Methods

Regexp.last_match

Returns the MatchData object for the last regular expression match performed in the current scope. This method call is identical to a $~ reference.

/(.)(.)/ =~ "ab" p Regexp.last_match # => #<MatchData:0x4599e58> p Regexp.last_match[0] # => "ab" p Regexp.last_match[1] # => "a" p Regexp.last_match[2] # => "b" p Regexp.last_match[3] # => nil

Regexp.last_match([nth])

If the integer nth is 0, returns the matching string ($&). Otherwise, returns the substring matching the nth set of parentheses ($1, $2, ...). When there are no corresponding parentheses or no matches, returns nil.

/(.)(.)/ =~ "ab" p Regexp.last_match # => #<MatchData:0x4599e58> p Regexp.last_match(0) # => "ab" p Regexp.last_match(1) # => "a" p Regexp.last_match(2) # => "b" p Regexp.last_match(3) # => nil

Because Regexp.last_match, with no arguments, returns nil when the entire regular expression does not



match, the format last_match[1] will throw a NameError exception. On the other hand, last_match(1) returns nil.

Methods

self =~ string self === string

Matches the string string to a regular expression. If the argument is not a string or does not match, returns false; if it matches, returns true.

Matching information can be configured in the built-in variable $~.

If string is neither nil nor a String object, throws a TypeError exception.

match(str)

Identical to self=~str, except that it does not return a MatchData object. If there is no match, returns nil.

When only the substring matching the regular expression is needed, use match(str) like this:

bar = /foo(.*)baz/.match("foobarbaz").to_a[1] _, foo, bar, baz = */(foo)(bar)(baz)/.match("foobarbaz")

to_a takes failed matches into account.

to_s

Creates and returns a string expression for a regular expression. Preserves the meaning of the returned string even if the string is embedded in another regular expression.

re = /foo|bar|baz/i p re.to_s # => "(?i-mx:foo|bar|baz)" p /#{re}+/o # => /(?i-mx:foo|bar|baz)+/

However, some regular expressions with backreferences may not work as expected. This is because backreferences can only be specified by number at present.

re = /(foo|bar)\1/ # \1 is foo or bar p /(baz)#{re}/ # \1 is baz # => /(baz)(?-mix:(foo|bar)\1)/

String The string class. Can handle byte sequences of arbitrary lengths. See String Literals for details.

The String class itself behaves like a byte sequence. Use scan(/./), etc. to extract characters from a multibyte string one at a time.

Superclass



Object

Included Modules

Comparable Enumerable

Methods

self + other

Returns a new concatenated string.

self * times

Creates and returns a new string consisting of the string contents repeated times times.

self <=> other

Compares self with other by ASCII order; returns a positive integer if self is larger, 0 if the two are equal, and a negative integer if self is smaller.

self == other

Determines whether the strings are equal.

self[nth, len]

Returns a len-byte-long substring found at the nth byte. When nth is negative, counts from the end of the string.

If nth is out of range, returns nil.

self[regexp]

Returns the first substring matching regexp. Matching information can be configured in the built-in variable $~.

If there is no match to regexp, returns nil.

p "foobar"[/bar/] # => "bar"

self[nth, len]=val

Replaces the len-byte-long substring found at the nth byte with the string val. When nth is negative, counts from the end of the string.

Returns val .

self[regexp]=val

Replaces the first substring matching the regular expression regexp with the string val.



If there is no match to the regular expression, throws an IndexError exception.

Returns val.

clone dup

Returns a new string with the same contents as the original string. Using clone on a frozen string will return a similarly frozen string, but dup returns an unfrozen string with identical contents.

concat(other)

Appends the contents of the string other to self. Returns self.

downcase downcase!

Replaces all uppercase characters with lowercase characters.

downcase creates and returns the modified string. downcase! modifies and returns self, but if no characters were replaced, returns nil.

See also upcase.

each {|line| ... } each_line {|line| ... }

Iterates over each line in the string.

Returns self.

each_byte {|byte| ... }

Iterates over each byte of the string. Returns self.

empty?

Returns true if the string is empty (i.e., a zero-length string).

gsub(pattern) {|matched| .... } gsub!(pattern) {|matched| .... }

Replaces all substrings matching pattern with the results of the block evaluation. The matching substring is passed to the block as an argument. The built-in variable $<digits> can be referenced within the block.

p 'abcabc'.gsub(/b/) {|s| s.upcase } # => "aBcaBc" p 'abcabc'.gsub(/b/) { $&.upcase } # => "aBcaBc" p 'abbbcd'.gsub(/a(b+)/) { $1 } # => "bbbcd"

gsub creates and returns the post-replacement string. gsub! modifies and returns self, but if no characters were replaced, returns nil.

See also sub.



include?(substr)

Returns true if the substring substr is included in the text string.

If substr is a Fixnum from 0 to 255, it is determined to be a character code and if that character is included, it returns true.

index(pattern[, pos])

Performs a search for the substring from left to right. Returns the left-hand position of the found substring. If nothing is found, nil is returned.

The pattern argument is used to specify the substring to search for, using a text string, an integer from 0 to 255, or a regular expression.

If pos is provided, the search starts from that position. The value of pos when it is omitted is 0.

insert(nth, other)

Inserts the string other immediately before the character in the nth position. Returns self.

p "foobaz".insert(3, "bar") # => "foobarbaz"

to_sym

Returns the symbol value (Symbol) corresponding to the string.

Use Symbol#id2name to obtain the string corresponding to a symbol.

p "foo".to_sym # => :foo p "foo".to_sym.to_s == "foo" # => true

length size

Returns the length of the string in bytes.

scan(re) scan(re) {|s| ... }

Repeatedly matches against self with the regular expression re and returns an array of matching substrings.

p "foobarbazfoobarbaz".scan(/ba./) # => ["bar", "baz", "bar", "baz"] p "abcde".scan(/./) # => ["a", "b", "c", "d", "e"]

When called with a block specified, the matching substrings become the block's parameters. (If parentheses are included, an array of strings that match the patterns in parentheses becomes the block's parameter.) If a block is specified, returns self.

"foobarbazfoobarbaz".scan(/ba./) {|s| p s} # => "bar" "baz" "bar" "baz"



slice(nth, len) slice(regexp)

Identical to self[].

slice!(nth, len) slice!(regexp)

Removes a specified range (see self[]) from a string and returns the removed substring.

If the argument is out of range, returns nil.

sub(pattern) {|matched| ... } sub!(pattern) {|matched| ... }

Replaces the first substring matching pattern with the results of the block evaluation.

sub creates and returns the post-replacement string. sub! modifies and returns self, but if no characters were replaced, returns nil.

Identical to gsub, except that sub only matches once.

to_f

Interprets the string as a base-10 expression and converts it into a floating point integer (Float).

to_i([base])

Interprets the string as a numeric expression and converts it into an integer.

The default is base-10. By specifing base, you can perform base 2-36 conversions as well.

upcase upcase!

Replaces all lowercase characters with uppercase characters.

downcase creates and returns the modified string. downcase! modifies and returns self, but if no characters were replaced, returns nil.

See also downcase.

Symbol The class that expresses symbols. See Symbol for more information.

Superclass

Object



Methods

id2name

Returns the string corresponding to a symbol.

Use String#to_sym to obtain the symbol corresponding to a string.

p :foo.id2name.to_sym == :foo # => true

to_i

Returns the integer corresponding to a symbol.

Use Fixnum#to_sym to obtain the symbol corresponding to this integer.

p :foo.to_i # => 8881 p :foo.to_i.to_sym # => :foo

In Ruby, reserved words, variable names, method names, and the like are controlled by these integers. Integers corresponding to objects (obtained via Object#object_id) and those corresponding to symbols are separate items.

Time The time class.

Superclass

Object

Included Module

Comparable

Class Method

Time.now

Returns the current Time object.

Methods

self + other

Returns a time that is later than self by other seconds.

self - other

When other is a Time object, returns the difference between the two times with Float. If other is a numeric



value, returns a time that is earlier than self by other.

self <=> other

Compares times. other must be a Time object or a numeric value; if a numeric value, the times are compared in terms of seconds since the epoch began.

strftime(format)

Returns the time, having been converted into a string via a format string. The format string may be specified with the following:

%A

Day of the week (Sunday, Monday ... )

%a

Day of the week, abbreviated (Sun, Mon ... )

%B

Month (January, February ... )

%b

Month, abbreviated (Jan, Feb ... )

%c

Date and time

%d

Day of the month (01-31)

%H

Time of day, 24-hour format (00-23)

%I

Time of day, 12-hour format (01-12)

%j

Day of the year (001-366)

%M

Minutes (00-59)

%m



Month of the year (01-12)

%p

AM or PM

%S

Seconds (00-60, 60 being a leap second)

%U

Week of the year, the first week starting with the first Sunday (00-53)

%W

Week of the year, the first week starting with the first Monday (00-53)

%w

Day of the week (0-6, 0 denoting Sunday)

%X

Time

%x

Date

%Y

Year, 4-digit

%y

Year, 2-digit (00-99)

%Z

Time zone

%%

The character %

sec

Returns the seconds.

min

Returns the minutes.



hour

Returns the hour.

mday

Returns the day.

mon

Returns the month.

year

Returns the year.

wday

Returns the number representing the day of the week.

TrueClass The true class. true is the only instance of the TrueClass class. true is a representative object that denotes a TRUE condition.

Superclass

Object

Methods

self & other

If other is TRUE, returns TRUE. If FALSE, returns FALSE.

self | other

Normally returns TRUE.

self ^ other

If other is TRUE, returns FALSE. If FALSE, returns TRUE.

Built-in Modules Comparable Enumerable Errno FileTest



GC Kernel Marshal Math

Comparable A mix-in allowing for relational operations. Classes including this module must define the basic relational operators <, =, and >. All other relational operators can be derived through use of those definitions.

Methods

self == other

Returns TRUE when self and other are equal.

When <=> returns nil, returns nil.

self > other

Returns TRUE when self is greater than other.

When <=> returns nil, throws an ArgumentError exception.

self >= other

Returns TRUE when self is greater than or equal to other.


self < other

Returns TRUE when self is less than other.


self <= other

Returns TRUE when self is less than or equal to other.


between?(min, max)

Returns TRUE when self falls within a range from min to max, inclusive.

When self <=> min or self <=> max returns nil, throws an ArgumentError exception.

Enumerable



A mix-in for repeating classes. This module's methods are all defined via each, so each must be defined in any class which includes this module.

Method

all? all? {|item| ... }

Returns TRUE when all items are true. If any item is false, immediately returns FALSE.

When using a block, evaluates the block against each item and returns TRUE if all outcomes are true. If the block returns FALSE at any time, immediately returns FALSE.

p [1,2,3].all? {|v| v > 0} # => true p [1,2,3].all? {|v| v > 1} # => false

any? any? {|item| ... }

Returns FALSE when all items are false. If any item is true, immediately returns TRUE.

When using a block, evaluates the block against each item and returns FALSE if all outcomes are false. If the block returns TRUE at any time, immediately returns TRUE.

p [1,2,3].any? {|v| v > 3} # => false p [1,2,3].any? {|v| v > 1} # => true

find {|item| ... }

Returns the first item that tested as true during the block evaluation. If no item was true, returns nil.

find_all {|item| ... }

Returns an array of all items that tested as true during the block evaluation. If no item was true, returns an empty array.

include?(val)

Returns TRUE when the list includes an item that satisfies the relationship val ==.

max

Returns the largest item. Assumes all items are comparable via the <=> method.

max {|a, b| ... }

Compares each item based on the block's evaluated value and returns the largest item.

Anticipates a block value that will be a positive integer when a>b, 0 when a==b, and a negative integer when a<b. When the block returns a non-integer, throws a TypeError exception.

min



Returns the smallest item. Assumes all items are comparable via the <=> method.

min {|a, b| ... }

Compares each item based on the block's evaluated value and returns the smallest item.

Anticipates a block value that will be a positive integer when a>b, 0 when a==b, and a negative integer when a<b. When the block returns a non-integer, throws a TypeError exception.

sort sort {|a, b| ... }

Creates and returns an array of all items sorted in ascending order.

When not using a block, calls the <=> against each item and sorts based upon those results.

To sort using other methods besides <=>, select a block; the items will be sorted based on the evaluation of this block. Anticipates a block value that will be a positive integer when a>b, 0 when a==b, and a negative integer when a<b. When the block returns a non-integer, throws a TypeError exception.

to_a entries

Returns an array of all items.

Errno A module containing exceptions corresponding to system call errors.

Inner Classes

These are representative exception classes. Many others are defined as well, but you need not be concerned about them.

E2BIG The argument list is too long.

EACCES Access permission was denied.

EAGAIN Cannot create any more processes.

EBADF Invalid file number.

ECHILD No child process exists.

EDEADLOCK Possibility of a resource deadlock.

EDOM The value of the numerical data function's argument is outside the function's domain.

EEXIST



File already exists. EINVAL

Invalid argument. EMFILE

Too many open files. ENOENT

No file or directory. ENOEXEC

Executable file error. ENOMEM

Not enough memory. ENOSPC

Not enough free space on device. ERANGE

Results are too large. EXDEV

Device interlink.

FileTest A module containing file test functions.

Module Functions

FileTest.exist?(filename)

Returns TRUE when filename exists.

FileTest.directory?(filename)

Returns TRUE when filename is a directory.

FileTest.file?(filename)

Returns TRUE when filename is an ordinary file.

FileTest.size(filename)

Returns the size of filename. If filename does not exist, throws an Errno::EXXX exception (most likely Errno::ENOENT).

GC A module that controls garbage collection in the Ruby interpreter.

Module Method



GC.disable

Halts garbage collection.

Returns the previous halt state (if halted, returns TRUE; if garbage collection was enabled, returns FALSE).

GC.enable

Permits garbage collection.

Returns the previous halt state (if halted, returns TRUE; if garbage collection was enabled, returns FALSE).

GC.start

Initializes garbage collection.

Returns nil.

Kernel A module defining the methods that can be referred to by all classes. Object classes are included in this module. The methods explained on the Built-in Functions page are defined in this module.

Object class methods are defined in this module. This ensures compatibility with top-level method redefinition.

Marshal A module providing the capability to write a Ruby object to and read it from a file (or string array).

Module Functions

Marshal.dump(obj[, port][, limit])

Writes obj to a file recursively.

Some objects may not be writeable to file, such as in instances of File or MatchData, or with objects that define unusual methods. When attempting to write such objects to file, a TypeError will occur.

port specifies an instance of IO (or a subclass). In this case, returns port. When omitted, dump returns the object's dump as a string.

When limit is specified, no objects linked at or deeper than limit can be dumped (100 levels is the default. When limit is negative, no depth checking is performed.

Marshal.load(port)

Reads marshal data from port (i.e., the string output from Marshal.dump) and creates an object with the same state as the original object. port specifies an instance of IO (or a subclass).



Math A module that supports floating point calculations.

Module Functions

Math.acos(x) Math.asin(x) Math.atan(x)

Returns the value of the inverse trigonometric functions of x in radians.

Values that can be returned have ranges of [0, +π], [-π/2, +π/2], and (-π/2, +π/2) respectively.

In acos(x), and asin(x), x must be in the range -1.0 <= x <= 1 (normally returns NaN).

acos() and asin() will throw an Errno::EDOM exception for arguments out of range.

Math.atan2(y, x)

Returns the arctangent of y/x in the range [-π, π].

Math.acosh(x) Math.asinh(x) Math.atanh(x)

Returns the value of the inverse hyperbolic functions of x.

asinh(x) = log(x + sqrt(x * x + 1)) acosh(x) = log(x + sqrt(x * x - 1)) [x >= 1] atanh(x) = log((1+x)/(1-x)) / 2 [-1 < x < 1]

In acosh(x), x must be >= 1 (normally throws an Errno::EDOM exception).

In atanh(x), x must be in the range -1.0 < x < 1 (normally throws an Errno::EDOM exception).

Math.cos(x) Math.sin(x) Math.tan(x)

Returns the value of the trigonometric functions of x in radians, in the range [-1, 1].

Math.cosh(x) Math.sinh(x) Math.tanh(x)

Returns the value of the hyperbolic functions of x.

cosh(x) = (exp(x) + exp(-x)) / 2 sinh(x) = (exp(x) - exp(-x)) / 2 tanh(x) = sinh(x) / cosh(x)



Math.erf(x) Math.erfc(x)

Returns the values of the error function (erf) and complementary error function (erfc) of x.

Math.exp(x)

Returns the value of the exponential function of x.

Math.frexp(x)

Returns the exponent and mantissa of the real number x.

Math.hypot(x, y)

Returns sqrt(x*x + y*y).

Math.ldexp(x, exp)

Returns the real number x multiplied by 2 to the power of exp.

Math.log(x)

Returns the natural logarithm of x.

x must be a positive value (normally returns NaN for negative values and -Infinity for 0).

Negative arguments out of range throw Errno::EDOM exceptions, while a 0 argument throws an Errno::ERANGE exception.

Math.log10(x)

Returns the common logarithm of x.

x must be a positive value (normally returns NaN for negative values and -Infinity for 0).

Negative arguments out of range throw Errno::EDOM exceptions, while a 0 argument throws an Errno::ERANGE exception.

Math.sqrt(x)

Returns the square root of x. When x is a negative value, throws an ArgumentError exception.

Normally, when x is negative, throws an Errno::EDOM exception.

Definitions

E

The natural logarithmic base.

p Math::E # => 2.718281828



PI

The circle ratio.

p Math::PI # => 3.141592654

Built-in Exception Classes Exception

The superclass of all exceptions. NoMemoryError

Thrown when attempting to reserve too much memory at once. ScriptError

Indicates a script error. NotImplementedError

Thrown when an unimplemented feature is invoked. SyntaxError

Thrown by a syntax error. StandardError

Without a class specified, the rescue class will catch the subclasses of this exception class. ArgumentError

Thrown when argument numbers do not match or when the values are incorrect. IndexError

Thrown when the index is out of range. IOError

Thrown when an I/O error occurs. EOFError

Thrown when EOF (End Of File) has been reached. LocalJumpError

Thrown when no jump destination is found for a control structure. NameError

Thrown when accessing an undefined local variable or constant. NoMethodError

Thrown when calling an undefined method. RangeError

A range exception. Thrown when an out-of-range integer conversion (from Bignum to Fixnum) , etc., occurs. FloatDomainError

Thrown when trying to convert a positive or negative infinite number or NaN (Not a Number) into Bignum , or when comparing a number to a NaN.

RegexpError Thrown when compiling a regular expression fails.

RuntimeError A runtime exception. Thrown when calling raise without specifying an exception.

SystemCallError Thrown when a system call fails. Errno::EXXX



Exception class for each errno. See the Errno module for more on each class name. SystemStackError

Thrown when a stack level becomes too deep. TypeError

Thrown when an illegal type is invoked. ZeroDivisionError

Thrown when dividing by zero. SystemExit

Terminates the program. See exit for more information. fatal

A fatal (internal) error. This object is not visible with normal methods.

Game Library RGSS Built-in Functions RGSS Built-in Classes

Bitmap Color Font Plane Rect Sprite Table Tilemap Tone Viewport Window RGSSError

RGSS Built-in Modules Audio Graphics Input RPG

RPGVX Data Structures RPG::Map RPG::MapInfo RPG::Area RPG::Event RPG::Event::Page RPG::Event::Page::Condition RPG::Event::Page::Graphic RPG::EventCommand RPG::MoveRoute RPG::MoveCommand RPG::Actor RPG::Class RPG::Class::Learning



RPG::BaseItem RPG::UsableItem

RPG::Skill RPG::Item

RPG::Weapon RPG::Armor

RPG::Enemy RPG::Enemy::DropItem RPG::Enemy::Action RPG::Troop RPG::Troop::Member RPG::Troop::Page RPG::Troop::Page::Condition RPG::State RPG::Animation RPG::Animation::Frame RPG::Animation::Timing RPG::CommonEvent RPG::System RPG::System::Vechile RPG::System::Terms RPG::System::TestBattler RPG::AudioFile

RPG::BGM RPG::BGS RPG::ME RPG::SE

RGSS Built-in Functions The following built-in functions are defined in RGSS.

load_data(filename)

Loads the data file indicated by filename and restores the object.

$data_actors = load_data("Data/Actors.rvdata")

This function is essentially the same as:

File.open(filename, "rb") { |f| obj = Marshal.load(f) }

However, it differs in that it can load files from within encrypted archives.

save_data(obj, filename)

Saves the object obj to the data file indicated by filename.

save_data($data_actors, "Data/Actors.rvdata")



This function is the same as:

File.open(filename, "wb") { |f| Marshal.dump(obj, f) }

It is unlikely you will ever use this function during a game, but it is defined as a counterpart to load_data.

Also, the built-in functions p and print are redefined for use in message box output.

RGSS Built-in Classes Bitmap Color Font Plane Rect Sprite Table Tilemap Tone Viewport Window RGSSError

Bitmap The bitmap class. Bitmaps are expressions of so-called graphics.

Sprites (Sprite) and other objects must be used to display bitmaps on the screen.

Superclass

Object

Class Methods

Bitmap.new(filename)

Loads the graphic file specified in filename and creates a bitmap object.

Also automatically searches files included in RGSS-RTP and encrypted archives. File extensions may be omitted.

Bitmap.new(width, height)

Creates a bitmap object with the specified size.



Methods

dispose

Frees the bitmap. If the bitmap has already been freed, does nothing.

disposed?

Returns TRUE if the bitmap has been freed.

width

Gets the bitmap width.

height

Gets the bitmap height.

rect

Gets the bitmap rectangle (Rect).

blt(x, y, src_bitmap, src_rect[, opacity])

Performs a block transfer from the src_bitmap box src_rect (Rect) to the specified bitmap coordinates (x, y).

opacity can be set from 0 to 255.

stretch_blt(dest_rect, src_bitmap, src_rect[, opacity])

Performs a block transfer from the src_bitmap box src_rect (Rect) to the specified bitmap box dest_rect (Rect).

opacity can be set from 0 to 255.

fill_rect(x, y, width, height, color) fill_rect(rect, color)

Fills the bitmap box (x, y, width, height) or rect (Rect) with color (Color).

gradient_fill_rect(x, y, width, height, color1, color2[, vertical]) (RGSS2) gradient_fill_rect(rect, color1, color2[, vertical]) (RGSS2)

Fills in this bitmap box (x, y, width, height) or rect (Rect) with a gradient from color1 (Color) to color2 (Color).

Set vertical to true to create a vertical gradient. Horizontal gradient is the default.

clear

Clears the entire bitmap.

clear_rect(x, y, width, height) (RGSS2)



clear_rect(rect) (RGSS2)

Clears this bitmap box or (x, y, width, height) or rect (Rect).

get_pixel(x, y)

Gets the color (Color) at the specified pixel (x, y).

set_pixel(x, y, color)

Sets the specified pixel (x, y) to color (Color).

hue_change(hue)

Changes the bitmap's hue within 360 degrees of displacement.

This process is time-consuming. Furthermore, due to conversion errors, repeated hue changes may result in color loss.

blur (RGSS2)

Applies a blur effect to the bitmap. This process is time consuming.

radial_blur(angle, division) (RGSS2)

Applies a radial blur to the bitmap. angle is used to specify an angle from 0 to 360. The larger the number, the rounder the effect.

division is the division number (from 2 to 100). The larger the number, the smoother it will be. This process can be very time consuming.

draw_text(x, y, width, height, str[, align]) draw_text(rect, str[, align])

Draws a string str in the bitmap box (x, y, width, height) or rect (Rect).

If str is not a character string object, it will be converted to a character string using the to_s method before processing is performed. (RGSS2)

If the text length exceeds the box's width, the text width will automatically be reduced by up to 60 percent.

Horizontal text is left-aligned by default; set align to 1 to center the text and to 2 to right-align it. Vertical text is always centered.

As this process is time-consuming, redrawing the text with every frame is not recommended.

text_size(str)

Gets the box (Rect) used when drawing a string str with the draw_text method. Does not include the angled portions of italicized text.

If str is not a character string object, it will be converted to a character string using the to_s method before



processing is performed.(RGSS2)

Property

font

The font (Font) used to draw a string with the draw_text method.

Color The RGBA color class. Each component is handled with a floating point value (Float).

Superclass

Object

Class Method

Color.new(red, green, blue[, alpha])

Creates a Color object. If alpha is omitted, it is assumed at 255.

Method

set(red, green, blue[, alpha])

Sets all components at once.

Properties

red

The red value (0-255). Values out of range are automatically corrected.

green

The green value (0-255). Values out of range are automatically corrected.

blue

The blue value (0-255). Values out of range are automatically corrected.

alpha

The alpha value (0-255). Values out of range are automatically corrected.

Font



The font class. Font is a property of the Bitmap class.

Superclass

Object

Class Methods

Font.new([name[, size]])

Creates a Font object.

Font.exist?(name)

Returns TRUE when the specified font exists within the system.

Properties

name

The font name. Include an array of strings to specify multiple fonts to be used in a desired order.

font.name = ["Myriad", "Verdana"]

In this example, if the higher priority font Myriad does not exist within the system, the second choice Verdana will be used instead.

The default is ["Verdana", "Arial", "Courier New"]. (RGSS2)

size

The font size. The default is 20. (RGSS2)

bold

The bold flag. The default is FALSE.

italic

The italic flag. The default is FALSE.

shadow (RGSS2)

The flag for shadow text. The default is TRUE. When enabled, a black shadow will be drawn to the bottom right of the character.

color

The font color (Color). Alpha values may also be used. The default is (255,255,255,255).

Alpha values are also used when drawing shadow text. (RGSS2)



Class Properties

default_name default_size default_bold default_italic default_shadow (RGSS2) default_color

Change the default values for each component, to be applied to each new Font object.

Font.default_name = ["Myriad", "Verdana"] Font.default_bold = true

Plane The Plane class. Planes are special sprites that tile bitmap patterns across the entire screen, and are used to display parallax backgrounds, etc.

Superclass

Object

Class Method

Plane.new([viewport])

Creates a Plane object. Specifies a Viewport (Viewport) when necessary.

Methods

dispose

Frees the plane. If the plane has already been freed, does nothing.

disposed?

Returns TRUE if the plane has been freed.

Properties

bitmap

Refers to the bitmap (Bitmap) used in the plane.

viewport (RGSS2)

Refers to the viewport (Viewport) associated with the plane.



visible

Whether the plane can be seen. If TRUE, the plane is visible.

z

The plane's Z-coordinate. The larger this value, the closer to the player the plane will be displayed. If multiple objects share the same Z-coordinate, the more recently created object will be displayed closest to the player.

ox

The X-coordinate of the plane's starting point. Change this value to scroll the plane.

oy

The Y-coordinate of the plane's starting point. Change this value to scroll the plane.

zoom_x

The plane's X-axis zoom level. 1.0 denotes actual pixel size.

zoom_y

The plane's Y-axis zoom level. 1.0 denotes actual pixel size.

opacity

The plane's opacity (0-255). Values out of range are automatically corrected.

blend_type

The plane's blending mode (0: normal, 1: addition, 2: subtraction).

color

The color (Color) to be blended with the plane. Alpha values are used in the blending ratio.

tone

The plane's color tone (Tone).

Rect The rectangle class.

Superclass

Object

Class Method



Rect.new(x, y, width, height)

Creates a new Rect object.

Method

set(x, y, width, height)

Sets all parameters at once.

Properties

x

The X-coordinate of the rectangle's upper left corner.

y

The Y-coordinate of the rectange's upper left corner.

width

The rectangle's width.

height

The rectangle's height.

Sprite The sprite class. Sprites are the basic concept used to display characters, etc. on the game screen.

Superclass

Object

Class Method

Sprite.new([viewport])

Creates a new Sprite object. Specifies a Viewport (Viewport) when necessary.

Methods

dispose

Frees the sprite. If the sprite has already been freed, does nothing.

disposed?



Returns TRUE if the sprite has been freed.

flash(color, duration)

Begins flashing the sprite. duration specifies the number of frames the flash will last.

If color is set to nil, the sprite will disappear while flashing.

update

Advances the sprite flash or wave phase (RGSS2). As a general rule, this method is called once per frame.

If a flash or wave is not needed, it is not necessary to call this.

width (RGSS2)

Gets the width of the sprite. Equivalent to src_rect.width.

height (RGSS2)

Gets the height of the sprite. Equivalent to src_rect.height.

Properties

bitmap

Refers to the bitmap (Bitmap) used for the sprite's starting point.

src_rect

The box (Rect) taken from a bitmap.

viewport (RGSS2)

Refers to the viewport (Viewport) associated with the sprite.

visible

The sprite's visibility. If TRUE, the sprite is visible.

x

The sprite's X-coordinate.

y

The sprite's Y-coordinate.

z

The sprite's Z-coordinate. The larger this value, the closer to the player the sprite will be displayed.

If two sprites have the same Z coordinates, the one with the larger Y coordinate will be displayed closer to



the player (RGSS2), and if the Y coordinates are the same, the one that was generated later will be displayed closer to the player.

ox

The X-coordinate of the sprite's starting point.

oy

The Y-coordinate of the sprite's starting point.

zoom_x

The sprite's X-axis zoom level. 1.0 denotes actual pixel size.

zoom_y

The sprite's Y-axis zoom level. 1.0 denotes actual pixel size.

angle

The sprite's angle of rotation. Specifies up to 360 degrees of counterclockwise rotation. However, drawing a rotated sprite is time-consuming, so avoid overuse.

wave_amp (RGSS2) wave_length (RGSS2) wave_speed (RGSS2) wave_phase (RGSS2)

Defines the amplitude, frequency, speed, and phase of the wave effect. A raster scroll effect is achieved by using a sinusoidal function to draw the sprite with each line's horizontal position a bit different from the last.

wave_amp is the wave amplitude and wave_length is the wave frequency, and each is specified by number of pixels.

wave_speed specifies the speed of the wave animation. The default is 360, and the larger the value, the faster the effect.

wave_phase specifies the phase of the top line of the sprite using an angle of up to 360 degrees. This is updated each time the update method is called. It is not necessary to use this property unless it is required for two sprites to have their wave effects synchronized.

mirror

Flag denoting the sprite has been flipped horizontally. If TRUE, the sprite will be drawn flipped.

bush_depth bush_opacity (RGSS2)

The bush depth and opacity of a sprite. This can be used to represent something like characters' legs being hidden by bushes.



For bush_depth, the number of pixels for the bush section is specified. The default value is 0.

For bush_opacity, the opacity of the bush section from 0 to 255 is specified. Values that are out of range will automatically be corrected. The default value is 128.

The bush_opacity value will be multiplied by opacity. For example, if both opacity and bush_opacity are set to 128, it will be handled as transparency on top of transparency, for an actual opacity of 64.

opacity

The sprite's opacity (0-255). Values out of range are automatically corrected.

blend_type

The sprite's blending mode (0: normal, 1: addition, 2: subtraction).

color

The color (Color) to be blended with the sprite. Alpha values are used in the blending ratio.

Handled separately from the color blended into a flash effect. However, the color with the higher alpha value when displayed will have the higher priority when blended.

tone

The sprite's color tone (Tone).

Table The multidimensional array class. Each element takes up 2 signed bytes, ranging from -32,768 to 32,767.

Ruby's Array class does not run efficiently when handling large amounts of data, hence the inclusion of this class.

Superclass

Object

Class Method

Table.new(xsize[, ysize[, zsize]])

Creates a Table object. Specifies the size of each dimension in the multidimensional array. 1-, 2-, and 3-dimensional arrays are possible. Arrays with no parameters are also permitted.

Methods

resize(xsize[, ysize[, zsize]])

Change the size of the array. All data from before the size change is retained.



xsize ysize zsize

Gets the sizes of each of the array's dimensions.

Properties

self[x] self[x, y] self[x, y, z]

Accesses the array's elements. Pulls the same number of arguments as there are dimensions in the created array. Returns nil if the specified element does not exist.

Tilemap The class governing tilemaps. Tilemaps are a specialized concept used in 2D game map displays, created internally from multiple sprites.

This class has been greatly changed with RGSS2. (RGSS2)

Superclass

Object

Class Method

Tilemap.new([viewport])

Creates a Tilemap object. Specifies a Viewport (Viewport) when necessary.

Methods

dispose

Frees the tilemap. If the tilemap has already been freed, does nothing.

disposed?

Returns TRUE if the tilemap has been freed.

update

Updates the autotile animation, etc. As a rule, this method is called once per frame.

Properties



bitmaps[index] (RGSS2)

Refers to the bitmap (Bitmap) indicated by the index number (0 - 8) that is used as a tile set.

The correspondence between numbers and sets is illustrated in the table below.。

map_data

Refers to map data (Table). Defines a 3-dimensional array measuring [ horizontal size * vertical size * 3 ].

flash_data

Refers to the flash data (Table) used when showing range of possible movement in simulation games, etc. Defines a 2-dimensional array measuring [ horizontal size * vertical size ]. This array must be the same size as the map data. Each element uses 4 bits to represent a tile's flash color in RGB; for example, 0xf84 flashes in RGB(15,8,4).

passages (RGSS2)

Reference to the passage table (Table). Defines a 1-dimensional array containing elements corresponding to tile IDs.

viewport (RGSS2)

Refers to the viewport (Viewport) associated with the tilemap.

visible

The tilemap's visibility. If TRUE, the tilemap is visible.

ox

The X-coordinate of the tilemap's starting point. Change this value to scroll the tilemap.

oy

The Y-coordinate of the tilemap's starting point. Change this value to scroll the tilemap.

Notes

The Z-coordinate of each sprite used to create a tilemap is fixed at a specific value.

1. A tile that should be displayed under the character has a Z coordinate of 0. 2. A tile that should be displayed over the character has a Z coordinate of 200. (RGSS2)

Keep these rules in mind when setting the Z-coordinates of any map characters.

0 TileA1 1 TileA2 2 TileA3

3 TileA4 4 TileA5 5 TileB

6 TileC 7 TileD 8 TileE



Tone The color tone class. Each component is handled with a floating point value (Float).

Superclass

Object

Class Method

Tone.new(red, green, blue[, gray])

Creates a Tone object. If gray is omitted, it is assumed at 0.

Method

set(red, green, blue[, gray])

Sets all components at once.

Properties

red

The red balance adjustment value (-255 to 255). Values out of range are automatically corrected.

green

The green balance adjustment value (-255 to 255). Values out of range are automatically corrected.

blue

The blue balance adjustment value (-255 to 255). Values out of range are automatically corrected.

gray

The grayscale filter strength (0 to 255). Values out of range are automatically corrected.

When this value is not 0, processing time is significantly longer than when using tone balance adjustment values alone.

Viewport The viewport class. Used when displaying sprites in one portion of the screen, with no overflow into other regions.

Superclass



Object

Class Methods

Viewport.new(x, y, width, height) Viewport.new(rect)

Creates a viewport object.

Methods

dispose

Frees the viewport. If the viewport has already been freed, does nothing.

This operation will not result in a separate associated object being automatically freed. (RGSS2)

disposed?

Returns TRUE if the viewport has been freed.

flash(color, duration)

Begins flashing the viewport. duration specifies the number of frames the flash will last.

If color is set to nil, the viewport will disappear while flashing.

update

Refreshes the viewport flash. As a rule, this method is called once per frame.

It is not necessary to call this method if no flash effect is needed.

Properties

rect

The box (Rect) defining the viewport.

visible

The viewport's visibility. If TRUE, the viewport is visible.

z

The viewport's Z-coordinate. The larger this value, the closer to the player the plane will be displayed. If multiple objects share the same Z-coordinate, the more recently created object will be displayed closest to the player.

ox



The X-coordinate of the viewport's starting point. Change this value to shake the screen, etc.

oy

The Y-coordinate of the viewport's starting point. Change this value to shake the screen, etc.

color

The color (Color) to be blended with the viewport. Alpha values are used in the blending ratio.

Handled separately from the color blended into a flash effect.

tone

The viewport's color tone (Tone).

Window The game window class. Created internally from multiple sprites.

Superclass

Object

Class Method

Window.new([viewport])

Creates a Window object. Specifies a Viewport (Viewport) when necessary.

Methods

dispose

Frees the window. If the window has already been freed, does nothing.

disposed?

Returns TRUE if the window has been freed.

update

Refreshes the cursor blink and the pause graphic animation. As a rule, this method is called once per frame.

Properties

windowskin

Refers to the bitmap (Bitmap) used as a windowskin.



Only RPGVX skins may be used. (RGSS2)

contents

Refers to the bitmap (Bitmap) used for the window's contents.

viewport (RGSS2)

Refers to the (Viewport) associated with the window.

cursor_rect

The cursor box (Rect). Sets the window's upper left corner using relative coordinates (-16, -16).

active

Cursor blink status. If TRUE, the cursor is blinking.

visible

The window's visibility. If TRUE, the window is visible.

pause

The pause graphic's visibility. This is a symbol that appears in the message window when waiting for the player to press a button. If TRUE, the graphic is visible.

x

The window's X-coordinate.

y

The window's Y-coordinate.

width

The window's width.

height

The window's height.

z

The window's Z-coordinate. The larger this value, the closer to the player the plane will be displayed. If multiple objects share the same Z-coordinate, the more recently created object will be displayed closest to the player.

It is no longer possible to use different Z coordinates for the window's background and its contents. (RGSS2)

ox



The X-coordinate of the starting point of the window's contents. Change this value to scroll the window's contents.

oy

The Y-coordinate of the starting point of the window's contents. Change this value to scroll the window's contents.

opacity

The window's opacity (0-255). Values out of range are automatically corrected.

back_opacity

The window background's opacity (0-255). Values out of range are automatically corrected.

contents_opacity

The opacity of the window's contents (0-255). Values out of range are automatically corrected.

openness (RGSS2)

The openness of the window (from 0 to 255). Values out of range are automatically corrected.

By changing this value from 0 (completely closed) to 255 (completely open), it is possible to create an animation of the window opening and closing. If the openness is less than 255, the contents of the window will not be displayed. The default value is 255.

RGSSError Exception class providing notifications of RGSS internal errors.

Generated when, for instance, trying to access Bitmap or Sprite class objects that have already been freed.

Superclass

StandardError

RGSS Built-in Modules Audio Graphics Input RPG

Audio The module that carries out music and sound processing.



Module Methods

Audio.bgm_play(filename[, volume[, pitch]])

Starts BGM playback. Sets the file name, volume, and pitch in turn.

Also automatically searches files included in RGSS-RTP. File extensions may be omitted.

Audio.bgm_stop

Stops BGM playback.

Audio.bgm_fade(time)

Starts BGM fadeout. time is the length of the fadeout in milliseconds.

Audio.bgs_play(filename[, volume[, pitch]])

Starts BGS playback. Sets the file name, volume, and pitch in turn.


Audio.bgs_stop

Stops BGS playback.

Audio.bgs_fade(time)

Starts BGS fadeout. time is the length of the fadeout in milliseconds.

Audio.me_play(filename[, volume[, pitch]])

Starts ME playback. Sets the file name, volume, and pitch in turn.


When ME is playing, the BGM will temporarily stop. The timing of when the BGM restarts is slightly different from RGSS1. (RGSS2)

Audio.me_stop

Stops ME playback.

Audio.me_fade(time)

Starts ME fadeout. time is the length of the fadeout in milliseconds.

Audio.se_play(filename[, volume[, pitch]])

Starts SE playback. Sets the file name, volume, and pitch in turn.




When attempting to play the same SE more than once in a very short period, they will automatically be filtered to prevent choppy playback.

Audio.se_stop

Stops SE playback.

Graphics The module that carries out graphics processing.

Module Methods

Graphics.update

Refreshes the game screen and advances time by 1 frame. This method must be called at set intervals.

loop do Graphics.update Input.update do_something end

With RGSS1, if this method was not called for more than 10 seconds, the script was judged to be out of control and was automatically shut down, but this has been done away with. Even if this method is not called for a long period of time, Windows messages will still be processed normally, and it is possible to force quit using Alt + F4 as usual.(RGSS2)

Graphics.wait(duration) (RGSS2)

Waits for the specified number of frames. Equivalent to the following.

duration.times do Graphics.update end

Graphics.fadeout(duration) (RGSS2)

Performs a fade-out of the screen.

duration is the number of frames to spend on the fade-out.

Graphics.fadein(duration) (RGSS2)

Performs a fade-in of the screen.

duration is the number of frames to spend on the fade-in.

Graphics.freeze

Fixes the current screen in preparation for transitions.

Screen rewrites are prohibited until the transition method is called.



Graphics.transition([duration[, filename[, vague]]])

Carries out a transition from the screen fixed in Graphics.freeze to the current screen.

duration is the number of frames the transition will last. When omitted, this value is set to 8.

filename specifies the transition graphic file name. When not specified, a standard fade will be used. Also automatically searches files included in RGSS-RTP and encrypted archives. File extensions may be omitted.

vague sets the ambiguity of the borderline between the graphic's starting and ending points. The larger the value, the greater the ambiguity. When omitted, this value is set to 40.

Graphics.snap_to_bitmap (RGSS2)

Gets the current game screen image as a bitmap object.

This reflects the graphics that should be displayed, without relation to use of the freeze method.

The created bitmap must be freed when it is no longer needed.

Graphics.frame_reset

Resets the screen refresh timing. After a time-consuming process, call this method to prevent extreme frame skips.

Graphics.width (RGSS2) Graphics.height (RGSS2)

Gets the width and height of the game screen.

These are normally 544 and 416.

Graphics.resize_screen(width, height) (RGSS2)

Changes the size of the game screen.

Specify a value up to 640×480 for width and height.

Module Properties

Graphics.frame_rate

The number of times the screen is refreshed per second. The larger the value, the more CPU power is required. Normally set at 60. (RGSS2)

Changing this property is not recommended; however, it can be set anywhere from 10 to 120. Values out of range are automatically corrected.

Graphics.frame_count

The screen's refresh rate count. Set this property to 0 at game start and the game play time (in seconds) can be calculated by dividing this value by the frame_rate property value.



Graphics.brightness (RGSS2)

The brightness of the screen. Takes a value from 0 to 255. The fadeout, fadein, and transition methods change this value internally, as required.

Input A module that handles input data from a gamepad or keyboard.

Module Methods

Input.update

Updates input data. As a rule, this method is called once per frame.

Input.press?(num)

Determines whether the button num is currently being pressed.

If the button is being pressed, returns TRUE. If not, returns FALSE.

if Input.press?(Input::C) do_something end

Input.trigger?(num)

Determines whether the button num is being pressed again.

"Pressed again" is seen as time having passed between the button being not pressed and being pressed.


Input.repeat?(num)

Determines whether the button num is being pressed again.

Unlike trigger?, takes into account the repeat input of a button being held down continuously.


Input.dir4

Checks the status of the directional buttons, translates the data into a specialized 4-direction input format, and returns the number pad equivalent (2, 4, 6, 8).

If no directional buttons are being pressed (or the equivalent), returns 0.

Input.dir8

Checks the status of the directional buttons, translates the data into a specialized 8-direction input format, and returns the number pad equivalent (1, 2, 3, 4, 6, 7, 8, 9).



If no directional buttons are being pressed (or the equivalent), returns 0.

Constants

DOWN LEFT RIGHT UP

Numbers corresponding to the directions down, left, right, and up.

A B C X Y Z L R

Numbers corresponding to the various controller buttons.

SHIFT CTRL ALT

Numbers directly corresponding to the keyboard's SHIFT, CTRL, and ALT keys.

F5 F6 F7 F8 F9

Numbers corresponding to the keyboard's function keys. The other function keys are reserved by the system and cannot be obtained.

RPG A module containing RPGVX Data Structures.

RPGVX Data Structures RPG::Map RPG::MapInfo RPG::Area RPG::Event RPG::Event::Page RPG::Event::Page::Condition RPG::Event::Page::Graphic RPG::EventCommand RPG::MoveRoute RPG::MoveCommand RPG::Actor RPG::Class RPG::Class::Learning RPG::BaseItem

RPG::UsableItem RPG::Skill RPG::Item

RPG::EquippableItem RPG::Weapon RPG::Armor

RPG::Enemy



RPG::Enemy::DropItem RPG::Enemy::Action RPG::Troop RPG::Troop::Member RPG::Troop::Page RPG::Troop::Page::Condition RPG::State RPG::Animation RPG::Animation::Frame RPG::Animation::Timing RPG::CommonEvent RPG::System RPG::System::Vehicle RPG::System::Terms RPG::System::TestBattler RPG::AudioFile

RPG::BGM RPG::BGS RPG::ME RPG::SE

RPG::Map Data class for maps.

Superclass

Object

Attributes

width

The map width.

height

The map height.

scroll_type

Scroll type (0: No Loop, 1: Vertical Loop, 2: Horizontal Loop, 3: Both Loop).

autoplay_bgm

Truth-value of whether BGM autoswitching is enabled.

bgm



If BGM autoswitching is enabled, the name of that BGM (RPG::AudioFile).

autoplay_bgs

Truth-value of whether BGS autoswitching is enabled.

bgs

If BGS autoswitching is enabled, the name of that BGS (RPG::AudioFile).

disable_dashing

Truth-value of the [Disable Dashing] option.

encounter_list

Encounter list. A troop ID array.

encounter_step

Number of steps between encounters.

parallax_name

The parallax background's graphic file name.

parallax_loop_x

Truth-value of the [Loop Horizontal] option.

parallax_loop_y

Truth-value of the [Loop Vertical] option.

parallax_sx

The automatic X-axis scrolling speed.

parallax_sy

The automatic Y-axis scrolling speed.

parallax_show

Truth-value of the [Show in the Editor] option.

data

The map data. A 3-dimensional tile ID array (Table).

events

Map events. A hash that represents RPG::Event instances as values, using event IDs as the keys.



Definition

module RPG class Map def initialize(width, height) @width = width @height = height @scroll_type = 0 @autoplay_bgm = false @bgm = RPG::AudioFile.new @autoplay_bgs = false @bgs = RPG::AudioFile.new("", 80) @disable_dashing = false @encounter_list = [] @encounter_step = 30 @parallax_name = "" @parallax_loop_x = false @parallax_loop_y = false @parallax_sx = 0 @parallax_sy = 0 @parallax_show = false @data = Table.new(width, height, 3) @events = {} end attr_accessor :width attr_accessor :height attr_accessor :scroll_type attr_accessor :autoplay_bgm attr_accessor :bgm attr_accessor :autoplay_bgs attr_accessor :bgs attr_accessor :disable_dashing attr_accessor :encounter_list attr_accessor :encounter_step attr_accessor :parallax_name attr_accessor :parallax_loop_x attr_accessor :parallax_loop_y attr_accessor :parallax_sx attr_accessor :parallax_sy attr_accessor :parallax_show attr_accessor :data attr_accessor :events end end

RPG::MapInfo Data class for map information.

Superclass

Object

Attributes

name

The map name.

parent_id

The parent map ID.



order

The map tree display order, used internally.

expanded

The map tree expansion flag, used internally.

scroll_x

The X-axis scroll position, used internally.

scroll_y

The Y-axis scroll position, used internally.

Definition

module RPG class MapInfo def initialize @name = "" @parent_id = 0 @order = 0 @expanded = false @scroll_x = 0 @scroll_y = 0 end attr_accessor :name attr_accessor :parent_id attr_accessor :order attr_accessor :expanded attr_accessor :scroll_x attr_accessor :scroll_y end end

RPG::Area Data class for areas.

Superclass

Object

Attributes

id

The area ID.

name

The area name.

map_id



The parent map ID.

rect

The area position (Rect) .

encounter_list

Encounter list. A troop ID array.

order

The map tree display order, used internally.

Definition

module RPG class Area def initialize @id = 0 @name = "" @map_id = 0 @rect = Rect.new(0,0,0,0) @encounter_list = [] @order = 0 end attr_accessor :id attr_accessor :name attr_accessor :map_id attr_accessor :rect attr_accessor :encounter_list attr_accessor :order end end

RPG::Event Data class for map events.

Superclass

Object

Referrer

RPG::Map

Attributes

id

The event ID.

name



The event name.

x

The event's X-coordinate on the map.

y

The event's Y-coordinate on the map.

pages

The Events pages. An RPG::Event::Page array.

Inner Class

RPG::Event::Page

Definition

module RPG class Event def initialize(x, y) @id = 0 @name = "" @x = x @y = y @pages = [RPG::Event::Page.new] end attr_accessor :id attr_accessor :name attr_accessor :x attr_accessor :y attr_accessor :pages end end

RPG::Event::Page Data class for the event page.

Superclass

Object

Referrer

RPG::Event

Attributes

condition

The event condition (RPG::Event::Page::Condition).



graphic

The event graphic (RPG::Event::Page::Graphic).

move_type

Type of movement (0: fixed, 1: random, 2: approach, 3: custom).

move_speed

Movement speed (1: x8 slower, 2: x4 slower, 3: x2 slower, 4: normal, 5: x2 faster, 6: x4 faster).

move_frequency

Movement frequency (1: lowest, 2: lower, 3: normal, 4: higher, 5: highest).

move_route

Movement route (RPG::MoveRoute). Referenced only when the movement type is set to Custom.

walk_anime

Truth value of the [Walking Anim.] option.

step_anime

Truth value of the [Stepping Anim.] option.

direction_fix

Truth value of the [Direction Fix] option.

through

Truth value of the [Through] option.

priority_type

Priority type (0: below characters, 1: same as characters, 2: above characters).

trigger

Event trigger (0: action button, 1: player touch, 2: event touch, 3: autorun, 4: parallel process).

list

List of event commands. An RPG::EventCommand array.

Inner Classes

RPG::Event::Page::Condition RPG::Event::Page::Graphic



Definition

module RPG class Event class Page def initialize @condition = RPG::Event::Page::Condition.new @graphic = RPG::Event::Page::Graphic.new @move_type = 0 @move_speed = 3 @move_frequency = 3 @move_route = RPG::MoveRoute.new @walk_anime = true @step_anime = false @direction_fix = false @through = false @priority_type = 0 @trigger = 0 @list = [RPG::EventCommand.new] end attr_accessor :condition attr_accessor :graphic attr_accessor :move_type attr_accessor :move_speed attr_accessor :move_frequency attr_accessor :move_route attr_accessor :walk_anime attr_accessor :step_anime attr_accessor :direction_fix attr_accessor :through attr_accessor :priority_type attr_accessor :trigger attr_accessor :list end end end

RPG::Event::Page::Condition Data class for the event page conditions.

Superclass

Object

Referrer

RPG::Event::Page

Attributes

switch1_valid

Truth value for whether the first [Switch] condition is valid.

switch2_valid

Truth value for whether the second [Switch] condition is valid.

variable_valid



Truth value for whether the [Variable] condition is valid.

self_switch_valid

Truth value for whether the [Self Switch] condition is valid.

item_valid

Truth value for whether the [Item] condition is valid.

actor_valid

Truth value for whether the [Actor] condition is valid.

switch1_id

If the first [Switch] condition is valid, the ID of that switch.

switch2_id

If the second [Switch] condition is valid, the ID of that switch.

variable_id

If the [Variable] condition is valid, the ID of that variable.

variable_value

If the [Variable] condition is valid, the standard value of that variable (x and greater).

self_switch_ch

If the [Self Switch] condition is valid, the letter of that self switch ("A".."D").

item_id

If the [Item] condition is valid, the ID of that item.

actor_id

If the [Actor] condition is valid, the ID of that actor.

Definition

module RPG class Event class Page class Condition def initialize @switch1_valid = false @switch2_valid = false @variable_valid = false @self_switch_valid = false @item_valid = false @actor_valid = false @switch1_id = 1 @switch2_id = 1



@variable_id = 1 @variable_value = 0 @self_switch_ch = "A" @item_id = 1 @actor_id = 1 end attr_accessor :switch1_valid attr_accessor :switch2_valid attr_accessor :variable_valid attr_accessor :self_switch_valid attr_accessor :item_valid attr_accessor :actor_valid attr_accessor :switch1_id attr_accessor :switch2_id attr_accessor :variable_id attr_accessor :variable_value attr_accessor :self_switch_ch attr_accessor :item_id attr_accessor :actor_id end end end end

RPG::Event::Page::Graphic Data class for the Event page [Graphics].

Superclass

Object

Referrer

RPG::Event::Page

Attributes

tile_id

The tile ID. If the specified graphic is not a tile, this value is 0.

character_name

The character's graphic file name.

character_index

The character's index of the graphic file (0..7).

direction

The direction in which the character is facing (2: down, 4: left, 6: right, 8: up).

pattern

The character's pattern (0..2).



Definition

module RPG class Event class Page class Graphic def initialize @tile_id = 0 @character_name = "" @character_index = 0 @direction = 2 @pattern = 0 end attr_accessor :tile_id attr_accessor :character_name attr_accessor :character_index attr_accessor :direction attr_accessor :pattern end end end end

RPG::EventCommand Data class for the Event command.

Superclass

Object

Referrers

RPG::Event::Page RPG::Troop::Page RPG::CommonEvent

Attributes

code

The event code.

indent

The indent depth. Usually 0; the [Conditional Branch] command, among others, adds 1 with every step deeper.

parameters

Array containing the Move command arguments. The contents vary for each command.

Definition

module RPG



class EventCommand def initialize(code = 0, indent = 0, parameters = []) @code = code @indent = indent @parameters = parameters end attr_accessor :code attr_accessor :indent attr_accessor :parameters end end

RPG::MoveRoute Data class for the Move route.

Superclass

Object

Referrer

RPG::EventPage

Attributes

repeat

Truth value of the [Repeat Action] option.

skippable

Truth value of the [Skip If Cannot Move] option.

wait

Truth value of the [Wait for Completion] option.

list

Program contents. An RPG::MoveCommand array.

Definition

module RPG class MoveRoute def initialize @repeat = true @skippable = false @wait = false @list = [RPG::MoveCommand.new] end attr_accessor :repeat attr_accessor :skippable attr_accessor :wait attr_accessor :list end



end

RPG::MoveCommand Data class for the Move command.

Superclass

Object

Referrer

RPG::MoveRoute

Attributes

code

Move command code.

parameters

Array containing the Move command arguments. The contents vary for each command.

Definition

module RPG class MoveCommand(code = 0, parameters = []) def initialize @code = code @parameters = parameters end attr_accessor :code attr_accessor :parameters end end

RPG::Actor Data class for actors.

Superclass

Object

Attributes

id

The actor ID.



name

The actor name.

class_id

The actor class ID.

initial_level

The actor's initial level.

exp_basis

The value on which the experience curve is based (10..40).

exp_inflation

The amount of experience curve inflation (20..50).

character_name

The actor's character graphic file name.

character_index

The actor's character index of the graphic file (0..7).

face_name

The actor's face graphic file name.

face_index

The actor's face index of the graphic file (0..7).

parameters

2-dimensional array containing base parameters for each level (Table).

Generally takes the form parameters[kind, level].

kind indicates the parameter type (0: MaxHP, 1: MaxMP, 2: Attack, 3: Defense, 4: Spirit, 5: Agility).

weapon_id

ID of the actor's initially equipped weapon.

armor1_id

ID of the actor's initially equipped shield.

armor2_id



ID of the actor's initially equipped helmet.

armor3_id

ID of the actor's initially equipped body armor.

armor4_id

ID of the actor's initially equipped accessory.

two_swords_style

Truth value of the [Two Swords Style] option.

fix_equipment

Truth value of the [Fix Equipment] option.

auto_battle

Truth value of the [Auto Battle] option.

super_guard

Truth value of the [Super Guard] option.

pharmacology

Truth value of the [Pharmacology] option.

critical_bonus

Truth value of the [Critical Bonus] option.

Definition

module RPG class Actor def initialize @id = 0 @name = "" @class_id = 1 @initial_level = 1 @exp_basis = 25 @exp_inflation = 35 @character_name = "" @character_index = 0 @face_name = "" @face_index = 0 @parameters = Table.new(6,100) for i in 1..99 @parameters[0,i] = 400+i*50 @parameters[1,i] = 80+i*10 @parameters[2,i] = 15+i*5/4 @parameters[3,i] = 15+i*5/4 @parameters[4,i] = 20+i*5/2 @parameters[5,i] = 20+i*5/2 end @weapon_id = 0 @armor1_id = 0



@armor2_id = 0 @armor3_id = 0 @armor4_id = 0 @two_swords_style = false @fix_equipment = false @auto_battle = false @super_guard = false @pharmacology = false @critical_bonus = false end attr_accessor :id attr_accessor :name attr_accessor :class_id attr_accessor :initial_level attr_accessor :exp_basis attr_accessor :exp_inflation attr_accessor :character_name attr_accessor :character_index attr_accessor :face_name attr_accessor :face_index attr_accessor :parameters attr_accessor :weapon_id attr_accessor :armor1_id attr_accessor :armor2_id attr_accessor :armor3_id attr_accessor :armor4_id attr_accessor :two_swords_style attr_accessor :fix_equipment attr_accessor :auto_battle attr_accessor :super_guard attr_accessor :pharmacology attr_accessor :critical_bonus end end

RPG::Class Data class for class.

Superclass

Object

Attributes

id

The class's ID.

name

The class name.

position

The class position (0: front, 1: middle, 2: rear).

weapon_set

Array containing IDs for equippable weapons.



armor_set

Array containing IDs for equippable armor.

element_ranks

Level of elements efficiency. 1-dimensional array using element IDs as subscripts (Table), with 6 levels (0: A, 1: B, 2: C, 3: D, 4: E, 5: F).

state_ranks

Level of states efficiency. 1-dimensional array using status IDs as subscripts (Table), with 6 levels (0: A, 1: B, 2: C, 3: D, 4: E, 5: F).

learnings

Skills to learn. An RPG::Class::Learning array.

skill_name_valid

Truth value for whether the skill name is valid.

skill_name

Name of the skill command.

Inner Class

RPG::Class::Learning

Definition

module RPG class Class def initialize @id = 0 @name = "" @position = 0 @weapon_set = [] @armor_set = [] @element_ranks = Table.new(1) @state_ranks = Table.new(1) @learnings = [] @skill_name_valid = false @skill_name = "" end attr_accessor :id attr_accessor :name attr_accessor :position attr_accessor :weapon_set attr_accessor :armor_set attr_accessor :element_ranks attr_accessor :state_ranks attr_accessor :learnings attr_accessor :skill_name_valid attr_accessor :skill_name end end



RPG::Class::Learning Data class for a [Class's Learned] skills.

Superclass

Object

Referrer

RPG::Class

Attributes

level

Skill level.

skill_id

The learned skill's ID.

Definition

module RPG class Class class Learning def initialize @level = 1 @skill_id = 1 end attr_accessor :level attr_accessor :skill_id end end end

RPG::BaseItem Superclass of Skill, Item, Weapon, and Armor.

Superclass

Object

Attributes

id

The item ID.



name

The item name.

icon_index

The icon number.

description

The description text.

note

The text of the note.

Definition

module RPG class Item def initialize @id = 0 @name = "" @icon_index = 0 @description = "" @note = "" end attr_accessor :id attr_accessor :name attr_accessor :icon_index attr_accessor :description attr_accessor :note end end

RPG::UsableItem Superclass of Skill and Item.

Superclass

RPG::BaseItem

Attributes

scope

Scope of the effects.

0: None 1: One Enemy 2: All Enemies 3: One Enemy Dual 4: One Random Enemy



5: 2 Random Enemies 6: 3 Random Enemies 7: One Ally 8: All Allies 9: One Ally (Dead) 10: All Allies (Dead) 11: The User

occasion

When the item/skill may be used.

0: Always 1: Only in Battle 2: Only from the Menu 3: Never

speed

The speed correction.

animation_id

The animation ID.

common_event_id

The Common Event ID.

base_damage

The base damage.

variance

The degree of variance.

atk_f

The factor of attack power.

spi_f

The factor of spirit.

physical_attack

Truth value of the [Physical Attack] option.

damage_to_mp

Truth value of the [Damage to MP] option.

absorb_damage



Truth value of the [Absorb Damage] option.

ignore_defense

Truth value of the [Ignore Defense] option.

element_set

Elements of the item. An Element ID array.

plus_state_set

States to add. A State ID array.

minus_state_set

States to cancel. A Stae ID array.

Methods

for_opponent?

Determines whether or not the area of effect is enemies. Returns true if the value of scope is 1, 2, 3, 4, 5, or 6.

for_friend?

Determines whether or not the area of effect is allies. Returns true if the value of scope is 7, 8, 9, 10, or 11.

for_dead_friend?

Determines whether or not the area of effect is downed allies. Returns true if the value of scope is 9 or 10.

for_user?

Determines whether or not the area of effect is the user. Returns true if the value of scope is 11.

for_one?

Determines whether or not the area of effect is one character. Returns true if the value of scope is 1, 3, 4, 7, 9, or 11.

for_two?

Determines whether or not the area of effect is two characters. Returns true if the value of scope is 5.

for_three?

Determines whether or not the area of effect is three characters. Returns true if the value of scope is 6.

for_random?



Determines whether or not the area of effect is random. Returns true if the value of scope is 4, 5, or 6.

for_all?

Determines whether or not the area of effect is everyone. Returns true if the value of scope is 2, 8, or 10.

dual?

Determines whether or not the area of effect is "One Enemy Dual." Returns true if the value of scope is 3.

need_selection?

Determines whether or not selection of the target is required. Returns true if the value of scope is 1, 3, 7, or 9.

battle_ok?

Determines if it may be used on the battle screen. Returns true if the value of occasion is 0 or 1.

menu_ok?

Determines if it may be used on the menu screen. Returns true if the value of occasion is 0 or 2.

Definition

module RPG class UsableItem < BaseItem def initialize super @scope = 0 @occasion = 0 @speed = 0 @animation_id = 0 @common_event_id = 0 @base_damage = 0 @variance = 20 @atk_f = 0 @spi_f = 0 @physical_attack = false @damage_to_mp = false @absorb_damage = false @ignore_defense = false @element_set = [] @plus_state_set = [] @minus_state_set = [] end def for_opponent? return [1, 2, 3, 4, 5, 6].include?(@scope) end def for_friend? return [7, 8, 9, 10, 11].include?(@scope) end def for_dead_friend? return [9, 10].include?(@scope) end def for_user? return [11].include?(@scope) end def for_one? return [1, 3, 4, 7, 9, 11].include?(@scope) end def for_two? return [5].include?(@scope) end



def for_three? return [6].include?(@scope) end def for_random? return [4, 5, 6].include?(@scope) end def for_all? return [2, 8, 10].include?(@scope) end def dual? return [3].include?(@scope) end def need_selection? return [1, 3, 7, 9].include?(@scope) end def battle_ok? return [0, 1].include?(@occasion) end def menu_ok? return [0, 2].include?(@occasion) end attr_accessor :scope attr_accessor :occasion attr_accessor :speed attr_accessor :animation_id attr_accessor :common_event_id attr_accessor :base_damage attr_accessor :variance attr_accessor :atk_f attr_accessor :spi_f attr_accessor :physical_attack attr_accessor :damage_to_mp attr_accessor :absorb_damage attr_accessor :ignore_defense attr_accessor :element_set attr_accessor :plus_state_set attr_accessor :minus_state_set end end

RPG::Skill Data class for skills.

Superclass

RPG::UsableItem

Attributes

mp_cost

Number of MP consumed.

hit

The skill's hit ratio.

message1 message2

The use message.



Definition

module RPG class Skill < UsableItem def initialize super @scope = 1 @mp_cost = 0 @hit = 100 @message1 = "" @message2 = "" end attr_accessor :mp_cost attr_accessor :hit attr_accessor :message1 attr_accessor :message2 end end

RPG::Item Data class for items.

Superclass

RPG::UsableItem

Attributes

price

The item price.

consumable

Truth value of whether the item disappears when used.

hp_recovery_rate

HP recovery rate.

hp_recovery

HP recovery amount.

mp_recovery_rate

MP recovery rate.

mp_recovery

MP recovery amount.

parameter_type



Parameter affected (0: None, 1: MaxHP, 2: MaxMP, 3: Attack, 4: Defense, 5: Spirit, 6: Agility).

parameter_points

Amount by which parameter increases.

Definition

module RPG class Item < UsableItem def initialize super @scope = 7 @price = 0 @consumable = true @hp_recovery_rate = 0 @hp_recovery = 0 @mp_recovery_rate = 0 @mp_recovery = 0 @parameter_type = 0 @parameter_points = 0 end attr_accessor :price attr_accessor :consumable attr_accessor :hp_recovery_rate attr_accessor :hp_recovery attr_accessor :mp_recovery_rate attr_accessor :mp_recovery attr_accessor :parameter_type attr_accessor :parameter_points end end

RPG::Weapon Data class for weapons.

Superclass

RPG::BaseItem

Attributes

animation_id

The animation ID when using the weapon.

price

The weapon's price.

hit

The weapon's hit ratio.

atk



The weapon's attack power.

def

The weapon's defense power.

spi

The weapon's spirit power.

agi

The weapon's agility power.

two_handed

Truth value of the [Two Handed] option.

fast_attack

Truth value of the [Fast Attack] option.

dual_attack

Truth value of the [Dual Attack] option.

critical_bonus

Truth value of the [Critical Bonus] option.

element_set

Elements of the weapon. An element ID array.

state_set

States to add. A state ID array.

Definition

module RPG class Weapon < BaseItem def initialize super @animation_id = 0 @price = 0 @hit = 95 @atk = 0 @def = 0 @spi = 0 @agi = 0 @two_handed = false @fast_attack = false @dual_attack = false @critical_bonus = false @element_set = [] @state_set = [] end



attr_accessor :animation_id attr_accessor :price attr_accessor :hit attr_accessor :atk attr_accessor :def attr_accessor :spi attr_accessor :agi attr_accessor :two_handed attr_accessor :fast_attack attr_accessor :dual_attack attr_accessor :critical_bonus attr_accessor :element_set attr_accessor :state_set end end

RPG::Armor Data class for armor.

Superclass

RPG::BaseItem

Attributes

kind

Type of armor (0: shield, 1: helmet, 2: body armor, 3: accessory).

price

The armor's price.

eva

The armor's evasion rate.

atk

The armor's attack power.

def

The armor's defense power.

spi

The armor's spirit power.

agi

The armor's agility power.

prevent_critical



Truth value of the [Prevent Critical] option.

half_mp_cost

Truth value of the [Half MP Cost] option.

double_exp_gain

Truth value of the [Double EXP Gain] option.

auto_hp_recover

Truth value of the [Auto HP Recover] option.

element_set

Elements to guard. An element ID array.

state_set

States to resist. A state ID array.

Definition

module RPG class Armor < BaseItem def initialize super @kind = 0 @price = 0 @eva = 0 @atk = 0 @def = 0 @spi = 0 @agi = 0 @prevent_critical = false @half_mp_cost = false @double_exp_gain = false @auto_hp_recover = false @element_set = [] @state_set = [] end attr_accessor :kind attr_accessor :price attr_accessor :eva attr_accessor :atk attr_accessor :def attr_accessor :spi attr_accessor :agi attr_accessor :prevent_critical attr_accessor :half_mp_cost attr_accessor :double_exp_gain attr_accessor :auto_hp_recover attr_accessor :element_set attr_accessor :state_set end end

RPG::Enemy Data class for enemies.



Superclass

Object

Attributes

id

The enemy ID.

name

The enemy name.

battler_name

The enemy's battler graphic file name.

battler_hue

The adjustment value for the battler graphic's hue (0..360).

maxhp

The enemy's MaxHP.

maxmp

The enemy's MaxMP.

atk

The enemy's attack power.

def

The enemy's defense power.

spi

The enemy's spirit.

agi

The enemy's agility.

hit

The enemy's hit ratio.

eva



The enemy's evasion rate.

exp

The enemy's experience.

gold

The enemy's gold.

drop_item1

The drop item 1 (RPG::Enemy::DropItem) 。

drop_item2

The drop item 2 (RPG::Enemy::DropItem) 。

levitate

Truth value of the [Levitate] option.

has_critical

Truth value of the [Has Critical] option.

element_ranks

Level of elements efficiency. 1-dimensional array using element IDs as subscripts (Table), with 6 levels (0: A, 1: B, 2: C, 3: D, 4: E, 5: F).

state_ranks

Level of states efficiency. 1-dimensional array using status IDs as subscripts (Table), with 6 levels (0: A, 1: B, 2: C, 3: D, 4: E, 5: F).

actions

Actions petterns. An RPG::Enemy::Action array.

note


Inner Class

RPG::Enemy::DropItem RPG::Enemy::Action

Definition

module RPG



class Enemy def initialize @id = 0 @name = "" @battler_name = "" @battler_hue = 0 @maxhp = 10 @maxmp = 10 @atk = 10 @def = 10 @spi = 10 @agi = 10 @hit = 95 @eva = 5 @exp = 0 @gold = 0 @drop_item1 = RPG::Enemy::DropItem.new @drop_item2 = RPG::Enemy::DropItem.new @levitate = false @has_critical = false @element_ranks = Table.new(1) @state_ranks = Table.new(1) @actions = [RPG::Enemy::Action.new] @note = "" end attr_accessor :id attr_accessor :name attr_accessor :battler_name attr_accessor :battler_hue attr_accessor :maxhp attr_accessor :maxmp attr_accessor :atk attr_accessor :def attr_accessor :spi attr_accessor :agi attr_accessor :hit attr_accessor :eva attr_accessor :exp attr_accessor :gold attr_accessor :drop_item1 attr_accessor :drop_item2 attr_accessor :levitate attr_accessor :has_critical attr_accessor :element_ranks attr_accessor :state_ranks attr_accessor :actions attr_accessor :note end end

RPG::Enemy::DropItem Data class for enemy [Drop Item].

Superclass

Object

Referrer

RPG::Enemy

Attributes

kind



Type of the drop item (0: none, 1: item, 2: weapon, 3: armor).

item_id

The item ID, when kind == 1.

weapon_id

The weapon ID, when kind == 2.

armor_id

The armor ID, when kind == 3.

denominator

N of the probability 1/N.

Definition

module RPG class Enemy class DropItem def initialize @kind = 0 @item_id = 1 @weapon_id = 1 @armor_id = 1 @denominator = 1 end attr_accessor :kind attr_accessor :item_id attr_accessor :weapon_id attr_accessor :armor_id attr_accessor :denominator end end end

RPG::Enemy::Action Data class for enemy [Actions].

Superclass

Object

Referrer

RPG::Enemy

Attributes

kind



Type of action.

0: Basic 1: Skill

basic

When set to a [Basic] action, defines it further.

0: Attack 1: Guard 2: Escape 3: Do Nothing

skill_id

When set to a [Skill], the ID of that skill.

condition_type

The type of condition.

0: Always 1: Turn No. 2: HP 3: MP 4: State 5: Party Level 6: Switch

condition_param1 condition_param2

A condition parameter. Shared by all types.

For example, if the condition is [HP], then condition_param1 will be the minimum value and condition_param2 will be the maximum value.

rating

The action's rating (1..10).

Methods

skill?

Determines if kind is skill or not. Returns true if kind is 1.

Definition

module RPG class Enemy class Action def initialize @kind = 0



@basic = 0 @skill_id = 1 @condition_type = 0 @condition_param1 = 0 @condition_param2 = 0 @rating = 5 end def skill? return @kind == 1 end attr_accessor :kind attr_accessor :basic attr_accessor :skill_id attr_accessor :condition_type attr_accessor :condition_param1 attr_accessor :condition_param2 attr_accessor :rating end end end

RPG::Troop Data class for troops.

Superclass

Object

Attributes

id

Troop ID.

name

Troop name.

members

Troop members. An RPG::Troop::Member array.

pages

Battle events. An RPG::Troop::Page array.

Inner Classes

RPG::Troop::Member RPG::Troop::Page

Definition

module RPG class Troop



def initialize @id = 0 @name = "" @members = [] @pages = [RPG::BattleEventPage.new] end attr_accessor :id attr_accessor :name attr_accessor :members attr_accessor :pages end end

RPG::Troop::Member Data class for troop members.

Superclass

Object

Referrer

RPG::Troop

Attributes

enemy_id

The enemy ID.

x

The troop member's X-coordinate.

y

The troop member's Y-coordinate.

hidden

Truth value of the [Appear Midway] option.

immortal

Truth value of the [Immortal] option.

Definition

module RPG class Troop class Member def initialize @enemy_id = 1 @x = 0



@y = 0 @hidden = false @immortal = false end attr_accessor :enemy_id attr_accessor :x attr_accessor :y attr_accessor :hidden attr_accessor :immortal end end end

RPG::Troop::Page Data class for battle events (pages).

Superclass

Object

Referrer

RPG::Troop

Attributes

condition

Condition (RPG::Troop::Page::Condition).

span

Span (0: battle, 1: turn, 2: moment).

list

Program contents. An RPG::EventCommand array.

Inner Class

RPG::Troop::Page::Condition

Definition

module RPG class Troop class Page def initialize @condition = RPG::Troop::Page::Condition.new @span = 0 @list = [RPG::EventCommand.new] end attr_accessor :condition attr_accessor :span attr_accessor :list



end end end

RPG::Troop::Page::Condition A database of battle event [Conditions].

Superclass

Object

Referrer

RPG::Troop::Page

Attributes

turn_ending

Truth value for whether the [When the end of the turn] condition is valid.

turn_valid

Truth value for whether the [Turn No.] condition is valid.

enemy_valid

Truth value for whether the [Enemy] condition is valid.

actor_valid

Truth value for whether the [Actor] condition is valid.

switch_valid

Truth value for whether the [Switch] condition is valid.

turn_a turn_b

a and b values specified in the [Turn No.] condition. To be input in the form A + B * X.

enemy_index

Troop member index specified in the [Enemy] condition (0..7).

enemy_hp

HP percentage specified in the [Enemy] condition.



actor_id

Actor ID specified in the [Actor] condition.

actor_hp

HP percentage specified in the [Actor] condition.

switch_id

Switch ID specified in the [Switch] condition.

Definition

module RPG class Troop class Page class Condition def initialize @turn_ending = false @turn_valid = false @enemy_valid = false @actor_valid = false @switch_valid = false @turn_a = 0 @turn_b = 0 @enemy_index = 0 @enemy_hp = 50 @actor_id = 1 @actor_hp = 50 @switch_id = 1 end attr_accessor :turn_ending attr_accessor :turn_valid attr_accessor :enemy_valid attr_accessor :actor_valid attr_accessor :switch_valid attr_accessor :turn_a attr_accessor :turn_b attr_accessor :enemy_index attr_accessor :enemy_hp attr_accessor :actor_id attr_accessor :actor_hp attr_accessor :switch_id end end end end

RPG::State Data class for state.

Superclass

Object

Attributes

id



State ID.

name

State name.

icon_index

The state's icon number.

restriction

Sets restrictions (0: none, 1: can't use magic, 2: always attack enemies, 3: always attack allies, 4: can't move, 5: can't move or evade).

priority

State priority (0..10).

atk_rate

Attack percentage.

def_rate

Defense percentage.

spi_rate

Spirit percentage.

agi_rate

Agility percentage.

nonresistance

Truth value of the [Nonresistance] option.

offset_by_opposite

Truth value of the [Offset By Opp.] option.

slip_damage

Truth value of the [Slip Damage] option.

reduce_hit_ratio

Truth value of the [Reduce Hit Ratio] option.

battle_only



Truth value of whether the state wears off at battle end.

release_by_damage

Truth value of whether the state wears after receiving damage.

hold_turn auto_release_prob

Probability of wearing off is auto_release_prob % after hold_turn turns have passed.

message1 message2 message3 message4

Messages. For an actor, for an enemy, remaining, releasing.

element_set

Elements to guard. An Element ID array.

state_set

States to cancel. A State ID array.

note


Definition

module RPG class State def initialize @id = 0 @name = "" @icon_index = 0 @restriction = 0 @priority = 5 @atk_rate = 100 @def_rate = 100 @spi_rate = 100 @agi_rate = 100 @nonresistance = false @offset_by_opposite = false @slip_damage = false @reduce_hit_ratio = false @battle_only = true @release_by_damage = false @hold_turn = 0 @auto_release_prob = 0 @message1 = "" @message2 = "" @message3 = "" @message4 = "" @element_set = [] @state_set = [] @note = "" end attr_accessor :id



attr_accessor :name attr_accessor :icon_index attr_accessor :restriction attr_accessor :priority attr_accessor :atk_rate attr_accessor :def_rate attr_accessor :spi_rate attr_accessor :agi_rate attr_accessor :nonresistance attr_accessor :offset_by_opposite attr_accessor :slip_damage attr_accessor :reduce_hit_ratio attr_accessor :battle_only attr_accessor :release_by_damage attr_accessor :hold_turn attr_accessor :auto_release_prob attr_accessor :message1 attr_accessor :message2 attr_accessor :message3 attr_accessor :message4 attr_accessor :element_set attr_accessor :state_set attr_accessor :note end end

RPG::Animation Data class for animation.

Superclass

Object

Attributes

id

The animation ID.

name

The animation name.

animation1_name

The first animation's graphic file name.

animation1_hue

The adjustment value for the first animation graphic's hue (0..360).

animation2_name

The second animation's graphic file name.

animation2_hue



The adjustment value for the second animation graphic's hue (0..360).

position

The base position (0: head, 1: center, 2: feet, 3: screen).

frame_max

Number of frames.

frames

Frame contents. An RPG::Animation::Frame array.

timings

Timing for SE and flash effects. An RPG::Animation::Timing array.

Inner Classes

RPG::Animation::Frame RPG::Animation::Timing

Definition

module RPG class Animation def initialize @id = 0 @name = "" @animation1_name = "" @animation1_hue = 0 @animation2_name = "" @animation2_hue = 0 @position = 1 @frame_max = 1 @frames = [RPG::Animation::Frame.new] @timings = [] end attr_accessor :id attr_accessor :name attr_accessor :animation1_name attr_accessor :animation1_hue attr_accessor :animation2_name attr_accessor :animation2_hue attr_accessor :position attr_accessor :frame_max attr_accessor :frames attr_accessor :timings end end

RPG::Animation::Frame Data class for animation frames.

Superclass



Object

Referrer

RPG::Animation

Attributes

cell_max

Number of cells. Equivalent to the largest cell number in the frame set.

cell_data

2-dimensional array containing cell contents (Table).

Generally takes the form cell_data[cell_index, data_index].

data_index ranges from 0 to 7 and denotes various information about a cell (0: pattern, 1: X-coordinate, 2: Y-coordinate, 3: zoom level, 4: angle of rotation, 5: horizontal flip, 6: opacity, 7: blending mode). Patterns are 1 less than the number displayed in RPGVX; -1 indicates that that cell is not in use.

Definition

module RPG class Animation class Frame def initialize @cell_max = 0 @cell_data = Table.new(0, 0) end attr_accessor :cell_max attr_accessor :cell_data end end end

RPG::Animation::Timing Data class for the timing of an animation's SE and flash effects.

Superclass

Object

Referrer

RPG::Animation

Attributes

frame



Frame number. 1 less than the number displayed in RPGVX.

se

SE, or sound effect (RPG::AudioFile).

flash_scope

Flash area (0: none, 1: target, 2: screen; 3: hide target).

flash_color

Flash color (Color).

flash_duration

Flash duration.

Definition

module RPG class Animation class Timing def initialize @frame = 0 @se = RPG::AudioFile.new("", 80) @flash_scope = 0 @flash_color = Color.new(255,255,255,255) @flash_duration = 5 end attr_accessor :frame attr_accessor :se attr_accessor :flash_scope attr_accessor :flash_color attr_accessor :flash_duration end end end

RPG::CommonEvent Data class for common events.

Superclass

Object

Attributes

id

The event ID.

name

The event name.



trigger

The event trigger (0: none, 1: autorun; 2: parallel).

switch_id

The condition switch ID.

list

List of event commands. An RPG::EventCommand array.

Definition

module RPG class CommonEvent def initialize @id = 0 @name = "" @trigger = 0 @switch_id = 1 @list = [RPG::EventCommand.new] end attr_accessor :id attr_accessor :name attr_accessor :trigger attr_accessor :switch_id attr_accessor :list end end

RPG::System Data class for the system.

Superclass

Object

Attributes

game_title

The game title.

version_id

Random number used for update checks. Updates changed values every time data is saved in RPGVX.

party_members

The initial party. An array of actor IDs.

elements



Element list. Text array using element IDs as subscripts, with the element in the 0 position being nil.

switches

Switch list. Text array using switch IDs as subscripts, with the element in the 0 position being nil.

variables

Variable list. Text array using variable IDs as subscripts, with the element in the 0 position being nil.

passages

Passage table. A 1-dimensional array (Table) containing various flags.

The tile ID is used as a subscript. Each bit is handled as follows:

0x01: Characters cannot move. 0x02: The boat cannot move. 0x04: The ship cannot move. 0x08: The airship cannot land. 0x10: Display above characters. 0x40: Bush. 0x80: Counter.

boat

The boat settings (RPG::System::Vehicle).

ship

The ship settings (RPG::System::Vehicle).

airship

The airship settings (RPG::System::Vehicle).

title_bgm

The title BGM (RPG::AudioFile).

battle_bgm

The battle BGM (RPG::AudioFile).

battle_end_me

The battle end ME (RPG::AudioFile).

gameover_me

The gameover ME (RPG::AudioFile).

sounds



Sound Effects. An RPG::AudioFile array.

start_map_id

The map ID of the player's initial position.

start_x

The map X-coordinate of the player's initial position.

start_y

The map Y-coordinate of the player's initial position.

terms

Terms (RPG::System::Terms).

test_battlers

Party settings for battle tests. An RPG::System::TestBattler array.

test_troop_id

The troop ID for battle tests.

battler_name

The battler graphic file name, for internal use.

battler_hue

The adjustment value for the battler graphic's hue (0..360), for internal use.

edit_map_id

The ID of the map currently being edited, for internal use.

Inner Classes

RPG::System::Vechile RPG::System::Terms RPG::System::TestBattler

Definition

module RPG class System def initialize @game_title = "" @version_id = 0 @party_members = [1] @elements = [nil, ""] @switches = [nil, ""] @variables = [nil, ""]



@passages = Table.new(8192) @boat = RPG::System::Vehicle.new @ship = RPG::System::Vehicle.new @airship = RPG::System::Vehicle.new @title_bgm = RPG::BGM.new @battle_bgm = RPG::BGM.new @battle_end_me = RPG::ME.new @gameover_me = RPG::ME.new @sounds = [] 20.times { @sounds.push(RPG::AudioFile.new) } @test_battlers = [] @test_troop_id = 1 @start_map_id = 1 @start_x = 0 @start_y = 0 @terms = RPG::System::Terms.new @battler_name = "" @battler_hue = 0 @edit_map_id = 1 end attr_accessor :game_title attr_accessor :version_id attr_accessor :party_members attr_accessor :elements attr_accessor :switches attr_accessor :variables attr_accessor :passages attr_accessor :boat attr_accessor :ship attr_accessor :airship attr_accessor :title_bgm attr_accessor :battle_bgm attr_accessor :battle_end_me attr_accessor :gameover_me attr_accessor :sounds attr_accessor :test_battlers attr_accessor :test_troop_id attr_accessor :start_map_id attr_accessor :start_x attr_accessor :start_y attr_accessor :terms attr_accessor :battler_name attr_accessor :battler_hue attr_accessor :edit_map_id end end

RPG::System::Vehicle Data class for vehicles.

Superclass

Object

Referrer

RPG::System

Attributes

character_name

The vehicle's character graphic file name.



character_index

The vehicle's character index of the graphic file (0..7).

bgm

The vehicle BGM (RPG::AudioFile).

start_map_id

The map ID of the vehicle's initial position.

start_x

The map X-coordinate of the vehicle's initial position.

start_y

The map Y-coordinate of the vehicle's initial position.

Definition

module RPG class System class Vehicle def initialize @character_name = "" @character_index = 0 @bgm = RPG::AudioFile.new @start_map_id = 0 @start_x = 0 @start_y = 0 end attr_accessor :character_name attr_accessor :character_index attr_accessor :bgm attr_accessor :start_map_id attr_accessor :start_x attr_accessor :start_y end end end

RPG::System::Terms Data class for terminology.

Superclass

Object

Referrer

RPG::System



Attributes

level

The term "Level".

level_a

The term "Level" (abbreviation).

hp

The term "HP".

hp_a

The term "HP" (abbreviation).

mp

The term "MP".

mp_a

The term "MP" (abbreviation).

atk

The term "Attack".

def

The term "Defense".

spi

The term "Spirit".

agi

The term "Agility".

weapon

The term "Weapon".

armor1

The term "Shield".

armor2

The term "Helmet".



armor3

The term "Body Armor".

armor4

The term "Accessory".

weapon1

The term "Weapon1"。

weapon2

The term "Weapon2"。

attack

The term "Attack".

skill

The term "Skill".

guard

The term "Guard".

item

The term "Item".

equip

The term "Equip".

status

The term "Status".

save

The term "Save".

game_end

The term "Game End".

fight

The term "Fight".

escape



The term "Escape".

new_game

The term "New Game".

continue

The term "Continue".

shutdown

The term "Shutdown".

to_title

The term "To Title".

cancel

The term "Cancel".

gold

The term "G" (the unit of currency).

Definition

module RPG class System class Terms def initialize @level = "" @level_a = "" @hp = "" @hp_a = "" @mp = "" @mp_a = "" @atk = "" @def = "" @spi = "" @agi = "" @weapon = "" @armor1 = "" @armor2 = "" @armor3 = "" @armor4 = "" @weapon1 = "" @weapon2 = "" @attack = "" @skill = "" @guard = "" @item = "" @equip = "" @status = "" @save = "" @game_end = "" @fight = "" @escape = "" @new_game = "" @continue = "" @shutdown = "" @to_title = ""



@cancel = "" @gold = "" end attr_accessor :level attr_accessor :level_a attr_accessor :hp attr_accessor :hp_a attr_accessor :mp attr_accessor :mp_a attr_accessor :atk attr_accessor :def attr_accessor :spi attr_accessor :agi attr_accessor :weapon attr_accessor :armor1 attr_accessor :armor2 attr_accessor :armor3 attr_accessor :armor4 attr_accessor :weapon1 attr_accessor :weapon2 attr_accessor :attack attr_accessor :skill attr_accessor :guard attr_accessor :item attr_accessor :equip attr_accessor :status attr_accessor :save attr_accessor :game_end attr_accessor :fight attr_accessor :escape attr_accessor :new_game attr_accessor :continue attr_accessor :shutdown attr_accessor :to_title attr_accessor :cancel attr_accessor :gold end end end

RPG::System::TestBattler Data class for the battlers used in battle tests.

Superclass

Object

Referrer

RPG::System

Attributes

actor_id

The actor ID.

level

The actor's level.



weapon_id

The actor's weapon ID.

armor1_id

The actor's shield ID.

armor2_id

The actor's helmet ID.

armor3_id

The actor's body armor ID.

armor4_id

The actor's accessory ID.

Definition

module RPG class System class TestBattler def initialize @actor_id = 1 @level = 1 @weapon_id = 0 @armor1_id = 0 @armor2_id = 0 @armor3_id = 0 @armor4_id = 0 end attr_accessor :actor_id attr_accessor :level attr_accessor :weapon_id attr_accessor :armor1_id attr_accessor :armor2_id attr_accessor :armor3_id attr_accessor :armor4_id end end end

RPG::AudioFile Superclass of BGM, BGS, ME, and SE.

Superclass

Object

Attributes

name



The sound file name.

volume

The sound's volume (0..100). The default values are 100 for BGM and ME and 80 for BGS and SE.

pitch

The sound's pitch (50..150). The default value is 100.

Definition

module RPG class AudioFile def initialize(name = "", volume = 100, pitch = 100) @name = name @volume = volume @pitch = pitch end attr_accessor :name attr_accessor :volume attr_accessor :pitch end end

RPG::BGM Data class for BGM. This class has a method to play oneself with Audio module.

Superclass

RPG::AudioFile

Referrers

RPG::Map RPG::System RPG::System::Vehicle RPG::EventCommand

Class Methods

RPG::BGM.last

Returns BGM (RPG::BGM) that playing now. If no playing BGM, returns nil.

RPG::BGM.stop

Stops BGM playback.

RPG::BGM.fade(time)

Starts BGM fadeout. time is the length of the fadeout in milliseconds.



Method

play

Starts the BGM playback.

Definition

module RPG class BGM < AudioFile @@last = BGM.new def play if @name.empty? Audio.bgm_stop @@last = BGM.new else Audio.bgm_play("Audio/BGM/" + @name, @volume, @pitch) @@last = self end end def self.stop Audio.bgm_stop @@last = BGM.new end def self.fade(time) Audio.bgm_fade(time) @@last = BGM.new end def self.last @@last end end end

RPG::BGS Data class for BGS. This class has a method to play oneself with Audio module.

Superclass

RPG::AudioFile

Referrers

RPG::Map RPG::EventCommand

Class Methods

RPG::BGS.last

Returns BGS (RPG::BGS) that playing now. If no playing BGS, returns nil.

RPG::BGS.stop

Stops BGS playback.



RPG::BGS.fade(time)

Starts BGS fadeout. time is the length of the fadeout in milliseconds.

Method

play

Starts the BGS playback.

Definition

module RPG class BGS < AudioFile @@last = BGS.new def play if @name.empty? Audio.bgs_stop @@last = BGS.new else Audio.bgs_play("Audio/BGS/" + @name, @volume, @pitch) @@last = self end end def self.stop Audio.bgs_stop @@last = BGS.new end def self.fade(time) Audio.bgs_fade(time) @@last = BGS.new end def self.last @@last end end end

RPG::ME Data class for ME. This class has a method to play oneself with Audio module.

Superclass

RPG::AudioFile

Referrers

RPG::System RPG::EventCommand

Class Methods

RPG::ME.stop

Stops ME playback.



RPG::ME.fade(time)

Starts ME fadeout. time is the length of the fadeout in milliseconds.

Method

play

Starts the ME playback.

Definition

module RPG class ME < AudioFile def play if @name.empty? Audio.me_stop else Audio.me_play("Audio/ME/" + @name, @volume, @pitch) end end def self.stop Audio.me_stop end def self.fade(time) Audio.me_fade(time) end end end

RPG::SE Data class for SE. This class has a method to play oneself with Audio module.

Superclass

RPG::AudioFile

Referrers

RPG::Animation::Timing RPG::System RPG::EventCommand RPG::MoveCommand

Class Methods

RPG::SE.stop

Stops SE playback.

Method



play

Starts the SE playback.

Definition

module RPG class SE < AudioFile def play unless @name.empty? Audio.se_play("Audio/SE/" + @name, @volume, @pitch) end end def self.stop Audio.se_stop end end end

Appendix Regular Expressions sprintf Format

Regular Expressions Back References Character Class

Bellow is a list of all the metacharacters that Ruby supports.

Letters and numbers without \ are not metacharacters

Symbols with \ are not metacharacters

窶ｦis the rule.

^

Beginning of line. Match directly before the first character or line feed.

$

End of line. Match directly before the end of a character string or line feed.

p "\n".gsub(/$/, "o") # => "o\no"

.

Match any single character that excludes a line feed (when working with multi-byte characters, this refers to one character, not one byte). With the Regular Expression option m (multiple line mode. See the Regular Expression Literal.), it matches with any character that includes a line feed.

\w



Letters or numbers. The same as [0-9A-Za-z_]

Matches the Japanese double-byte characters.

\W

Non-alphanumeric character. Characters besides \w.

\s

Space character. The same as [ \t\n\r\f].

\S

Non-blank character. Characters besides [ \t\n\r\f]

\d

Number. The same as [0-9].

\D

Non-number.

\A

Beginning of a Character String. Differently from ^, it does not influence the effectiveness of a line feed.

\Z

End of a character string. Matches the front of a line feed if the character string ends at the line feed.

p "\n".gsub(/\Z/, "o") # => "o\no"

\z

End of a character string. Differently from $ or \Z, it does not influence the effectiveness of a line feed.

\b

Outside the specified character class it is a language boundary. (Matches between \a and \W.) While in the specified class it is a back space (0x08).

\B

Non-language boundary.

\G

Matches (doesn't have a width) the place matched from the previous one (directly after). Matches the front position only the first time. (Same as \A)

Can use with scan or gsub. Use when you want to make a match after the location that was matched the



time before.

# Takes values from the front of the line three at a time (for as long as the values continue.)str = "123456 789" str.scan(/\G\d\d\d/) {|m| p m }

[ ]

Set character class. See character class.

*

Return the expression from directly before more then 0 times. Will try to match for as long as possible.

*?

Quantifiers. Return the expression from directly before more then 0 times. (At shortest 1 match)

+

Quantifiers. Return the expression from directly before more then 1 time.

+?

Quantifiers. Return the expression from directly before more then 1 time. (At shortest 1 match.)

{m} {m,} {m,n}

Control the return of a set group (interval quantifier). Return all of the Regular Expressions from directly before.

m times more then m times more then m times, at most n times.

Matches for {n} or {,} will always fail.

str = "foofoofoo" p str[/(foo){1}/] # => "foo" p str[/(foo){2,}/] # => "foofoofoo" p str[/(foo){1,2}/] # => "foofoo"

Regular Expression ?, *, + are all the same as {0,1}, {0,} {1,}.

{m}? {m,}? {m,n}?

Interval Quantifier. Will return the regular expression from each before for

m times more then m times more then m times, at most n times.



at least one time.

?

Quantifiers. Will return the previous regular expression 1 or 0 times.

??

Quantifiers. Will return the previous regular expression 1 or 0 times (at least once).

|

Alternative.

( )

Regular Expression group movement. The character string matched to the regular expression in parenthesis is remembered for back referencing.

\1, \2 ... \n

Back reference. Reference a Back Reference.

(?# )

Comment. Ignore all the character strings in parentheses.

(?: )

Back Reference without group movement. That is, use a flexible group movement without becoming the targets \1, \2 (also $1, $2) etc .

/(abc)/ =�ｾ "abc" p $1 => "abc" /(?:abc)/ =�ｾ "abc" p $1 => nil

(?= )

Lookahead. Set location according to pattern. (Has no width.) The

(?=re1)re2

expression is a regular expression that matches a match of both re1 and re2. The

re1(?=re2)

expression, is a regular expression that continues to the following character string which matches with re2,



called re1.

p /foo(?=bar)/ =�ｾ "foobar" # => 0 p $& # => "foo" (no information about the "bar" section)

(?! )

Negative Loookahead. Set place depending on the negation of a pattern. (Has not width.) The

(?!re1)re2

expression, is a regular expression that does not match re1 but does match re2.

# 000 Number that excludes 3 characters re = /(?!000)\d\d\d/ p re =�ｾ "000" # => nil p re =�ｾ "012" # => 0 p re =�ｾ "123" # => 0 #C Identifier (Starts at [A-Za-z_] and continues with the [0-9A-Za-z_] character string.

/\b(?![0-9])\w+\b/

Back References

The regular expression \1 \2 窶ｦ \n is a back reference. It matches the character string matched in the nth parentheses (Regular Expression ( ) Grouping).

/((foo)bar)\1\2/

is the same as:

/((foo)bar)foobarfoo/

Example:

re = /(foo|bar|baz)\1/ p re =�ｾ 'foofoo' # => 0 p re =�ｾ 'barbar' # => 0 p re =�ｾ 'bazbaz' # => 0 p re =�ｾ 'foobar' # => nil

The parentheses in use must be more to the left than the back reference.

If there is a back reference in the parentheses in use the match will consistently fail. Also, the match will consistently fail when a single digit back reference has no parenthesis too.

p /(\1)/ =�ｾ "foofoofoo" # => nil p /(foo)\2/ =�ｾ "foo\2" # => nil

While one can specify a back reference greater then 2 digits, one must be carefull not to confuse it with \nnn (characters corresponding to the octal nnn) of backslash notation. If a numeric value is 1 digit, it is a back reference. When establishing more then 2 digits, it will be perceived as 8-bit code if parentheses are not used.

Also, when working with regular expressions it is necessary to start with 0 (such as \01, etc.) when using 1 bit code in 8 bit. (There is no back reference \0 so it isn't unclear.)



p /\1/ =�ｾ "\1" # => nil # back reference that doesn�� use parentheses. p /\01/ =�ｾ "\1" # => 0 8 bit code p /\11/ =�ｾ "\11" # => 0 8 bit code # 8 bit code (because there are no parentheses in use) p /(.)\10/ =�ｾ "1\10" # => 0 # back reference (because there are parentheses in use) p /((((((((((.))))))))))\10/ =�ｾ "aa" # => 0 # 8 bit code (However because there is no such # \08 "\0" + "8" 8 bit code) p /(.)\08/ =�ｾ "1\0008" # => 0 #If you want to write numbers following a back reference #you have to use parentheses to group them and split them up. p /(.)(\1)1/ =�ｾ "111" # => 0

Character Class

Regular class [] is a set character class. One character listed inside the [] will be matched.

For example, for /[abc]/ one of "a", "b" or "c" will be matched. You can also write character strings using the "-" when characters follow the ASCII code order like this: /[a-c]/. Also, if the first character is a ^ character from outside of the set character string will be matched.

Any 窶録' not at the beginning will be matched with that character. Also, any "-" at the front or end of a line will be matched with that character.

p /[a^]/ =�ｾ "^" # => 0 p /[-a]/ =�ｾ "-" # => 0 p /[a-]/ =�ｾ "-" # => 0 p /[-]/ =�ｾ "-" # => 0

A blank character class will result in an error.

p /[]/ =�ｾ "" p /[^]/ =�ｾ "^" # => invalid regular expression; empty character class: /[^]/

The "]" at the front of a line (or directly after a NOT "^") doesn't mean that the character class is over but is just a simple "]". It is recommended that this kind of "]" performs a backslash escape.

p /[]]/ =�ｾ "]" # => 0 p /[^]]/ =�ｾ "]" # => nil

"^", "-", "]" and "\\" (backslash) can do a backslash escape and make a match with that character.

p /[\^]/ =�ｾ "^" # => 0 p /[\-]/ =�ｾ "-" # => 0 p /[\]]/ =�ｾ "]" # => 0 p /[\\]/ =�ｾ "\\" # => 0

Inside the [] you can use character string and the same backslash notation, and also the regular expressions \w, \W, \s, \S, \d, \D (these are short-hand for the character class).

Please pay attention to to the fact that the character classes below can make a match with a line feed character too according to the negation (the same is true with regular expressions \W and \D.)

p /[^a-z]/ =�ｾ "\n" # => 0



sprintf Format The sprintf format of Ruby is basically the same as that the C language. However, there are some differences such as, (1) there is no short or long modifier like in C, (2) there is a 2 bit variable indicator (%b), and (3) not all of the dialects of sprintf (': 3-digit separators) are supported.

A complete explanation of Ruby's sprintf format is given below.

Below is a sprintf format form. The parts enclosed in [] can be omitted.

%[flag][width][.accuracy]indicator

To output '%' type '%%'.

Below is an explanation of each of the elements.

Flag

There are 5 types of flags: '#', '+', ' ' (space), '-', '0'

#

With the 2, 8, and 16 bit indicators ('b', 'o', 'x', 'X'), "0b", "0", "0x" and "0X" are added as prefixes.

p sprintf("%#b", 10) # => "0b1010" p sprintf("%#o", 10) # => "012" p sprintf("%#x", 10) # => "0xa" p sprintf("%#X", 10) # => "0XA"

For floating point numbers ('f', 'e', 'E', 'g' and 'G') always put a "." in the output.

p sprintf("%.0f", 10) # => "10" p sprintf("%#.0f", 10) # => "10." p sprintf("%.0e", 10) # => "1e+01" p sprintf("%#.0e", 10) # => "1.e+01"

By adding 'g', 'G' to the above there is a left over 0 on the end.

p sprintf("%.05g", 10) # => "10" p sprintf("%#.05g", 10) # => "10.000"

+

Symbols will be attached to output character strings. A '+' symbol will especially be added to positive numbers. This only applies to the following numerical value indicators: 'd', 'i', 'b', 'o', 'x', 'X', 'u', 'f', 'e', 'E', 'g' and 'G'. Also, for 'b', 'o', 'x', 'X', and 'u', a '-' symbol will be added to negative numbers.

p sprintf("%d", 1) # => "1" p sprintf("%+d", 1) # => "+1" p sprintf("%x", -1) # => "..f" # ".." shows that f continues infinitely p sprintf("%+x", -1) # => "-1"

' ' (space)

Same meaning as a '+' symbol but here, a blank space is used in place of the '+' symbol, meaning positive.



This only applies to the following numerical value indicators: 'd', 'i', 'b', 'o', 'x', 'X', 'u', 'f', 'e', 'E', 'g', 'G'.

p sprintf("%d", 1) # => "1" p sprintf("%+d", 1) # => "+1" p sprintf("% d", 1) # => " 1" p sprintf("%x", -1) # => "..f" p sprintf("% x", 1) # => " 1" p sprintf("% x", -1) # => "-1"

-

Output is left justified. It only has meaning if "Width" is specified.

0

If output is right justified, '0' will fill in the left over sections in place of a blank space.

This only applies to the following numerical value indicators: 'd', 'i', 'b', 'o', 'x', 'X', 'u', 'f', 'g', 'G' (It does not apply to 'e' or 'E').

p sprintf("%010d", 10) # => "0000000010"

Outputs specified together with '#' are shown below.

p sprintf("%#010x", 10) # => "0x0000000a" p sprintf("%#010o", 10) # => "0000000012" p sprintf("%#010b", 10) # => "0b00001010"

This is the same as below.

p sprintf("%#10.8x", 10) # => "0x0000000a" p sprintf("%#10.9o", 10) # => "0000000012" p sprintf("%#10.8b", 10) # => "0b00001010"

Normally shown as displayed below.

p sprintf("%#10x", 10) # => " 0xa" p sprintf("%#10o", 10) # => " 012" p sprintf("%#10b", 10) # => " 0b1010"

Width

A number string that begins with any number other than 0 is the specified width. Width displays the length of the character string produced. Contrary to the value of "Precision", which is mentioned later, only the number string of the width part is produced.

As for width specification, the length of " ", "+", "-", "0b", "0", "0x", "0X", which are presented as "Flags", is also considered.

p sprintf("%#05x", 10) # => "0x00a"

Width is a specification of the "minimum necessary width." If the resulting number string goes over the specified width, width specification is no longer valid.

If width is specified as '*', then the width value is received from an argument.

p sprintf("%10s", "foo") # => " foo"



p sprintf("%*s", 10, "foo") # => " foo"

Precision

A number string that follows a "." shows the precision (when only a "." is displayed, it is the same as ".0"). Precision means the length of a portion of numerical value strings for the following integer indicators: 'd', 'i', 'b', 'o', 'x', 'X', 'u'.

p sprintf("%10.5d", 1) # => " 00001" p sprintf("%#10.5x", 1) # => " 0x00001" p sprintf("%+10.5x", 1) # => " +00001"

This means the decimal places for the floating point indicator 'f'.

p sprintf("%10.5f", 1) # => " 1.00000" p sprintf("%10.5f", 10) # => " 10.00000"

This means the number of significant figures for floating point indicators 'e', 'E', 'g', and 'G'.

p sprintf("%10.5e", 1) # => "1.00000e+00" p sprintf("%10.5e", 10) # => "1.00000e+01" p sprintf("%10.5g", 10) # => " 10" p sprintf("%#10.5G", 10) # => " 10.000"

For character string indicators 's' and 'p', the portion which goes over the specified number within the argument character string is cut out. If width and precision values are the same, only the output for that length will be performed, no matter what argument is being considered.

p sprintf("%10.2s", "foo") # => " fo" p sprintf("%5.5s", "foo") # => # => " foo" p sprintf("%5.5s", "foobar") # => # => "fooba"

If '*' is specified as precision, the precision value will be received from the argument.

p sprintf("%.5s", "foobar") # => "fooba" p sprintf("%.*s", 5, "foobar") # => "fooba"

Indicators

Indicators show argument pattern interpretations. They cannot be abbreviated, and are divided into the following groups:

Indicators showing character strings: 'c', 's', 'p' Indicators showing integers: 'd', 'i', 'u', 'b', 'o', 'x', 'X', Indicators showing floating points: 'f', 'g', 'e', 'E', 'G'

c

Argument values 0-255 are considered together with character codes, then the corresponding characters are outputted. Argument conversion is attempted with the to_int method for objects other than numerical values, String, nil, true, and false.

This only applies to flag '-' and "width" specification.

s



Character strings are outputted.

If the argument is not a String object, the to_s method causes the object turned into a character string to be treated as an argument.

p

Object#inspect results are outputted.

p sprintf("%s", [1, 2, 3]) # => "123" p sprintf("%p", [1, 2, 3]) # => "[1, 2, 3]"

d i

An argument's numerical value is outputted as an integer decimal expression.

If the argument is not an integer it will be converted to one.

u

The argument value is considered as an integer without a symbol, then outputted as a decimal integer.

p sprintf("%u", -1) # => "4294967295"

outputs p 0xffff_ffff.to_s.

'%u' regards the argument as an integer's fixed length, and

printf("%u", n)

has the same meaning as

printf("%d", n & ~(-1 << n.size*8))

for negative integer n.

b o x X

Integers are outputted as character strings with binary, octal, hexadecimal, and hexadecimal (upper case letter) expressions.

If the '#' flag is specified, "0b", "0", "0x", "0X" are added to the front.

If the '+' or ' ' flags are not used, ".." (if the '#' flag is used, after "0x" etc.) is added to the front of negative numbers. This means that characters of the highest-order digit continue infinetely, and negative numbers are shown in complementary numbers of 2.

p sprintf("%#b", 10) # => "0b1010" p sprintf("%#o", 10) # => "012" p sprintf("%#x", 10) # => "0xa" ".." is added to # negative numbers



p sprintf("%#b", -1) # => "0b..1" p sprintf("%#o", -1) # => "0..7" p sprintf("%#x", -1) # => "0x..f" p sprintf("%10x", -1) # => " ..f" p sprintf("%-10x", -1) # => "..f " If # "precision" has been specified, ".." is not added. p sprintf("%.10x", -1) # => "ffffffffff"

f e E g G

'f' outputs numerical values with a decimal expression (xxx.xxx).

'e' outputs numerical values with an exponential notation (x.xxxe+xx).

When the exponent is smaller then -4, or higher than the precision, 'g' outputs the same as 'e'. In all other cases, it outputs the same as 'f'. However, 0 at the end of a decimal fraction is omitted.

Upper case indicators 'E' and 'G' change the output alphabet into upper case letters.

p sprintf("%f", 1.0) # => "1.000000" p sprintf("%e", 1.0) # => "1.000000e+000" p sprintf("%g", 1.0) # => "1" p sprintf("%f", 10.1) # => "10.100000" p sprintf("%e", 10.1) # => "1.010000e+001" p sprintf("%g", 10.1) # => "10.1" p sprintf("%g", 10 ** 6) # => "1e+006" p sprintf("%g", 10 ** -5) # => "1e-005"

The precision default value is 6.

Argument Specification

This is not used often, so it is explained last.

nth$

Indicates that formatting of the nth argument will be performed.

p sprintf("%1$d, %1$x, %1$o", 10) => "10, a, 12" p sprintf("%3$d, %2$x, %1$o", 1, 2, 3) => "3, 2, 1"

Used when you want to change the format according to the situation, but do not want to change the order.

case ENV['LC_TIME'] when /^ja_JP/ fmt = "%1$d�ｴ%2$d�・3$d�･" else fmt = "%2$02d/%03$2d/%1$02d" end p sprintf(fmt, 1, 4, 22)



=> "04/22/01"



Help RPGmaker

Documents

Transcript of Help RPGmaker