3584 lines
No EOL
119 KiB
Ruby
3584 lines
No EOL
119 KiB
Ruby
#******************************************************************************
|
||
#
|
||
# ＊ TES基本セットモジュール ＊
|
||
#
|
||
# for RGSS3
|
||
#
|
||
# Ver 1.01 2013.09.28
|
||
#
|
||
# ◆機能説明
|
||
# ツクールのイベントコマンドを網羅した基本モジュールです。
|
||
#
|
||
# ◆注意事項
|
||
# ※このモジュールの動作には、TESの本体が必要です。
|
||
#
|
||
# 提供者：睡工房 http://hime.be/
|
||
#
|
||
#******************************************************************************
|
||
if $TEST
|
||
class Tes_Validator
|
||
#----------------------------------------------------------------------------
|
||
# ◆ タグ検証の設定
|
||
# 各引数の検証方法を、@@validatesに設定します。
|
||
#----------------------------------------------------------------------------
|
||
@@validates["message_h"] = {
|
||
"index" => {
|
||
:isNumeric => [0, 7]
|
||
},
|
||
"back" => {
|
||
:isNumeric => [0, 2],
|
||
},
|
||
"pos" => {
|
||
:isNumeric => [0, 2]
|
||
}
|
||
}
|
||
|
||
@@validates["message"] = {
|
||
"value" => {
|
||
:notEmpty => []
|
||
}
|
||
}
|
||
|
||
@@validates["choice_h"] = {
|
||
"cancel" => {
|
||
:isNumeric => [0, 5]
|
||
}
|
||
}
|
||
|
||
@@validates["choice_if"] = {
|
||
"index" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, 4]
|
||
}
|
||
}
|
||
|
||
@@validates["input_num"] = {
|
||
"var" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"num" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, 8]
|
||
}
|
||
}
|
||
|
||
@@validates["choice_item"] = {
|
||
"var" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["scroll_h"] = {
|
||
"speed" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, 8]
|
||
},
|
||
"noskip"=> {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["scroll"] = {
|
||
"value" => {
|
||
:notEmpty => []
|
||
}
|
||
}
|
||
|
||
@@validates["sw"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"end" => {
|
||
:isNumeric => [:id, nil]
|
||
},
|
||
"flag" => {
|
||
:notEmpty => [],
|
||
:list => ["on", "off"]
|
||
}
|
||
}
|
||
|
||
@@validates["var"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"end" => {
|
||
:isNumeric => [:id, nil]
|
||
},
|
||
"op" => {
|
||
:notEmpty => [],
|
||
:list => ["eq", "+", "-", "*", "/", "%"]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[-+]{0,1}(var\.){0,1}\d+$/]
|
||
}
|
||
}
|
||
|
||
@@validates["var_random"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"end" => {
|
||
:isNumeric => [:id, nil]
|
||
},
|
||
"op" => {
|
||
:notEmpty => [],
|
||
:list => ["eq", "+", "-", "*", "/", "%"]
|
||
},
|
||
"min" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [nil, nil]
|
||
},
|
||
"max" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [:min, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["var_item"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"end" => {
|
||
:isNumeric => [:id, nil]
|
||
},
|
||
"op" => {
|
||
:notEmpty => [],
|
||
:list => ["eq", "+", "-", "*", "/", "%"]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["var_weapon"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"end" => {
|
||
:isNumeric => [:id, nil]
|
||
},
|
||
"op" => {
|
||
:notEmpty => [],
|
||
:list => ["eq", "+", "-", "*", "/", "%"]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["var_armor"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"end" => {
|
||
:isNumeric => [:id, nil]
|
||
},
|
||
"op" => {
|
||
:notEmpty => [],
|
||
:list => ["eq", "+", "-", "*", "/", "%"]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["var_actor"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"end" => {
|
||
:isNumeric => [:id, nil]
|
||
},
|
||
"op" => {
|
||
:notEmpty => [],
|
||
:list => ["eq", "+", "-", "*", "/", "%"]
|
||
},
|
||
"actor" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"data" => {
|
||
:notEmpty => [],
|
||
:list => ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
|
||
"10", "11", "level", "exp", "hp", "mp", "maxhp", "maxmp", "atk",
|
||
"def", "matk", "mdef", "agi", "luk"]
|
||
}
|
||
}
|
||
|
||
@@validates["var_enemy"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"end" => {
|
||
:isNumeric => [:id, nil]
|
||
},
|
||
"op" => {
|
||
:notEmpty => [],
|
||
:list => ["eq", "+", "-", "*", "/", "%"]
|
||
},
|
||
"enemy" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, nil]
|
||
},
|
||
"data" => {
|
||
:notEmpty => [],
|
||
:list => ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
|
||
"hp", "mp", "maxhp", "maxmp", "atk", "def", "matk", "mdef",
|
||
"agi", "luk"]
|
||
}
|
||
}
|
||
|
||
@@validates["var_character"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"end" => {
|
||
:isNumeric => [:id, nil]
|
||
},
|
||
"op" => {
|
||
:notEmpty => [],
|
||
:list => ["eq", "+", "-", "*", "/", "%"]
|
||
},
|
||
"character" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-1, nil]
|
||
},
|
||
"data" => {
|
||
:notEmpty => [],
|
||
:list => ["0", "1", "2", "3", "4",
|
||
"mapx", "mapy", "direction", "screenx", "screeny"]
|
||
}
|
||
}
|
||
|
||
@@validates["var_party"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"end" => {
|
||
:isNumeric => [:id, nil]
|
||
},
|
||
"op" => {
|
||
:notEmpty => [],
|
||
:list => ["eq", "+", "-", "*", "/", "%"]
|
||
},
|
||
"member" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["var_other"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"end" => {
|
||
:isNumeric => [:id, nil]
|
||
},
|
||
"op" => {
|
||
:notEmpty => [],
|
||
:list => ["eq", "+", "-", "*", "/", "%"]
|
||
},
|
||
"data" => {
|
||
:notEmpty => [],
|
||
:list => ["0", "1", "2", "3", "4", "5", "6", "7",
|
||
"mapid", "members", "money", "steps", "playtime", "timer",
|
||
"save_num", "battle_num"]
|
||
}
|
||
}
|
||
|
||
@@validates["var_script"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"end" => {
|
||
:isNumeric => [:id, nil]
|
||
},
|
||
"op" => {
|
||
:notEmpty => [],
|
||
:list => ["eq", "+", "-", "*", "/", "%"]
|
||
},
|
||
"script" => {
|
||
:notEmpty => []
|
||
}
|
||
}
|
||
|
||
@@validates["self_sw"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:list => ["A", "B", "C", "D"]
|
||
},
|
||
"flag" => {
|
||
:notEmpty => [],
|
||
:list => ["on", "off"]
|
||
}
|
||
}
|
||
|
||
@@validates["timer"] = {
|
||
"flag" => {
|
||
:notEmpty => [],
|
||
:list => ["on", "off"]
|
||
},
|
||
"time" => {
|
||
:isNumeric => [1, 5999]
|
||
}
|
||
}
|
||
|
||
@@validates["if_sw"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"flag" => {
|
||
:list => ["on", "off"]
|
||
}
|
||
}
|
||
|
||
@@validates["if_var"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[-+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[-+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
},
|
||
"op" => {
|
||
:list => ["eq", "ge", "le", "gt", "lt", "ne"]
|
||
}
|
||
}
|
||
|
||
@@validates["if_self_sw"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:list => ["A", "B", "C", "D"]
|
||
},
|
||
"flag" => {
|
||
:list => ["on", "off"]
|
||
}
|
||
}
|
||
|
||
@@validates["if_timer"] = {
|
||
"time" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, 5999]
|
||
},
|
||
"op" => {
|
||
:list => ["ge", "le"]
|
||
}
|
||
}
|
||
|
||
@@validates["if_actor"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"type" => {
|
||
:list => ["party", "name", "class", "skill", "weapon",
|
||
"armor", "state"]
|
||
}
|
||
}
|
||
|
||
@@validates["if_enemy"] = {
|
||
"enemy" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, nil]
|
||
},
|
||
"type" => {
|
||
:list => ["visible", "state"]
|
||
},
|
||
"value" => {
|
||
:isNumeric => [1, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["if_character"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-1, nil]
|
||
},
|
||
"direction"=> {
|
||
:notEmpty => [],
|
||
:list => ["2", "4", "6", "8",
|
||
"left", "right", "up", "down"]
|
||
}
|
||
}
|
||
|
||
@@validates["if_vehicle"] = {
|
||
"vehicle" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, 2]
|
||
}
|
||
}
|
||
|
||
@@validates["if_money"] = {
|
||
"money" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, nil]
|
||
},
|
||
"op" => {
|
||
:list => ["ge", "le", "lt"]
|
||
}
|
||
}
|
||
|
||
@@validates["if_item"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["if_weapon"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"equip" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["if_armor"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"equip" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["if_button"] = {
|
||
"button" => {
|
||
:notEmpty => [],
|
||
:list => ["2", "4", "6", "8",
|
||
"11", "12", "13", "14", "15", "16", "17", "18",
|
||
"down", "left", "right",
|
||
"up", "A", "B", "C", "X", "Y", "Z", "L", "R"]
|
||
}
|
||
}
|
||
|
||
@@validates["if_script"] = {
|
||
"script" => {
|
||
:notEmpty => []
|
||
}
|
||
}
|
||
|
||
@@validates["common"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["label"] = {
|
||
"value" => {
|
||
:notEmpty => []
|
||
}
|
||
}
|
||
|
||
@@validates["label_jump"] = {
|
||
"value" => {
|
||
:notEmpty => []
|
||
}
|
||
}
|
||
|
||
@@validates["comment"] = {
|
||
"value" => {
|
||
:notEmpty => []
|
||
}
|
||
}
|
||
|
||
@@validates["comment2"] = {
|
||
"value" => {
|
||
:notEmpty => []
|
||
}
|
||
}
|
||
|
||
@@validates["money"] = {
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[-+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[-+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
}
|
||
}
|
||
|
||
@@validates["item"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[-+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[-+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
}
|
||
}
|
||
|
||
@@validates["weapon"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[-+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[-+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
},
|
||
"equip" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["armor"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[-+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[-+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
},
|
||
"equip" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["member"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [],
|
||
:varCheck => [/^[-+]{0,1}(\d+)$/, 0, 1]
|
||
},
|
||
"init" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["hp"] = {
|
||
"actor" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[-+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[-+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
},
|
||
"death" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["mp"] = {
|
||
"actor" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[-+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[-+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
}
|
||
}
|
||
|
||
@@validates["state"] = {
|
||
"actor" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [nil, nil],
|
||
:zeroCheck => []
|
||
}
|
||
}
|
||
|
||
@@validates["all_recovery"] = {
|
||
"actor" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
}
|
||
}
|
||
|
||
@@validates["exp"] = {
|
||
"actor" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[-+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[-+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
},
|
||
"message" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["level"] = {
|
||
"actor" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[-+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[-+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
},
|
||
"message" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["capability"] = {
|
||
"actor" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
},
|
||
"capability" => {
|
||
:notEmpty => [],
|
||
:list => ["0", "1", "2", "3", "4", "5", "6", "7",
|
||
"maxhp", "maxmp", "atk", "def", "matk", "mdef", "agi",
|
||
"luk" ]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[-+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[-+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
}
|
||
}
|
||
|
||
@@validates["skill"] = {
|
||
"actor" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [nil, nil],
|
||
:zeroCheck => []
|
||
}
|
||
}
|
||
|
||
@@validates["equip"] = {
|
||
"actor" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"part" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, 4],
|
||
},
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, nil],
|
||
}
|
||
}
|
||
|
||
@@validates["name"] = {
|
||
"actor" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"value" => {
|
||
:notEmpty => []
|
||
}
|
||
}
|
||
|
||
@@validates["class"] = {
|
||
"actor" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["nickname"] = {
|
||
"actor" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"value" => {
|
||
:notEmpty => []
|
||
}
|
||
}
|
||
|
||
@@validates["map_move"] = {
|
||
"type" => {
|
||
:list => ["const", "var"]
|
||
},
|
||
"map" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"x" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, nil],
|
||
:varCheck2 => ["type"]
|
||
},
|
||
"y" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, nil],
|
||
:varCheck2 => ["type"]
|
||
},
|
||
"direction"=> {
|
||
:list => ["0", "2", "4", "6", "8",
|
||
"left", "right", "up", "down"]
|
||
},
|
||
"fade" => {
|
||
:list => ["0", "1", "2", "black", "white", "none"]
|
||
}
|
||
}
|
||
|
||
@@validates["vehicle_pos"] = {
|
||
"vehicle" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, 2]
|
||
},
|
||
"type" => {
|
||
:list => ["const", "var"]
|
||
},
|
||
"map" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"x" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, nil],
|
||
:varCheck2 => ["type"]
|
||
},
|
||
"y" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, nil],
|
||
:varCheck2 => ["type"]
|
||
}
|
||
}
|
||
|
||
@@validates["event_pos"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-1, nil]
|
||
},
|
||
"type" => {
|
||
:list => ["const", "var", "target"]
|
||
},
|
||
"x" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, nil],
|
||
:varCheck2 => ["type"],
|
||
},
|
||
"y" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, nil],
|
||
:varCheck2 => ["type"]
|
||
},
|
||
"direction"=> {
|
||
:list => ["0", "2", "4", "6", "8",
|
||
"left", "right", "up", "down"]
|
||
}
|
||
}
|
||
|
||
@@validates["scroll_map"] = {
|
||
"direction"=> {
|
||
:notEmpty => [],
|
||
:list => ["2", "4", "6", "8",
|
||
"left", "right", "up", "down"]
|
||
},
|
||
"num" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, 100]
|
||
},
|
||
"speed" => {
|
||
:isNumeric => [1, 6]
|
||
}
|
||
}
|
||
|
||
@@validates["route_h"] = {
|
||
"event" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-1, nil]
|
||
},
|
||
"repeat" => {
|
||
:isBool => []
|
||
},
|
||
"skip" => {
|
||
:isBool => []
|
||
},
|
||
"wait" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["transparent"] = {
|
||
"flag" => {
|
||
:notEmpty => [],
|
||
:list => ["on", "off"]
|
||
}
|
||
}
|
||
|
||
@@validates["followers"] = {
|
||
"flag" => {
|
||
:notEmpty => [],
|
||
:list => ["on", "off"]
|
||
}
|
||
}
|
||
|
||
@@validates["anime"] = {
|
||
"target" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-1, nil]
|
||
},
|
||
"anime" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"wait" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["balloon"] = {
|
||
"target" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-1, nil]
|
||
},
|
||
"balloon" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"wait" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["tone"] = {
|
||
"red" => {
|
||
:isNumeric => [-255, 255]
|
||
},
|
||
"green" => {
|
||
:isNumeric => [-255, 255]
|
||
},
|
||
"blue" => {
|
||
:isNumeric => [-255, 255]
|
||
},
|
||
"gray" => {
|
||
:isNumeric => [0, 255]
|
||
},
|
||
"time" => {
|
||
:isNumeric => [1, 600]
|
||
},
|
||
"wait" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["flash"] = {
|
||
"red" => {
|
||
:isNumeric => [0, 255]
|
||
},
|
||
"green" => {
|
||
:isNumeric => [0, 255]
|
||
},
|
||
"blue" => {
|
||
:isNumeric => [0, 255]
|
||
},
|
||
"strength"=> {
|
||
:isNumeric => [0, 255]
|
||
},
|
||
"time" => {
|
||
:isNumeric => [1, 600]
|
||
},
|
||
"wait" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["shake"] = {
|
||
"strength"=> {
|
||
:isNumeric => [1, 9]
|
||
},
|
||
"speed" => {
|
||
:isNumeric => [1, 9]
|
||
},
|
||
"time" => {
|
||
:isNumeric => [1, 600]
|
||
},
|
||
"wait" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["wait"] = {
|
||
"time" => {
|
||
:isNumeric => [1, 999]
|
||
}
|
||
}
|
||
|
||
@@validates["picture"] = {
|
||
"layer" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, 100]
|
||
},
|
||
"file" => {
|
||
:notEmpty => []
|
||
},
|
||
"origin" => {
|
||
:list => ["ul", "center"]
|
||
},
|
||
"type" => {
|
||
:list => ["const", "var"]
|
||
},
|
||
"x" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-9999, 9999],
|
||
:varCheck2 => ["type"]
|
||
},
|
||
"y" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-9999, 9999],
|
||
:varCheck2 => ["type"]
|
||
},
|
||
"zoom_x" => {
|
||
:isNumeric => [0, 2000]
|
||
},
|
||
"zoom_y" => {
|
||
:isNumeric => [0, 2000]
|
||
},
|
||
"transparent"=> {
|
||
:isNumeric => [0, 255]
|
||
},
|
||
"blend" => {
|
||
:isNumeric => [0, 2]
|
||
}
|
||
}
|
||
|
||
@@validates["picture_move"] = {
|
||
"layer" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, 100]
|
||
},
|
||
"origin" => {
|
||
:list => ["ul", "center"]
|
||
},
|
||
"type" => {
|
||
:list => ["const", "var"]
|
||
},
|
||
"x" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-9999, 9999],
|
||
:varCheck2 => ["type"]
|
||
},
|
||
"y" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-9999, 9999],
|
||
:varCheck2 => ["type"]
|
||
},
|
||
"zoom_x" => {
|
||
:isNumeric => [0, 2000]
|
||
},
|
||
"zoom_y" => {
|
||
:isNumeric => [0, 2000]
|
||
},
|
||
"transparent"=> {
|
||
:isNumeric => [0, 255]
|
||
},
|
||
"blend" => {
|
||
:isNumeric => [0, 2]
|
||
},
|
||
"time" => {
|
||
:isNumeric => [1, 600]
|
||
},
|
||
"wait" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["picture_rotation"] = {
|
||
"layer" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, 100]
|
||
},
|
||
"speed" => {
|
||
:isNumeric => [-90, 90]
|
||
}
|
||
}
|
||
|
||
@@validates["picture_tone"] = {
|
||
"layer" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, 100]
|
||
},
|
||
"red" => {
|
||
:isNumeric => [-255, 255]
|
||
},
|
||
"green" => {
|
||
:isNumeric => [-255, 255]
|
||
},
|
||
"blue" => {
|
||
:isNumeric => [-255, 255]
|
||
},
|
||
"gray" => {
|
||
:isNumeric => [0, 255]
|
||
},
|
||
"time" => {
|
||
:isNumeric => [0, 600]
|
||
},
|
||
"wait" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["picture_erace"] = {
|
||
"layer" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, 100]
|
||
}
|
||
}
|
||
|
||
@@validates["weather"] = {
|
||
"weather" => {
|
||
:list => ["none", "rain", "storm", "snow"]
|
||
},
|
||
"strength"=> {
|
||
:isNumeric => [1, 9]
|
||
},
|
||
"time" => {
|
||
:isNumeric => [0, 600]
|
||
},
|
||
"wait" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["bgm"] = {
|
||
"volume" => {
|
||
:isNumeric => [0, 100]
|
||
},
|
||
"pitch" => {
|
||
:isNumeric => [50, 150]
|
||
}
|
||
}
|
||
|
||
@@validates["fadeout_bgm"] = {
|
||
"time" => {
|
||
:isNumeric => [1, 60]
|
||
}
|
||
}
|
||
|
||
@@validates["bgs"] = {
|
||
"volume" => {
|
||
:isNumeric => [0, 100]
|
||
},
|
||
"pitch" => {
|
||
:isNumeric => [50, 150]
|
||
}
|
||
}
|
||
|
||
@@validates["fadeout_bgs"] = {
|
||
"time" => {
|
||
:isNumeric => [1, 60]
|
||
}
|
||
}
|
||
|
||
@@validates["me"] = {
|
||
"volume" => {
|
||
:isNumeric => [0, 100]
|
||
},
|
||
"pitch" => {
|
||
:isNumeric => [50, 150]
|
||
}
|
||
}
|
||
|
||
@@validates["se"] = {
|
||
"volume" => {
|
||
:isNumeric => [0, 100]
|
||
},
|
||
"pitch" => {
|
||
:isNumeric => [50, 150]
|
||
}
|
||
}
|
||
|
||
@@validates["battle"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^(var\.){0,1}\d+$/],
|
||
:varCheck => [/^(var\.){0,1}(\d+)$/, 1, 2]
|
||
},
|
||
"can_escape" => {
|
||
:isBool => []
|
||
},
|
||
"loss_continue"=> {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["shop"] = {
|
||
"type" => {
|
||
:notEmpty => [],
|
||
:list => ["0", "1", "2", "item", "weapon", "armor"],
|
||
},
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"price" => {
|
||
:list => ["db", "value"]
|
||
},
|
||
"value" => {
|
||
:isNumeric => [0, 9999999]
|
||
},
|
||
"buy_only"=> {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["input_name"] = {
|
||
"actor" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"number" => {
|
||
:isNumeric => [1, 16]
|
||
}
|
||
}
|
||
|
||
@@validates["battle_bgm"] = {
|
||
"volume" => {
|
||
:isNumeric => [0, 100]
|
||
},
|
||
"pitch" => {
|
||
:isNumeric => [50, 150]
|
||
}
|
||
}
|
||
|
||
@@validates["battle_end_me"] = {
|
||
"volume" => {
|
||
:isNumeric => [0, 100]
|
||
},
|
||
"pitch" => {
|
||
:isNumeric => [50, 150]
|
||
}
|
||
}
|
||
|
||
@@validates["save_disable"] = {
|
||
"flag" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["menu_disable"] = {
|
||
"flag" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["encount_disable"] = {
|
||
"flag" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["formation_disable"] = {
|
||
"flag" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["window_color"] = {
|
||
"red" => {
|
||
:isNumeric => [-255, 255]
|
||
},
|
||
"green" => {
|
||
:isNumeric => [-255, 255]
|
||
},
|
||
"blue" => {
|
||
:isNumeric => [-255, 255]
|
||
}
|
||
}
|
||
|
||
@@validates["actor_graphic"] = {
|
||
"actor" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"walk_index"=> {
|
||
:isNumeric => [0, 7]
|
||
},
|
||
"face_index"=> {
|
||
:isNumeric => [0, 7]
|
||
}
|
||
}
|
||
|
||
@@validates["vehicle_graphic"] = {
|
||
"vehicle" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, 2]
|
||
},
|
||
"index" => {
|
||
:isNumeric => [0, 7]
|
||
}
|
||
}
|
||
|
||
@@validates["movie"] = {
|
||
"file" => {
|
||
:notEmpty => []
|
||
}
|
||
}
|
||
|
||
@@validates["map_name_disable"] = {
|
||
"flag" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["tileset"] = {
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["parallax"] = {
|
||
"loop_x" => {
|
||
:isBool => []
|
||
},
|
||
"scroll_x"=> {
|
||
:isNumeric => [-32, 32]
|
||
},
|
||
"loop_y" => {
|
||
:isBool => []
|
||
},
|
||
"scroll_y"=> {
|
||
:isNumeric => [-32, 32]
|
||
}
|
||
}
|
||
|
||
@@validates["pos_info"] = {
|
||
"var" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"type" => {
|
||
:isNumeric => [0, 5]
|
||
},
|
||
"pos" => {
|
||
:list => ["const", "var"]
|
||
},
|
||
"x" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, nil],
|
||
:varCheck2 => ["pos"]
|
||
},
|
||
"y" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [0, nil],
|
||
:varCheck2 => ["pos"]
|
||
}
|
||
}
|
||
|
||
@@validates["enemy_hp"] = {
|
||
"enemy" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-1, nil]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[-+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[-+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
},
|
||
"death" => {
|
||
:isBool => []
|
||
}
|
||
}
|
||
|
||
@@validates["enemy_mp"] = {
|
||
"enemy" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-1, nil]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:regCheck => [/^[-+]{0,1}(var\.){0,1}\d+$/],
|
||
:varCheck => [/^[-+]{0,1}(var\.){0,1}(\d+)$/, 1, 2]
|
||
}
|
||
}
|
||
|
||
@@validates["enemy_state"] = {
|
||
"enemy" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-1, nil]
|
||
},
|
||
"value" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [nil, nil],
|
||
:zeroCheck => []
|
||
}
|
||
}
|
||
|
||
@@validates["enemy_all_recovery"] = {
|
||
"enemy" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-1, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["enemy_appear"] = {
|
||
"enemy" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-1, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["enemy_trans"] = {
|
||
"enemy" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-1, nil]
|
||
},
|
||
"trans" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["battle_anime"] = {
|
||
"enemy" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-1, nil]
|
||
},
|
||
"anime" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["force"] = {
|
||
"battler" => {
|
||
:notEmpty => [],
|
||
:list => ["actor", "enemy"],
|
||
},
|
||
"id" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-1, nil]
|
||
},
|
||
"skill" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [1, nil]
|
||
},
|
||
"target" => {
|
||
:notEmpty => [],
|
||
:isNumeric => [-2, nil]
|
||
}
|
||
}
|
||
|
||
@@validates["script"] = {
|
||
"value" => {
|
||
:notEmpty => []
|
||
}
|
||
}
|
||
|
||
@@validates["script2"] = {
|
||
"value" => {
|
||
:notEmpty => []
|
||
}
|
||
}
|
||
end
|
||
|
||
class Tes_Splitter
|
||
#----------------------------------------------------------------------------
|
||
# ◆ コマンド分割用メソッド仕様
|
||
# メソッド名 split_タグ名
|
||
# 返り値 なし
|
||
#----------------------------------------------------------------------------
|
||
#--------------------------------------------------------------------------
|
||
# ○ 分割処理 ：選択肢の表示（ヘッダ）
|
||
#--------------------------------------------------------------------------
|
||
def split_choice_h
|
||
text = get_line
|
||
labels = []
|
||
temp = {}
|
||
if args = text["choice_h".size + 1, 9999].strip
|
||
args.gsub!(/\s*=\s*/) { "<=>" }
|
||
args.split(/\s+/).each do |arg|
|
||
key, param = arg.split("<=>", 2)
|
||
if key.downcase == "label"
|
||
labels << param
|
||
elsif key.downcase == "cancel"
|
||
temp["cancel"] = param
|
||
end
|
||
end
|
||
end
|
||
temp["labels"] = labels
|
||
@data << ["choice_h", temp, line_number]
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 分割処理 ：選択肢の表示（分岐部）
|
||
#--------------------------------------------------------------------------
|
||
def split_choice_if
|
||
if @data.empty? or (@data[-1][0] != "choice_h" and @data[-1][0] != "end")
|
||
raise(TesSyntaxError,
|
||
"選択肢分岐前にヘッダまたは終端タグがありません。")
|
||
end
|
||
split_normal
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 分割処理 ：選択肢の表示（キャンセル部）
|
||
#--------------------------------------------------------------------------
|
||
def split_choice_cancel
|
||
if @data.empty? or (@data[-1][0] != "choice_h" and @data[-1][0] != "end")
|
||
raise(TesSyntaxError,
|
||
"選択肢分岐前にヘッダまたは終端タグがありません。")
|
||
end
|
||
split_normal
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 分割処理 ：文章スクロールの表示
|
||
#--------------------------------------------------------------------------
|
||
def split_scroll_h
|
||
split_normal # ヘッダを一般処理
|
||
|
||
# 文章本体格納
|
||
messages = []
|
||
until eoc?
|
||
break unless next_message? # メッセージ行以外が来るまで格納
|
||
@index += 1
|
||
messages << ["scroll", {"value" => get_line}, line_number]
|
||
end
|
||
if messages.size == 0
|
||
raise(TesSyntaxError, "文章スクロールの中身がありません。")
|
||
end
|
||
@data += messages
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（一般）
|
||
#--------------------------------------------------------------------------
|
||
def split_var
|
||
@lines[@index][0].gsub!(/=\s*=/) { "=eq" }
|
||
split_normal
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（ランダム）
|
||
#--------------------------------------------------------------------------
|
||
def split_var_random
|
||
split_var
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（アイテム）
|
||
#--------------------------------------------------------------------------
|
||
def split_var_item
|
||
split_var
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（武器）
|
||
#--------------------------------------------------------------------------
|
||
def split_var_weapon
|
||
split_var
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（防具）
|
||
#--------------------------------------------------------------------------
|
||
def split_var_armor
|
||
split_var
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（アクター）
|
||
#--------------------------------------------------------------------------
|
||
def split_var_actor
|
||
split_var
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（敵キャラ）
|
||
#--------------------------------------------------------------------------
|
||
def split_var_enemy
|
||
split_var
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（キャラクター）
|
||
#--------------------------------------------------------------------------
|
||
def split_var_character
|
||
split_var
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（パーティ）
|
||
#--------------------------------------------------------------------------
|
||
def split_var_party
|
||
split_var
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（スクリプト）
|
||
#--------------------------------------------------------------------------
|
||
def split_var_script
|
||
split_var
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（その他）
|
||
#--------------------------------------------------------------------------
|
||
def split_var_other
|
||
split_var
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（変数）
|
||
#--------------------------------------------------------------------------
|
||
def split_if_var
|
||
@lines[@index][0].gsub!(/=\s*<>|=\s*></) { "=ne" } # 不等号
|
||
@lines[@index][0].gsub!(/=\s*>=|=\s*=>/) { "=ge" } # 以上
|
||
@lines[@index][0].gsub!(/=\s*<=|=\s*=</) { "=le" } # 以下
|
||
@lines[@index][0].gsub!(/=\s*>/) { "=gt" } # 超
|
||
@lines[@index][0].gsub!(/=\s*</) { "=lt" } # 未満
|
||
@lines[@index][0].gsub!(/=\s*=/) { "=eq" } # 等号
|
||
split_normal
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（タイマー）
|
||
#--------------------------------------------------------------------------
|
||
def split_if_timer
|
||
split_if_var
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（お金）
|
||
#--------------------------------------------------------------------------
|
||
def split_if_money
|
||
split_if_var
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 分割処理 ：注釈の開始
|
||
#--------------------------------------------------------------------------
|
||
def split_comment
|
||
comments = []
|
||
@index += 1
|
||
until eoc?
|
||
break if get_command_name(get_line) == "comment_end"
|
||
comments << ["comment2", {"value" => get_line}, line_number]
|
||
@index += 1
|
||
end
|
||
if eoc?
|
||
raise(TesSyntaxError, "コメントタグが閉じられていません。")
|
||
end
|
||
unless comments.empty?
|
||
comments[0][0] = "comment" # 先頭のタグ名修正
|
||
@data += comments
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 分割処理 ：注釈の終了
|
||
#--------------------------------------------------------------------------
|
||
def split_comment_end
|
||
raise(TesSyntaxError, "コメントタグが開始されていません。")
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 分割処理 ：移動ルーツの設定（ヘッダ）
|
||
#--------------------------------------------------------------------------
|
||
def split_route_h
|
||
split_normal # ヘッダはそのまま一般処理
|
||
|
||
# 移動ルート格納
|
||
route_number = 0
|
||
until eoc?
|
||
break if get_command_name(get_next_line) != "route"
|
||
@index += 1
|
||
route_number += 1
|
||
split_normal # 一般タグの分割処理
|
||
end
|
||
if route_number == 0
|
||
raise(TesSyntaxError, "移動ルートが設定されていません。")
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 分割処理 ：移動ルート
|
||
#--------------------------------------------------------------------------
|
||
def split_route
|
||
raise(TesSyntaxError, "移動ルートのヘッダがありません。")
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 分割処理 ：バトルの処理（勝った場合）
|
||
#--------------------------------------------------------------------------
|
||
def split_battle_win
|
||
if @data.empty? or (@data[-1][0] != "battle" and @data[-1][0] != "end")
|
||
raise(TesSyntaxError,
|
||
"戦闘分岐前にヘッダまたは終端タグがありません。")
|
||
end
|
||
split_normal
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 分割処理 ：バトルの処理（逃げた場合）
|
||
#--------------------------------------------------------------------------
|
||
def split_battle_escape
|
||
split_battle_win
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 分割処理 ：バトルの処理（負けた場合）
|
||
#--------------------------------------------------------------------------
|
||
def split_battle_loss
|
||
split_battle_win
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 分割処理 ：スクリプトの開始
|
||
#--------------------------------------------------------------------------
|
||
def split_script
|
||
scripts = []
|
||
@index += 1
|
||
until eoc?
|
||
break if get_command_name(get_line) == "script_end"
|
||
scripts << ["script2", {"value" => get_line}, line_number]
|
||
@index += 1
|
||
end
|
||
if eoc?
|
||
raise(TesSyntaxError, "スクリプトタグが閉じられていません。")
|
||
end
|
||
unless scripts.empty?
|
||
scripts[0][0] = "script" # 先頭のタグ名修正
|
||
@data += scripts
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 分割処理 ：スクリプトの終了
|
||
#--------------------------------------------------------------------------
|
||
def split_script_end
|
||
raise(TesSyntaxError, "スクリプトタグが開始されていません。")
|
||
end
|
||
end
|
||
|
||
class Tes_Validator
|
||
#----------------------------------------------------------------------------
|
||
# ◆ 検証用メソッド仕様
|
||
# 共通メソッド名 validate_検証名
|
||
# 共通引数 vargs 検証に必要な指示リスト
|
||
# param_name 検証中の引数名
|
||
# params TESコマンドの引数リスト
|
||
# 検証結果に異常がある場合は例外を投げてください。
|
||
#----------------------------------------------------------------------------
|
||
#--------------------------------------------------------------------------
|
||
# ○ 必須要素
|
||
#--------------------------------------------------------------------------
|
||
def validate_notEmpty(vargs, param_name, params)
|
||
if !params[param_name] or params[param_name].empty?
|
||
raise(TesValidateError,
|
||
"[#{param_name}] : 必須引数が省略されています。")
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 真偽値チェック
|
||
#--------------------------------------------------------------------------
|
||
def validate_isBool(vargs, param_name, params)
|
||
return unless params[param_name]
|
||
unless params[param_name] =~ /^(true|false)$/i
|
||
raise(TesValidateError,
|
||
"[#{param_name}] : true/false 以外が代入されました。")
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 数値チェック
|
||
# vargs[0] : 最小値（nilで無効）
|
||
# vargs[1] : 最大値（nilで無効）
|
||
#--------------------------------------------------------------------------
|
||
def validate_isNumeric(vargs, param_name, params)
|
||
return unless params[param_name]
|
||
unless params[param_name] =~ /^[-+0-9]\d*$/
|
||
raise(TesValidateError,
|
||
"[#{param_name}] : 数値以外が代入されました。")
|
||
end
|
||
|
||
# 最小値判定
|
||
if min = vargs[0]
|
||
min = params[min.id2name] if min.is_a?(Symbol)
|
||
min = eval(min) if min.is_a?(String)
|
||
min = min.to_i
|
||
if params[param_name].to_i < min
|
||
raise(TesValidateError,
|
||
"[#{param_name}] : 最小値より小さい値が使われています。")
|
||
end
|
||
end
|
||
|
||
# 最大値判定
|
||
if max = vargs[1]
|
||
max = params[max.id2name] if max.is_a?(Symbol)
|
||
max = eval(max) if max.is_a?(String)
|
||
max = max.to_i
|
||
if params[param_name].to_i > max
|
||
raise(TesValidateError,
|
||
"[#{param_name}] : 最大値より大きい値が使われています。")
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ リスト
|
||
# vargs : 許可された値のリスト（例：["A", "B", "C", "D"]）
|
||
#--------------------------------------------------------------------------
|
||
def validate_list(vargs, param_name, params)
|
||
return unless params[param_name]
|
||
unless vargs.include?(params[param_name])
|
||
raise(TesValidateError,
|
||
"[#{param_name}] : 許可されていない値が使われました。")
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ０以外のチェック
|
||
#--------------------------------------------------------------------------
|
||
def validate_zeroCheck(vargs, param_name, params)
|
||
return unless params[param_name]
|
||
if params[param_name].to_i == 0
|
||
raise(TesValidateError,
|
||
"[#{param_name}] : 「0」が使われました。")
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 正規表現でチェック
|
||
# vargs[0] : 正規表現
|
||
#--------------------------------------------------------------------------
|
||
def validate_regCheck(vargs, param_name, params)
|
||
return unless params[param_name]
|
||
unless params[param_name] =~ vargs[0]
|
||
raise(TesValidateError,
|
||
"[#{param_name}] : 正規表現にマッチしませんでした。")
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の値チェック
|
||
# vargs[0] : 正規表現
|
||
# vargs[1] : 変数判断位置
|
||
# vargs[2] : 変数ＩＤの位置
|
||
#--------------------------------------------------------------------------
|
||
def validate_varCheck(vargs, param_name, params)
|
||
return unless params[param_name]
|
||
params[param_name] =~ vargs[0]
|
||
return unless Regexp.last_match(vargs[1]) # 変数指定ではない
|
||
if Regexp.last_match(vargs[2]).to_i == 0
|
||
raise(TesValidateError,
|
||
"[#{param_name}] : 「0」が使われました。")
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の値チェック２
|
||
# 引数 0: 数値/変数を指定している引数名
|
||
#--------------------------------------------------------------------------
|
||
def validate_varCheck2(vargs, param_name, params)
|
||
return unless params[param_name]
|
||
return if params[vargs[0]] != "var" # 変数指定ではない
|
||
if params[param_name].to_i == 0
|
||
raise(TesValidateError,
|
||
"[#{param_name}] : 「0」が使われました。")
|
||
end
|
||
end
|
||
end
|
||
|
||
class Tes_Converter
|
||
#----------------------------------------------------------------------------
|
||
# ◆ 変換用メソッド仕様
|
||
# メソッド名 convert_タグ名
|
||
# 引数 args タグに渡された引数のリスト
|
||
# 返り値 PRG::EventCommandのオブジェクト
|
||
#----------------------------------------------------------------------------
|
||
|
||
#****************************************************************************
|
||
# メッセージ系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ 文章の表示（ヘッダー部）
|
||
#--------------------------------------------------------------------------
|
||
def convert_message_h(args)
|
||
file = (args["actor"] || "")
|
||
index = (args["index"] || 0).to_i
|
||
back = (args["back"] || 0).to_i
|
||
pos = (args["pos"] || 2).to_i
|
||
return RPG::EventCommand.new(101, @indent, [file, index, back, pos])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 文章の表示（文字部）
|
||
#--------------------------------------------------------------------------
|
||
def convert_message(args)
|
||
return RPG::EventCommand.new(401, @indent,
|
||
[args["value"].gsub(/^_/) { "" }])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 選択肢の表示（ヘッダー部）
|
||
#--------------------------------------------------------------------------
|
||
def convert_choice_h(args)
|
||
texts = args["labels"]
|
||
if texts.size == 0
|
||
raise(TesConvertError, "ラベルが１つも指示されていません。")
|
||
end
|
||
flag = (args["cancel"] || texts.size).to_i
|
||
return RPG::EventCommand.new(102, @indent, [texts, flag])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 選択肢の表示（分岐部）
|
||
#--------------------------------------------------------------------------
|
||
def convert_choice_if(args)
|
||
@indent += 1
|
||
return RPG::EventCommand.new(402, @indent - 1, [args["index"].to_i - 1])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 選択肢の表示（キャンセル時）
|
||
#--------------------------------------------------------------------------
|
||
def convert_choice_cancel(args)
|
||
@indent += 1
|
||
return RPG::EventCommand.new(403, @indent - 1, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 選択肢の表示（選択肢の終了）
|
||
#--------------------------------------------------------------------------
|
||
def convert_choice_end(args)
|
||
return RPG::EventCommand.new(404, @indent, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 数値入力の処理
|
||
#--------------------------------------------------------------------------
|
||
def convert_input_num(args)
|
||
return RPG::EventCommand.new(103, @indent,
|
||
[args["var"].to_i, args["num"].to_i])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ アイテム選択の処理
|
||
#--------------------------------------------------------------------------
|
||
def convert_choice_item(args)
|
||
return RPG::EventCommand.new(104, @indent, [args["var"].to_i])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 文章スクロール表示（ヘッダー部）
|
||
#--------------------------------------------------------------------------
|
||
def convert_scroll_h(args)
|
||
@scroll = true
|
||
flag = (args["noskip"] || "false") == "true" ? true : false
|
||
return RPG::EventCommand.new(105, @indent, [args["speed"].to_i, flag])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 文章スクロール表示（文章部）
|
||
#--------------------------------------------------------------------------
|
||
def convert_scroll(args)
|
||
return RPG::EventCommand.new(405, @indent,
|
||
[args["value"].gsub(/^_/) { "" }])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 文章スクロール表示（終了部）
|
||
#--------------------------------------------------------------------------
|
||
def convert_scroll_end(args)
|
||
@scroll = false
|
||
return nil
|
||
end
|
||
|
||
#****************************************************************************
|
||
# ゲーム進行系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ スイッチの操作
|
||
#--------------------------------------------------------------------------
|
||
def convert_sw(args)
|
||
s_num = args["id"].to_i
|
||
e_num = (args["end"] || s_num).to_i
|
||
flag = args["flag"] == "on" ? 0 : 1
|
||
return RPG::EventCommand.new(121, @indent, [s_num, e_num, flag])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 演算子の取得
|
||
#--------------------------------------------------------------------------
|
||
def get_operator(op)
|
||
case op
|
||
when "eq"
|
||
op = 0
|
||
when "+"
|
||
op = 1
|
||
when "-"
|
||
op = 2
|
||
when "*"
|
||
op = 3
|
||
when "/"
|
||
op = 4
|
||
when "%"
|
||
op = 5
|
||
else
|
||
op = 0
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（一般）
|
||
#--------------------------------------------------------------------------
|
||
def convert_var(args)
|
||
s_num = args["id"].to_i
|
||
e_num = (args["end"] || s_num).to_i
|
||
op = get_operator(args["op"])
|
||
value = args["value"]
|
||
type = value.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
if type == 1 and value.to_i <= 0
|
||
raise(TesConvertError, "変数指定時に「0」以下が使われました。")
|
||
end
|
||
return RPG::EventCommand.new(122, @indent,
|
||
[s_num, e_num, op, type, value.to_i])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（ランダム）
|
||
#--------------------------------------------------------------------------
|
||
def convert_var_random(args)
|
||
s_num = args["id"].to_i
|
||
e_num = (args["end"] || s_num).to_i
|
||
op = get_operator(args["op"])
|
||
min = args["min"].to_i
|
||
max = args["max"].to_i
|
||
return RPG::EventCommand.new(122, @indent,
|
||
[s_num, e_num, op, 2, min, max])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（アイテム）
|
||
#--------------------------------------------------------------------------
|
||
def convert_var_item(args)
|
||
s_num = args["id"].to_i
|
||
e_num = (args["end"] || s_num).to_i
|
||
op = get_operator(args["op"])
|
||
value = args["value"].to_i
|
||
return RPG::EventCommand.new(122, @indent,
|
||
[s_num, e_num, op, 3, 0, value, 0])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（武器）
|
||
#--------------------------------------------------------------------------
|
||
def convert_var_weapon(args)
|
||
s_num = args["id"].to_i
|
||
e_num = (args["end"] || s_num).to_i
|
||
op = get_operator(args["op"])
|
||
value = args["value"].to_i
|
||
return RPG::EventCommand.new(122, @indent,
|
||
[s_num, e_num, op, 3, 1, value, 0])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（防具）
|
||
#--------------------------------------------------------------------------
|
||
def convert_var_armor(args)
|
||
s_num = args["id"].to_i
|
||
e_num = (args["end"] || s_num).to_i
|
||
op = get_operator(args["op"])
|
||
value = args["value"].to_i
|
||
return RPG::EventCommand.new(122, @indent,
|
||
[s_num, e_num, op, 3, 2, value, 0])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（アクター）
|
||
#--------------------------------------------------------------------------
|
||
def convert_var_actor(args)
|
||
s_num = args["id"].to_i
|
||
e_num = (args["end"] || s_num).to_i
|
||
op = get_operator(args["op"])
|
||
actor = args["actor"].to_i
|
||
case args["data"]
|
||
when "0", "level"
|
||
data = 0
|
||
when "1", "exp"
|
||
data = 1
|
||
when "2", "hp"
|
||
data = 2
|
||
when "3", "mp"
|
||
data = 3
|
||
when "4", "maxhp"
|
||
data = 4
|
||
when "5", "maxmp"
|
||
data = 5
|
||
when "6", "atk"
|
||
data = 6
|
||
when "7", "def"
|
||
data = 7
|
||
when "8", "matk"
|
||
data = 8
|
||
when "9", "mdef"
|
||
data = 9
|
||
when "10", "agi"
|
||
data = 10
|
||
when "11", "luk"
|
||
data = 11
|
||
end
|
||
return RPG::EventCommand.new(122, @indent,
|
||
[s_num, e_num, op, 3, 3, actor, data])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（敵キャラ）
|
||
#--------------------------------------------------------------------------
|
||
def convert_var_enemy(args)
|
||
s_num = args["id"].to_i
|
||
e_num = (args["end"] || s_num).to_i
|
||
op = get_operator(args["op"])
|
||
enemy = args["enemy"].to_i
|
||
case args["data"]
|
||
when "0", "hp"
|
||
data = 0
|
||
when "1", "mp"
|
||
data = 1
|
||
when "2", "maxhp"
|
||
data = 2
|
||
when "3", "maxmp"
|
||
data = 3
|
||
when "4", "atk"
|
||
data = 4
|
||
when "5", "def"
|
||
data = 5
|
||
when "6", "matk"
|
||
data = 6
|
||
when "7", "mdef"
|
||
data = 7
|
||
when "8", "agi"
|
||
data = 8
|
||
when "9", "luk"
|
||
data = 9
|
||
end
|
||
return RPG::EventCommand.new(122, @indent,
|
||
[s_num, e_num, op, 3, 4, enemy, data])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（キャラクター）
|
||
#--------------------------------------------------------------------------
|
||
def convert_var_character(args)
|
||
s_num = args["id"].to_i
|
||
e_num = (args["end"] || s_num).to_i
|
||
op = get_operator(args["op"])
|
||
character = args["character"].to_i
|
||
case args["data"]
|
||
when "0", "mapx"
|
||
data = 0
|
||
when "1", "mapy"
|
||
data = 1
|
||
when "2", "direction"
|
||
data = 2
|
||
when "3", "screenx"
|
||
data = 3
|
||
when "4", "screeny"
|
||
data = 4
|
||
end
|
||
return RPG::EventCommand.new(122, @indent,
|
||
[s_num, e_num, op, 3, 5, character, data])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（パーティ）
|
||
#--------------------------------------------------------------------------
|
||
def convert_var_party(args)
|
||
s_num = args["id"].to_i
|
||
e_num = (args["end"] || s_num).to_i
|
||
op = get_operator(args["op"])
|
||
member = args["member"].to_i
|
||
return RPG::EventCommand.new(122, @indent,
|
||
[s_num, e_num, op, 3, 6, member, 0])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（その他）
|
||
#--------------------------------------------------------------------------
|
||
def convert_var_other(args)
|
||
s_num = args["id"].to_i
|
||
e_num = (args["end"] || s_num).to_i
|
||
op = get_operator(args["op"])
|
||
case args["data"]
|
||
when "0", "mapid"
|
||
data = 0
|
||
when "1", "members"
|
||
data = 1
|
||
when "2", "money"
|
||
data = 2
|
||
when "3", "steps"
|
||
data = 3
|
||
when "4", "playtime"
|
||
data = 4
|
||
when "5", "timer"
|
||
data = 5
|
||
when "6", "save_num"
|
||
data = 6
|
||
when "7", "battle_num"
|
||
data = 7
|
||
end
|
||
return RPG::EventCommand.new(122, @indent,
|
||
[s_num, e_num, op, 3, 7, data, 0])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 変数の操作（スクリプト）
|
||
#--------------------------------------------------------------------------
|
||
def convert_var_script(args)
|
||
s_num = args["id"].to_i
|
||
e_num = (args["end"] || s_num).to_i
|
||
op = get_operator(args["op"])
|
||
return RPG::EventCommand.new(122, @indent,
|
||
[s_num, e_num, op, 4, args["script"]])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ セルフスイッチの操作
|
||
#--------------------------------------------------------------------------
|
||
def convert_self_sw(args)
|
||
id = args["id"]
|
||
flag = args["flag"] == "on" ? 0 : 1
|
||
return RPG::EventCommand.new(123, @indent, [id, flag])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ タイマーの操作
|
||
#--------------------------------------------------------------------------
|
||
def convert_timer(args)
|
||
flag = args["flag"] == "on" ? 0 : 1
|
||
if flag == 0
|
||
unless args["time"]
|
||
raise(TesConvertError, "[time] : 必須引数が省略されています。")
|
||
end
|
||
time = args["time"].to_i
|
||
end
|
||
return RPG::EventCommand.new(124, @indent, [flag, time])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# フロー制御系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（スイッチ）
|
||
#--------------------------------------------------------------------------
|
||
def convert_if_sw(args)
|
||
@indent += 1
|
||
ifnum = 0
|
||
id = args["id"].to_i
|
||
flag = (args["flag"] || "on") == "on" ? 0 : 1
|
||
return RPG::EventCommand.new(111, @indent - 1, [ifnum, id, flag])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（変数）
|
||
#--------------------------------------------------------------------------
|
||
def convert_if_var(args)
|
||
@indent += 1
|
||
ifnum = 1
|
||
id = args["id"].to_i
|
||
value = args["value"]
|
||
type = value.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
op = ["eq", "ge", "le", "gt", "lt", "ne"].index(args["op"]) || 0
|
||
op = 0 unless op
|
||
if type == 1 and value.to_i <= 0
|
||
raise(TesConvertError, "変数指定時に「0」以下が使われました。")
|
||
end
|
||
return RPG::EventCommand.new(111, @indent - 1,
|
||
[ifnum, id, type, value.to_i, op])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（セルフスイッチ）
|
||
#--------------------------------------------------------------------------
|
||
def convert_if_self_sw(args)
|
||
@indent += 1
|
||
ifnum = 2
|
||
id = args["id"]
|
||
flag = (args["flag"] || "on") == "on" ? 0 : 1
|
||
return RPG::EventCommand.new(111, @indent - 1, [ifnum, id, flag])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（タイマー）
|
||
#--------------------------------------------------------------------------
|
||
def convert_if_timer(args)
|
||
@indent += 1
|
||
ifnum = 3
|
||
time = args["time"].to_i
|
||
op = ["ge", "le"].index(args["op"]) || 0
|
||
return RPG::EventCommand.new(111, @indent - 1, [ifnum, time, op])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（アクター）
|
||
#--------------------------------------------------------------------------
|
||
def convert_if_actor(args)
|
||
@indent += 1
|
||
ifnum = 4
|
||
id = args["id"].to_i
|
||
case args["type"]
|
||
when "party"
|
||
type = 0
|
||
value = 0
|
||
when "name"
|
||
type = 1
|
||
value = args["value"]
|
||
when "class"
|
||
type = 2
|
||
check_notEmpty(args, "value")
|
||
check_numeric(args, "value", 1, nil)
|
||
value = args["value"].to_i
|
||
when "skill"
|
||
type = 3
|
||
check_notEmpty(args, "value")
|
||
check_numeric(args, "value", 1, nil)
|
||
value = args["value"].to_i
|
||
when "weapon"
|
||
type = 4
|
||
check_notEmpty(args, "value")
|
||
check_numeric(args, "value", 1, nil)
|
||
value = args["value"].to_i
|
||
when "armor"
|
||
type = 5
|
||
check_notEmpty(args, "value")
|
||
check_numeric(args, "value", 1, nil)
|
||
value = args["value"].to_i
|
||
when "state"
|
||
type = 6
|
||
check_notEmpty(args, "value")
|
||
check_numeric(args, "value", 1, nil)
|
||
value = args["value"].to_i
|
||
else
|
||
type = 0
|
||
value = 0
|
||
end
|
||
return RPG::EventCommand.new(111, @indent - 1, [ifnum, id, type, value])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（敵キャラ）
|
||
#--------------------------------------------------------------------------
|
||
def convert_if_enemy(args)
|
||
@indent += 1
|
||
ifnum = 5
|
||
enemy = args["enemy"].to_i
|
||
case args["type"]
|
||
when "visible"
|
||
type = 0
|
||
value = 0
|
||
when "state"
|
||
type = 1
|
||
check_notEmpty(args, "value")
|
||
check_numeric(args, "value", 1, nil)
|
||
value = args["value"].to_i
|
||
else
|
||
type = 0
|
||
value = 0
|
||
end
|
||
return RPG::EventCommand.new(111, @indent - 1, [ifnum, enemy, type, value])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（キャラクター）
|
||
#--------------------------------------------------------------------------
|
||
def convert_if_character(args)
|
||
@indent += 1
|
||
ifnum = 6
|
||
id = args["id"].to_i
|
||
case args["direction"]
|
||
when "2", "down"
|
||
direction = 2
|
||
when "4", "left"
|
||
direction = 4
|
||
when "6", "right"
|
||
direction = 6
|
||
when "8", "up"
|
||
direction = 8
|
||
end
|
||
return RPG::EventCommand.new(111, @indent - 1, [ifnum, id, direction])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（乗り物）
|
||
#--------------------------------------------------------------------------
|
||
def convert_if_vehicle(args)
|
||
@indent += 1
|
||
ifnum = 13
|
||
vehicle = args["vehicle"].to_i
|
||
return RPG::EventCommand.new(111, @indent - 1, [ifnum, vehicle])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（お金）
|
||
#--------------------------------------------------------------------------
|
||
def convert_if_money(args)
|
||
@indent += 1
|
||
ifnum = 7
|
||
money = args["money"].to_i
|
||
op = ["ge", "le", "lt"].index(args["op"]) || 0
|
||
return RPG::EventCommand.new(111, @indent - 1, [ifnum, money, op])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（アイテム）
|
||
#--------------------------------------------------------------------------
|
||
def convert_if_item(args)
|
||
@indent += 1
|
||
ifnum = 8
|
||
id = args["id"].to_i
|
||
return RPG::EventCommand.new(111, @indent - 1, [ifnum, id])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（武器）
|
||
#--------------------------------------------------------------------------
|
||
def convert_if_weapon(args)
|
||
@indent += 1
|
||
ifnum = 9
|
||
id = args["id"].to_i
|
||
equip = (args["equip"] || "false") == "true" ? true : false
|
||
return RPG::EventCommand.new(111, @indent - 1, [ifnum, id, equip])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（防具）
|
||
#--------------------------------------------------------------------------
|
||
def convert_if_armor(args)
|
||
@indent += 1
|
||
ifnum = 10
|
||
id = args["id"].to_i
|
||
equip = (args["equip"] || "false") == "true" ? true : false
|
||
return RPG::EventCommand.new(111, @indent - 1, [ifnum, id, equip])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（ボタン）
|
||
#--------------------------------------------------------------------------
|
||
def convert_if_button(args)
|
||
@indent += 1
|
||
ifnum = 11
|
||
case args["button"]
|
||
when "2", "down"
|
||
button = 2
|
||
when "4", "left"
|
||
button = 4
|
||
when "6", "right"
|
||
button = 6
|
||
when "8", "up"
|
||
button = 7
|
||
when "11", "A"
|
||
button = 11
|
||
when "12", "B"
|
||
button = 12
|
||
when "13", "C"
|
||
button = 13
|
||
when "14", "X"
|
||
button = 14
|
||
when "15", "Y"
|
||
button = 15
|
||
when "16", "Z"
|
||
button = 16
|
||
when "17", "L"
|
||
button = 17
|
||
when "17", "R"
|
||
button = 18
|
||
end
|
||
return RPG::EventCommand.new(111, @indent - 1, [ifnum, button])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（スクリプト）
|
||
#--------------------------------------------------------------------------
|
||
def convert_if_script(args)
|
||
@indent += 1
|
||
ifnum = 12
|
||
script = args["script"]
|
||
return RPG::EventCommand.new(111, @indent - 1, [ifnum, script])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 条件分岐（それ以外）
|
||
#--------------------------------------------------------------------------
|
||
def convert_else(args)
|
||
@indent += 1
|
||
return RPG::EventCommand.new(411, @indent - 1, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ループ
|
||
#--------------------------------------------------------------------------
|
||
def convert_loop(args)
|
||
@indent += 1
|
||
return RPG::EventCommand.new(112, @indent - 1, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ループの終わり
|
||
#--------------------------------------------------------------------------
|
||
def convert_loop_end(args)
|
||
@indent -= 1
|
||
return RPG::EventCommand.new(413, @indent, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ループの中断
|
||
#--------------------------------------------------------------------------
|
||
def convert_loop_break(args)
|
||
return RPG::EventCommand.new(113, @indent, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ イベントの中断
|
||
#--------------------------------------------------------------------------
|
||
def convert_event_break(args)
|
||
return RPG::EventCommand.new(115, @indent, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ イベントの中断（returnタグにて）
|
||
#--------------------------------------------------------------------------
|
||
def convert_return(args)
|
||
return RPG::EventCommand.new(115, @indent, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ コモンイベント
|
||
#--------------------------------------------------------------------------
|
||
def convert_common(args)
|
||
return RPG::EventCommand.new(117, @indent, [args["id"].to_i])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ラベル
|
||
#--------------------------------------------------------------------------
|
||
def convert_label(args)
|
||
return RPG::EventCommand.new(118, @indent, [args["value"]])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ラベルジャンプ
|
||
#--------------------------------------------------------------------------
|
||
def convert_label_jump(args)
|
||
return RPG::EventCommand.new(119, @indent, [args["value"]])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 注釈
|
||
#--------------------------------------------------------------------------
|
||
def convert_comment(args)
|
||
return RPG::EventCommand.new(108, @indent, [args["value"]])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 注釈（２行目以降）
|
||
#--------------------------------------------------------------------------
|
||
def convert_comment2(args)
|
||
return RPG::EventCommand.new(408, @indent, [args["value"]])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# パーティ系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ 所持金の増減
|
||
#--------------------------------------------------------------------------
|
||
def convert_money(args)
|
||
value = args["value"]
|
||
type = value.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
operate = value.gsub!(/(^-)/) { "" } ? 1 : 0 #0:加算 1:減算
|
||
return RPG::EventCommand.new(125, @indent, [operate, type, value.to_i])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ アイテムの増減
|
||
#--------------------------------------------------------------------------
|
||
def convert_item(args)
|
||
id = args["id"].to_i
|
||
value = args["value"]
|
||
type = value.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
operate = value.gsub!(/(^-)/) { "" } ? 1 : 0 #0:加算 1:減算
|
||
return RPG::EventCommand.new(126, @indent,
|
||
[id, operate, type, value.to_i])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 武器の増減
|
||
#--------------------------------------------------------------------------
|
||
def convert_weapon(args)
|
||
id = args["id"].to_i
|
||
value = args["value"]
|
||
type = value.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
operate = value.gsub!(/(^-)/) { "" } ? 1 : 0 #0:加算 1:減算
|
||
equip = (args["equip"] || "false") == "true" ? true : false
|
||
return RPG::EventCommand.new(127, @indent,
|
||
[id, operate, type, value.to_i, equip])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 防具の増減
|
||
#--------------------------------------------------------------------------
|
||
def convert_armor(args)
|
||
id = args["id"].to_i
|
||
value = args["value"]
|
||
type = value.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
operate = value.gsub!(/(^-)/) { "" } ? 1 : 0 #0:加算 1:減算
|
||
equip = (args["equip"] || "false") == "true" ? true : false
|
||
return RPG::EventCommand.new(128, @indent,
|
||
[id, operate, type, value.to_i, equip])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ メンバーの入れ替え
|
||
#--------------------------------------------------------------------------
|
||
def convert_member(args)
|
||
id = args["id"]
|
||
operate = id.gsub!(/(^-)/) { "" } ? 1 : 0 #0:加算 1:減算
|
||
init = (args["init"] || "false") == "true" ? 1 : 0
|
||
return RPG::EventCommand.new(129, @indent, [id.to_i, operate, init])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# アクター系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ ＨＰの増減
|
||
#--------------------------------------------------------------------------
|
||
def convert_hp(args)
|
||
actor = args["actor"]
|
||
is_var = actor.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
value = args["value"]
|
||
type = value.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
operate = value.gsub!(/(^-)/) { "" } ? 1 : 0 #0:加算 1:減算
|
||
death = (args["death"] || "false") == "true" ? true : false
|
||
return RPG::EventCommand.new(311, @indent,
|
||
[is_var, actor.to_i, operate, type, value.to_i, death])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ＭＰの増減
|
||
#--------------------------------------------------------------------------
|
||
def convert_mp(args)
|
||
actor = args["actor"]
|
||
is_var = actor.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
value = args["value"]
|
||
type = value.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
operate = value.gsub!(/(^-)/) { "" } ? 1 : 0 #0:加算 1:減算
|
||
return RPG::EventCommand.new(312, @indent,
|
||
[is_var, actor.to_i, operate, type, value.to_i])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ステートの変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_state(args)
|
||
actor = args["actor"]
|
||
is_var = actor.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
value = args["value"]
|
||
operate = value.gsub!(/(^-)/) { "" } ? 1 : 0 #0:加算 1:減算
|
||
return RPG::EventCommand.new(313, @indent,
|
||
[is_var, actor.to_i, operate, value.to_i])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 全回復
|
||
#--------------------------------------------------------------------------
|
||
def convert_all_recovery(args)
|
||
actor = args["actor"]
|
||
is_var = actor.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
return RPG::EventCommand.new(314, @indent, [is_var, actor.to_i])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 経験値の増減
|
||
#--------------------------------------------------------------------------
|
||
def convert_exp(args)
|
||
actor = args["actor"]
|
||
is_var = actor.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
value = args["value"]
|
||
type = value.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
operate = value.gsub!(/(^-)/) { "" } ? 1 : 0 #0:加算 1:減算
|
||
message = (args["message"] || "false") == "true" ? true : false
|
||
return RPG::EventCommand.new(315, @indent,
|
||
[is_var, actor.to_i, operate, type, value.to_i, message])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ レベルの増減
|
||
#--------------------------------------------------------------------------
|
||
def convert_level(args)
|
||
actor = args["actor"]
|
||
is_var = actor.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
value = args["value"]
|
||
type = value.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
operate = value.gsub!(/(^-)/) { "" } ? 1 : 0 #0:加算 1:減算
|
||
message = (args["message"] || "false") == "true" ? true : false
|
||
return RPG::EventCommand.new(316, @indent,
|
||
[is_var, actor.to_i, operate, type, value.to_i, message])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 能力値の増減
|
||
#--------------------------------------------------------------------------
|
||
def convert_capability(args)
|
||
actor = args["actor"]
|
||
is_var = actor.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
case args["capability"]
|
||
when "0", "maxhp"
|
||
capability = 0
|
||
when "1", "maxmp"
|
||
capability = 1
|
||
when "2", "atk"
|
||
capability = 2
|
||
when "3", "def"
|
||
capability = 3
|
||
when "4", "matk"
|
||
capability = 4
|
||
when "5", "mdef"
|
||
capability = 5
|
||
when "6", "agi"
|
||
capability = 6
|
||
when "7", "luk"
|
||
capability = 7
|
||
end
|
||
value = args["value"]
|
||
type = value.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
operate = value.gsub!(/(^-)/) { "" } ? 1 : 0 #0:加算 1:減算
|
||
return RPG::EventCommand.new(317, @indent,
|
||
[is_var, actor.to_i, capability, operate, type, value.to_i])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ スキルの増減
|
||
#--------------------------------------------------------------------------
|
||
def convert_skill(args)
|
||
actor = args["actor"]
|
||
is_var = actor.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
value = args["value"]
|
||
operate = value.gsub!(/(^-)/) { "" } ? 1 : 0 #0:加算 1:減算
|
||
return RPG::EventCommand.new(318, @indent,
|
||
[is_var, actor.to_i, operate, value.to_i])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 装備の変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_equip(args)
|
||
actor = args["actor"].to_i
|
||
part = args["part"].to_i
|
||
id = args["id"].to_i
|
||
return RPG::EventCommand.new(319, @indent, [actor, part, id])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 名前の変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_name(args)
|
||
actor = args["actor"].to_i
|
||
value = args["value"]
|
||
return RPG::EventCommand.new(320, @indent, [actor, value])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 職業の変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_class(args)
|
||
actor = args["actor"].to_i
|
||
value = args["value"].to_i
|
||
return RPG::EventCommand.new(321, @indent, [actor, value])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 二つ名の変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_nickname(args)
|
||
actor = args["actor"].to_i
|
||
value = args["value"]
|
||
return RPG::EventCommand.new(324, @indent, [actor, value])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# 移動系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ 場所移動
|
||
#--------------------------------------------------------------------------
|
||
def convert_map_move(args)
|
||
type = (args["type"] || "const") == "const" ? 0 : 1
|
||
map = args["map"].to_i
|
||
x = args["x"].to_i
|
||
y = args["y"].to_i
|
||
case args["direction"]
|
||
when "2", "down"
|
||
direction = 2
|
||
when "4", "left"
|
||
direction = 4
|
||
when "6", "right"
|
||
direction = 6
|
||
when "8", "up"
|
||
direction = 8
|
||
else
|
||
direction = 0
|
||
end
|
||
case args["fade"]
|
||
when "1", "white"
|
||
fade = 1
|
||
when "2", "none"
|
||
fade = 2
|
||
else
|
||
fade = 0
|
||
end
|
||
return RPG::EventCommand.new(201, @indent,
|
||
[type, map, x, y, direction, fade])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 乗り物の位置設定
|
||
#--------------------------------------------------------------------------
|
||
def convert_vehicle_pos(args)
|
||
vehicle = args["vehicle"].to_i
|
||
type = (args["type"] || "const") == "const" ? 0 : 1
|
||
map = args["map"].to_i
|
||
x = args["x"].to_i
|
||
y = args["y"].to_i
|
||
return RPG::EventCommand.new(202, @indent, [vehicle, type, map, x, y])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ イベントの位置設定
|
||
#--------------------------------------------------------------------------
|
||
def convert_event_pos(args)
|
||
id = args["id"].to_i
|
||
type = 1 if args["type"] == "var"
|
||
type = 2 if args["type"] == "target"
|
||
type = 0 unless type
|
||
x = args["x"].to_i
|
||
y = args["y"].to_i
|
||
case args["direction"]
|
||
when "2", "down"
|
||
direction = 2
|
||
when "4", "left"
|
||
direction = 4
|
||
when "6", "right"
|
||
direction = 6
|
||
when "8", "up"
|
||
direction = 8
|
||
else
|
||
direction = 0
|
||
end
|
||
return RPG::EventCommand.new(203, @indent, [id, type, x, y, direction])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ マップのスクロール
|
||
#--------------------------------------------------------------------------
|
||
def convert_scroll_map(args)
|
||
case args["direction"]
|
||
when "2", "down"
|
||
direction = 2
|
||
when "4", "left"
|
||
direction = 4
|
||
when "6", "right"
|
||
direction = 6
|
||
when "8", "up"
|
||
direction = 8
|
||
end
|
||
num = args["num"].to_i
|
||
speed = (args["speed"] || 4).to_i
|
||
return RPG::EventCommand.new(204, @indent, [direction, num, speed])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 移動ルートの設定（ヘッダー部）
|
||
#--------------------------------------------------------------------------
|
||
def convert_route_h(args)
|
||
event = args["event"].to_i
|
||
temp = RPG::MoveRoute.new
|
||
temp.repeat = (args["repeat"] || "false") == "true" ? true : false
|
||
temp.skippable = (args["skip"] || "false") == "true" ? true : false
|
||
temp.wait = (args["wait"] || "false") == "true" ? true : false
|
||
temp.repeat = false if temp.repeat and temp.wait # 同時true防止
|
||
return RPG::EventCommand.new(205, @indent, [event, temp])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 移動ルートの設定（移動方法）
|
||
#--------------------------------------------------------------------------
|
||
def convert_route(args)
|
||
param = []
|
||
case args["type"]
|
||
when "1", "down"
|
||
type = 1
|
||
when "2", "left"
|
||
type = 2
|
||
when "3", "right"
|
||
type = 3
|
||
when "4", "up"
|
||
type = 4
|
||
when "5", "dl"
|
||
type = 5
|
||
when "6", "dr"
|
||
type = 6
|
||
when "7", "ul"
|
||
type = 7
|
||
when "8", "ur"
|
||
type = 8
|
||
when "9", "random"
|
||
type = 9
|
||
when "10", "toward"
|
||
type = 10
|
||
when "11", "away"
|
||
type = 11
|
||
when "12", "foward"
|
||
type = 12
|
||
when "13", "backward"
|
||
type = 13
|
||
when "14", "jump"
|
||
type = 14
|
||
check_numeric(args, "x", -100, 100)
|
||
check_numeric(args, "y", -100, 100)
|
||
param[0] = (args["x"] || 0).to_i
|
||
param[1] = (args["y"] || 0).to_i
|
||
when "15", "wait"
|
||
type = 15
|
||
check_numeric(args, "time", 1, 999)
|
||
param[0] = (args["time"] || 60).to_i
|
||
when "16", "turn_down"
|
||
type = 16
|
||
when "17", "turn_left"
|
||
type = 17
|
||
when "18", "turn_right"
|
||
type = 18
|
||
when "19", "turn_up"
|
||
type = 19
|
||
when "20", "turn_90_r"
|
||
type = 20
|
||
when "21", "turn_90_l"
|
||
type = 21
|
||
when "22", "turn_180"
|
||
type = 22
|
||
when "23", "turn_90_rl", "turn_90_lr"
|
||
type = 23
|
||
when "24", "turn_random"
|
||
type = 24
|
||
when "25", "turn_toward"
|
||
type = 25
|
||
when "26", "turn_away"
|
||
type = 26
|
||
when "27", "switch_on", "sw_on"
|
||
type = 27
|
||
check_notEmpty(args, "id")
|
||
check_numeric(args, "id", 1, nil)
|
||
param[0] = args["id"].to_i
|
||
when "28", "switch_off", "sw_off"
|
||
type = 28
|
||
check_notEmpty(args, "id")
|
||
check_numeric(args, "id", 1, nil)
|
||
param[0] = args["id"].to_i
|
||
when "29", "change_speed"
|
||
type = 29
|
||
check_numeric(args, "speed", 1, 6)
|
||
param[0] = (args["speed"] || 3).to_i
|
||
when "30", "change_freq"
|
||
type = 30
|
||
check_numeric(args, "freq", 1, 5)
|
||
param[0] = (args["freq"] || 3).to_i
|
||
when "31", "walk_anime_on"
|
||
type = 31
|
||
when "32", "walk_anime_off"
|
||
type = 32
|
||
when "33", "step_anime_on"
|
||
type = 33
|
||
when "34", "step_anime_off"
|
||
type = 34
|
||
when "35", "dir_fix_on"
|
||
type = 35
|
||
when "36", "dir_fix_off"
|
||
type = 36
|
||
when "37", "through_on"
|
||
type = 37
|
||
when "38", "through_off"
|
||
type = 38
|
||
when "39", "transparent_on"
|
||
type = 39
|
||
when "40", "transparent_off"
|
||
type = 40
|
||
when "41", "change_graphic"
|
||
type = 41
|
||
check_notEmpty(args, "file")
|
||
check_notEmpty(args, "index")
|
||
check_numeric(args, "index", 0, 7)
|
||
param[0] = args["file"]
|
||
param[1] = args["index"].to_i
|
||
when "42", "change_opacity"
|
||
type = 42
|
||
check_numeric(args, "opacity", 0, 255)
|
||
param[0] = (args["opacity"] || 255).to_i
|
||
when "43", "change_blend"
|
||
type = 43
|
||
check_numeric(args, "blend", 0, 2)
|
||
param[0] = (args["blend"] || 0).to_i
|
||
when "44", "play_se"
|
||
type = 44
|
||
check_numeric(args, "volume", 0, 100)
|
||
check_numeric(args, "pitch", 50, 150)
|
||
file = (args["file"] || "")
|
||
volume = (args["volume"] || 100).to_i
|
||
pitch = (args["pitch"] || 100).to_i
|
||
param = [RPG::SE.new(file, volume, pitch)]
|
||
when "45", "script"
|
||
type = 45
|
||
check_notEmpty(args, "script")
|
||
param[0] = args["script"]
|
||
else
|
||
raise(TesConvertError, "存在しない移動コマンドです。")
|
||
end
|
||
return RPG::EventCommand.new(505, @indent,
|
||
[RPG::MoveCommand.new(type, param)])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 乗り物の乗降
|
||
#--------------------------------------------------------------------------
|
||
def convert_vehicle(args)
|
||
return RPG::EventCommand.new(206, @indent, [])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# キャラクター系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ 透明状態の変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_transparent(args)
|
||
flag = args["flag"] == "on" ? 0 : 1
|
||
return RPG::EventCommand.new(211, @indent, [flag])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 隊列歩行の変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_followers(args)
|
||
flag = args["flag"] == "on" ? 0 : 1
|
||
return RPG::EventCommand.new(216, @indent, [flag])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 隊列メンバーの集合
|
||
#--------------------------------------------------------------------------
|
||
def convert_gather(args)
|
||
return RPG::EventCommand.new(217, @indent, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ アニメーションの表示
|
||
#--------------------------------------------------------------------------
|
||
def convert_anime(args)
|
||
target = args["target"].to_i
|
||
anime = args["anime"].to_i
|
||
wait = (args["wait"] || "false") == "true" ? true : false
|
||
return RPG::EventCommand.new(212, @indent, [target, anime, wait])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ フキダシアイコンの表示
|
||
#--------------------------------------------------------------------------
|
||
def convert_balloon(args)
|
||
target = args["target"].to_i
|
||
balloon = args["balloon"].to_i
|
||
wait = (args["wait"] || "false") == "true" ? true : false
|
||
return RPG::EventCommand.new(213, @indent, [target, balloon, wait])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ イベントの一時消去
|
||
#--------------------------------------------------------------------------
|
||
def convert_erace(args)
|
||
return RPG::EventCommand.new(214, @indent, [])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# 画面効果系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ 画面のフェードアウト
|
||
#--------------------------------------------------------------------------
|
||
def convert_fadeout(args)
|
||
return RPG::EventCommand.new(221, @indent, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 画面のフェードイン
|
||
#--------------------------------------------------------------------------
|
||
def convert_fadein(args)
|
||
return RPG::EventCommand.new(222, @indent, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 画面の色調変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_tone(args)
|
||
red = (args["red"] || 0.0).to_f
|
||
green = (args["green"] || 0.0).to_f
|
||
blue = (args["blue"] || 0.0).to_f
|
||
gray = (args["gray"] || 0.0).to_f
|
||
tone = Tone.new(red, green, blue, gray)
|
||
time = (args["time"] || 60).to_i
|
||
wait = (args["wait"] || "true") == "true" ? true : false
|
||
return RPG::EventCommand.new(223, @indent, [tone, time, wait])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 画面のフラッシュ
|
||
#--------------------------------------------------------------------------
|
||
def convert_flash(args)
|
||
red = (args["red"] || 255.0).to_f
|
||
green = (args["green"] || 255.0).to_f
|
||
blue = (args["blue"] || 255.0).to_f
|
||
strength = (args["strength"] || 255.0).to_f
|
||
color = Color.new(red, green, blue, strength)
|
||
time = (args["time"] || 60).to_i
|
||
wait = (args["wait"] || "true") == "true" ? true : false
|
||
return RPG::EventCommand.new(224, @indent, [color, time, wait])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 画面のシェイク
|
||
#--------------------------------------------------------------------------
|
||
def convert_shake(args)
|
||
strength = (args["strength"] || 5).to_i
|
||
speed = (args["speed"] || 5).to_i
|
||
time = (args["time"] || 60).to_i
|
||
wait = (args["wait"] || "true") == "true" ? true : false
|
||
return RPG::EventCommand.new(225, @indent, [strength, speed, time, wait])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# 時間調整系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ ウェイト
|
||
#--------------------------------------------------------------------------
|
||
def convert_wait(args)
|
||
time = (args["time"] || 60).to_i
|
||
return RPG::EventCommand.new(230, @indent, [time])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# ピクチャと天候系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ ピクチャの表示
|
||
#--------------------------------------------------------------------------
|
||
def convert_picture(args)
|
||
layer = args["layer"].to_i
|
||
file = args["file"]
|
||
origin = (args["origin"] || "ul") == "ul" ? 0 : 1
|
||
type = (args["type"] || "const") == "const" ? 0 : 1
|
||
x = args["x"].to_i
|
||
y = args["y"].to_i
|
||
zoom_x = (args["zoom_x"] || 100).to_i
|
||
zoom_y = (args["zoom_y"] || 100).to_i
|
||
transparent = (args["transparent"] || 255).to_i
|
||
blend = (args["blend"] || 0).to_i
|
||
return RPG::EventCommand.new(231, @indent,
|
||
[layer, file, origin, type, x, y, zoom_x, zoom_y, transparent, blend])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ピクチャの移動
|
||
#--------------------------------------------------------------------------
|
||
def convert_picture_move(args)
|
||
layer = args["layer"].to_i
|
||
file = nil
|
||
origin = (args["origin"] || "ul") == "ul" ? 0 : 1
|
||
type = (args["type"] || "const") == "const" ? 0 : 1
|
||
x = args["x"].to_i
|
||
y = args["y"].to_i
|
||
zoom_x = (args["zoom_x"] || 100).to_i
|
||
zoom_y = (args["zoom_y"] || 100).to_i
|
||
transparent = (args["transparent"] || 255).to_i
|
||
blend = (args["blend"] || 0).to_i
|
||
time = (args["time"] || 60).to_i
|
||
wait = (args["wait"] || "true") == "true" ? true : false
|
||
return RPG::EventCommand.new(232, @indent, [layer, nil,
|
||
origin, type, x, y, zoom_x, zoom_y, transparent, blend, time, wait])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ピクチャの回転
|
||
#--------------------------------------------------------------------------
|
||
def convert_picture_rotation(args)
|
||
layer = args["layer"].to_i
|
||
speed = (args["speed"] || 5).to_i
|
||
return RPG::EventCommand.new(233, @indent, [layer, speed])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ピクチャの色調変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_picture_tone(args)
|
||
layer = args["layer"].to_i
|
||
red = (args["red"] || 0.0).to_f
|
||
green = (args["green"] || 0.0).to_f
|
||
blue = (args["blue"] || 0.0).to_f
|
||
gray = (args["gray"] || 0.0).to_f
|
||
tone = Tone.new(red, green, blue, gray)
|
||
time = (args["time"] || 60).to_i
|
||
wait = (args["wait"] || "true") == "true" ? true : false
|
||
return RPG::EventCommand.new(234, @indent, [layer, tone, time, wait])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ピクチャの消去
|
||
#--------------------------------------------------------------------------
|
||
def convert_picture_erace(args)
|
||
layer = args["layer"].to_i
|
||
return RPG::EventCommand.new(235, @indent, [layer])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 天候の設定
|
||
#--------------------------------------------------------------------------
|
||
def convert_weather(args)
|
||
weather = (args["weather"] || "none").to_sym
|
||
strength = (args["strength"] || 5).to_i
|
||
time = (args["time"] || 60).to_i
|
||
wait = (args["wait"] || "true") == "true" ? true : false
|
||
return RPG::EventCommand.new(236, @indent,
|
||
[weather, strength, time, wait])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# 音楽と効果音系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ ＢＧＭの演奏
|
||
#--------------------------------------------------------------------------
|
||
def convert_bgm(args)
|
||
file = (args["file"] || "")
|
||
volume = (args["volume"] || 100).to_i
|
||
pitch = (args["pitch"] || 100).to_i
|
||
temp = RPG::BGM.new(file, volume, pitch)
|
||
return RPG::EventCommand.new(241, @indent, [temp])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ＢＧＭのフェードアウト
|
||
#--------------------------------------------------------------------------
|
||
def convert_fadeout_bgm(args)
|
||
time = (args["time"] || 10).to_i
|
||
return RPG::EventCommand.new(242, @indent, [time])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ＢＧＭの保存
|
||
#--------------------------------------------------------------------------
|
||
def convert_save_bgm(args)
|
||
return RPG::EventCommand.new(243, @indent, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ＢＧＭの再開
|
||
#--------------------------------------------------------------------------
|
||
def convert_resume_bgm(args)
|
||
return RPG::EventCommand.new(244, @indent, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ＢＧＳの演奏
|
||
#--------------------------------------------------------------------------
|
||
def convert_bgs(args)
|
||
file = (args["file"] || "")
|
||
volume = (args["volume"] || 100).to_i
|
||
pitch = (args["pitch"] || 100).to_i
|
||
temp = RPG::BGS.new(file, volume, pitch)
|
||
return RPG::EventCommand.new(245, @indent, [temp])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ＢＧＳのフェードアウト
|
||
#--------------------------------------------------------------------------
|
||
def convert_fadeout_bgs(args)
|
||
time = (args["time"] || 10).to_i
|
||
return RPG::EventCommand.new(246, @indent, [time])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ＭＥの演奏
|
||
#--------------------------------------------------------------------------
|
||
def convert_me(args)
|
||
file = (args["file"] || "")
|
||
volume = (args["volume"] || 100).to_i
|
||
pitch = (args["pitch"] || 100).to_i
|
||
temp = RPG::ME.new(file, volume, pitch)
|
||
return RPG::EventCommand.new(249, @indent, [temp])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ＳＥの演奏
|
||
#--------------------------------------------------------------------------
|
||
def convert_se(args)
|
||
file = (args["file"] || "")
|
||
volume = (args["volume"] || 80).to_i
|
||
pitch = (args["pitch"] || 100).to_i
|
||
temp = RPG::SE.new(file, volume, pitch)
|
||
return RPG::EventCommand.new(250, @indent, [temp])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ＳＥの停止
|
||
#--------------------------------------------------------------------------
|
||
def convert_stop_se(args)
|
||
return RPG::EventCommand.new(251, @indent, [])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# シーン制御系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ バトルの処理（ヘッダー部）
|
||
#--------------------------------------------------------------------------
|
||
def convert_battle(args)
|
||
id = args["id"]
|
||
type = id.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
id = id.to_i
|
||
type = 2 if id == 0
|
||
escape = (args["can_escape"] || "false") == "true" ? true : false
|
||
continue = (args["loss_continue"] || "false") == "true" ? true : false
|
||
return RPG::EventCommand.new(301, @indent,
|
||
[type, id, escape, continue])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ バトルの処理（勝った場合）
|
||
#--------------------------------------------------------------------------
|
||
def convert_battle_win(args)
|
||
@indent += 1
|
||
return RPG::EventCommand.new(601, @indent - 1, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ バトルの処理（逃げた場合）
|
||
#--------------------------------------------------------------------------
|
||
def convert_battle_escape(args)
|
||
@indent += 1
|
||
return RPG::EventCommand.new(602, @indent - 1, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ バトルの処理（負けた場合）
|
||
#--------------------------------------------------------------------------
|
||
def convert_battle_loss(args)
|
||
@indent += 1
|
||
return RPG::EventCommand.new(603, @indent - 1, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ バトルの処理（分岐終了）
|
||
#--------------------------------------------------------------------------
|
||
def convert_battle_end(args)
|
||
return RPG::EventCommand.new(604, @indent, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ショップの処理
|
||
#--------------------------------------------------------------------------
|
||
def convert_shop(args)
|
||
type = 0 if ["0", "item"].include?(args["type"])
|
||
type = 1 if ["1", "weapon"].include?(args["type"])
|
||
type = 2 if ["2", "armor"].include?(args["type"])
|
||
id = args["id"].to_i
|
||
price = (args["price"] || "db") == "db" ? 0 : 1
|
||
value = (args["value"] || 50).to_i
|
||
buy_only = (args["buy_only"] || "false") == "true" ? true : false
|
||
return RPG::EventCommand.new(605, @indent,
|
||
[type, id, price, value, buy_only])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 名前入力の処理
|
||
#--------------------------------------------------------------------------
|
||
def convert_input_name(args)
|
||
actor = args["actor"].to_i
|
||
number = (args["number"] || 6).to_i
|
||
return RPG::EventCommand.new(303, @indent, [actor, number])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ メニュー画面を開く
|
||
#--------------------------------------------------------------------------
|
||
def convert_menu_open(args)
|
||
return RPG::EventCommand.new(351, @indent, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ セーブ画面を開く
|
||
#--------------------------------------------------------------------------
|
||
def convert_save_open(args)
|
||
return RPG::EventCommand.new(352, @indent, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ゲームオーバー
|
||
#--------------------------------------------------------------------------
|
||
def convert_gameover(args)
|
||
return RPG::EventCommand.new(353, @indent, [])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ タイトル画面に戻す
|
||
#--------------------------------------------------------------------------
|
||
def convert_title_return(args)
|
||
return RPG::EventCommand.new(354, @indent, [])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# システム設定系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ 戦闘ＢＧＭの変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_battle_bgm(args)
|
||
file = (args["file"] || "")
|
||
volume = (args["volume"] || 100).to_i
|
||
pitch = (args["pitch"] || 100).to_i
|
||
temp = RPG::BGM.new(file, volume, pitch)
|
||
return RPG::EventCommand.new(132, @indent, [temp])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 戦闘終了ＭＥの変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_battle_end_me(args)
|
||
file = (args["file"] || "")
|
||
volume = (args["volume"] || 100).to_i
|
||
pitch = (args["pitch"] || 100).to_i
|
||
temp = RPG::ME.new(file, volume, pitch)
|
||
return RPG::EventCommand.new(133, @indent, [temp])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ セーブ禁止の変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_save_disable(args)
|
||
flag = (args["flag"] || "true") == "true" ? 0 : 1
|
||
return RPG::EventCommand.new(134, @indent, [flag])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ メニュー禁止の変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_menu_disable(args)
|
||
flag = (args["flag"] || "true") == "true" ? 0 : 1
|
||
return RPG::EventCommand.new(135, @indent, [flag])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ エンカウント禁止の変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_encount_disable(args)
|
||
flag = (args["flag"] || "true") == "true" ? 0 : 1
|
||
return RPG::EventCommand.new(136, @indent, [flag])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 並び替え禁止の変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_formation_disable(args)
|
||
flag = (args["flag"] || "true") == "true" ? 0 : 1
|
||
return RPG::EventCommand.new(137, @indent, [flag])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ ウィンドウカラーの変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_window_color(args)
|
||
red = (args["red"] || -34.0).to_i
|
||
green = (args["green"] || 0.0).to_i
|
||
blue = (args["blue"] || 68.0).to_i
|
||
color = Color.new(red, green, blue)
|
||
return RPG::EventCommand.new(138, @indent, [color])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ アクターのグラフィック変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_actor_graphic(args)
|
||
actor = args["actor"].to_i
|
||
walk_file = (args["walk_file"] || "")
|
||
walk_index = (args["walk_index"] || 0).to_i
|
||
face_file = (args["face_file"] || "")
|
||
face_index = (args["face_index"] || 0).to_i
|
||
return RPG::EventCommand.new(322, @indent,
|
||
[actor, walk_file, walk_index, face_file, face_index])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 乗り物のグラフィック変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_vehicle_graphic(args)
|
||
type = args["vehicle"].to_i
|
||
file = (args["file"] || "")
|
||
index = (args["index"] || 0).to_i
|
||
return RPG::EventCommand.new(323, @indent, [type, file, index])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# ムービー系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ ムービーの再生
|
||
#--------------------------------------------------------------------------
|
||
def convert_movie(args)
|
||
file = args["file"]
|
||
return RPG::EventCommand.new(261, @indent, [file])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# マップ系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ マップ名表示の変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_map_name_disable(args)
|
||
flag = (args["flag"] || "true") == "true" ? 0 : 1
|
||
return RPG::EventCommand.new(281, @indent, [flag])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ タイルセットの変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_tileset(args)
|
||
id = args["id"].to_i
|
||
return RPG::EventCommand.new(282, @indent, [id])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 戦闘背景の変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_battle_background(args)
|
||
floor = (args["floor"] || "")
|
||
wall = (args["wall"] || "")
|
||
return RPG::EventCommand.new(283, @indent, [floor, wall])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 遠景の変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_parallax(args)
|
||
file = (args["file"] || "")
|
||
loop_x = (args["loop_x"] || "false") == "true" ? true : false
|
||
loop_y = (args["loop_y"] || "false") == "true" ? true : false
|
||
scroll_x = loop_x ? (args["scroll_x"] || 0).to_i : 0
|
||
scroll_y = loop_y ? (args["scroll_y"] || 0).to_i : 0
|
||
return RPG::EventCommand.new(284, @indent,
|
||
[file, loop_x, loop_y, scroll_x, scroll_y])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 指定位置の情報取得
|
||
#--------------------------------------------------------------------------
|
||
def convert_pos_info(args)
|
||
var = args["var"].to_i
|
||
type = (args["type"] || 0).to_i
|
||
pos = (args["pos"] || "const") == "const" ? 0 : 1
|
||
x = args["x"].to_i
|
||
y = args["y"].to_i
|
||
return RPG::EventCommand.new(285, @indent, [var, type, pos, x, y])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# バトル系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ 敵キャラのＨＰ増減
|
||
#--------------------------------------------------------------------------
|
||
def convert_enemy_hp(args)
|
||
enemy = args["enemy"].to_i
|
||
value = args["value"]
|
||
type = value.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
operate = value.gsub!(/(^-)/) { "" } ? 1 : 0 #0:加算 1:減算
|
||
death = (args["death"] || "false") == "true" ? true : false
|
||
return RPG::EventCommand.new(331, @indent,
|
||
[enemy, operate, type, value.to_i, death])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 敵キャラのＭＰ増減
|
||
#--------------------------------------------------------------------------
|
||
def convert_enemy_mp(args)
|
||
enemy = args["enemy"].to_i
|
||
value = args["value"]
|
||
type = value.gsub!(/(var\.)/) { "" } ? 1 : 0 #0:数値 1:変数
|
||
operate = value.gsub!(/(^-)/) { "" } ? 1 : 0 #0:加算 1:減算
|
||
return RPG::EventCommand.new(332, @indent,
|
||
[enemy, operate, type, value.to_i])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 敵キャラのステート変更
|
||
#--------------------------------------------------------------------------
|
||
def convert_enemy_state(args)
|
||
enemy = args["enemy"].to_i
|
||
value = args["value"]
|
||
operate = value.gsub!(/(^-)/) { "" } ? 1 : 0 #0:加算 1:減算
|
||
return RPG::EventCommand.new(333, @indent, [enemy, operate, value.to_i])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 敵キャラの全回復
|
||
#--------------------------------------------------------------------------
|
||
def convert_enemy_all_recovery(args)
|
||
enemy = args["enemy"].to_i
|
||
return RPG::EventCommand.new(334, @indent, [enemy])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 敵キャラの出現
|
||
#--------------------------------------------------------------------------
|
||
def convert_enemy_appear(args)
|
||
enemy = args["enemy"].to_i
|
||
return RPG::EventCommand.new(335, @indent, [enemy])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 敵キャラの変身
|
||
#--------------------------------------------------------------------------
|
||
def convert_enemy_trans(args)
|
||
enemy = args["enemy"].to_i
|
||
trans = args["trans"].to_i
|
||
return RPG::EventCommand.new(336, @indent, [enemy, trans])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 戦闘アニメーションの表示
|
||
#--------------------------------------------------------------------------
|
||
def convert_battle_anime(args)
|
||
enemy = args["enemy"].to_i
|
||
anime = args["anime"].to_i
|
||
return RPG::EventCommand.new(337, @indent, [enemy, anime])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 戦闘行動の強制
|
||
#--------------------------------------------------------------------------
|
||
def convert_force(args)
|
||
battler = args["battler"] == "enemy" ? 0 : 1
|
||
id = args["id"].to_i
|
||
skill = args["skill"].to_i
|
||
target = args["target"].to_i
|
||
return RPG::EventCommand.new(339, @indent, [battler, id, skill, target])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ バトルの中断
|
||
#--------------------------------------------------------------------------
|
||
def convert_battle_abort(args)
|
||
return RPG::EventCommand.new(340, @indent, [])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# 上級系
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ スクリプト
|
||
#--------------------------------------------------------------------------
|
||
def convert_script(args)
|
||
return RPG::EventCommand.new(355, @indent, [args["value"]])
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ スクリプト（２行目以降）
|
||
#--------------------------------------------------------------------------
|
||
def convert_script2(args)
|
||
return RPG::EventCommand.new(655, @indent, [args["value"]])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# その他
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ イベントの終了位置
|
||
#--------------------------------------------------------------------------
|
||
def convert_end(args)
|
||
@indent -= 1
|
||
return RPG::EventCommand.new(0, @indent + 1, [])
|
||
end
|
||
|
||
#****************************************************************************
|
||
# 後処理
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ 後処理
|
||
#--------------------------------------------------------------------------
|
||
alias tes_basic_set_post_processing post_processing
|
||
def post_processing
|
||
tes_basic_set_post_processing
|
||
@route_h = 0
|
||
@index = 0
|
||
while @data.size > @index
|
||
post_processing_events
|
||
@index += 1
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 後処理（各インデックスに対して）
|
||
#--------------------------------------------------------------------------
|
||
def post_processing_events
|
||
# ルートタグのダミーをヘッダに収納
|
||
if @data[@index].code == 205
|
||
route_h = @index
|
||
route = []
|
||
while @data[@index + 1].code == 505
|
||
@index += 1
|
||
route << @data[@index].parameters[0]
|
||
end
|
||
route << RPG::MoveCommand.new
|
||
@data[route_h].parameters[1].list = route
|
||
end
|
||
|
||
# ショップタグの先頭をヘッダコードに変換
|
||
if @data[@index].code == 605
|
||
@data[@index].code = 302
|
||
while @data[@index + 1].code == 605
|
||
@index += 1
|
||
end
|
||
end
|
||
end
|
||
|
||
#****************************************************************************
|
||
# バリデータで出来ない値の確認
|
||
#****************************************************************************
|
||
#--------------------------------------------------------------------------
|
||
# ○ 数値確認
|
||
#--------------------------------------------------------------------------
|
||
def check_numeric(params, param_name, amin, amax)
|
||
return unless params[param_name]
|
||
unless params[param_name] =~ /^[-+0-9]\d*$/
|
||
raise(TesConvertError,
|
||
"[#{param_name}] : 数値以外が代入されました。")
|
||
end
|
||
|
||
# 最小値判定
|
||
if min = amin
|
||
min = params[min.id2name] if min.is_a?(Symbol)
|
||
min = eval(min) if min.is_a?(String)
|
||
min = min.to_i
|
||
if params[param_name].to_i < min
|
||
raise(TesConvertError,
|
||
"[#{param_name}] : 最小値より小さい値が使われています。")
|
||
end
|
||
end
|
||
|
||
# 最大値判定
|
||
if max = amax
|
||
max = params[max.id2name] if max.is_a?(Symbol)
|
||
max = eval(max) if max.is_a?(String)
|
||
max = max.to_i
|
||
if params[param_name].to_i > max
|
||
raise(TesConvertError,
|
||
"[#{param_name}] : 最大値より大きい値が使われています。")
|
||
end
|
||
end
|
||
end
|
||
#--------------------------------------------------------------------------
|
||
# ○ 必須要素
|
||
#--------------------------------------------------------------------------
|
||
def check_notEmpty(params, param_name)
|
||
if !params[param_name] or params[param_name].empty?
|
||
raise(TesConvertError,
|
||
"[#{param_name}] : 必須引数が省略されています。")
|
||
end
|
||
end
|
||
end
|
||
end |