Project1

标题: 小旅的脚本入门教程（8.14基础篇完结!）~ [打印本页]
作者: 「旅」    时间: 2011-7-29 23:37
标题: 小旅的脚本入门教程（8.14基础篇完结!）~
本帖最后由 「旅」 于 2011-8-14 11:23 编辑

近况：昨天更新了4篇教程，今天完成了细节处理和图片提示的上传～～



写作初衷：
也许只是我个人理解有问题，但确实有种感觉，最开始接触的无论是脚本入门还是站上的各种教程时，总是不习惯一大堆的理论内容，而又经常找不到半句相关的代码，于是最终总因不知所云而放弃。除此之外，自己比较想知道的例如”生成图片”、”保持读取”的问题也根本看不到踪迹，弄得自己更加头大。所以正是因此，自己一直希望写出一个能适合和我有同样遭遇的同学的教程。趁着暑假的到来，希望完成这个想法，请大家支持我^-^




注意事项：
1.这个教程是更多的是面向那些为了制作出更精美游戏的制作者而写的，如果你单纯是为了学习编程的话，我个人不推荐这个教程。
2.脚本是比较抽象的事物，学习起来会比较辛苦，所以一定要先确保自己真的有一份制作游戏的热情，能不能学好都看你的觉悟。
3.教程最开始的基础篇(03-08和13-15)会复制脚本入门的内容，但很多地方都有修改，会尽力更加适合新人观看的。




麻烦大家啦：
可能有些错别字或讲解错的内容之类，希望察觉的同学可以帮忙回帖提示下。有什么好建议或疑惑也可以回帖~~
感谢大家的支持~~
作者: 秋庭里香    时间: 2011-7-30 09:51
本帖最后由 「旅」 于 2011-8-14 11:23 编辑

01.  写在前面(主楼)

（基础篇）10-12是重点课程
02.  脚本的介绍(板凳)
03.  开始(4楼)
04.  数字的计算(5楼)
05.  变量(6楼)
06.  条件分歧(7楼)
07.  字符串(8楼)
08.  循环(9楼)
09.  方法和函数(13楼)
10.  类和实例(14楼)
11.  类的属性(15楼)
12.  深入认识类(16楼)
13.  显示图片(17楼)
14.  数组(18楼)
15.  哈希表(19楼)

（解读篇1）
16.  数据库
17.  场景类
18.  游戏对象
19.  精灵
20.  窗口
21.  讲解Bitmap
22.  Main

（解读篇2）
23.  Selectable
24.  对话框
25.  保存与读取
26.  编译器

（解读篇3）
27.   Rect Viewport
28.   Table
29.   Color Font Tone
30.   RPG::Weather Tilemap
31.   冷门类的讲解
32.   错误Error

（扩展篇）
33.   Plane
34.   常量
35.   模块
36.   alias的用法
37.   另一种注释(10楼)
38.   类变量(11楼)
39.   分歧注意事项(12楼)
40.   Proc
41.   脚本运行的效率
42.   split的用法
43.   begin
44.   几何图形的描绘
45.   描绘艺术字

（选修篇）
46.   *的用法
作者: 「旅」    时间: 2011-7-30 09:55
本帖最后由 「旅」 于 2011-8-13 11:08 编辑

02.脚本的介绍

什么是脚本：
脚本语言是一种独特的简单语言，RPGXP 采用的是 Ruby 脚本语言。Ruby 的官方网页是 点击进入
Ruby 是松本行弘先生开发的免费软件，描述大规模的游戏也能保持良好性能。是善长文本处理的语言，照原样会加大游戏开发的难度。因此，对游戏开发用途的 Ruby 语言进行了特殊化，这就是 RGSS（Ruby Game Scripting System），中文意思就是 Ruby 游戏脚本系统。

总而言之，RGSS是Ruby的特殊化（稍微加了些东西），而脚本是以RGSS为基础来编写的事物就是了。你要把脚本说成RGSS或Ruby都可以。

ps.默认下脚本文件是 游戏目录/Data/Scripts.rxdata 在里面存放的就是代码的数据了。

脚本有什么用：
只要你有技术，它可以帮助你做出一切你想要的游戏。技术稍浅的同学，整合、修改站上的各种脚本都够你用的了。如果技术足够，又富含想象力，那么一个惊天地泣鬼神的银河系统（大雾）也将自然不在话下，只要你努力~!

学脚本需要什么条件：
1.热情
2.信心
3.耐心

无论你现在只是上小学或是初中，无论你英语数学考得多么糟糕，不要觉得脚本就和自己没有任何关系了。

1.论坛上很多学会脚本的人都和你一样也在读小学和初中，而他们也并非所谓的天才只是普普通通的人，但不同的是他们坚信自己能够学好脚本，所以他们做到了!
2.学习脚本以及写脚本，其实真正需要你记住的英语单词少之又少。
3.第三，制作游戏需要的数学基础很少，所以也不要担心这点。

总而言之，只要有信心，每个人都可以学好脚本。

学习脚本的好习惯：
1.量力而为。做人要醒目，不要横冲直撞。每次看脚本不要过久，大概50分钟后可以休息一下，这样既可以事半功倍，还可以防止因为厌烦情绪导致的学习信心下降。
2.即时复习。虽然每次看完脚本都会有种云里雾里的感觉，这很正常。先休息一天，到了第二天复习时便会时不时有感觉到"昨天看起来很复杂的东西，今天却领悟到了什么"这样奇妙的滋味。
3.不要懒惰。每一段在教程里出现的代码都应该自己亲自改改、试试，这样才能学的牢固。
4.不耻下问。有问题别自己纠结太久，可以到论坛寻求帮助(但先搜索)，在论坛学习的贴子总都会得到热心回答。

作者: 「旅」    时间: 2011-7-30 10:08
本帖最后由 「旅」 于 2011-8-13 11:18 编辑

03.开始(难度系数：★☆☆☆☆ 超容易)

新建脚本：
首先打开脚本编辑器，可以用快捷键F11直接打开。打开之后，在左边那里右键选择插入，下面的名称可以随便取，他不会有任何的影响。恩这样就建立了我们第一个脚本页。



结束程序：
接下来我们来执行一下下面这段代码，
  1. exit
复制代码
注意，在 Ruby 中是区分字母大小写的，所以不能输入 EXIT 或 Exit。当然全角文字也不行。请全部以半角的小写字母输入。输入完毕后关闭脚本编辑器，运行(游戏测试 按F12)看看吧。
运行游戏测试，窗口应该显示一瞬间后立即关闭。因为exit是结束程序的代码，所以一进去就被退出来了。

显示数据：
在写脚本时经常会用到的一个代码就是p了，它的作用很大。很多数据都可以用p显示出来。例如：
  1. p 1
  2. p "66RPG"
  3. p true
复制代码



注释：
有时脚本写起来会比较多行，内容会比较复杂，所以为了避免忘记某段脚本是什么意思，所以可以利用#来说明。例如：
  1. p 123 # 我只是打酱油的
  2. exit # 我只是路过的
复制代码
你可以试试把#和后面的文字去掉，前后的效果都是一样的。所以说，在#后面的内容是不会影响到脚本的运行。
作者: 「旅」    时间: 2011-7-30 10:17
本帖最后由 「旅」 于 2011-8-2 10:21 编辑

04.数字的计算(难度系数：★☆☆☆☆ 超容易)

数字
Ruby 中能使用的数字，包括整数和浮点数两种。
p 3           # 整数
p 52          # 整数
p -99         # 整数
p 1.5         # 浮点数
p 3.0         # 浮点数
所谓浮点数，就是有小数点的数。数值相同的话写作 3 是整数，而写作 3.0 即是浮点数。整数计算速度快，如果不需要小数点以下的话尽量使用整数。

计算方法
在 脚本编辑器 输入这些计算内容吧。
  1. p 1 + 1             # 加法
  2. p 10 - 3            # 减法
  3. p 7 * 5             # 乘法
  4. p 24 / 4            # 除法
复制代码
这样，写上普通算式就会输出计算的结果。

优先顺序
和普通的数学算式一样，* 和 / 计算要优先于 + 和 - 计算。想改变这个顺序就要使用括号 ( )，括号中的算式将会优先计算。ps.注意不要用（）而应该用()才对。
  1. p 2 * 2 + 3 * 4     # 16
  2. p 2 * (2 + 3) * 4   # 40
  3. p 2 * (2 + 3 * 4)   # 28
复制代码
按优先顺序，示例第一行其实是 4+12，第二行是 2*5*4，第三行是 2*14，所以会是不同的计算结果。
括号还可以多层重叠起来，例如：
  1. p (2 * (3 + 4)) – 5
复制代码

小数点以下的计算
整数除整数的情况下，会省略余数，答案将还是整数。想得到小数点以下的答案，就要使用到浮点数。除数或被除数至少要有一个是浮点数（明确标明了小数点以下），计算的答案就会是浮点数。
  1. p 15 / 4            # 3
  2. p 15.0 / 4          # 3.75
  3. p 15 / 4.0          # 3.75
复制代码

余数的计算
求余数（除法的余数），是使用 % 符号。
  1. p 14 % 4            # 2
  2. p 13 % 4            # 1
  3. p 12 % 4            # 0
复制代码
不知道什么是余数的同学可以去百度查一下，因为余数这样东西在以后写脚本时大有用途。

乘方的计算
乘方（同一个数指定次数的相乘）是使用 ** 符号。
  1. p 2 ** 4            # => 16
复制代码
这个示例求 2 的 4 次方，计算 2*2*2*2，也就是2连续乘以4次的意思。
作者: 「旅」    时间: 2011-7-30 10:33
本帖最后由 「旅」 于 2011-8-13 11:28 编辑

05.变量(难度系数：★☆☆☆☆ 超容易)

脚本里变量是一个很重要的东西，几乎每段代码都会涉及到变量。让我们一起来学习变量的基础知识。

变量的命名
我们可以为变量取比如 x 和 y 或者更长的像 level 或 gold 这样的名称。名称的长度没有限制。
变量有几个类型，首先我们来学习最基本的局部变量。局部变量的命名规则有以下几点。其中的第 1 条应该特别注意。
1.第一个字符必须以小写英文字母或 _（下划线）开头。
2.第二个字符开始可以使用英文字母、数字或 _（下划线） 。
3.不能使用保留字作变量的名称。

保留字是作为 Ruby 中具有特殊意义的词而被系统所「保留」，所以变量名称不能使用。以下就是系统的保留字。
alias    def      false    nil      return   unless
and      do       for      not      self     until
begin    else     if       or       super    when
break    elsif    in       redo     then     while
case     end      module   rescue   true     yield
class    ensure   next     retry    undef
(保留字不用特意去记住，只要清楚，输入后是蓝色字的是保留字就行)除上面列出的保留字以外，其它的词都可以作变量的名称。

赋值和引用
在实际中使用变量看看吧。
  1. x = 3
  2. y = 4
  3. p x + y     # 7
复制代码
第一行和第二行是进行变量的赋值。其中 = 号是赋值运算符。和数学上使用等号表示「左边等于右边」的意思不同，这里表示「左边的变量代入右边的数值」。在上述示例中，第一行 x 变量和第二行 y 变量分别代入数值 3 和 4。
第三行是引用变量 x 和 y。所谓引用就是取得那个变量的数值。变量的计算和数字的计算方法完全一样。这里的 x + y 可以解释为 3 + 4，计算结果就为 7。

另外，引用从未进行赋值的局部变量，就会使程序出现错误。
  1. p zzz       # 系统会提示错误
复制代码



请记住，变量一定要进行赋值后才能使用。
  1. zzz = 5
  2. p zzz       #  5
复制代码
这个示例中，第一行变量 zzz 为其赋值代入 5 后，第二行引用。

自运算
变量引用自己的数值，并再次代入计算结果称为自运算。
  1. x = 1
  2. x += 7
  3. x -= 3
  4. x *= 2
  5. p x         # 10
复制代码
第二行的 x += 7 相当于 x = x + 7，总之就是向变量 x 里加上 7。同样 -=、*=、/=、%= 等也是如此使用。这些运算符就是自运算运算符。
这个示例中第一行是赋值直接代入 1，第二行加上 7，这时 x 的值其实是 8，第三行减去 3，第四行再乘以 2，最后的计算结果就是 10。

全局变量
局部变量是暂时使用的变量，只能在方法和类等定义（在后面讲述）内部使用，之外变量就无效。与之相对，在程序任何地方都能引用的就是全局变量。全局变量可以在程序中任何地方使用，名称相同，就必然是同一个变量。
如下面的示例，以 $ 号开头的变量就作为全局变量使用。赋值方法和局部变量完全相同。
  1. $global
复制代码
虽然在任何地方都能引用，但使用全局变量不一定比局部变量好。全局变量十分强大，胡乱使用恐怕会使程序变得很难懂，而且因为它会一直存在，导致内存的浪费，部分新人就是因为过度使用它导致游戏卡机的。请在使用时注意。

作者: 「旅」    时间: 2011-7-30 10:34
本帖最后由 「旅」 于 2011-8-13 11:42 编辑

06.条件分歧(难度系数：★★☆☆☆ 容易)

满足特定的条件与否，之后的动作会根据其不同而改变就叫作条件分歧。

比较运算符
在具体地学习处理条件分歧的方法之前，要先记住条件构成中使用的运算符。
下面 6 个运算符称为比较运算符。使用这些运算符，和给予条件（数字和字符串）相比较，然后返回结果。
== 相等
!= 不相等
< 小于
> 大于
<= 小于或相等
>= 大于或相等
这里一定要注意的是，判断相等的运算符不是 = 而是 ==。像已学习过的那样，所谓 = 符号表示的不是比较而是代入。请注意不要弄混淆了。

真伪值
比较运算的运算结果就称为真伪值。有真（正确）、伪（错误）两种情况。
比较后是正确的话为 true 值，是错误的话就为 false 值。请试试看吧。
  1. p ("早安" == "早安")                # true
  2. p ("早安" == "晚安")                # false
  3. p (3 + 1 == 3 + 5)                  # false
  4. p (3 + 1 == 2 + 2)                  # true
  5. p 2 = 2                                  # 出错!
复制代码


逻辑运算符
下面 6 个运算符称为逻辑运算符。
and
&& 「～，与，～」的意思
or
|| 「～，或，～」的意思
not
! 「非～」的意思
英文单词运算符和符号运算符，无论用哪个都是一样的。在预置脚本中运用的主要是英文单词。使用这些逻辑运算符就能指定更加复杂的条件。
  1. p (100 > 77 and 1 + 1 == 2)         # true
  2. p (100 > 77 && 1 + 1 == 2)          # true
复制代码
上述示例中，第一行和第二行表示的都是一个内容「100 大于 77 同时 1 + 1 等于 2」。不用说 100 是比 77 大的整数，1 + 1 答案也为 2，两个运算都成立。所以输出结果就为 true（真，正确）。

那么，看下一个算式吧。
  1. p (1 + 1 == 3 or 2 + 2 == 3)        # false
  2. p (1 + 1 == 3 || 2 + 2 == 3)        # false
复制代码
上述示例中，第一行和第二行表示的也都是一个内容「1 + 1 等于 3 或 2 + 2 等于 3」。很显然，1 + 1 不等于 3，2 + 2 也不等于 3，这样两个运算都不成立。比较运算符 or（||）是只要有一个运算成立就为 ture（真，正确），而这里两个运算全都不成立，所以输出结果就为 false（伪，错误）。

另外，not（!）和上面的例子稍微有些不同， not（!）表示的内容为后面的条件不成立。可以理解为颠倒 true 或 false 的运算符。
  1. p (not true)                        # false
  2. p (! true)                          # false
复制代码
上述示例中的内容是「非 true」的意思，所以输出结果为 false。

if ～ elsif ～ else ～ end
if ～ end 语句是条件分歧的句法。这个和英文的 if（如果～就）意思相同，表示「如果 if 后面的条件成立的话，就运行下面的处理」的意思。下面示例中的 3～5行就是条件分歧。
  1. a = 20              # 为变量 a 赋值代入 20。

  3. if a >= 10          # 如果 a 为 10 以上的话，
  4.   p "big"       #   显示 big。
  5. end                 # 分歧结束。
复制代码
在条件不满足时也要进行处理的情况下就使用 else，条件不满足但指定另一个条件的情况下就使用 elsif。
  1. a = 7               # 为变量 a 赋值代入 7。

  3. if a >= 10          # 如果 a 为 10 以上的话，
  4.   p "big"       #   显示 big。
  5. elsif a >= 5        # 除此之外，如果 a 为 5 以上的话，
  6.   p "medium"    #   显示 medium。
  7. else                # 其他，
  8.   p "small"     #   显示 small。
  9. end                 # 分歧结束。
复制代码

unless ～ end
与 if 相反，在条件不满足时才进行某些处理的情况下使用 unless 语句。
  1. a = 7               # 为变量 a 赋值代入 7。

  3. unless a >= 10      # 如果 a 不为 10 以上的话，
  4.   p "small"     #   显示 small。
  5. end                 # 分歧结束。
复制代码

case ～ end
在条件为特定的变量值进行分歧的情况下使用 case 语句会更方便。
  1. a = 0               # 为变量 a 赋值代入 0。

  3. case a              # 分歧开始。
  4. when 0              #  当 a 为 0 时，
  5.   p "零"        #   显示 零。
  6. when 1              #  当 a 为 1 时，
  7.   p "壹"        #   显示 壹。
  8. when 2              #  当 a 为 2 时，
  9.   p "贰"        #   显示 贰。
  10. end                 # 分歧结束。
复制代码
把第一行 a = 后面的 0 改为 1 和 2，然后再来看看分歧的结果吧。当 a 代入 1 时会显示“壹”，代入 2 时会显示“贰”。

条件运算符
使用符号 ? 和 : 也是运算符形式的条件分歧语句。
  1. a = 3

  3. p (a >= 10 ? "big" : "small")   # => "small"
复制代码
这个示例的意思是，变量 a 的值在 10 以上的话就显示 "big"， 9 以下的话就显示 "small"。条件运算符的语法是「条件 ? 真时的值 : 伪时的值」。上述的条件是 a >= 10，真时的值为 "big"，伪时的值为 "small"，会根据条件是否满足来决定使用 ? 或 : 的值。

当然使用 if 语句也能完成同样的事情。
  1. a = 3

  3. if a >= 10
  4.   p "big"
  5. else
  6.   p "small"
  7. end
复制代码
使用 if 语句的语法会像上面写的那样，但是使用条件运算符语句会更加简洁。该语句在当前的脚本中也使用得很多，所以最好事先记住。


附加内容：

最后讲一个脚本入门没讲但经常会看到的一个格式，
  1. p 2 if 1 + 1 == 2
复制代码
就是这个，它和下面是一样的：
  1. if 1 + 1 == 2
  2.   p 2
  3. end
复制代码
所以如果条件分歧里的内容只有一行，可以用前一种方法，会方便很多、简洁很多。同时unless也可以这样，
  1. p 2 unless 1 + 1 != 2
复制代码
好了这节课就到这里~
作者: 「旅」    时间: 2011-7-30 10:34
本帖最后由 「旅」 于 2011-8-2 10:55 编辑

07.字符串(难度系数：★☆☆☆☆ 超容易)

一般来说，由文字连接起来的数据就称为字符串。

print
双引号 " " 或单引号 '' 中间的部分，就作为字符串数据使用。
  1. p "RPG Maker XP"                    # "RPG Maker XP"
  2. p 'RPG Maker XP'                    # "RPG Maker XP"
复制代码

p 命令会导致双引号和字符串一起输出，所以可以使用 print 命令代替。
  1. print "RPG Maker XP"                # RPG Maker XP
复制代码

这次双引号就没有了。print 和 p 相似，但它只显示字符串本身。

为变量赋值
和数字一样，字符串也能代入变量为该变量赋值。
  1. a = "RPG Maker XP"
  2. print a                         # RPG Maker XP
复制代码
字符串也能作加法，字符串加上字符串，就会得到一个连接起来的字符串为答案。
  1. a = "我的 "
  2. b = "RPG Maker XP"
  3. print a + b                     # 我的 RPG Maker XP
复制代码
还可以作乘法，字符串乘以一个整数，就会得到该整数次重复的字符串为答案。
  1. a = "RPG Maker XP"
  2. print a * 2                     # RPG Maker XPRPG Maker XP
复制代码

控制码
这个东西在原来的脚本入门里有讲，但其实学了也没有太大的意义，所以这里就不讲了，没看过的同学可以去脚本入门稍微过目一下，不过不用太在意就是了。

内嵌表达式
在字符串里面，可以用 #{变量名} 的形式把变量的内容嵌入在字符串当中。
  1. game = "RPG"
  2. print "#{game} Maker XP"         # RPG Maker XP
复制代码
上述示例里，第一行是为 game 变量赋值代入字符串"RPG"。第二行里面，其中 #{game} 是表示直接嵌入变量 game 的值字符串"RPG"，和后面的" Maker XP"组合在一起，从而输出一个新的字符串。
这和以下的脚本一样，不过上面的用法就灵活多了。
  1. game = "RPG"
  2. print game + " Maker XP"  # RPG Maker XP
复制代码
唯一要注意的一点，内镶表达式不可以用在 单引号 ' '中，会无效的。
  1. game = "RPG"
  2. print '#{game} Maker XP'         # #{game} Maker XP
复制代码
作者: 「旅」    时间: 2011-7-30 10:35
本帖最后由 「旅」 于 2011-8-13 11:52 编辑

08.循环(难度系数：★★★☆☆ 较难)

重复进行特定的处理就要使用循环。

while ～ end
在满足特定条件期间进行循环的情况下使用 while 语句。
  1. a = 0               # 为变量 a 赋值代入 0。
  2. i = 1               # 为变量 i 赋值代入 1。

  4. while i <= 5        # 当变量 i 为 5 以下时循环开始（重复以下处理），
  5.   a += i            #   变量 a 加上 i 的值。
  6.   i += 1            #   变量 i 的值增加 1。
  7. end                 # 循环结束。

  9. p a                 # 显示计算结果。
复制代码
这个示例是求从 1 到 5 这五个数字总和的程序。在这里，变量 i 是用来产生从 1 到 5 这五个数字用的。
那么，这个程序最重要的是 i += 1 这行。如果没有这行 i 的值永远为 1，而 i <= 5 的条件也会一直满足，就会成为无限循环。因此，这里每次都向i加上1使得 i 的值依次变为 2、3、4、5、6 从而使得循环结束。

变量 a 和 i 的数值变化，如下表所示。
循环a 的值i 的值
初始状态 0 1
1 次后 1 2
2 次后 3 3
3 次后 6 4
4 次后 10 5
5 次后 15 6
循环5次后，在a的数值里面实际上进行了1+2+3+4+5的计算，i的值也超过5而执行end使得循环结束。
然后以 p 命令显示最终 a 的值，就会显示出答案 15。

变化范围
数值的范围，例如类似于「从 1 到 5」这样的概念就称为变化范围。
  1. 1..5
复制代码
上述示例表示「从 1 到 5」的意思。使用 .. 运算符，就能作成一个变化范围。
而且，使用 ... 运算符也可以。
  1. 1...5
复制代码
但... 和 .. 不同的是「不含最后一个数」。所以，1...5这种情况实际上表示的是「从 1 到 4」的意思。

for ～ in ～ end
想在变化范围表示的范围内循环的情况下使用 for 语句。
  1. a = 0               # 为变量 a 赋值代入 0。

  3. for i in 1..5       # 变量 i 的值按从 1 到 5 的范围变化，
  4.   a += i            #   变量 a 加上 i 的值。
  5. end                 # 循环结束。
  6. p a                 # 显示计算结果。
复制代码
这个示例和使用 while 语句的示例完全相同，也是求从 1 到 5 这五个数字总和的程序，但比使用 while 的情况更加简洁。在 while 中变量 i 加上 1 表示的是从 1 到 5 的范围，然而在 for 中是用变量 i 按「从 1 到 5 的范围」的顺序代入来表示。表面看起来不同，但实际上进行的是意思完全相同的处理。

Ruby 中有许多语法，循环中也存在各种各样不同的方法。在不同语法使用中，请按照这个示例提示的「让编写更简便」的方式来思考。实际上，如果理解了条件分歧和循环的话，就能进行大部分逻辑运算了。

loop do ～ end
未指定循环次数和条件的情况下，也就是想进行无限循环时使用 loop 语句。这个与 while 和 for 语句的性质稍微有所不同，一般情况下没有必要注意。
  1. i = 0               # 为变量 i 赋值代入 0。

  3. loop do             # 循环开始。
  4.   i += 1            #   变量 i 的值增加 1。
  5.   p i               #   显示变量 i 的值。
  6. end                 # 循环结束。
复制代码
这个示例是「一边把 i 的值加上 1，一边显示 i 的值」的程序，没有结束条件。一旦运行的话就会连续显示 1、2、3……。如果这种对话框不断显示的话，就算要结束程序也是不可能的，只能按着 F12 键不放强行关闭对话框，并点击右上方的结束按钮关闭程序。

break
想中途中断循环就要使用 break 命令。
  1. i = 0               # 为变量 i 赋值代入 0。

  3. loop do             # 循环开始。
  4.   i += 1            #   变量 i 的值增加 1。
  5.   if i == 5         #   如果变量 i 的值为 5 的话，
  6.     break           #     中断循环。
  7.   end               #   条件分歧结束。
  8.   p i               #   显示变量 i 的值。
  9. end                 # 循环结束。
复制代码
上述示例在程序中加上了「i 等于 5 的就中断循环」的条件。运行该程序，显示 1、2、3、4 就结束了。
break 即使在 while 和 for 等其它方法作成的循环中也能使用。

next
在不中断循环的情况下，跳过本次循环而进入下一次循环时使用 next 命令。
  1. for i in 1..5       # 变量 i 的值按从 1 到 5 的范围变化，
  2.   if i == 3         #   如果变量 i 的值为 3 的话，
  3.     next            #     进入下一次循环。
  4.   end               #   条件分歧结束。
  5.   p i               #   显示变量 i 的值。
  6. end                 # 循环结束。
复制代码
运行这个示例，会显示 1、2、4、5。
作者: 「旅」    时间: 2011-7-30 10:35
本帖最后由 「旅」 于 2011-8-13 21:56 编辑

扩展篇37.另一种注释(难度系数：★☆☆☆☆ 超容易)

我们在最开始学习脚本时就学习过注释的方法，还有就是"注释后面的内容不会影响正常脚本的运行"。今天我们来继续学习另一种注释的方法。

如果有试过在脚本前写注释的同学应该都有感觉，就是用#那样做实在是太麻烦了。例如：
  1. # 大家好我叫做懒散王
  2. # 今天我写了一个脚本
  3. # 这个脚本有很强大的功能
  4. # 例如说他可以OXXOXX
  5. # 很厉害吧
  6. # 想要使用他的话你可以OXXOXX
  7. # 这样就可以了
复制代码
(不要吐槽范例>.<)例如这样的一个注释，又因为作者废话很多，这种写法就麻烦很多了。
所以可以用这种写法，超方便的嘎嘎。
  1. =begin
  2. 大家好我叫做懒散王
  3. 今天我写了一个脚本
  4. 这个脚本有很强大的功能
  5. 例如说他可以OXXOXX
  6. 很厉害吧
  7. 想要使用他的话你可以OXXOXX
  8. 这样就可以了
  9. =end
复制代码
是不是很方便。只需要把注释内容放入 =begin 到 = end 的中间就行了。不过需要注意一点，=begin和=end前面都不可以有空格，不然会发生错误!
  1.   =begin
  2.   =end
  3. # 出错啦!
复制代码
好了教程就到这了。
作者: 「旅」    时间: 2011-7-30 10:35
本帖最后由 「旅」 于 2011-8-13 21:58 编辑

扩展38.类变量(难度系数：★★★☆☆ 较难)

观看条件：
已经学过类，知道什么是@xxx、attr_accessor的意思。

内容讲解：
以前一直没讲过类变量，因为这个东西应用的很少，一般制作游戏的人完全不会遇见，但大家可以稍微了解下，说不定有一天会有妙用。

首先，类变量不是实例变量。我们在基础篇讲过的@xxxx是实例变量，而@@xxxx才是类变量。所以，类变量是@@的格式。
@@类变量和@实例变量的区别在于他们存在的地方不同，一个是跟随类，一个是跟随实例，请看范例：
  1. # 定义类
  2. class A
  3.   attr_accessor :a
  4.   @a = 100
  5.   @@a = 999
  6.   def a2
  7.     return @@a
  8.   end
  9.   def a2=(a2)
  10.     @@a = a2
  11.   end
  12. end

  14. # 生成实例
  15. jiong1 = A.new
  16. jiong2 = A.new

  18. # 测试
  19. jiong1.a = "我是1"
  20. jiong2.a = "我是2"

  22. p jiong1.a # “我是1”
  23. p jiong2.a # “我是2” ——>两个不一样

  25. jiong1.a2 = "我打酱油"
  26. jiong2.a2 = "我卖炸弹"

  28. p jiong1.a2 # "我卖炸弹"
  29. p jiong2.a2 # "我卖炸弹"——>两个一样
复制代码
因为@@类变量没有attr_accessor可用，我们只好用麻烦些，自己写方法来读取和写入。
范例的大概意思就是，两个实例带入不同的东西，最终修改@a的结果会不同，而修改@@a的结果却是相同的，都是"我卖炸弹"。这是因为@a是实例自己用的，而@@a是两个实例共用的，为什么是共用的?因为它叫做类变量咯，他们都是A类的实例。
所以，不管生成几个实例，只要是修改同一个类的@@类变量，它们最终修改的都是同一个变量。
作者: 「旅」    时间: 2011-7-30 10:35
本帖最后由 「旅」 于 2011-8-2 11:09 编辑

扩展39.分歧注意事项(难度系数：★★★☆☆ 较难)

这堂课的内容比较容易，是关于条件分歧一个特别需要注意的细节，如果不知道的话可是会遇上大麻烦的哦。

大家都知道if a or b 或 if a and b的意思，但大家一直会猜错unless a or b 和 unless a and b的含义。为什么呢，让我们来先来看一下下面这个问题。
首先，unless 的触发条件是伪的情况下（也可以说是非、false的情况，都一样）。那么如果我照上面那样写unless a or b，那么是不是代表在a为伪"或"b为伪的情况下，就会触发unless。那么我们试一下：
  1. a = true
  2. b = false
  3. unless a or b
  4.   p "你好啊"
  5. end
  6. exit
复制代码
测试完毕，大家会发现，根本就没有显示”你好啊”。那不是a为伪，或b为伪就可以触发吗，这里的b就是伪的呀，这是为什么呢。呵呵所以说问题来了。

首先我告诉大家，这个脚本没有问题，但只是大家理解的不够透彻。
or这个东西的作用，就是根据左右的真伪值（true和false），如果其中有一个为true，那么就返回true，只有全部都不是true的时候，才返回false。
也就是说，我们上面的那段脚本，就等于写出unless true，那么永远都不可能会执行了。
同样的情况也发生在unless a and b的身上。

所以unless a and b的中文意思其实是a"或"b为false时触发条件，而unless a or b的中文意思其实是a"和"b为false时触发条件。
所以说有点时候理解脚本不能单纯从表面来理解。恩这堂课大家大概知道了解什么意思就行了。
只用记住，遇到unless，用中文解读代码意思时，就要把or和and倒过来用，这样就不会遇到问题了。

作者: 「旅」    时间: 2011-7-30 10:35
本帖最后由 「旅」 于 2011-8-24 15:48 编辑

09.方法和函数(难度系数：★★★☆☆ 较难)

今天我们来学习"方法"。所谓方法是一种指令，我们曾经学过的exit、p、print都是方法的一种。

方法的定义：
我们先来看看怎么样定义方法。方法只需要def~end的格式就可以定义了，如下：
  1. def 方法名
  2.   方法内容
  3. end
复制代码
方法名称的命名方法，基本上和局部变量有相同的限制。也能在开头使用大写字母，但不推荐方法命名时使用。另外，作为方法命名的例外，在名称的最后还可以添加 ? 或 ! 符号。

我们来随便定义一个方法：
  1. def a
  2.   p 1
  3. end
复制代码
这样我们就定义好方法了，接着我们来调用方法，(调用方法也就是执行方法的内容)
  1. def a
  2.   p 1
  3. end
  4. a
复制代码
调用方法的方式很简单，直接把方法名写上去就行了。测试，工程显示了1，说明我们成功地调用了方法。

参数：
带有参数的方法，定义如下：
  1. def jiong(a)
  2.   p a
  3. end
  4. jiong(10)  # 显示10
  5. jiong("你好吗") # 显示"你好吗"
复制代码
这个方法可以根据在括号()里写入的数值，p出来。在这里，定义时的a被称为临时参数，而调用时写入的10和"你好吗"则称为实参数。在调用方法时，实参数会代入到临时参数中。
参数可以同时有多个，只需要用 , 逗号隔开就可以了。(注意不要写这个 ， 而是 , 才对)
  1. def jiong(a,b,c,d)
  2.   p a + b + c + d
  3. end
  4. jiong(1,2,3,4) # 显示10
复制代码

默认参数：
定义方法时就已指定且使用时可以省略的参数称为默认参数。默认参数是在临时参数后面加上符号 = 来指定的。事先设定好了默认参数，在使用方法时未指定括号 () 内实参数数值的情况下，临时参数就会自动代入默认参数数值。
  1. def a(n = 6)
  2.   p n
  3. end
  4. a # 显示6
  5. a(5) #显示5
复制代码
默认参数同样可以指定多个参数，不过要注意一点，默认参数必须在普通参数的最后~!
  1. def jiong(c,a=2)
  2.   p a + c
  3. end
  4. jiong(2) # 显示4
复制代码
  1. def jiong(a=2,c) # 提示错误!!
  2.   p a + c
  3. end
复制代码


方法重定义：
如果在脚本中定义了两次同个方法，那么调用时就会选择最接近的那个定义。
  1. def jiong
  2.   p 2
  3. end
  4. jiong # 显示2

  6. def jiong
  7.   p 999
  8. end
  9. jiong # 显示999
复制代码
重定义专业点讲可以叫做重写，它是导致脚本冲突的重要原因之一，大家要记住了。

方法的中断：
如果想要中断方法的运行，可以使用return这个指令。(注意:方法中断是return，而循环中断是break)让我们看下面的例子：
  1. def jiong(a)
  2.   if a == 1
  3.     return
  4.   end
  5.   p a
  6. end

  8. jiong(1) # 什么都不显示

  10. jiong(4) # 显示4
复制代码
这个例子就是说当a为1时，执行return指令，正因为执行了return，所以第一个调用没有任何的显示。

函数
在原来的脚本入门教程里，作者直接把方法叫做函数了，但如果考虑到数学里所讲的函数的话，那么这个说法就太奇怪了。以我个人的看法吧，一般只有那些专门用于计算的方法才称得上是函数。

返回数值
在学习函数前，我们先来学习返回数值的方法return。没错，这个正是我们前面讲的那个return，它不单可以中断方法运行，同时它也可以返回指定的数值。范例如下：
  1. def jiong
  2.   return 1
  3. end
  4. p jiong # 显示1
复制代码
好了，返回数值成功，调用jiong时1被返回过来了。
返回数值是指把一个数值放在return的右侧，接着它会被传送到调用方法的地方。

要注意一点，这里p jiong的jiong是方法，但似乎在某个地方也看到类似的格式，没错，
  1. jiong = 1
  2. p jiong # 显示1
复制代码
它就和局部变量的格式完完全全一样。所以我们要注意下面这种情况，
  1. def jiong
  2.   return 1
  3. end

  5. jiong = 2

  7. p jiong # 显示2
复制代码
如果刚好同时方法名和局部变量名都是一模一样的话，那么脚本只会用局部变量。

函数的使用：
学习好了返回数值我们正式开始学习函数。我上面说过了，一般只有专门用于计算的方法才称为函数。例如我们想知道某数量商品的价格，可以先写一个这样的函数：
  1. def zongjia(danjia,shulian)
  2.   return danjia * shulian
  3. end
复制代码
(为了方便理解，上面函数名叫做zongjia总价，参数分别是danjia单价、shulian数量)
写好这个函数后我们来调用，
  1. p zongjia(10,20) # 显示200
复制代码
这样一个函数就完成了。也许看后有的同学开始纳闷了，"我直接10*20得出结果不就好了?"。这样想就不对了，因为有些真正的函数它的内容格外复杂，是用了数条物理公式最终才得出的结论，例如：
  1. def d(a,b,c)
  2.   return Math.sqrt(Math.sqrt(a**2 + b**2)**2 + c**2)
  3. end
复制代码
这个是用来算出长方形对顶角间距离的函数，如果是每次都那么麻烦去写一次的话，估计有一堆同学要挂了。但我们现在只需要，
  1. p d(1,2,3)
复制代码
很方便吧。所以写程序永远记住一点，一劳永逸(写了大型脚本就会体会到)。另外写成函数的格式还方便观看，特别是在脚本写多时可以避免很多麻烦。
作者: 「旅」    时间: 2011-7-30 10:35
本帖最后由 「旅」 于 2011-8-13 22:37 编辑

10.类和实例(难度系数：★★★☆☆ 较难)

今天我们来学习类的定义。注意一下，在默认脚本里，除了最后一个Main不是外，其余全部的脚本都是类，这足以说明类这样东西在脚本中的重要地位。

类的定义：
我们先来学习怎么定义类吧。定义类很容易，和定义方法的def~end相似，定义类是class~end，如下
  1. class Aaaa
  2. end
复制代码
这样我们就定义一个类了。注意，方法名和局部变量名开头是小写，但类名的开头必须是大写哦，而后面就无所谓了。

类的方法：
我们前一节课已经学过方法了，而方法这样东西，除非特别用途，他一般都是定义在类中的，如下：
  1. class A
  2.   def jiong
  3.     p 1
  4.   end
  5. end
复制代码
只要把方法放到类中，这样的话方法就属于类了。

调用类中的方法：
  1. class A
  2.   def jiong
  3.     p 1
  4.   end
  5. end

  7. a = A.new # 生成类的实例，并带入局部变量a
  8. a.jiong # 调用方法，显示1
复制代码
在调用前我们需要先生成类的实例，这是因为类就像一个大楼的规划图，而规划图终究是规划图，他不可能可以代替实物的功能，你必须把它建起它才能让人们住进去，也就是只有实物才能真正完成想要做到的事情。在这里，A.new就是按照类的定义建立起的实物，称之为实例。(当然因为A.new代入到局部变量a里了，所以你可以称被代入后的a为实例)。

总之使用类，就必须先生成它的实例，实例只需 类名.new 就可以生成了。接着调用方法， 变量名.方法名 就可以了。

实例变量：
属于实例专用的变量称为实例变量或实变量，以@开头的变量，自动作为实例变量使用。局部变量只有在def~end等结构里才会有效，然而实例变量的话，只要他的实例存在，没有被系统清除，那实例变量就会一直存在了。另外在同一个实例的方法中可以一起共享哦。
  1. class A
  2.   def jiong
  3.     @rpg = "你好吗?"
  4.   end
  5.   def jiong2
  6.     p @rpg
  7.   end
  8. end
  9. a = A.new

  11. a.jiong2 # 显示nil

  13. a.jiong
  14. a.jiong2 # 显示"你好吗?"

  16. p woshiceshide # 局部变量没有赋值，出错!!
复制代码
(注意这里的nil是空的意思，也就是什么都没有。变量在赋值前，都是nil的。不过局部变量和实例变量有不同，局部变量在赋值前调用会出错，而实例变量则不会。)
上面调用jiong方法后，@rpg被赋予"你好吗?"这个字符串，所以第二次调用jiong2时，就显示"你好吗?"而不是nil了。

初始化：
我们使用类时，经常会用到许多变量，然而如果没有对变量进行初始化的话，容易发生下面的错误：
  1. class A
  2.   def plus_hp(hp)
  3.     @hp += hp
  4.   end
  5. end
  6. a = A.new
  7. p a.plus_hp(100) # 出现错误!!!
复制代码
因为@hp这时还只是nil，nil是不能进行+=这样的加法运算的，所以当然就会发生错误咯。
  1. class A
  2.   def initialize(hp=1000)
  3.     @hp = hp
  4.   end
  5.   def plus_hp(hp)
  6.     @hp += hp
  7.   end
  8. end

  10. a = A.new
  11. p a.plus_hp(100)
复制代码
我们可以用initialize (必背!) 这个方法名，它的中文意思就是初始化，当你在 .new 时，就会自动执行这个方法。另外initialize和普通方法一样，可以为它加上参数。

父类
往往为了便于阅读、修改等理由，你都可以用父类这样东西。例如你原本定义了一个叫做Car(汽车)的类，而你又打算定义Rolls_Royce(劳斯莱斯)和Benz(奔驰)这两个类，那么可以把Car作为父类，劳斯莱斯和奔驰作为子类，例子如下：
  1. class Car
  2.   def initialize
  3.     @luntai = 4
  4.     @ranliao = "汽油"
  5.   end
  6.   def jiong
  7.     p @luntai
  8.   end
  9. end

  11. class Rolls_Royce < Car
  12.   def initialize
  13.     super
  14.     @jiage = 100000000
  15.     @shuoming = "很昂贵的车"
  16.   end
  17. end

  19. class Benz < Car
  20.   def initialize
  21.     super
  22.     @jiage = 1999999
  23.     @shuoming = "很拉风的车"
  24.   end
  25. end
复制代码
首先我们定义Car，因为汽车嘛，都是luntai(轮胎)有4个，ranliao(燃料)是汽油，这凡是汽车都具有的特性，所以我们没必要每种车子都废话一次。
往下看，劳斯莱斯和奔驰都用了 < Car 这个东西，它便是用来指明自己的父类的。指定好后，我们就可以直接使用父类的方法了，如下：
  1. benz = Benz.new
  2. benz.jiong # 显示4 (jiong虽然只有在父类Car中定义，但子类却也可以调用它)
复制代码


不过有的同学注意到，父类和子类都定义了initialize方法，按照我们之前学的，那样的话父类的方法就被子类给覆盖掉了。的确，不过我们可以使用super，它会自动调用与该子类方法名相同的父类方法名的内容。
  1. class A
  2.   def initialize(jiong)
  3.     p jiong
  4.   end
  5. end

  7. class B < A
  8.   def initialize
  9.     super(100)
  10.     p 999
  11.   end
  12. end

  14. b = B.new # 显示100，显示999
复制代码
而且super还可以写上参数哦。
作者: 「旅」    时间: 2011-8-1 11:04
本帖最后由 「旅」 于 2011-8-17 22:18 编辑

11.类的属性(难度：★★☆☆☆ 容易)

外部使用实例变量：
我们前一节课有讲解过实例变量，也就是以@开头的那种变量。我们讲过，它有一个特点，和局部变量只可以在def~end等结构中存在不同，它可以在在类的全部方法中共同享用。但它有一个问题，就是外部不能直接写入或读取它，如下：
  1. class A
  2.   def initialize
  3.     @jiong = 1
  4.   end
  5. end

  7. a = A.new
  8. p a.jiong # 出错
复制代码
  1. class A
  2.   def initialize
  3.     @jiong = 1
  4.   end
  5. end

  7. a = A.new
  8. a.jiong = 22 # 出错
复制代码
我们如果想要从外边写入或读取实例变量，就必须为它建立一个方法：
  1. class A
  2.   def initialize
  3.     @jiong = 1
  4.   end
  5.   def jiong # 读取方法
  6.     return @jiong
  7.   end
  8.   def jiong=(jiong) # 写入方法
  9.     @jiong = jiong
  10.   end
  11. end

  13. a = A.new
  14. a.jiong = 22
  15. p a.jiong # 显示22
复制代码
这次我们成功地写入和读取到@jiong这个实变量了。(以前讲过return是返回数值，所以它可以把实变量返回出来)

不过如果单单为了实现写入或读取一个变量的功能，我们就需要写两个方法，那也未免太麻烦了。所以我们平时写的时候可以直接用attr_accessor这个东西，是不是简洁很多?
  1. class A
  2.   attr_accessor :jiong
  3.   def initialize
  4.     @jiong = 1
  5.   end
  6. end

  8. a = A.new
  9. a.jiong = 22
  10. p a.jiong # 显示22
复制代码
attr_accessor可以帮我们直接定义写入方法和读取方法，可以省去很多时间的哦。
不过有的时候只需要定义写入方法的话，则是用attr_writer；只是读取方法的话，是attr_reader。

类的属性：
我们定义类这样东西，往往都是将具体的事物进行了脚本化。例如先前说的Car，就是把车的概念转移到脚本上来。而车的一些数据，例如4个轮胎，叫做"奔驰"，这在脚本里都可以叫做类的属性。
方便理解的话，配合了写入或读取方法的实例变量，都可以称为类的属性。
作者: 「旅」    时间: 2011-8-1 11:09
本帖最后由 「旅」 于 2011-8-17 22:21 编辑

12.深入认识类(难度系数：★★☆☆☆ 容易)

内部类：
先让我们打开RM的F1帮助文件-RGSS参考-标准库-内部类-Object (好长orz)。打开后大家会看到一堆的英文，不要太在意，我们只需先知道下面这几样东西：
类名
中文
实例
01.NilClass
空的类
nil
02.FalseClass
伪的类
false
03.TrueClass
真的类
true
04.Range
范围
1..2 或 1…5
05.String
字符串
"大家你们好吗"
06.Integer (父类Numeric)
整数(整型)
100
07.Float  (父类Numeric)
浮点数
100.9999
首先我们看到右侧的实例，没错，100、”大家你们好吗”这些都是左边那些类的实例，这点大家要记清楚了。
正因为它们都是实例，按照我们以前学习类时的知识，只要生成了实例，就可以调用类中有定义的方法了。(包括父类中的方法)它的方法我们都可以在帮助文件中找到，例如，
  1. a = -999 # 生成整数的实例，并代入a
  2. p a.abs # 显示999
复制代码
这里的abs是整数Integer的父类Numeric里的一个方法，它可以取得数的绝对值(也就是会把负数变正数，而正数不变)。

我们再来试试String里的方法，这里我们用它的最后一个方法upcase(将所有字母都变为大写形式)，
  1. a = "我来自66rpg"
  2. p a.upcase # 显示"我来自66RPG"
复制代码
不出我们所料，测试很成功~!
另外，细心的同学应该发现了一个问题，字符串类里面有分upcase和upcase!两种方法，他们都可以返回字母改为大写形式后的字符串，但是……
  1. a = "我来自66rpg"
  2. p a.upcase # 显示"我来自66RPG"
  3. p a # ——>还是"我来自66rpg"
复制代码
  1. a = "我来自66rpg"
  2. p a.upcase! # 显示"我来自66RPG"
  3. p a # ——>变成了"我来自66RPG"
复制代码
(注意范例的大小写)也就是带有!的方法，会真正地永远地改变实例的内容。

大家可以自己再试试这几个类中的其他方法，有一些看不明白的方法可以无视(因为制作游戏的话几乎没有接触那些东西)，而有一些重要的我以后也会讲到。好了这节课就到这了^-^
作者: 「旅」    时间: 2011-8-1 11:27
本帖最后由 「旅」 于 2011-8-2 11:19 编辑

13.显示图片(难度系数：★★☆☆☆ 容易)

今天让我们稍稍轻松一下，来学习显示图片的脚本吧。

Graphics 模块
首先我们如果要显示图片的话，需要调用Graphics模块中的update(中文:更新)方法。因为模块这个东西用得比较少，所以暂时我们不详细讲解。总之调用模块里的方法可以直接 模块名.方法名 就行了。这和类需要生成实例才可以调用方法相比，就简单多了：
  1. # 类方法的调用：较麻烦
  2. a = A.new
  3. a.xxxx
复制代码
  1. # 模块方法的调用：容易
  2. Graphics.update
复制代码

好了抛开模块的事情，继续学习显示图片。
  1. loop do
  2.   Graphics.update
  3. end
复制代码
请大家看看上面，这段脚本是指不停地调用update方法，因为游戏画面总是需要更新的，所以要不断调用它。这个方法可以做到「处理游戏画面，并前进1帧(0.05秒)」的效果，处理游戏画面就是要显示什么它来负责；前进1帧的意思就和等待1帧一样。例如：
  1. p 1
  2. for i in 1..20
  3.   Graphics.update
  4. end
  5. p 2
复制代码
在这里显示1后等待1秒才显示2，所以证明游戏的等待就是由它来完成。

  1. loop do
  2.   Graphics.update
  3. end
复制代码
继续回到这段脚本。因为现在我们根部没有生成图片，所以运行上面的示例后什么也没有显示。这只是个反复显示乌黑画面的处理而已。下面我们就来学习实际显示图片的方法吧。

精灵和位图
向刚才的脚本中加入 2 行，如下所示。如果画面左上角显示出小恶魔的图片就表示成功了。
  1. devil = Sprite.new
  2. devil.bitmap = Bitmap.new("Graphics/Battlers/075-Devil01")

  4. loop do
  5.   Graphics.update
  6. end
复制代码
这里出现了Sprite(精灵)和Bitmap(位图)两个新类。Sprite是在游戏画面上显示某些图片的基本概念即精灵的类，Bitmap是精灵传输元位图本身内容的类。具体它们是做什么的，我们以后再讲，现在只需知道显示图片需要用到它们就行。
(另外，指定 Bitmap.new 参数的路径名，分隔符号是使用 / 而不是 \ 这点要特别注意)

属性
很多类都有属性，Sprite类也不另外。我们可以通过写入方法修改它的坐标变量x和y。
  1. devil = Sprite.new
  2. devil.bitmap = Bitmap.new("Graphics/Battlers/075-Devil01")
  3. devil.x = 320
  4. devil.y = 240

  6. loop do
  7.   Graphics.update
  8. end
复制代码
这样写的话，小恶魔就会出现在中间附近了。

让我们进一步加工一下。
  1. devil = Sprite.new
  2. devil.bitmap = Bitmap.new("Graphics/Battlers/075-Devil01")
  3. devil.ox = devil.bitmap.width / 2
  4. devil.oy = devil.bitmap.height / 2
  5. devil.x = 320
  6. devil.y = 240

  8. loop do
  9.   Graphics.update
  10. end
复制代码

这里 ox、oy 属性的设定，更改了精灵的原点。这和 RPGXP 的事件指令”显示图片”中选择”左上”、”中心”是一样的概念。默认状态下，原点在图片的左上。赋值运算符的右侧调用的 width、height 是 Bitmap 类的方法，作用是分别取得图片的宽和高。这里使用了其值的 1/2，也就是把图片的中心点设定为原点。

总之，这样修改就可以让小恶魔完完全全出现在中间了。好了，显示图片先讲到这里。

作者: 「旅」    时间: 2011-8-2 11:21
本帖最后由 「旅」 于 2011-8-14 11:21 编辑

14.数组(难度系数：★★☆☆☆ 容易)

想一起处理多个数据就要使用数组。

数组的生成
在 [] 符号中间排列多个单元就生成了一个数组。如下例所示。
  1. a = ["艾力克斯","布莱恩","卡罗来"]
复制代码
上述程序建立了一个包含 "艾力克斯"、"布莱恩"、"卡罗来" 这三个字符串单元的数组，并把这个数组代入变量 a 为其赋值。
要取出数组中数据，如下例所示。
  1. a = ["艾力克斯","布莱恩","卡罗来"]

  3. p a[0]          # => "艾力克斯"
  4. p a[1]          # => "布莱恩"
  5. p a[2]          # => "卡罗来"
复制代码
上述中，a[0] 和 a[1] 等各个单元，能和其它变量那样单独使用。这里 0、1、2 那样的数字被称为数组的附加码。附加码不是从 1 开始而是从 0 开始的，这点一定要注意。从 0 开始，单元从左至右依次为 0、1、2 ……。
数组中除了字符串外还可以包含其它数据。而且，使用 p 命令也可以不指定附加码，那样就会显示数组的全部单元。
  1. a = [2000,"艾力克斯",true,1..50]

  3. p a             # => [2000,"艾力克斯",true,1..50]
复制代码
数组单元的重赋值
数组的各单元的使用和普通的变量一样，也能进行变量的重赋值。
  1. a = [10, 20, 30]
  2. a[0] = 100

  4. p a             # => [100, 20, 30]
复制代码
该示例中，首先是建立了一个由 10、20、30 这三个数字单元组成的数组，然后向第一个单元里重赋值代入 100。这时 a[0] 原先的数值 10 就被代入的 100 所代替，显示的结果就更改了。这个处理和普通变量的重赋值是一样的。
指定超过最初数组附加码范围的单元并为之赋值，会自动扩大数组添加新的单元。
  1. a = [10, 20, 30]
  2. a[3] = 40

  4. p a             # => [10, 20, 30, 40]
复制代码
建立数组时只有 3 个单元，现在为在其范围外的 a[3] 赋值，就会自动添加第 4 个单元扩大数组。C 语言等其它语言是不充许这样赋值的，而 Ruby 这种灵活的语言就可以放心添加。
如果跳过范围的话会如何呢？
  1. a = [10, 20, 30]
  2. a[5] = 60

  4. p a             # => [10, 20, 30, nil, nil, 60]
复制代码
中间就会出现 nil 值。这个与 true 和 false 等一样是常量的一种，意思是「什么都没有」。和 true 表示「真」，false 表示「伪」一样，nil 表示「无」。

数组的操作
数组是 Array 类的实例。可以调用这个类定义的方法对数据进行操作。
(可以打开RM帮助文件-RGSS参考-标准库-Object-Array参考方法类型)~~~~





比如，想知道数组的单元数量的话就可以使用 size 方法(当然也可以用它上方的length，它们是一样的)。和 String 类的 size 方法返回字符串字节数相似，Array 类的 size 方法是返回数组的单元数。数组为空时就返回 0。
  1. a = ["艾力克斯","布莱恩","卡罗来"]

  3. p a.size        # => 3
复制代码
想知道数组中是否含有特定的值的话，就要使用到 include? 方法。



  1. a = ["艾力克斯","布莱恩","卡罗来"]

  3. p a.include?("布莱恩")            # => true
  4. p a.include?("小田纯一狼")        # => false
复制代码
第三行中使用 include? 方法，是确认数组中是否含有字符串 "布莱恩"。上例在第一行生成数组时设定有字符串 "布莱恩"，所以输出结果为 true(真)。同样第四行是确认数组中是否含有字符串 "小田纯一狼"。然而这个字符串在数组中是不存在的，所以输出结果就为 false(伪)。

数组的循环
使用 for 循环，可以把数组里全部数据都拿出来一遍。
  1. a = ["艾力克斯","布莱恩","卡罗来"]

  3. for s in a
  4.   p s
  5. end
复制代码
这里使用变量 s，循环代入数组 a 中所包含的单元。循环的范围是数组 a 包含的所有单元，按 "艾力克斯"、"布莱恩"、"卡罗来" 的顺序在对话框中显示，最后循环结束。
作者: 「旅」    时间: 2011-8-2 11:22
本帖最后由 「旅」 于 2011-8-14 11:19 编辑

15.哈希表(难度系数：★★☆☆☆ 容易)

Hash 表是一种和数组比较类似的数据构造形式。

Hash 表的生成
Hash 表也称为关联数组。和数组不同的是，作为取出数值 的主键(相当于数组的附加码)，可以使用任意的数据。 在 {} 符号中间排列多个单元就生成了一个哈希表。
  1. a = {"艾力克斯"=>2000, "杰克"=>2003}
复制代码
这个例子中，"艾力克斯" 和 "杰克" 就是取出数值的主 键，2000 和 2003 就是实际的数值。这样， 使用 => 符号把主键和数值连接起来就形成了 Hash 表。
要取出 Hash 表中数据的时候，应按如下操作。
  1. a = {"艾力克斯"=>2000, "杰克"=>2003}

  3. p a["艾力克斯"]        # => 2000
  4. p a["杰克"]            # => 2003
  5. p a["宇佐助"]          # => nil
复制代码
从上例最后一行可以得知，当指定主键不存在时就会返回 nil。
这里是以字符串为主键，当然不使用字符串也可以。作为主键还可以使用整数等其它数据类型，在有很多编号单元的情况下使用哈希表会比使用数组更加方便。
另外，哈希表的反操作，也就是「检查与数值对应的主键」的情况下，在 [] 中写入数值是不能得到其主键的。这里不再多作陈述，该种操作方法我们会在后面特别介绍。

Hash 表数值的添加
实际操作中，Hash 表可以在程序中直接指定数据建立， 亦可以使用先建立一个空的 Hash 表然后向其中添加单元数据等多种方法生成。 生成一个空的 Hash 表只需写入 {} 就行了。
  1. a = {}
复制代码
当然我们也可以用普通生成实例的方法生成，
  1. a = Hash.new
复制代码
这两种生成方法都是一样的。
然后我们来向 Hash 表中添加数值，和数组单元的重赋值完全相同。
  1. a = {}
  2. a["艾力克斯"] = 2000

  4. p a                 # => {"艾力克斯"=>2000}
复制代码

Hash 表的操作
同数组一样，可以调用这个类定义的方法对数据进行操作。比如要从 Hash 表中删除数值的话，就要使用 delete 方法。
  1. a = {"艾力克斯"=>2000, "杰克"=>2003}
  2. a.delete("杰克")

  4. p a                 # => {"艾力克斯"=>2000}
复制代码
想知道 Hash 表中是否含有某个特定主键的情况下，就要使用 include? 方法。
  1. a = {"艾力克斯"=>2000, "杰克"=>2003}

  3. p a.include?("艾力克斯")    # => true
  4. p a.include?("宇佐助")      # => false
复制代码
第三行中使用 include? 方法，是确认哈希表中是否含有主键 "艾力克斯"。上例在第一行生成哈希表时主键设定有 "艾力克斯"，所以输出结果为 true(真)。同样第四行是确认哈希表中是否含有主键 "宇佐助"。然而这个主键在哈希表中是不存在的，所以输出结果就为 false(伪)。



Hash 表的循环
在 Hash 类中，有取得全部主键排列的 keys 方法。
  1. a = {3=>6, 4=>10, 5=>15}
  2. p a.keys            # => [5, 3, 4]
复制代码
这样，=> 左侧的主键会全部排列出来。 但 Hash 表中是没有顺序的，所以排列会无顺序可言。

前节中，我们学习了使用 for 循环指定数组的方法。 现在让我们来用 for 循环指定 keys 方法的返回值，作成 Hash 表主键的循环吧。
  1. a = {3=>6, 4=>10, 5=>15}

  3. for k in a.keys
  4.   p k
  5. end
复制代码
运行上例就会按不同顺序显示 3、4、5。

而且，使用 values 方法的话，还能取得 Hash 表全部数值的排列。
  1. a = {3=>6, 4=>10, 5=>15}

  3. for v in a.values
  4.   p v
  5. end
复制代码
运行上例就会按不同顺序显示 6、10、15。



作者: 「旅」    时间: 2011-8-2 11:22
占楼占楼~ ^o^
作者: 「旅」    时间: 2011-8-2 11:22
本帖最后由 「旅」 于 2011-8-23 11:47 编辑

[数据]01.整数和浮点

整数 ( 类名:Integer ) ( 实例:100、200、-999、0 )
浮点 ( 类名:Float ) ( 实例:1.55、-999.5、0.0 )



方法(以下方法整数和浮点都可使用):
     01.+  (加法)
     02.-  (减法)
     03.*  (乘法)
     04./  (除法)
     05.%  (求余)
     06.** (乘方)
  1. p 1 + 1              # 加法
  2. p 10 - 3             # 减法
  3. p 7 * 5              # 乘法
  4. p 24 / 4             # 除法
  5. p 2 ** 3             # 乘方
复制代码
     07.== (等于)
     08.!= (不等于)
     09.<  (小于)
     10.>  (大于)
     11.<= (小等于)
     12.>= (大等于)
     13.<=>(请看注意事项01)
  1. p 1 == 1    # true 真(正确)
  2. p 1 != 1    # false 伪(错误)
  3. p 2 < 3     # true
  4. p 3 > 2     # true
  5. p 2 <= 2    # true
  6. p 3 >= 0    # false
  7. p 3 <=> 1   # 1
复制代码
     14.to_s (转为字符串)
     15.abs  (绝对值)
     16.round(四舍五入)
  1. p 1.to_s     # "1"
复制代码
     17.to_i (转换为整型，去掉小数点后的数位，但不四舍五入)
     18.to_f (转换为浮点)
  1. p 1.9.to_i   # 1
复制代码
     19.integer? (若为整型，则返回true)
  1. p 2.integer?    # true
复制代码

注意事项:
     01.<=> 的用法是，左右进行比较，左大于右返回1，右大于左返回-1，等于返回0。
  1. p 10 <=> 100      # -1
  2. p 100<=> 10       # 1
  3. p 10 <=> 10       # 0
复制代码
    02.<= 和 >= 都是 = 在后面，千万别写错。
  1. p 10 =< 10 # 出错!
复制代码
     03./ 除法只会返回整数，若要小数点后，必须在其中有一个为浮点数(Float)。
  1. p 15 / 4            # 3
  2. p 15.0 / 4          # 3.75
  3. p 15 / 4.0          # 3.75
复制代码

作者: 「旅」    时间: 2011-8-2 11:22
占楼占楼~ ^o^
作者: 「旅」    时间: 2011-8-2 11:22
占楼占楼~ ^o^
作者: 纳尔德    时间: 2011-8-2 12:24
赶快写Array和Hash的教程吧!
作者: piaoy    时间: 2011-8-2 19:08
这这。。。这几乎是自带教程手打了一遍吧
作者: AEGIS    时间: 2011-8-2 20:37
提示: 作者被禁止或删除 内容自动屏蔽
作者: 纳尔德    时间: 2011-8-17 20:09
总感觉这里和F1的有相似的.然后还是得看看实例.这样只是学到方法.不懂得去应用.
作者: fux2    时间: 2011-8-17 20:17
其实个人感觉带各种情况的例子的教程才易懂，但那工作量可以压死人囧.
作者: 忧雪の伤    时间: 2011-8-17 21:20
本帖最后由 忧雪の伤 于 2011-8-17 21:33 编辑

其实我那篇东西大部分都是原创的……
不过没什么好参考的啊，大家都说看不懂……
函数
Function
严格地讲，Ruby中没有函数。但那些省略被调的方法调用看来确实很像函数，而且有的方法根本不需要self或实例变量等被调信息，事实上后者已成为函数了。所以有时也就网开一面地把这样的方法叫成函数了。

通常将这种函数(式的方法)的方法可视性设成了private，这样就只能以省略被调的形式来调用它们了。这类方法中比较有代表性的是 模块函数。

函数的定义我想你可能搞错了= =
作者: 574656549    时间: 2011-8-17 22:44
提示: 作者被禁止或删除 内容自动屏蔽
作者: 510035021    时间: 2011-10-1 14:41
学到方法和类的介绍的时候，要先看完所有方法再往下看吗
作者: 幻耶    时间: 2011-10-2 21:04
期待后续。。
作者: z12508186    时间: 2012-2-17 16:58
简单，用很直白语言表达。。令新人中的小白我也能一眼看明白。。。期待更新
作者: 从小就暴力    时间: 2012-4-21 20:14
看了有点明白了~ 原来怎么用脚本方法哦，谢谢楼主，希望多多写像这个教程，我很喜欢
作者: BLACK_LOOP    时间: 2012-8-6 15:09
很不错的教程，有自己的特色，希望楼主能再接再厉~

......顺便问一句，楼主是妹纸？
作者: wuchi1042    时间: 2012-8-9 15:12
跟JAVA 的语法差不多嘛。。。{:2_262:}
作者: gqhondafit    时间: 2012-8-11 21:55
感谢楼主的教程，可以理解一点脚本了！
作者: soulcage    时间: 2012-9-8 21:10
本帖最后由 soulcage 于 2012-9-8 22:20 编辑
「旅」 发表于 2011-7-30 10:08
03.开始(难度系数：★☆☆☆☆ 超容易)

新建脚本：
首先打开脚本编辑器，可以用快捷键F11直接打开 ...


新手问个问题
我使用的是VX ace
为什么我在脚本里输入

p 1
p "66RPG"
p true

之后，测试时没有影响，还是跳出了游戏的开始画面？

-----------------------------------

晕，打扰了

自己看帮助搞明白了

应该是系统运行了后面的脚本

rgss_stop

输入这个就搞定了
作者: zakums06f    时间: 2014-1-17 17:50
a=教程
if a 〉= good
p good
end

作者: 无脑之人    时间: 2014-1-19 15:26
LS挖的一手好坟 @恋′挂机  
作者: 冷峻逸    时间: 2015-7-17 21:19
提示: 作者被禁止或删除 内容自动屏蔽
作者: 光明骑士    时间: 2016-6-4 05:54
为了以后回来看，下个锚
作者: 玉蝶儿    时间: 2016-10-22 11:26
完全看不懂呀，呜呜呜
作者: JJB1994    时间: 2016-12-18 09:46
谢谢楼主！
作者: jokers    时间: 2020-1-31 15:22
「旅」 发表于 2011-7-30 10:34
06.条件分歧(难度系数：★★☆☆☆ 容易)

满足特定的条件与否，之后的动作会根据其不同而改变就叫 ...

学到了，简单易懂
作者: jokers    时间: 2020-1-31 15:23
「旅」 发表于 2011-7-30 10:34
06.条件分歧(难度系数：★★☆☆☆ 容易)

满足特定的条件与否，之后的动作会根据其不同而改变就叫 ...

学到了，简单易懂



欢迎光临 Project1 (https://rpg.blue/) Powered by Discuz! X3.1