| 赞 | 349 |
| VIP | |
| 好人卡 | |
| 积分 | 299 |
| 经验 | |
| 最后登录 | 2026-9-30 |
| 在线时间 | 2423 小时 |
遠航の猫咪
- 梦石
- 3
- 星屑
- 26947
- 在线时间
- 2423 小时
- 注册时间
- 2005-10-15
- 回帖
- 987
|
加入我们，或者，欢迎回来。
您需要 登录 才可以下载或查看，没有账号？注册会员
×
本帖最后由 SailCat 于 2016-1-28 02:05 编辑
你有过999条数据不够用的时候吗？
你有过给主角设置了15把武器（1－15）结果游戏都快做完了，发现剧情需要再多一把，然而新武器的ID变成了100往后吗？
你有过本来想让200号敌人开始是boss，结果说什么普通敌人都只有195个，导致敌人图鉴什么的脚本完全不能用吗？
不是不能在数据库里做剪切粘贴，实在是因为修改数据库的数据编号，将会导致所有地图的所有事件全部要手工重刷，甚至比这更多……
够了！来尝试这个重排工具，享受四大便利吧！
一：扩展数据库13大类数据的条数上限（我试到9999条仍然有效，再多没试）
二：任意在某个数据库位置前插入N个空白数据
三：交换任意两个数据的编号
四：删除所有空白的无效数据，将所有数据库从1开始进行紧密编号
所有这些操作，将会自动重刷全工程内对于它们的引用，保证你的游戏逻辑不受影响
警告：
1）本脚本发布前已经过详细测试并尽可能的考虑覆盖情况，但不保证100%覆盖到位，强烈建议使用前备份原工程。
2）本脚本支持对于事件脚本的转换，但仅限标准写法（如$data_actors[2].xx这样的写法），不支持变量指针ID引用，也不支持对于RGSS脚本系统本身引用的转换。（原始系统中实际上没有这类引用，但不排除你改过的系统中有）
3）本脚本在转换后，不能追溯修改已有游戏存档中的数据。
用法：
插入本脚本（见下，一共14个分割定义）到Game_Temp（注意不是Main）之前，然后在最后一个分割定义的后面，添加指令：
dr = Data_Reorder.new
dr.insert_enemy(101,100) # 在101号敌人前面插入100个空白的敌人
dr.swap_class(4, 7) # 交换4号职业和7号职业
dr.set_actor_id(5..9, 15) # 把5号到9号角色的位置挪到15号开始
dr.expand_weapon(1500) # 将武器上限扩展至1500个
dr.sort_armor # 将防具中的空白项（包括末尾空白项）删除恢复为1开始的紧密编号
dr.zap # 将数据库中的所有内容恢复为1开始的紧密编号
exit # 退出操作
这里面的enemy, class, actor, weapon, armor等，都可以改换为数据库的13大类数据名称
在执行完本脚本后，请勿做其他操作，立即关闭工程重新打开！如果系统问你要不要保存工程，选择不要！
修改日志会写在DReorder.txt文件中，可以打开查看。
以下为脚本：
[fold=Data_Reorder (分割定义1) 核心引擎][pre lang="ruby"]#==============================================================================
# ■ Data_Reorder (分割定义 1)
#------------------------------------------------------------------------------
# 数据库重排工具 by SailCat
# 该程序能够将数据库内容ID重新排列，包括插入空序列，紧密重排，交换，重设等
#==============================================================================
class Data_Reorder
#--------------------------------------------------------------------------
# ● 初期化
#--------------------------------------------------------------------------
def initialize
# 加载数据文件
$data_actors = load_data("Data/Actors.rxdata")
$data_classes = load_data("Data/Classes.rxdata")
$data_skills = load_data("Data/Skills.rxdata")
$data_items = load_data("Data/Items.rxdata")
$data_weapons = load_data("Data/Weapons.rxdata")
$data_armors = load_data("Data/Armors.rxdata")
$data_enemies = load_data("Data/Enemies.rxdata")
$data_troops = load_data("Data/Troops.rxdata")
$data_states = load_data("Data/States.rxdata")
$data_animations = load_data("Data/Animations.rxdata")
$data_tilesets = load_data("Data/Tilesets.rxdata")
$data_common_events = load_data("Data/CommonEvents.rxdata")
$data_system = load_data("Data/System.rxdata")
# 初始化被修改的ID表
@mod_actor_ids = {}
@mod_class_ids = {}
@mod_skill_ids = {}
@mod_item_ids = {}
@mod_weapon_ids = {}
@mod_armor_ids = {}
@mod_enemy_ids = {}
@mod_troop_ids = {}
@mod_state_ids = {}
@mod_anime_ids = {}
@mod_tileset_ids = {}
@mod_common_ids = {}
@mod_element_ids = {}
# 删除前次导出的文件
if FileTest.exist?("DReorder.txt")
File.delete("DReorder.txt")
end
end
#--------------------------------------------------------------------------
# ● 文本的变换
# 用于显示文章、脚本变换等
# text: 源文本
# mod_ids: 变换用ID表
# regex: 正则表达式
#--------------------------------------------------------------------------
def translate_text(text, mod_ids, regex)
log = ""
loop do
if text[regex] != nil
id = $2.to_i
if mod_ids.has_key?(id)
log += " 引用 #{id} -> #{mod_ids[id]}"
id = mod_ids[id]
end
text.sub!(regex) {$1 + "\001#{id}\001" + $3}
else
text.gsub!(/\001/) {""}
break
end
end
return log
end
#--------------------------------------------------------------------------
# ● 处理战斗事件
# f: 输出日志的文件
# proc: 变换的内容
# check_actor: 检查角色
# check_enemy: 检查敌人
#--------------------------------------------------------------------------
def translate_troop_events(f, proc, check_actor = false, check_enemy = false)
s = false
# 循环队伍中所有事件
for i in 1...$data_troops.size
troop = $data_troops
if troop != nil
t = false
log = sprintf(" □ 队伍 %d: %s \n", troop.id, troop.name)
# 如果要检查敌人情况
if check_enemy
for member in troop.members
if @mod_enemy_ids.has_key?(member.enemy_id)
t = true
log += sprintf(" 敌人: %d -> %d\n",
member.enemy_id, @mod_enemy_ids[member.enemy_id])
member.enemy_id = @mod_enemy_ids[member.enemy_id]
end
end
end
# 循环事件的每一页
page_id = 0
troop.pages.each do |page|
page_id += 1
# 如果条件中引用了角色
if check_actor and page.condition.actor_valid
if @mod_actor_ids.has_key?(page.condition.actor_id)
t = true
log += sprintf(" 页 %d: 条件角色 %d -> %d\n", page_id,
page.condition.actor_id, @mod_actor_ids[page.condition.actor_id])
page.condition.actor_id = @mod_actor_ids[page.condition.actor_id]
end
end
# 如果指令不为空
if page.list.length > 0
# 循环页的所有指令
page.list.each do |command|
vlog = proc.call(command)
if vlog != ""
t = true
log += sprintf(" 页 %d: 指令 %s", page_id, vlog)
end
end
end
end
# 输出事件提示字样
if t
unless s
f.write("-----------------------------------------------------\n")
f.write(" ■ 战斗事件\n")
f.write("-----------------------------------------------------\n")
s = true
end
f.write(log)
end
end
end
save_data($data_troops, "Data/Troops.rxdata") if s
end
#--------------------------------------------------------------------------
# ● 处理公共事件
# f: 输出日志的文件
# proc: 变换的内容
#--------------------------------------------------------------------------
def translate_common_events(f, proc)
# 处理公共事件
s = false
# 循环所有公共事件
for i in 1...$data_common_events.size
event = $data_common_events
if event != nil
t = false
log = sprintf(" □ 公共事件 %d: %s \n", event.id, event.name)
# 如果指令不为空
if event.list.length > 0
# 循环事件的所有指令
event.list.each do |command|
vlog = proc.call(command)
if vlog != ""
t = true
log += sprintf(" 指令 %s", vlog)
end
end
end
# 输出事件提示字样
if t
unless s
f.write("-----------------------------------------------------\n")
f.write(" ■ 公共事件\n")
f.write("-----------------------------------------------------\n")
s = true
end
f.write(log)
end
end
end
save_data($data_common_events, "Data/CommonEvents.rxdata") if s
end
#--------------------------------------------------------------------------
# ● 处理地图事件
# f: 输出日志的文件
# proc: 变换的内容
# mod_ids: 变换事件脚本用的对照表
# regexs: 变换事件脚本用的正则表达式
# check_enemy: 检查遇敌列表
# check_tileset: 检查图块
#--------------------------------------------------------------------------
def translate_map_events(f, proc, mod_ids, regexs, check_troop = false, check_tileset = false)
# 循环所有地图
for map_id in 1..999
map_name = sprintf("Data/Map%03d.rxdata", map_id)
# 载入当前地图
if FileTest.exist?(map_name)
Graphics.update
map = load_data(map_name)
else
next
end
s = false
# 循环地图中所有事件
for i in 1..999
event = map.events
if event != nil
t = false
log = sprintf(" □ 事件 %d: %s \n", event.id, event.name)
# 循环事件的每一页
page_id = 0
event.pages.each do |page|
page_id += 1
# 如果自定义移动路线
if page.move_type == 3
log2 = ""
# 循环自定义移动指令
for movecommand in page.move_route.list
# 脚本
if movecommand.code == 45
regexs.each do |r|
log2 += translate_text(movecommand.parameters[0],
mod_ids, r)
end
end
end
if log2 != ""
t = true
log += sprintf(" 页 %d: 自定义路线:%s\n", page_id, log2)
end
end
# 如果指令不为空
if page.list.length > 0
# 循环页的所有指令
page.list.each do |command|
vlog = proc.call(command)
if vlog != ""
t = true
log += sprintf(" 页 %d: 指令 %s", page_id, vlog)
end
end
end
end
# 输出事件提示字样
if t
unless s
f.write("-----------------------------------------------------\n")
f.write(sprintf(" ■ 地图ID: %d\n", map_id))
f.write("-----------------------------------------------------\n")
s = true
end
f.write(log)
end
end
end
# 如果要检查遇敌列表
log = ""
if check_troop
for i in 0...map.encounter_list.size
if @mod_troop_ids.has_key?(map.encounter_list)
log += sprintf(" □ 遇敌队伍: %d -> %d\n",
map.encounter_list, @mod_troop_ids[map.encounter_list])
map.encounter_list = @mod_troop_ids[map.encounter_list]
end
end
end
# 如果要检查图块
if check_tileset
if @mod_tileset_ids.has_key?(map.tileset_id)
log += sprintf(" □ 图块 ID: %d -> %d\n",
map.tileset_id, @mod_tileset_ids[map.tileset_id])
map.tileset_id = @mod_tileset_ids[map.tileset_id]
end
end
# 输出事件提示字样
if log != ""
unless s
f.write("-----------------------------------------------------\n")
f.write(sprintf(" ■ 地图ID: %d\n", map_id))
f.write("-----------------------------------------------------\n")
s = true
end
f.write(log)
end
save_data(map, map_name) if s
end
end
#--------------------------------------------------------------------------
# ● 插入序号
# data_source: 数据源
# mod_ids: 记录变更的表
# new_object: 空白对象
# position: 插入位置
# count: 插入的数目
#--------------------------------------------------------------------------
def insert(data_source, mod_ids, new_object, position, count)
# 初始化被修改的ID表
mod_ids.clear
# 从最后一个开始
id = position + count - 1
# 循环每一个大于position的ID
while id >= position
object = data_source[id]
# 如果该对象存在
if object != nil
# 对象后移
object.id = id + count
data_source[id + count] = object
# 设置修改标记
mod_ids[id] = id + count
end
# 原位置空
dummy_object = new_object.clone
dummy_object.id = id
data_source[id] = dummy_object
id -= 1
end
end
#--------------------------------------------------------------------------
# ● 交换序号
# data_source: 数据源
# mod_ids: 记录变更的表
# id1: 序号1
# id2: 序号2
#--------------------------------------------------------------------------
def swap(data_source, mod_ids, id1, id2)
# 初始化被修改的ID表
mod_ids.clear
# 取得2个对象
object1 = data_source[id1]
object2 = data_source[id2]
# 两个对象都存在的情况下
if object1 != nil and object2 != nil
# 互换ID
object1.id = id2
object2.id = id1
# 互换对象
data_source[id1] = object2
data_source[id2] = object1
# 设置修改标记
mod_ids[id1] = id2
mod_ids[id2] = id1
end
end
#--------------------------------------------------------------------------
# ● 设置新的序号
# data_source: 数据源
# mod_ids: 记录变更的表
# old_ids: 原序号
# new_id: 新序号
#--------------------------------------------------------------------------
def set_id(data_source, mod_ids, old_ids, new_id)
# 初始化被修改的ID表
mod_ids.clear
# 单个调整的情况下，转换为区段调整
if old_ids.is_a?(Integer)
old_ids = old_ids..old_ids
end
offset = new_id - old_ids.first
range = old_ids.last - old_ids.first
range += 1 unless old_ids.exclude_end?
return if offset == 0
# 取得原对象
objects = data_source[old_ids]
objects.each do |object|
# 如果原对象存在
if object != nil
# 更改对象ID
mod_ids[object.id] = object.id + offset
object.id += offset
end
end
# 移位操作
if offset > 0
last_id = old_ids.first + range
last_id.upto(new_id + range - 1) do |id|
object = data_source[id]
object.id -= range
data_source[id - range] = object
mod_ids[id] = object.id
end
else
last_id = old_ids.first - 1
last_id.downto(new_id) do |id|
object = data_source[id]
object.id += range
data_source[id + range] = object
mod_ids[id] = object.id
end
end
# 设置对象索引
objects.each do |object|
if objects != nil
data_source[object.id] = object
end
end
end
#--------------------------------------------------------------------------
# ● 重排序号(从1开始连续排)
# data_source: 数据源
# mod_ids: 记录变更的表
#--------------------------------------------------------------------------
def sort(data_source, mod_ids)
# 初始化被修改的ID表
mod_ids.clear
# 从1开始
new_id = 1
# 循环每个ID
for i in 1...data_source.size
object = data_source
# 如果该对象存在且不为空
if object != nil and object.name != ""
# 如果对象已经移位
if i != new_id
# 跟着前移
object.id = new_id
data_source[new_id] = object
# 设置修改标记
mod_ids = new_id
end
new_id += 1
end
end
data_source.delete_at(new_id) until data_source.size == new_id
end
#--------------------------------------------------------------------------
# ● 压缩数据库
#--------------------------------------------------------------------------
def zap
sort_actor
sort_class
sort_skill
sort_item
sort_weapon
sort_armor
sort_enemy
sort_troop
sort_state
sort_anime
sort_tileset
sort_common
sort_element
end
end
[/pre][/fold]
[fold=Data_Reorder (分割定义2) 角色数据][pre lang="ruby"]#==============================================================================
# ■ Data_Reorder (分割定义 2)
#------------------------------------------------------------------------------
# 数据库重排工具 by SailCat
# 该程序能够将数据库内容ID重新排列，包括插入空序列，紧密重排，交换，重设等
#==============================================================================
class Data_Reorder
#--------------------------------------------------------------------------
# ● 插入角色序号
# position: 插入位置
# count: 插入的数目
#--------------------------------------------------------------------------
def insert_actor(position, count)
insert($data_actors, @mod_actor_ids, RPG::Actor.new, position, count)
# 刷新角色ID的引用
reset_actors
end
#--------------------------------------------------------------------------
# ● 交换角色序号
# actor_id1: 角色序号1
# actor_id2: 角色序号2
#--------------------------------------------------------------------------
def swap_actor(actor_id1, actor_id2)
swap($data_actors, @mod_actor_ids, actor_id1, actor_id2)
# 刷新角色ID的引用
reset_actors
end
#--------------------------------------------------------------------------
# ● 设置新的角色序号
# old_actor_ids: 原角色序号
# new_actor_id: 新角色序号
#--------------------------------------------------------------------------
def set_actor_id(old_actor_ids, new_actor_id)
set_id($data_actors, @mod_actor_ids, old_actor_ids, new_actor_id)
# 刷新角色ID的引用
reset_actors
end
#--------------------------------------------------------------------------
# ● 重排角色序号(从1开始连续排)
#--------------------------------------------------------------------------
def sort_actor
sort($data_actors, @mod_actor_ids)
# 刷新角色ID的引用
reset_actors
end
#--------------------------------------------------------------------------
# ● 扩展角色序号
# num: 新的角色个数
#--------------------------------------------------------------------------
def expand_actor(num)
l = $data_actors.size
if l <= num
for i in l..num
$data_actors = RPG::Actor.new
end
save_data($data_actors, "Data/Actors.rxdata")
end
end
#--------------------------------------------------------------------------
# ● 刷新角色ID的引用
#--------------------------------------------------------------------------
def reset_actors
# 刷新数据库引用
reset_actors_in_database
# 刷新地图引用
reset_actors_in_maps
# 保存修改
save_data($data_actors, "Data/Actors.rxdata")
end
#--------------------------------------------------------------------------
# ● 刷新事件引用（角色）
# command: 指令
#--------------------------------------------------------------------------
def reset_actors_in_command(command)
log = ""
regex1 = /(\\n\[)([0-9]+)(\])/
regex2 = /(\$game_actors\[|\$data_actors\[)([0-9]+)(\])/
case command.code
when 101, 401 # 显示文章
log = translate_text(command.parameters[0], @mod_actor_ids, regex1)
if log != ""
log = sprintf("显示文章:%s\n", log)
end
when 102 # 显示选择项
for i in 0...command.parameters[0].size
log += translate_text(command.parameters[0], @mod_actor_ids, regex1)
end
if log != ""
log = sprintf("显示选择项:%s\n", log)
end
when 111 # 条件分歧
if command.parameters[0] == 4 # 角色
if @mod_actor_ids.has_key?(command.parameters[1])
log = sprintf(" 角色 %d -> %d", command.parameters[1],
@mod_actor_ids[command.parameters[1]])
command.parameters[1] = @mod_actor_ids[command.parameters[1]]
end
elsif command.parameters[0] == 12 # 脚本
log = translate_text(command.parameters[1], @mod_actor_ids, regex2)
end
if log != ""
log = sprintf("条件分歧:%s\n", log)
end
when 122 # 变量操作
if command.parameters[3] == 4 # 角色
if @mod_actor_ids.has_key?(command.parameters[4])
log = sprintf("变量操作: 角色 %d -> %d", command.parameters[4],
@mod_actor_ids[command.parameters[4]])
command.parameters[4] = @mod_actor_ids[command.parameters[4]]
end
end
when 129 # 替换队员
if @mod_actor_ids.has_key?(command.parameters[0])
log = sprintf("替换队员: %d -> %d\n", command.parameters[0],
@mod_actor_ids[command.parameters[0]])
command.parameters[0] = @mod_actor_ids[command.parameters[0]]
end
when 209 # 设置移动路线
# 循环强制移动指令
for movecommand in command.parameters[1].list
# 脚本
if movecommand.code == 45
log = translate_text(movecommand.parameters[0], @mod_actor_ids, regex2)
end
end
if log != ""
log = sprintf("设置移动路线:%s\n", log)
end
when 303 # 输入名称
if @mod_actor_ids.has_key?(command.parameters[0])
log = sprintf("输入名称: %d -> %d\n", command.parameters[0],
@mod_actor_ids[command.parameters[0]])
command.parameters[0] = @mod_actor_ids[command.parameters[0]]
end
when 311..322 # 更改指数
s = ["增减HP", "增减SP", "更改状态", "完全回复", "增减EXP", "增减等级",
"增减能力", "增减特技", "变更装备", "变更角色姓名", "变更角色职业",
"变更角色图形"][command.code - 311]
if @mod_actor_ids.has_key?(command.parameters[0])
log = sprintf("%s: %d -> %d\n", s, command.parameters[0],
@mod_actor_ids[command.parameters[0]])
command.parameters[0] = @mod_actor_ids[command.parameters[0]]
end
when 355, 655 # 脚本
log = translate_text(command.parameters[0], @mod_actor_ids, regex2)
if log != ""
log = sprintf("脚本:%s\n", log)
end
end
return log
end
#--------------------------------------------------------------------------
# ● 刷新数据库引用（角色）
#--------------------------------------------------------------------------
def reset_actors_in_database
proc = Proc.new {|c| reset_actors_in_command(c)}
File.open("DReorder.txt", "a") do |f|
# 通用处理
translate_troop_events(f, proc, true)
translate_common_events(f, proc)
# 处理初期同伴
s = false
log = ""
# 循环所有初期同伴
for i in 0...$data_system.party_members.size
if @mod_actor_ids.has_key?($data_system.party_members)
s = true
log += sprintf(" □ 初期同伴: %d -> %d\n", $data_system.party_members,
@mod_actor_ids[$data_system.party_members])
$data_system.party_members = @mod_actor_ids[$data_system.party_members]
end
end
# 循环所有战斗测试员
for i in 0...$data_system.test_battlers.size
test_battler = $data_system.test_battlers
if @mod_actor_ids.has_key?(test_battler.actor_id)
s = true
log += sprintf(" □ 战斗测试员: %d -> %d\n", test_battler.actor_id,
@mod_actor_ids[test_battler.actor_id])
test_battler.actor_id = @mod_actor_ids[test_battler.actor_id]
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 系统\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_system, "Data/System.rxdata")
end
end
end
#--------------------------------------------------------------------------
# ● 刷新地图引用（角色）
#--------------------------------------------------------------------------
def reset_actors_in_maps
proc = Proc.new {|c| reset_actors_in_command(c)}
regexs = [/(\$game_actors\[|\$data_actors\[)([0-9]+)(\])/]
File.open("DReorder.txt", "a") do |f|
translate_map_events(f, proc, @mod_actor_ids, regexs)
end
end
end
[/pre][/fold]
[fold=Data_Reorder (分割定义3) 职业数据][pre lang="ruby"]#==============================================================================
# ■ Data_Reorder (分割定义 3)
#------------------------------------------------------------------------------
# 数据库重排工具 by SailCat
# 该程序能够将数据库内容ID重新排列，包括插入空序列，紧密重排，交换，重设等
#==============================================================================
class Data_Reorder
#--------------------------------------------------------------------------
# ● 插入职业序号
# position: 插入位置
# count: 插入的数目
#--------------------------------------------------------------------------
def insert_class(position, count)
insert($data_classes, @mod_class_ids, RPG::Class.new, position, count)
# 刷新职业ID的引用
reset_classes
end
#--------------------------------------------------------------------------
# ● 交换职业序号
# class_id1: 职业序号1
# class_id2: 职业序号2
#--------------------------------------------------------------------------
def swap_class(class_id1, class_id2)
swap($data_classes, @mod_class_ids, class_id1, class_id2)
# 刷新职业ID的引用
reset_classes
end
#--------------------------------------------------------------------------
# ● 设置新的职业序号
# old_class_ids: 原职业序号
# new_class_id: 新职业序号
#--------------------------------------------------------------------------
def set_class_id(old_class_ids, new_class_id)
set_id($data_classes, @mod_class_ids, old_class_ids, new_class_id)
# 刷新职业ID的引用
reset_classes
end
#--------------------------------------------------------------------------
# ● 重排职业序号(从1开始连续排)
#--------------------------------------------------------------------------
def sort_class
sort($data_classes, @mod_class_ids)
# 刷新职业ID的引用
reset_classes
end
#--------------------------------------------------------------------------
# ● 扩展职业序号
# num: 新的职业个数
#--------------------------------------------------------------------------
def expand_class(num)
l = $data_classes.size
if l <= num
for i in l..num
$data_classes = RPG::Class.new
end
save_data($data_classes, "Data/Classes.rxdata")
end
end
#--------------------------------------------------------------------------
# ● 刷新职业ID的引用
#--------------------------------------------------------------------------
def reset_classes
# 刷新数据库引用
reset_classes_in_database
# 刷新地图引用
reset_classes_in_maps
# 保存修改
save_data($data_classes, "Data/Classes.rxdata")
end
#--------------------------------------------------------------------------
# ● 刷新事件引用（职业）
# command: 指令
#--------------------------------------------------------------------------
def reset_classes_in_command(command)
log = ""
regex1 = /(\$data_classes\[)([0-9]+)(\])/
regex2 = /(\.class_id[ <=>!]+)([0-9]+)()/
case command.code
when 111 # 条件分歧
if command.parameters[0] == 12 # 脚本
log = translate_text(command.parameters[1], @mod_class_ids, regex1)
log += translate_text(command.parameters[1], @mod_class_ids, regex2)
end
if log != ""
log = sprintf("条件分歧:%s\n", log)
end
when 209 # 设置移动路线
# 循环强制移动指令
for movecommand in command.parameters[1].list
# 脚本
if movecommand.code == 45
log = translate_text(movecommand.parameters[0], @mod_class_ids, regex1)
log += translate_text(movecommand.parameters[0], @mod_class_ids, regex2)
end
end
if log != ""
log = sprintf("设置移动路线:%s\n", log)
end
when 321 # 变更角色职业
if @mod_class_ids.has_key?(command.parameters[1])
log = sprintf("变更角色职业: %d -> %d\n", command.parameters[1],
@mod_class_ids[command.parameters[1]])
command.parameters[1] = @mod_class_ids[command.parameters[1]]
end
when 355, 655 # 脚本
log = translate_text(command.parameters[0], @mod_class_ids, regex1)
log += translate_text(command.parameters[0], @mod_class_ids, regex2)
if log != ""
log = sprintf("脚本:%s\n", log)
end
end
return log
end
#--------------------------------------------------------------------------
# ● 刷新数据库引用（职业）
#--------------------------------------------------------------------------
def reset_classes_in_database
proc = Proc.new {|c| reset_classes_in_command(c)}
File.open("DReorder.txt", "a") do |f|
# 通用处理
translate_troop_events(f, proc)
translate_common_events(f, proc)
# 处理角色职业
s = false
log = ""
# 循环所有角色
for actor in $data_actors
if actor != nil and @mod_class_ids.has_key?(actor.class_id)
s = true
log += sprintf(" □ 角色 %s 的职业: %d -> %d\n", actor.name,
actor.class_id, @mod_class_ids[actor.class_id])
actor.class_id = @mod_class_ids[actor.class_id]
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 角色\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_actors, "Data/Actors.rxdata")
end
end
end
#--------------------------------------------------------------------------
# ● 刷新地图引用（职业）
#--------------------------------------------------------------------------
def reset_classes_in_maps
proc = Proc.new {|c| reset_classes_in_command(c)}
regexs = [/(\$data_classes\[)([0-9]+)(\])/, /(\.class_id[ <=>!]+)([0-9]+)()/]
File.open("DReorder.txt", "a") do |f|
translate_map_events(f, proc, @mod_class_ids, regexs)
end
end
end
[/pre][/fold]
[fold=Data_Reorder (分割定义4) 特技数据][pre lang="ruby"]#==============================================================================
# ■ Data_Reorder (分割定义 4)
#------------------------------------------------------------------------------
# 数据库重排工具 by SailCat
# 该程序能够将数据库内容ID重新排列，包括插入空序列，紧密重排，交换，重设等
#==============================================================================
class Data_Reorder
#--------------------------------------------------------------------------
# ● 插入特技序号
# position: 插入位置
# count: 插入的数目
#--------------------------------------------------------------------------
def insert_skill(position, count)
insert($data_skills, @mod_skill_ids, RPG::Skill.new, position, count)
# 刷新特技ID的引用
reset_skills
end
#--------------------------------------------------------------------------
# ● 交换特技序号
# skill_id1: 特技序号1
# skill_id2: 特技序号2
#--------------------------------------------------------------------------
def swap_skill(skill_id1, skill_id2)
swap($data_skills, @mod_skill_ids, skill_id1, skill_id2)
# 刷新特技ID的引用
reset_skills
end
#--------------------------------------------------------------------------
# ● 设置新的特技序号
# old_skill_ids: 原特技序号
# new_skill_id: 新特技序号
#--------------------------------------------------------------------------
def set_skill_id(old_skill_ids, new_skill_id)
set_id($data_skills, @mod_skill_ids, old_skill_ids, new_skill_id)
# 刷新特技ID的引用
reset_skills
end
#--------------------------------------------------------------------------
# ● 重排特技序号(从1开始连续排)
#--------------------------------------------------------------------------
def sort_skill
sort($data_skills, @mod_skill_ids)
# 刷新特技ID的引用
reset_skills
end
#--------------------------------------------------------------------------
# ● 扩展特技序号
# num: 新的特技个数
#--------------------------------------------------------------------------
def expand_skill(num)
l = $data_skills.size
if l <= num
for i in l..num
$data_skills = RPG::Skill.new
end
save_data($data_skills, "Data/Skills.rxdata")
end
end
#--------------------------------------------------------------------------
# ● 刷新特技ID的引用
#--------------------------------------------------------------------------
def reset_skills
# 刷新数据库引用
reset_skills_in_database
# 刷新地图引用
reset_skills_in_maps
# 保存修改
save_data($data_skills, "Data/Skills.rxdata")
end
#--------------------------------------------------------------------------
# ● 刷新事件引用（特技）
# command: 指令
#--------------------------------------------------------------------------
def reset_skills_in_command(command)
log = ""
regex1 = /(\$data_skills\[)([0-9]+)(\])/
regex2 = /(\.skill_learn\?\(|\.learn_skill\(|\.forget_skill\(|\.skill_can_use\?\()([0-9]+)(\))/
case command.code
when 111 # 条件分歧
if command.parameters[0] == 4 and command.parameters[2] == 2 # 角色的特技
if @mod_skill_ids.has_key?(command.parameters[3])
log = sprintf(" 角色特技: %d -> %d", command.parameters[3],
@mod_skill_ids[command.parameters[3]])
command.parameters[3] = @mod_skill_ids[command.parameters[3]]
end
elsif command.parameters[0] == 12 # 脚本
log = translate_text(command.parameters[1], @mod_skill_ids, regex1)
log += translate_text(command.parameters[1], @mod_skill_ids, regex2)
end
if log != ""
log = sprintf("条件分歧:%s\n", log)
end
when 209 # 设置移动路线
# 循环强制移动指令
for movecommand in command.parameters[1].list
# 脚本
if movecommand.code == 45
log = translate_text(movecommand.parameters[0], @mod_skill_ids, regex1)
log += translate_text(movecommand.parameters[0], @mod_skill_ids, regex2)
end
end
if log != ""
log = sprintf("设置移动路线:%s\n", log)
end
when 318 # 增减特技
if @mod_skill_ids.has_key?(command.parameters[2])
log = sprintf("增减特技: %d -> %d\n", command.parameters[2],
@mod_skill_ids[command.parameters[2]])
command.parameters[2] = @mod_skill_ids[command.parameters[2]]
end
when 339 # 强制行动
if command.parameters[2] == 1 # 使用特技的情况下
if @mod_skill_ids.has_key?(command.parameters[3])
log = sprintf("强制行动: 特技 %d -> %d\n", command.parameters[3],
@mod_skill_ids[command.parameters[3]])
command.parameters[3] = @mod_skill_ids[command.parameters[3]]
end
end
when 355, 655 # 脚本
log = translate_text(command.parameters[0], @mod_skill_ids, regex1)
log += translate_text(command.parameters[0], @mod_skill_ids, regex2)
if log != ""
log = sprintf("脚本:%s\n", log)
end
end
return log
end
#--------------------------------------------------------------------------
# ● 刷新数据库引用（特技）
#--------------------------------------------------------------------------
def reset_skills_in_database
proc = Proc.new {|c| reset_skills_in_command(c)}
File.open("DReorder.txt", "a") do |f|
# 通用处理
translate_troop_events(f, proc)
translate_common_events(f, proc)
# 处理职业特技
s = false
log = ""
# 循环所有职业
for klass in $data_classes
if klass != nil
for learning in klass.learnings
if @mod_skill_ids.has_key?(learning.skill_id)
s = true
log += sprintf(" □ 职业 %s 的特技: %d -> %d\n", klass.name,
learning.skill_id, @mod_skill_ids[learning.skill_id])
learning.skill_id = @mod_skill_ids[learning.skill_id]
end
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 职业\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_classes, "Data/Classes.rxdata")
end
# 处理敌人特技
s = false
log = ""
for enemy in $data_enemies
if enemy != nil
for action in enemy.actions
if @mod_skill_ids.has_key?(action.skill_id)
s = true
log += sprintf(" □ 敌人 %s 的特技: %d -> %d\n", enemy.name,
action.skill_id, @mod_skill_ids[action.skill_id])
action.skill_id = @mod_skill_ids[action.skill_id]
end
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 敌人\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_enemies, "Data/Enemies.rxdata")
end
end
end
#--------------------------------------------------------------------------
# ● 刷新地图引用（特技）
#--------------------------------------------------------------------------
def reset_skills_in_maps
proc = Proc.new {|c| reset_skills_in_command(c)}
regexs = [/(\$data_skills\[)([0-9]+)(\])/,
/(\.skill_learn\?\(|\.learn_skill\(|\.forget_skill\(|\.skill_can_use\?\()([0-9]+)(\))/]
File.open("DReorder.txt", "a") do |f|
translate_map_events(f, proc, @mod_skill_ids, regexs)
end
end
end
[/pre][/fold]
[fold=Data_Reorder (分割定义5) 物品数据][pre lang="ruby"]#==============================================================================
# ■ Data_Reorder (分割定义 5)
#------------------------------------------------------------------------------
# 数据库重排工具 by SailCat
# 该程序能够将数据库内容ID重新排列，包括插入空序列，紧密重排，交换，重设等
#==============================================================================
class Data_Reorder
#--------------------------------------------------------------------------
# ● 插入物品序号
# position: 插入位置
# count: 插入的数目
#--------------------------------------------------------------------------
def insert_item(position, count)
insert($data_items, @mod_item_ids, RPG::Item.new, position, count)
# 刷新物品ID的引用
reset_items
end
#--------------------------------------------------------------------------
# ● 交换物品序号
# item_id1: 物品序号1
# item_id2: 物品序号2
#--------------------------------------------------------------------------
def swap_item(item_id1, item_id2)
swap($data_items, @mod_item_ids, item_id1, item_id2)
# 刷新物品ID的引用
reset_items
end
#--------------------------------------------------------------------------
# ● 设置新的物品序号
# old_item_ids: 原物品序号
# new_item_id: 新物品序号
#--------------------------------------------------------------------------
def set_item_id(old_item_ids, new_item_id)
set_id($data_items, @mod_item_ids, old_item_ids, new_item_id)
# 刷新物品ID的引用
reset_items
end
#--------------------------------------------------------------------------
# ● 重排物品序号(从1开始连续排)
#--------------------------------------------------------------------------
def sort_item
sort($data_items, @mod_item_ids)
# 刷新物品ID的引用
reset_items
end
#--------------------------------------------------------------------------
# ● 扩展物品序号
# num: 新的物品个数
#--------------------------------------------------------------------------
def expand_item(num)
l = $data_items.size
if l <= num
for i in l..num
$data_items = RPG::Item.new
end
save_data($data_items, "Data/Items.rxdata")
end
end
#--------------------------------------------------------------------------
# ● 刷新物品ID的引用
#--------------------------------------------------------------------------
def reset_items
# 刷新数据库引用
reset_items_in_database
# 刷新地图引用
reset_items_in_maps
# 保存修改
save_data($data_items, "Data/Items.rxdata")
end
#--------------------------------------------------------------------------
# ● 刷新事件引用（物品）
# command: 指令
#--------------------------------------------------------------------------
def reset_items_in_command(command)
log = ""
regex1 = /(\$data_items\[)([0-9]+)(\])/
regex2 = /(\.item_can_use\?\(|\.gain_item\(|\.lose_item\(|\.item_number\()([0-9]+)(\)|,)/
case command.code
when 111 # 条件分歧
if command.parameters[0] == 8 # 物品
if @mod_item_ids.has_key?(command.parameters[1])
log = sprintf(" 物品: %d -> %d", command.parameters[1],
@mod_item_ids[command.parameters[1]])
command.parameters[1] = @mod_item_ids[command.parameters[1]]
end
elsif command.parameters[0] == 12 # 脚本
log = translate_text(command.parameters[1], @mod_item_ids, regex1)
log += translate_text(command.parameters[1], @mod_item_ids, regex2)
end
if log != ""
log = sprintf("条件分歧:%s\n", log)
end
when 122 # 变量操作
if command.parameters[3] == 3 # 物品
if @mod_item_ids.has_key?(command.parameters[4])
log = sprintf("变量操作: 物品 %d -> %d", command.parameters[4],
@mod_item_ids[command.parameters[4]])
command.parameters[4] = @mod_item_ids[command.parameters[4]]
end
end
when 126 # 增减物品
if @mod_item_ids.has_key?(command.parameters[0])
log = sprintf("增减物品: %d -> %d\n", command.parameters[0],
@mod_item_ids[command.parameters[0]])
command.parameters[0] = @mod_item_ids[command.parameters[0]]
end
when 209 # 设置移动路线
# 循环强制移动指令
for movecommand in command.parameters[1].list
# 脚本
if movecommand.code == 45
log = translate_text(movecommand.parameters[0], @mod_item_ids, regex1)
log += translate_text(movecommand.parameters[0], @mod_item_ids, regex2)
end
end
if log != ""
log = sprintf("设置移动路线:%s\n", log)
end
when 302, 605 # 商店处理
if command.parameters[0] == 0 # 物品
if @mod_item_ids.has_key?(command.parameters[1])
log = sprintf("商店处理: 物品 %d -> %d\n", command.parameters[1],
@mod_item_ids[command.parameters[1]])
command.parameters[1] = @mod_item_ids[command.parameters[1]]
end
end
when 355, 655 # 脚本
log = translate_text(command.parameters[0], @mod_item_ids, regex1)
log += translate_text(command.parameters[0], @mod_item_ids, regex2)
if log != ""
log = sprintf("脚本:%s\n", log)
end
end
return log
end
#--------------------------------------------------------------------------
# ● 刷新数据库引用（物品）
#--------------------------------------------------------------------------
def reset_items_in_database
proc = Proc.new {|c| reset_items_in_command(c)}
File.open("DReorder.txt", "a") do |f|
# 通用处理
translate_troop_events(f, proc)
translate_common_events(f, proc)
# 处理敌人物品
s = false
log = ""
for enemy in $data_enemies
if enemy != nil
if @mod_item_ids.has_key?(enemy.item_id)
s = true
log += sprintf(" □ 敌人 %s 的物品: %d -> %d\n", enemy.name,
enemy.item_id, @mod_item_ids[enemy.item_id])
enemy.item_id = @mod_item_ids[enemy.item_id]
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 敌人\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_enemies, "Data/Enemies.rxdata")
end
end
end
#--------------------------------------------------------------------------
# ● 刷新地图引用（物品）
#--------------------------------------------------------------------------
def reset_items_in_maps
proc = Proc.new {|c| reset_items_in_command(c)}
regexs = [/(\$data_items\[)([0-9]+)(\])/,
/(\.item_can_use\?\(|\.gain_item\(|\.lose_item\(|\.item_number\()([0-9]+)(\)|,)/]
File.open("DReorder.txt", "a") do |f|
translate_map_events(f, proc, @mod_item_ids, regexs)
end
end
end
[/pre][/fold]
[fold=Data_Reorder (分割定义6) 武器数据][pre lang="ruby"]#==============================================================================
# ■ Data_Reorder (分割定义 6)
#------------------------------------------------------------------------------
# 数据库重排工具 by SailCat
# 该程序能够将数据库内容ID重新排列，包括插入空序列，紧密重排，交换，重设等
#==============================================================================
class Data_Reorder
#--------------------------------------------------------------------------
# ● 插入武器序号
# position: 插入位置
# count: 插入的数目
#--------------------------------------------------------------------------
def insert_weapon(position, count)
insert($data_weapons, @mod_weapon_ids, RPG::Weapon.new, position, count)
# 刷新武器ID的引用
reset_weapons
end
#--------------------------------------------------------------------------
# ● 交换武器序号
# weapon_id1: 武器序号1
# weapon_id2: 武器序号2
#--------------------------------------------------------------------------
def swap_weapon(weapon_id1, weapon_id2)
swap($data_weapons, @mod_weapon_ids, weapon_id1, weapon_id2)
# 刷新武器ID的引用
reset_weapons
end
#--------------------------------------------------------------------------
# ● 设置新的武器序号
# old_weapon_ids: 原武器序号
# new_weapon_id: 新武器序号
#--------------------------------------------------------------------------
def set_weapon_id(old_weapon_ids, new_weapon_id)
set_id($data_weapons, @mod_weapon_ids, old_weapon_ids, new_weapon_id)
# 刷新武器ID的引用
reset_weapons
end
#--------------------------------------------------------------------------
# ● 重排武器序号(从1开始连续排)
#--------------------------------------------------------------------------
def sort_weapon
sort($data_weapons, @mod_weapon_ids)
# 刷新武器ID的引用
reset_weapons
end
#--------------------------------------------------------------------------
# ● 扩展武器序号
# num: 新的武器个数
#--------------------------------------------------------------------------
def expand_weapon(num)
l = $data_weapons.size
if l <= num
for i in l..num
$data_weapons = RPG::Weapon.new
end
save_data($data_weapons, "Data/Weapons.rxdata")
end
end
#--------------------------------------------------------------------------
# ● 刷新武器ID的引用
#--------------------------------------------------------------------------
def reset_weapons
# 刷新数据库引用
reset_weapons_in_database
# 刷新地图引用
reset_weapons_in_maps
# 保存修改
save_data($data_weapons, "Data/Weapons.rxdata")
end
#--------------------------------------------------------------------------
# ● 刷新事件引用（武器）
# command: 指令
#--------------------------------------------------------------------------
def reset_weapons_in_command(command)
log = ""
regex1 = /(\$data_weapons\[)([0-9]+)(\])/
regex2 = /(\.weapon_number\(|\.gain_weapon\(|\.lose_weapon\(|\.equip\(0, ?)([0-9]+)(\)|,)/
case command.code
when 111 # 条件分歧
if command.parameters[0] == 4 and command.parameters[2] == 3 # 角色的武器
if @mod_weapon_ids.has_key?(command.parameters[3])
log = sprintf(" 角色武器: %d -> %d", command.parameters[3],
@mod_weapon_ids[command.parameters[3]])
command.parameters[3] = @mod_weapon_ids[command.parameters[3]]
end
elsif command.parameters[0] == 9 # 武器
if @mod_weapon_ids.has_key?(command.parameters[1])
log = sprintf(" 武器: %d -> %d", command.parameters[1],
@mod_weapon_ids[command.parameters[1]])
command.parameters[1] = @mod_weapon_ids[command.parameters[1]]
end
elsif command.parameters[0] == 12 # 脚本
log = translate_text(command.parameters[1], @mod_weapon_ids, regex1)
log += translate_text(command.parameters[1], @mod_weapon_ids, regex2)
end
if log != ""
log = sprintf("条件分歧:%s\n", log)
end
when 127 # 增减武器
if @mod_weapon_ids.has_key?(command.parameters[0])
log = sprintf("增减武器: %d -> %d\n", command.parameters[0],
@mod_weapon_ids[command.parameters[0]])
command.parameters[0] = @mod_weapon_ids[command.parameters[0]]
end
when 209 # 设置移动路线
# 循环强制移动指令
for movecommand in command.parameters[1].list
# 脚本
if movecommand.code == 45
log = translate_text(movecommand.parameters[0], @mod_weapon_ids, regex1)
log += translate_text(movecommand.parameters[0], @mod_weapon_ids, regex2)
end
end
if log != ""
log = sprintf("设置移动路线:%s\n", log)
end
when 302, 605 # 商店处理
if command.parameters[0] == 1 # 武器
if @mod_weapon_ids.has_key?(command.parameters[1])
log = sprintf("商店处理: 武器 %d -> %d\n", command.parameters[1],
@mod_weapon_ids[command.parameters[1]])
command.parameters[1] = @mod_weapon_ids[command.parameters[1]]
end
end
when 319 # 变更装备
if command.parameters[1] == 0 # 武器
if @mod_weapon_ids.has_key?(command.parameters[2])
log = sprintf("变更装备: 武器 %d -> %d\n", command.parameters[2],
@mod_weapon_ids[command.parameters[2]])
command.parameters[2] = @mod_weapon_ids[command.parameters[2]]
end
end
when 355, 655 # 脚本
log = translate_text(command.parameters[0], @mod_weapon_ids, regex1)
log += translate_text(command.parameters[0], @mod_weapon_ids, regex2)
if log != ""
log = sprintf("脚本:%s\n", log)
end
end
return log
end
#--------------------------------------------------------------------------
# ● 刷新数据库引用（武器）
#--------------------------------------------------------------------------
def reset_weapons_in_database
proc = Proc.new {|c| reset_weapons_in_command(c)}
File.open("DReorder.txt", "a") do |f|
# 通用处理
translate_troop_events(f, proc)
translate_common_events(f, proc)
# 处理角色武器
s = false
log = ""
for actor in $data_actors
if actor != nil
if @mod_weapon_ids.has_key?(actor.weapon_id)
s = true
log += sprintf(" □ 角色 %s 的武器: %d -> %d\n", actor.name,
actor.weapon_id, @mod_weapon_ids[actor.weapon_id])
actor.weapon_id = @mod_weapon_ids[actor.weapon_id]
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 角色\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_actors, "Data/Actors.rxdata")
end
# 处理职业武器
s = false
log = ""
for klass in $data_classes
if klass != nil
for i in 0...klass.weapon_set.size
if @mod_weapon_ids.has_key?(klass.weapon_set)
s = true
log += sprintf(" □ 职业 %s 的武器: %d -> %d\n", klass.name,
klass.weapon_set, @mod_weapon_ids[klass.weapon_set])
klass.weapon_set = @mod_weapon_ids[klass.weapon_set]
end
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 职业\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_classes, "Data/Classes.rxdata")
end
# 处理敌人武器
s = false
log = ""
for enemy in $data_enemies
if enemy != nil
if @mod_weapon_ids.has_key?(enemy.weapon_id)
s = true
log += sprintf(" □ 敌人 %s 的武器: %d -> %d\n", enemy.name,
enemy.weapon_id, @mod_weapon_ids[enemy.weapon_id])
enemy.weapon_id = @mod_weapon_ids[enemy.weapon_id]
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 敌人\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_enemies, "Data/Enemies.rxdata")
end
# 处理战斗测试员武器
s = false
log = ""
for test_battler in $data_system.test_battlers
if @mod_weapon_ids.has_key?(test_battler.weapon_id)
s = true
log += sprintf(" □ 战斗测试员 %d 的武器: %d -> %d\n", test_battler.actor_id,
test_battler.weapon_id, @mod_weapon_ids[test_battler.weapon_id])
test_battler.weapon_id = @mod_weapon_ids[test_battler.weapon_id]
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 系统\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_system, "Data/System.rxdata")
end
end
end
#--------------------------------------------------------------------------
# ● 刷新地图引用（武器）
#--------------------------------------------------------------------------
def reset_weapons_in_maps
proc = Proc.new {|c| reset_weapons_in_command(c)}
regexs = [/(\$data_weapons\[)([0-9]+)(\])/,
/(\.weapon_number\(|\.gain_weapon\(|\.lose_weapon\(|\.equip\(0, ?)([0-9]+)(\)|,)/]
File.open("DReorder.txt", "a") do |f|
translate_map_events(f, proc, @mod_weapon_ids, regexs)
end
end
end
[/pre][/fold]
[fold=Data_Reorder (分割定义7) 防具数据][pre lang="ruby"]#==============================================================================
# ■ Data_Reorder (分割定义 7)
#------------------------------------------------------------------------------
# 数据库重排工具 by SailCat
# 该程序能够将数据库内容ID重新排列，包括插入空序列，紧密重排，交换，重设等
#==============================================================================
class Data_Reorder
#--------------------------------------------------------------------------
# ● 插入防具序号
# position: 插入位置
# count: 插入的数目
#--------------------------------------------------------------------------
def insert_armor(position, count)
insert($data_armors, @mod_armor_ids, RPG::Armor.new, position, count)
# 刷新防具ID的引用
reset_armors
end
#--------------------------------------------------------------------------
# ● 交换防具序号
# armor_id1: 防具序号1
# armor_id2: 防具序号2
#--------------------------------------------------------------------------
def swap_armor(armor_id1, armor_id2)
swap($data_armors, @mod_armor_ids, armor_id1, armor_id2)
# 刷新防具ID的引用
reset_armors
end
#--------------------------------------------------------------------------
# ● 设置新的防具序号
# old_armor_ids: 原防具序号
# new_armor_id: 新防具序号
#--------------------------------------------------------------------------
def set_armor_id(old_armor_ids, new_armor_id)
set_id($data_armors, @mod_armor_ids, old_armor_ids, new_armor_id)
# 刷新防具ID的引用
reset_armors
end
#--------------------------------------------------------------------------
# ● 重排防具序号(从1开始连续排)
#--------------------------------------------------------------------------
def sort_armor
sort($data_armors, @mod_armor_ids)
# 刷新防具ID的引用
reset_armors
end
#--------------------------------------------------------------------------
# ● 扩展防具序号
# num: 新的防具个数
#--------------------------------------------------------------------------
def expand_armor(num)
l = $data_armors.size
if l <= num
for i in l..num
$data_armors = RPG::Armor.new
end
save_data($data_armors, "Data/Armors.rxdata")
end
end
#--------------------------------------------------------------------------
# ● 刷新防具ID的引用
#--------------------------------------------------------------------------
def reset_armors
# 刷新数据库引用
reset_armors_in_database
# 刷新地图引用
reset_armors_in_maps
# 保存修改
save_data($data_armors, "Data/Armors.rxdata")
end
#--------------------------------------------------------------------------
# ● 刷新事件引用（防具）
# command: 指令
#--------------------------------------------------------------------------
def reset_armors_in_command(command)
log = ""
regex1 = /(\$data_armors\[)([0-9]+)(\])/
regex2 = /(\.armor_number\(|\.gain_armor\(|\.lose_armor\(|\.equip\([1-4], ?)([0-9]+)(\)|,)/
case command.code
when 111 # 条件分歧
if command.parameters[0] == 4 and command.parameters[2] == 4 # 角色的防具
if @mod_armor_ids.has_key?(command.parameters[3])
log = sprintf(" 角色防具: %d -> %d", command.parameters[3],
@mod_armor_ids[command.parameters[3]])
command.parameters[3] = @mod_armor_ids[command.parameters[3]]
end
elsif command.parameters[0] == 10 # 防具
if @mod_armor_ids.has_key?(command.parameters[1])
log = sprintf(" 防具: %d -> %d", command.parameters[1],
@mod_armor_ids[command.parameters[1]])
command.parameters[1] = @mod_armor_ids[command.parameters[1]]
end
elsif command.parameters[0] == 12 # 脚本
log = translate_text(command.parameters[1], @mod_armor_ids, regex1)
log += translate_text(command.parameters[1], @mod_armor_ids, regex2)
end
if log != ""
log = sprintf("条件分歧:%s\n", log)
end
when 128 # 增减防具
if @mod_armor_ids.has_key?(command.parameters[0])
log = sprintf("增减防具: %d -> %d\n", command.parameters[0],
@mod_armor_ids[command.parameters[0]])
command.parameters[0] = @mod_armor_ids[command.parameters[0]]
end
when 209 # 设置移动路线
# 循环强制移动指令
for movecommand in command.parameters[1].list
# 脚本
if movecommand.code == 45
log = translate_text(movecommand.parameters[0], @mod_armor_ids, regex1)
log += translate_text(movecommand.parameters[0], @mod_armor_ids, regex2)
end
end
if log != ""
log = sprintf("设置移动路线:%s\n", log)
end
when 302, 605 # 商店处理
if command.parameters[0] == 2 # 防具
if @mod_armor_ids.has_key?(command.parameters[1])
log = sprintf("商店处理: 防具 %d -> %d\n", command.parameters[1],
@mod_armor_ids[command.parameters[1]])
command.parameters[1] = @mod_armor_ids[command.parameters[1]]
end
end
when 319 # 变更装备
if command.parameters[1] != 0 # 防具
if @mod_armor_ids.has_key?(command.parameters[2])
log = sprintf("变更装备: 防具 %d -> %d\n", command.parameters[2],
@mod_armor_ids[command.parameters[2]])
command.parameters[2] = @mod_armor_ids[command.parameters[2]]
end
end
when 355, 655 # 脚本
log = translate_text(command.parameters[0], @mod_armor_ids, regex1)
log += translate_text(command.parameters[0], @mod_armor_ids, regex2)
if log != ""
log = sprintf("脚本:%s\n", log)
end
end
return log
end
#--------------------------------------------------------------------------
# ● 刷新数据库引用（防具）
#--------------------------------------------------------------------------
def reset_armors_in_database
proc = Proc.new {|c| reset_armors_in_command(c)}
File.open("DReorder.txt", "a") do |f|
# 通用处理
translate_troop_events(f, proc)
translate_common_events(f, proc)
# 处理角色防具
s = false
log = ""
for actor in $data_actors
t = false
log2 = ""
if actor != nil
if @mod_armor_ids.has_key?(actor.armor1_id)
t = true
log2 += sprintf(" 盾牌: %d -> %d\n",
actor.armor1_id, @mod_armor_ids[actor.armor1_id])
actor.armor1_id = @mod_armor_ids[actor.armor1_id]
end
if @mod_armor_ids.has_key?(actor.armor2_id)
t = true
log2 += sprintf(" 头部: %d -> %d\n",
actor.armor2_id, @mod_armor_ids[actor.armor2_id])
actor.armor2_id = @mod_armor_ids[actor.armor2_id]
end
if @mod_armor_ids.has_key?(actor.armor3_id)
t = true
log2 += sprintf(" 身体: %d -> %d\n",
actor.armor3_id, @mod_armor_ids[actor.armor3_id])
actor.armor3_id = @mod_armor_ids[actor.armor3_id]
end
if @mod_armor_ids.has_key?(actor.armor4_id)
t = true
log2 += sprintf(" 饰品: %d -> %d\n",
actor.armor4_id, @mod_armor_ids[actor.armor4_id])
actor.armor4_id = @mod_armor_ids[actor.armor4_id]
end
if t
s = true
log += sprintf(" □ 角色 %s:\n%s", actor.name, log2)
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 角色\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_actors, "Data/Actors.rxdata")
end
# 处理职业防具
s = false
log = ""
for klass in $data_classes
if klass != nil
for i in 0...klass.armor_set.size
if @mod_armor_ids.has_key?(klass.armor_set)
s = true
log += sprintf(" □ 职业 %s 的防具: %d -> %d\n", klass.name,
klass.armor_set, @mod_armor_ids[klass.armor_set])
klass.armor_set = @mod_armor_ids[klass.armor_set]
end
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 职业\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_classes, "Data/Classes.rxdata")
end
# 处理敌人防具
s = false
log = ""
for enemy in $data_enemies
if enemy != nil
if @mod_armor_ids.has_key?(enemy.armor_id)
s = true
log += sprintf(" □ 敌人 %s 的防具: %d -> %d\n", enemy.name,
enemy.armor_id, @mod_armor_ids[enemy.armor_id])
enemy.armor_id = @mod_armor_ids[enemy.armor_id]
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 敌人\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_enemies, "Data/Enemies.rxdata")
end
# 处理战斗测试员防具
s = false
log = ""
for test_battler in $data_system.test_battlers
if @mod_armor_ids.has_key?(test_battler.armor1_id)
s = true
log += sprintf(" □ 战斗测试员 %d 的盾牌: %d -> %d\n", test_battler.actor_id,
test_battler.armor1_id, @mod_armor_ids[test_battler.armor1_id])
test_battler.armor1_id = @mod_armor_ids[test_battler.armor1_id]
end
if @mod_armor_ids.has_key?(test_battler.armor2_id)
s = true
log += sprintf(" □ 战斗测试员 %d 的头部: %d -> %d\n", test_battler.actor_id,
test_battler.armor2_id, @mod_armor_ids[test_battler.armor2_id])
test_battler.armor2_id = @mod_armor_ids[test_battler.armor2_id]
end
if @mod_armor_ids.has_key?(test_battler.armor3_id)
s = true
log += sprintf(" □ 战斗测试员 %d 的身体: %d -> %d\n", test_battler.actor_id,
test_battler.armor3_id, @mod_armor_ids[test_battler.armor3_id])
test_battler.armor3_id = @mod_armor_ids[test_battler.armor3_id]
end
if @mod_armor_ids.has_key?(test_battler.armor4_id)
s = true
log += sprintf(" □ 战斗测试员 %d 的饰品: %d -> %d\n", test_battler.actor_id,
test_battler.armor4_id, @mod_armor_ids[test_battler.armor4_id])
test_battler.armor4_id = @mod_armor_ids[test_battler.armor4_id]
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 系统\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_system, "Data/System.rxdata")
end
end
end
#--------------------------------------------------------------------------
# ● 刷新地图引用（防具）
#--------------------------------------------------------------------------
def reset_armors_in_maps
proc = Proc.new {|c| reset_armors_in_command(c)}
regexs = [/(\$data_armors\[)([0-9]+)(\])/,
/(\.armor_number\(|\.gain_armor\(|\.lose_armor\(|\.equip\([1-4], ?)([0-9]+)(\)|,)/]
File.open("DReorder.txt", "a") do |f|
translate_map_events(f, proc, @mod_armor_ids, regexs)
end
end
end
[/pre][/fold]
[fold=Data_Reorder (分割定义8) 敌人数据][pre lang="ruby"]#==============================================================================
# ■ Data_Reorder (分割定义 8)
#------------------------------------------------------------------------------
# 数据库重排工具 by SailCat
# 该程序能够将数据库内容ID重新排列，包括插入空序列，紧密重排，交换，重设等
#==============================================================================
class Data_Reorder
#--------------------------------------------------------------------------
# ● 插入敌人序号
# position: 插入位置
# count: 插入的数目
#--------------------------------------------------------------------------
def insert_enemy(position, count)
insert($data_enemies, @mod_enemy_ids, RPG::Enemy.new, position, count)
# 刷新敌人ID的引用
reset_enemies
end
#--------------------------------------------------------------------------
# ● 交换敌人序号
# enemy_id1: 敌人序号1
# enemy_id2: 敌人序号2
#--------------------------------------------------------------------------
def swap_enemy(enemy_id1, enemy_id2)
swap($data_enemies, @mod_enemy_ids, enemy_id1, enemy_id2)
# 刷新敌人ID的引用
reset_enemies
end
#--------------------------------------------------------------------------
# ● 设置新的敌人序号
# old_enemy_ids: 原敌人序号
# new_enemy_id: 新敌人序号
#--------------------------------------------------------------------------
def set_enemy_id(old_enemy_ids, new_enemy_id)
set_id($data_enemies, @mod_enemy_ids, old_enemy_ids, new_enemy_id)
# 刷新敌人ID的引用
reset_enemies
end
#--------------------------------------------------------------------------
# ● 重排敌人序号(从1开始连续排)
#--------------------------------------------------------------------------
def sort_enemy
sort($data_enemies, @mod_enemy_ids)
# 刷新敌人ID的引用
reset_enemies
end
#--------------------------------------------------------------------------
# ● 扩展敌人序号
# num: 新的敌人个数
#--------------------------------------------------------------------------
def expand_enemy(num)
l = $data_enemies.size
if l <= num
for i in l..num
$data_enemies = RPG::Enemy.new
end
save_data($data_enemies, "Data/Enemies.rxdata")
end
end
#--------------------------------------------------------------------------
# ● 刷新敌人ID的引用
#--------------------------------------------------------------------------
def reset_enemies
# 刷新数据库引用
reset_enemies_in_database
# 刷新地图引用
reset_enemies_in_maps
# 保存修改
save_data($data_enemies, "Data/Enemies.rxdata")
end
#--------------------------------------------------------------------------
# ● 刷新事件引用（敌人）
# command: 指令
#--------------------------------------------------------------------------
def reset_enemies_in_command(command)
log = ""
regex1 = /(\$data_enemies\[)([0-9]+)(\])/
regex2 = /(\.transform\()([0-9]+)(\))/
case command.code
when 111 # 条件分歧
if command.parameters[0] == 12 # 脚本
log = translate_text(command.parameters[1], @mod_enemy_ids, regex1)
log += translate_text(command.parameters[1], @mod_enemy_ids, regex2)
end
if log != ""
log = sprintf("条件分歧:%s\n", log)
end
when 209 # 设置移动路线
# 循环强制移动指令
for movecommand in command.parameters[1].list
# 脚本
if movecommand.code == 45
log = translate_text(movecommand.parameters[0], @mod_enemy_ids, regex1)
log += translate_text(movecommand.parameters[0], @mod_enemy_ids, regex2)
end
end
if log != ""
log = sprintf("设置移动路线:%s\n", log)
end
when 336 # 敌人变身
if @mod_enemy_ids.has_key?(command.parameters[1])
log = sprintf("敌人变身: %d -> %d\n", command.parameters[1],
@mod_enemy_ids[command.parameters[1]])
command.parameters[1] = @mod_enemy_ids[command.parameters[1]]
end
when 355, 655 # 脚本
log = translate_text(command.parameters[0], @mod_enemy_ids, regex1)
log += translate_text(command.parameters[0], @mod_enemy_ids, regex2)
if log != ""
log = sprintf("脚本:%s\n", log)
end
end
return log
end
#--------------------------------------------------------------------------
# ● 刷新数据库引用（敌人）
#--------------------------------------------------------------------------
def reset_enemies_in_database
proc = Proc.new {|c| reset_enemies_in_command(c)}
File.open("DReorder.txt", "a") do |f|
# 通用处理
translate_troop_events(f, proc, false, true)
translate_common_events(f, proc)
end
end
#--------------------------------------------------------------------------
# ● 刷新地图引用（敌人）
#--------------------------------------------------------------------------
def reset_enemies_in_maps
proc = Proc.new {|c| reset_enemies_in_command(c)}
regexs = [/(\$data_enemies\[)([0-9]+)(\])/,
/(\.transform\()([0-9]+)(\))/]
File.open("DReorder.txt", "a") do |f|
translate_map_events(f, proc, @mod_enemy_ids, regexs)
end
end
end
[/pre][/fold]
[fold=Data_Reorder (分割定义9) 队伍数据][pre lang="ruby"]#==============================================================================
# ■ Data_Reorder (分割定义 9)
#------------------------------------------------------------------------------
# 数据库重排工具 by SailCat
# 该程序能够将数据库内容ID重新排列，包括插入空序列，紧密重排，交换，重设等
#==============================================================================
class Data_Reorder
#--------------------------------------------------------------------------
# ● 插入队伍序号
# position: 插入位置
# count: 插入的数目
#--------------------------------------------------------------------------
def insert_troop(position, count)
insert($data_troops, @mod_troop_ids, RPG::Troop.new, position, count)
# 刷新队伍ID的引用
reset_troops
end
#--------------------------------------------------------------------------
# ● 交换队伍序号
# troop_id1: 队伍序号1
# troop_id2: 队伍序号2
#--------------------------------------------------------------------------
def swap_troop(troop_id1, troop_id2)
swap($data_troops, @mod_troop_ids, troop_id1, troop_id2)
# 刷新队伍ID的引用
reset_troops
end
#--------------------------------------------------------------------------
# ● 设置新的队伍序号
# old_troop_ids: 原队伍序号
# new_troop_id: 新队伍序号
#--------------------------------------------------------------------------
def set_troop_id(old_troop_ids, new_troop_id)
set_id($data_troops, @mod_troop_ids, old_troop_ids, new_troop_id)
# 刷新队伍ID的引用
reset_troops
end
#--------------------------------------------------------------------------
# ● 重排队伍序号(从1开始连续排)
#--------------------------------------------------------------------------
def sort_troop
sort($data_troops, @mod_troop_ids)
# 刷新队伍ID的引用
reset_troops
end
#--------------------------------------------------------------------------
# ● 扩展队伍序号
# num: 新的队伍个数
#--------------------------------------------------------------------------
def expand_troop(num)
l = $data_troops.size
if l <= num
for i in l..num
$data_troops = RPG::Troop.new
end
save_data($data_troops, "Data/Troops.rxdata")
end
end
#--------------------------------------------------------------------------
# ● 刷新队伍ID的引用
#--------------------------------------------------------------------------
def reset_troops
# 刷新数据库引用
reset_troops_in_database
# 刷新地图引用
reset_troops_in_maps
# 保存修改
save_data($data_troops, "Data/Troops.rxdata")
end
#--------------------------------------------------------------------------
# ● 刷新事件引用（队伍）
# command: 指令
#--------------------------------------------------------------------------
def reset_troops_in_command(command)
log = ""
regex = /(\$data_troops\[)([0-9]+)(\])/
case command.code
when 111 # 条件分歧
if command.parameters[0] == 12 # 脚本
log = translate_text(command.parameters[1], @mod_troop_ids, regex)
end
if log != ""
log = sprintf("条件分歧:%s\n", log)
end
when 209 # 设置移动路线
# 循环强制移动指令
for movecommand in command.parameters[1].list
# 脚本
if movecommand.code == 45
log = translate_text(movecommand.parameters[0], @mod_troop_ids, regex)
end
end
if log != ""
log = sprintf("设置移动路线:%s\n", log)
end
when 301 # 战斗处理
if @mod_troop_ids.has_key?(command.parameters[0])
log = sprintf("战斗处理: %d -> %d\n", command.parameters[0],
@mod_troop_ids[command.parameters[0]])
command.parameters[0] = @mod_troop_ids[command.parameters[0]]
end
when 355, 655 # 脚本
log = translate_text(command.parameters[0], @mod_troop_ids, regex)
if log != ""
log = sprintf("脚本:%s\n", log)
end
end
return log
end
#--------------------------------------------------------------------------
# ● 刷新数据库引用（队伍）
#--------------------------------------------------------------------------
def reset_troops_in_database
proc = Proc.new {|c| reset_troops_in_command(c)}
File.open("DReorder.txt", "a") do |f|
# 通用处理
translate_troop_events(f, proc)
translate_common_events(f, proc)
end
end
#--------------------------------------------------------------------------
# ● 刷新地图引用（队伍）
#--------------------------------------------------------------------------
def reset_troops_in_maps
proc = Proc.new {|c| reset_troops_in_command(c)}
regexs = [/(\$data_troops\[)([0-9]+)(\])/]
File.open("DReorder.txt", "a") do |f|
translate_map_events(f, proc, @mod_troop_ids, regexs, true)
end
end
end
[/pre][/fold]
[fold=Data_Reorder (分割定义10) 状态数据][pre lang="ruby"]#==============================================================================
# ■ Data_Reorder (分割定义 10)
#------------------------------------------------------------------------------
# 数据库重排工具 by SailCat
# 该程序能够将数据库内容ID重新排列，包括插入空序列，紧密重排，交换，重设等
#==============================================================================
class Data_Reorder
#--------------------------------------------------------------------------
# ● 插入状态序号
# position: 插入位置
# count: 插入的数目
#--------------------------------------------------------------------------
def insert_state(position, count)
insert($data_states, @mod_state_ids, RPG::State.new, position, count)
# 刷新状态ID的引用
reset_states
end
#--------------------------------------------------------------------------
# ● 交换状态序号
# state_id1: 状态序号1
# state_id2: 状态序号2
#--------------------------------------------------------------------------
def swap_state(state_id1, state_id2)
swap($data_states, @mod_state_ids, state_id1, state_id2)
# 刷新状态ID的引用
reset_states
end
#--------------------------------------------------------------------------
# ● 设置新的状态序号
# old_state_ids: 原状态序号
# new_state_id: 新状态序号
#--------------------------------------------------------------------------
def set_state_id(old_state_ids, new_state_id)
set_id($data_states, @mod_state_ids, old_state_ids, new_state_id)
# 刷新状态ID的引用
reset_states
end
#--------------------------------------------------------------------------
# ● 重排状态序号(从1开始连续排)
#--------------------------------------------------------------------------
def sort_state
sort($data_states, @mod_state_ids)
# 刷新状态ID的引用
reset_states
end
#--------------------------------------------------------------------------
# ● 扩展状态序号
# num: 新的状态个数
#--------------------------------------------------------------------------
def expand_state(num)
l = $data_states.size
if l <= num
for i in l..num
$data_states = RPG::State.new
end
save_data($data_states, "Data/States.rxdata")
end
end
#--------------------------------------------------------------------------
# ● 刷新状态ID的引用
#--------------------------------------------------------------------------
def reset_states
# 刷新数据库引用
reset_states_in_database
# 刷新地图引用
reset_states_in_maps
# 保存修改
save_data($data_states, "Data/States.rxdata")
end
#--------------------------------------------------------------------------
# ● 刷新事件引用（状态）
# command: 指令
#--------------------------------------------------------------------------
def reset_states_in_command(command)
log = ""
regex1 = /(\$data_states\[)([0-9]+)(\])/
regex2 = /(\.state\?\(|\.state_full\?\(|\.state_guard\?\(|\.add_state\(|\.remove_state\()([0-9]+)(\)|,)/
case command.code
when 111 # 条件分歧
if command.parameters[0] == 4 and command.parameters[2] == 5 # 角色的状态
if @mod_state_ids.has_key?(command.parameters[3])
log = sprintf(" 角色状态: %d -> %d", command.parameters[3],
@mod_state_ids[command.parameters[3]])
command.parameters[3] = @mod_state_ids[command.parameters[3]]
end
elsif command.parameters[0] == 5 and command.parameters[2] == 1 # 敌人的状态
if @mod_state_ids.has_key?(command.parameters[3])
log = sprintf(" 敌人状态: %d -> %d", command.parameters[3],
@mod_state_ids[command.parameters[3]])
command.parameters[3] = @mod_state_ids[command.parameters[3]]
end
elsif command.parameters[0] == 12 # 脚本
log = translate_text(command.parameters[1], @mod_state_ids, regex1)
log += translate_text(command.parameters[1], @mod_state_ids, regex2)
end
if log != ""
log = sprintf("条件分歧:%s\n", log)
end
when 209 # 设置移动路线
# 循环强制移动指令
for movecommand in command.parameters[1].list
# 脚本
if movecommand.code == 45
log = translate_text(movecommand.parameters[0], @mod_state_ids, regex1)
log += translate_text(movecommand.parameters[0], @mod_state_ids, regex2)
end
end
if log != ""
log = sprintf("设置移动路线:%s\n", log)
end
when 313, 333 # 更改状态
if @mod_state_ids.has_key?(command.parameters[2])
log = sprintf("更改%s状态: %d -> %d\n", command.code == 313 ? "角色" : "敌人",
command.parameters[2], @mod_state_ids[command.parameters[2]])
command.parameters[2] = @mod_state_ids[command.parameters[2]]
end
when 355, 655 # 脚本
log = translate_text(command.parameters[0], @mod_state_ids, regex1)
log += translate_text(command.parameters[0], @mod_state_ids, regex2)
if log != ""
log = sprintf("脚本:%s\n", log)
end
end
return log
end
#--------------------------------------------------------------------------
# ● 刷新数据库引用（状态）
#--------------------------------------------------------------------------
def reset_states_in_database
proc = Proc.new {|c| reset_states_in_command(c)}
File.open("DReorder.txt", "a") do |f|
# 通用处理
translate_troop_events(f, proc)
translate_common_events(f, proc)
# 处理职业状态
s = false
log = ""
for klass in $data_classes
if klass != nil
next if klass.state_ranks.xsize == 1
original_state_ranks = klass.state_ranks.clone
size = $data_states.size
klass.state_ranks.resize(size) if klass.state_ranks.xsize < size
@mod_state_ids.each_key do |k|
klass.state_ranks[k] = 3
end
@mod_state_ids.each do |k, v|
s = true
if original_state_ranks[k]
klass.state_ranks[v] = original_state_ranks[k]
else
klass.state_ranks[v] = 3
end
end
klass.state_ranks.resize(size) if klass.state_ranks.xsize > size
log += sprintf(" □ 职业 %s 的状态有效度已重排\n", klass.name) if s
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 职业\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_classes, "Data/Classes.rxdata")
end
# 处理特技状态
s = false
log = ""
for skill in $data_skills
if skill != nil
for i in 0...skill.plus_state_set.size
if @mod_state_ids.has_key?(skill.plus_state_set)
s = true
log += sprintf(" □ 特技 %s 的(+)状态: %d -> %d\n", skill.name,
skill.plus_state_set, @mod_state_ids[skill.plus_state_set])
skill.plus_state_set = @mod_state_ids[skill.plus_state_set]
end
end
for i in 0...skill.minus_state_set.size
if @mod_state_ids.has_key?(skill.minus_state_set)
s = true
log += sprintf(" □ 特技 %s 的(-)状态: %d -> %d\n", skill.name,
skill.minus_state_set, @mod_state_ids[skill.minus_state_set])
skill.minus_state_set = @mod_state_ids[skill.minus_state_set]
end
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 特技\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_skills, "Data/Skills.rxdata")
end
# 处理物品状态
s = false
log = ""
for item in $data_items
if item != nil
for i in 0...item.plus_state_set.size
if @mod_state_ids.has_key?(item.plus_state_set)
s = true
log += sprintf(" □ 物品 %s 的(+)状态: %d -> %d\n", item.name,
item.plus_state_set, @mod_state_ids[item.plus_state_set])
item.plus_state_set = @mod_state_ids[item.plus_state_set]
end
end
for i in 0...item.minus_state_set.size
if @mod_state_ids.has_key?(item.minus_state_set)
s = true
log += sprintf(" □ 物品 %s 的(-)状态: %d -> %d\n", item.name,
item.minus_state_set, @mod_state_ids[item.minus_state_set])
item.minus_state_set = @mod_state_ids[item.minus_state_set]
end
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 物品\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_items, "Data/Items.rxdata")
end
# 处理武器状态
s = false
log = ""
for weapon in $data_weapons
if weapon != nil
for i in 0...weapon.plus_state_set.size
if @mod_state_ids.has_key?(weapon.plus_state_set)
s = true
log += sprintf(" □ 武器 %s 的(+)状态: %d -> %d\n", weapon.name,
weapon.plus_state_set, @mod_state_ids[weapon.plus_state_set])
weapon.plus_state_set = @mod_state_ids[weapon.plus_state_set]
end
end
for i in 0...weapon.minus_state_set.size
if @mod_state_ids.has_key?(weapon.minus_state_set)
s = true
log += sprintf(" □ 武器 %s 的(-)状态: %d -> %d\n", weapon.name,
weapon.minus_state_set, @mod_state_ids[weapon.minus_state_set])
weapon.minus_state_set = @mod_state_ids[weapon.minus_state_set]
end
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 武器\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_weapons, "Data/Weapons.rxdata")
end
# 处理防具状态
s = false
log = ""
for armor in $data_armors
if armor != nil
for i in 0...armor.guard_state_set.size
if @mod_state_ids.has_key?(armor.guard_state_set)
s = true
log += sprintf(" □ 防具 %s 的防御状态: %d -> %d\n", armor.name,
armor.guard_state_set, @mod_state_ids[armor.guard_state_set])
armor.guard_state_set = @mod_state_ids[armor.guard_state_set]
end
end
if @mod_state_ids.has_key?(armor.auto_state_id)
s = true
log += sprintf(" □ 防具 %s 的自动状态: %d -> %d\n", armor.name,
armor.auto_state_id, @mod_state_ids[armor.auto_state_id])
armor.auto_state_id = @mod_state_ids[armor.auto_state_id]
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 防具\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_armors, "Data/armors.rxdata")
end
# 处理敌人状态
s = false
log = ""
for enemy in $data_enemies
if enemy != nil
next if enemy.state_ranks.xsize == 1
original_state_ranks = enemy.state_ranks.clone
size = $data_states.size
enemy.state_ranks.resize(size) if enemy.state_ranks.xsize < size
@mod_state_ids.each_key do |k|
enemy.state_ranks[k] = 3
end
@mod_state_ids.each do |k, v|
s = true
if original_state_ranks[k]
enemy.state_ranks[v] = original_state_ranks[k]
else
enemy.state_ranks[v] = 3
end
end
enemy.state_ranks.resize(size) if enemy.state_ranks.xsize > size
log += sprintf(" □ 敌人 %s 的状态有效度已重排\n", enemy.name) if s
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 敌人\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_enemies, "Data/Enemies.rxdata")
end
# 处理状态自身
s = false
log = ""
for state in $data_states
if state != nil
for i in 0...state.plus_state_set.size
if @mod_state_ids.has_key?(state.plus_state_set)
s = true
log += sprintf(" □ 状态 %s 的(+)状态: %d -> %d\n", state.name,
state.plus_state_set, @mod_state_ids[state.plus_state_set])
state.plus_state_set = @mod_state_ids[state.plus_state_set]
end
end
for i in 0...state.minus_state_set.size
if @mod_state_ids.has_key?(state.minus_state_set)
s = true
log += sprintf(" □ 状态 %s 的(-)状态: %d -> %d\n", state.name,
state.minus_state_set, @mod_state_ids[state.minus_state_set])
state.minus_state_set = @mod_state_ids[state.minus_state_set]
end
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 状态\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_states, "Data/States.rxdata")
end
end
end
#--------------------------------------------------------------------------
# ● 刷新地图引用（状态）
#--------------------------------------------------------------------------
def reset_states_in_maps
proc = Proc.new {|c| reset_states_in_command(c)}
regexs = [/(\$data_states\[)([0-9]+)(\])/,
/(\.state\?\(|\.state_full\?\(|\.state_guard\?\(|\.add_state\(|\.remove_state\()([0-9]+)(\)|,)/]
File.open("DReorder.txt", "a") do |f|
translate_map_events(f, proc, @mod_state_ids, regexs)
end
end
end
[/pre][/fold]
[fold=Data_Reorder (分割定义11) 动画数据][pre lang="ruby"]#==============================================================================
# ■ Data_Reorder (分割定义 11)
#------------------------------------------------------------------------------
# 数据库重排工具 by SailCat
# 该程序能够将数据库内容ID重新排列，包括插入空序列，紧密重排，交换，重设等
#==============================================================================
class Data_Reorder
#--------------------------------------------------------------------------
# ● 插入动画序号
# position: 插入位置
# count: 插入的数目
#--------------------------------------------------------------------------
def insert_anime(position, count)
insert($data_animations, @mod_anime_ids, RPG::Animation.new, position, count)
# 刷新动画ID的引用
reset_animes
end
#--------------------------------------------------------------------------
# ● 交换动画序号
# anime_id1: 动画序号1
# anime_id2: 动画序号2
#--------------------------------------------------------------------------
def swap_anime(anime_id1, anime_id2)
swap($data_animations, @mod_anime_ids, anime_id1, anime_id2)
# 刷新动画ID的引用
reset_animes
end
#--------------------------------------------------------------------------
# ● 设置新的动画序号
# old_anime_ids: 原动画序号
# new_anime_id: 新动画序号
#--------------------------------------------------------------------------
def set_anime_id(old_anime_ids, new_anime_id)
set_id($data_animations, @mod_anime_ids, old_anime_ids, new_anime_id)
# 刷新动画ID的引用
reset_animes
end
#--------------------------------------------------------------------------
# ● 重排动画序号(从1开始连续排)
#--------------------------------------------------------------------------
def sort_anime
sort($data_animations, @mod_anime_ids)
# 刷新动画ID的引用
reset_animes
end
#--------------------------------------------------------------------------
# ● 扩展动画序号
# num: 新的动画个数
#--------------------------------------------------------------------------
def expand_anime(num)
l = $data_animations.size
if l <= num
for i in l..num
$data_animations = RPG::Animation.new
end
save_data($data_animations, "Data/Animations.rxdata")
end
end
#--------------------------------------------------------------------------
# ● 刷新动画ID的引用
#--------------------------------------------------------------------------
def reset_animes
# 刷新数据库引用
reset_animes_in_database
# 刷新地图引用
reset_animes_in_maps
# 保存修改
save_data($data_animations, "Data/Animations.rxdata")
end
#--------------------------------------------------------------------------
# ● 刷新事件引用（动画）
# command: 指令
#--------------------------------------------------------------------------
def reset_animes_in_command(command)
log = ""
regex1 = /(\$data_animations\[)([0-9]+)(\])/
regex2 = /(animation[12]?_id[ <=>!]+)([0-9]+)()/
case command.code
when 111 # 条件分歧
if command.parameters[0] == 12 # 脚本
log = translate_text(command.parameters[1], @mod_anime_ids, regex1)
log += translate_text(command.parameters[1], @mod_anime_ids, regex2)
end
if log != ""
log = sprintf("条件分歧:%s\n", log)
end
when 207 # 显示动画
if @mod_anime_ids.has_key?(command.parameters[1])
log = sprintf("显示动画: %d -> %d\n",
command.parameters[1], @mod_anime_ids[command.parameters[1]])
command.parameters[1] = @mod_anime_ids[command.parameters[1]]
end
when 209 # 设置移动路线
# 循环强制移动指令
for movecommand in command.parameters[1].list
# 脚本
if movecommand.code == 45
log = translate_text(movecommand.parameters[0], @mod_anime_ids, regex1)
log += translate_text(movecommand.parameters[0], @mod_anime_ids, regex2)
end
end
if log != ""
log = sprintf("设置移动路线:%s\n", log)
end
when 337 # 显示动画
if @mod_anime_ids.has_key?(command.parameters[2])
log = sprintf("显示动画: %d -> %d\n",
command.parameters[2], @mod_anime_ids[command.parameters[2]])
command.parameters[2] = @mod_anime_ids[command.parameters[2]]
end
when 355, 655 # 脚本
log = translate_text(command.parameters[0], @mod_anime_ids, regex1)
log += translate_text(command.parameters[0], @mod_anime_ids, regex2)
if log != ""
log = sprintf("脚本:%s\n", log)
end
end
return log
end
#--------------------------------------------------------------------------
# ● 刷新数据库引用（动画）
#--------------------------------------------------------------------------
def reset_animes_in_database
proc = Proc.new {|c| reset_animes_in_command(c)}
File.open("DReorder.txt", "a") do |f|
# 通用处理
translate_troop_events(f, proc)
translate_common_events(f, proc)
# 处理特技动画
s = false
log = ""
for skill in $data_skills
if skill != nil
if @mod_anime_ids.has_key?(skill.animation1_id)
s = true
log += sprintf(" □ 特技 %s 的攻击动画: %d -> %d\n", skill.name,
skill.animation1_id, @mod_anime_ids[skill.animation1_id])
skill.animation1_id = @mod_anime_ids[skill.animation1_id]
end
if @mod_anime_ids.has_key?(skill.animation2_id)
s = true
log += sprintf(" □ 特技 %s 的对象动画: %d -> %d\n", skill.name,
skill.animation2_id, @mod_anime_ids[skill.animation2_id])
skill.animation2_id = @mod_anime_ids[skill.animation2_id]
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 特技\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_skills, "Data/Skills.rxdata")
end
# 处理物品动画
s = false
log = ""
for item in $data_items
if item != nil
if @mod_anime_ids.has_key?(item.animation1_id)
s = true
log += sprintf(" □ 物品 %s 的攻击动画: %d -> %d\n", item.name,
item.animation1_id, @mod_anime_ids[item.animation1_id])
item.animation1_id = @mod_anime_ids[item.animation1_id]
end
if @mod_anime_ids.has_key?(item.animation2_id)
s = true
log += sprintf(" □ 物品 %s 的对象动画: %d -> %d\n", item.name,
item.animation2_id, @mod_anime_ids[item.animation2_id])
item.animation2_id = @mod_anime_ids[item.animation2_id]
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 物品\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_items, "Data/Items.rxdata")
end
# 处理武器动画
s = false
log = ""
for weapon in $data_weapons
if weapon != nil
if @mod_anime_ids.has_key?(weapon.animation1_id)
s = true
log += sprintf(" □ 武器 %s 的攻击动画: %d -> %d\n", weapon.name,
weapon.animation1_id, @mod_anime_ids[weapon.animation1_id])
weapon.animation1_id = @mod_anime_ids[weapon.animation1_id]
end
if @mod_anime_ids.has_key?(weapon.animation2_id)
s = true
log += sprintf(" □ 武器 %s 的对象动画: %d -> %d\n", weapon.name,
weapon.animation2_id, @mod_anime_ids[weapon.animation2_id])
weapon.animation2_id = @mod_anime_ids[weapon.animation2_id]
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 武器\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_weapons, "Data/Weapons.rxdata")
end
# 处理敌人动画
s = false
log = ""
for enemy in $data_enemies
if enemy != nil
if @mod_anime_ids.has_key?(enemy.animation1_id)
s = true
log += sprintf(" □ 敌人 %s 的攻击动画: %d -> %d\n", enemy.name,
enemy.animation1_id, @mod_anime_ids[enemy.animation1_id])
enemy.animation1_id = @mod_anime_ids[enemy.animation1_id]
end
if @mod_anime_ids.has_key?(enemy.animation2_id)
s = true
log += sprintf(" □ 敌人 %s 的对象动画: %d -> %d\n", enemy.name,
enemy.animation2_id, @mod_anime_ids[enemy.animation2_id])
enemy.animation2_id = @mod_anime_ids[enemy.animation2_id]
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 敌人\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_enemies, "Data/Enemies.rxdata")
end
# 处理状态动画
s = false
log = ""
for state in $data_states
if state != nil
if @mod_anime_ids.has_key?(state.animation_id)
s = true
log += sprintf(" □ 状态 %s 的动画: %d -> %d\n", state.name,
state.animation_id, @mod_anime_ids[state.animation_id])
state.animation_id = @mod_anime_ids[state.animation_id]
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 状态\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_states, "Data/States.rxdata")
end
end
end
#--------------------------------------------------------------------------
# ● 刷新地图引用（动画）
#--------------------------------------------------------------------------
def reset_animes_in_maps
proc = Proc.new {|c| reset_animes_in_command(c)}
regexs = [/(\$data_animations\[)([0-9]+)(\])/,
/(animation[12]?_id[ <=>!]+)([0-9]+)()/]
File.open("DReorder.txt", "a") do |f|
translate_map_events(f, proc, @mod_anime_ids, regexs)
end
end
end
[/pre][/fold]
[fold=Data_Reorder (分割定义12) 图块数据][pre lang="ruby"]#==============================================================================
# ■ Data_Reorder (分割定义 12)
#------------------------------------------------------------------------------
# 数据库重排工具 by SailCat
# 该程序能够将数据库内容ID重新排列，包括插入空序列，紧密重排，交换，重设等
#==============================================================================
class Data_Reorder
#--------------------------------------------------------------------------
# ● 插入图块序号
# position: 插入位置
# count: 插入的数目
#--------------------------------------------------------------------------
def insert_tileset(position, count)
insert($data_tilesets, @mod_tileset_ids, RPG::Tileset.new, position, count)
# 刷新图块ID的引用
reset_tilesets
end
#--------------------------------------------------------------------------
# ● 交换图块序号
# tileset_id1: 图块序号1
# tileset_id2: 图块序号2
#--------------------------------------------------------------------------
def swap_tileset(tileset_id1, tileset_id2)
swap($data_tilesets, @mod_tileset_ids, tileset_id1, tileset_id2)
# 刷新图块ID的引用
reset_tilesets
end
#--------------------------------------------------------------------------
# ● 设置新的图块序号
# old_tileset_ids: 原图块序号
# new_tileset_id: 新图块序号
#--------------------------------------------------------------------------
def set_tileset_id(old_tileset_ids, new_tileset_id)
set_id($data_tilesets, @mod_tileset_ids, old_tileset_ids, new_tileset_id)
# 刷新图块ID的引用
reset_tilesets
end
#--------------------------------------------------------------------------
# ● 重排图块序号(从1开始连续排)
#--------------------------------------------------------------------------
def sort_tileset
sort($data_tilesets, @mod_tileset_ids)
# 刷新图块ID的引用
reset_tilesets
end
#--------------------------------------------------------------------------
# ● 扩展图块序号
# num: 新的图块个数
#--------------------------------------------------------------------------
def expand_tileset(num)
l = $data_tilesets.size
if l <= num
for i in l..num
$data_tilesets = RPG::Tileset.new
end
save_data($data_tilesets, "Data/Tilesets.rxdata")
end
end
#--------------------------------------------------------------------------
# ● 刷新图块ID的引用
#--------------------------------------------------------------------------
def reset_tilesets
# 刷新数据库引用
reset_tilesets_in_database
# 刷新地图引用
reset_tilesets_in_maps
# 保存修改
save_data($data_tilesets, "Data/Tilesets.rxdata")
end
#--------------------------------------------------------------------------
# ● 刷新事件引用（图块）
# command: 指令
#--------------------------------------------------------------------------
def reset_tilesets_in_command(command)
log = ""
regex = /(\$data_tilesets\[)([0-9]+)(\])/
case command.code
when 111 # 条件分歧
if command.parameters[0] == 12 # 脚本
log = translate_text(command.parameters[1], @mod_tileset_ids, regex)
end
if log != ""
log = sprintf("条件分歧:%s\n", log)
end
when 209 # 设置移动路线
# 循环强制移动指令
for movecommand in command.parameters[1].list
# 脚本
if movecommand.code == 45
log = translate_text(movecommand.parameters[0], @mod_tileset_ids, regex)
end
end
if log != ""
log = sprintf("设置移动路线:%s\n", log)
end
when 355, 655 # 脚本
log = translate_text(command.parameters[0], @mod_tileset_ids, regex)
if log != ""
log = sprintf("脚本:%s\n", log)
end
end
return log
end
#--------------------------------------------------------------------------
# ● 刷新数据库引用（图块）
#--------------------------------------------------------------------------
def reset_tilesets_in_database
proc = Proc.new {|c| reset_tilesets_in_command(c)}
File.open("DReorder.txt", "a") do |f|
# 通用处理
translate_troop_events(f, proc)
translate_common_events(f, proc)
end
end
#--------------------------------------------------------------------------
# ● 刷新地图引用（图块）
#--------------------------------------------------------------------------
def reset_tilesets_in_maps
proc = Proc.new {|c| reset_tilesets_in_command(c)}
regexs = [/(\$data_tilesets\[)([0-9]+)(\])/]
File.open("DReorder.txt", "a") do |f|
translate_map_events(f, proc, @mod_tileset_ids, regexs, false, true)
end
end
end
[/pre][/fold]
[fold=Data_Reorder (分割定义13) 公共事件数据][pre lang="ruby"]#==============================================================================
# ■ Data_Reorder (分割定义 13)
#------------------------------------------------------------------------------
# 数据库重排工具 by SailCat
# 该程序能够将数据库内容ID重新排列，包括插入空序列，紧密重排，交换，重设等
#==============================================================================
class Data_Reorder
#--------------------------------------------------------------------------
# ● 插入公共事件序号
# position: 插入位置
# count: 插入的数目
#--------------------------------------------------------------------------
def insert_common(position, count)
insert($data_common_events, @mod_common_ids, RPG::CommonEvent.new, position, count)
# 刷新公共事件ID的引用
reset_commons
end
#--------------------------------------------------------------------------
# ● 交换公共事件序号
# common_id1: 公共事件序号1
# common_id2: 公共事件序号2
#--------------------------------------------------------------------------
def swap_common(common_id1, common_id2)
swap($data_common_events, @mod_common_ids, common_id1, common_id2)
# 刷新公共事件ID的引用
reset_commons
end
#--------------------------------------------------------------------------
# ● 设置新的公共事件序号
# old_common_ids: 原公共事件序号
# new_common_id: 新公共事件序号
#--------------------------------------------------------------------------
def set_common_id(old_common_ids, new_common_id)
set_id($data_common_events, @mod_common_ids, old_common_ids, new_common_id)
# 刷新公共事件ID的引用
reset_commons
end
#--------------------------------------------------------------------------
# ● 重排公共事件序号(从1开始连续排)
#--------------------------------------------------------------------------
def sort_common
sort($data_common_events, @mod_common_ids)
# 刷新公共事件ID的引用
reset_commons
end
#--------------------------------------------------------------------------
# ● 扩展公共事件序号
# num: 新的公共事件个数
#--------------------------------------------------------------------------
def expand_common(num)
l = $data_common_events.size
if l <= num
for i in l..num
$data_common_events = RPG::CommonEvent.new
end
save_data($data_common_events, "Data/CommonEvents.rxdata")
end
end
#--------------------------------------------------------------------------
# ● 刷新公共事件ID的引用
#--------------------------------------------------------------------------
def reset_commons
# 刷新数据库引用
reset_commons_in_database
# 刷新地图引用
reset_commons_in_maps
# 保存修改
save_data($data_common_events, "Data/CommonEvents.rxdata")
end
#--------------------------------------------------------------------------
# ● 刷新事件引用（公共事件）
# command: 指令
#--------------------------------------------------------------------------
def reset_commons_in_command(command)
log = ""
regex1 = /(\$data_common_events\[)([0-9]+)(\])/
regex2 = /(common_event_id[ <=>!]+)([0-9]+)()/
case command.code
when 111 # 条件分歧
if command.parameters[0] == 12 # 脚本
log = translate_text(command.parameters[1], @mod_common_ids, regex1)
log += translate_text(command.parameters[1], @mod_common_ids, regex2)
end
if log != ""
log = sprintf("条件分歧:%s\n", log)
end
when 117 # 公共事件
if @mod_common_ids.has_key?(command.parameters[0])
log = sprintf("公共事件: %d -> %d\n",
command.parameters[0], @mod_common_ids[command.parameters[0]])
command.parameters[0] = @mod_common_ids[command.parameters[0]]
end
when 209 # 设置移动路线
# 循环强制移动指令
for movecommand in command.parameters[1].list
# 脚本
if movecommand.code == 45
log = translate_text(movecommand.parameters[0], @mod_common_ids, regex1)
log += translate_text(movecommand.parameters[0], @mod_common_ids, regex2)
end
end
if log != ""
log = sprintf("设置移动路线:%s\n", log)
end
when 355, 655 # 脚本
log = translate_text(command.parameters[0], @mod_common_ids, regex1)
log += translate_text(command.parameters[0], @mod_common_ids, regex2)
if log != ""
log = sprintf("脚本:%s\n", log)
end
end
return log
end
#--------------------------------------------------------------------------
# ● 刷新数据库引用（公共事件）
#--------------------------------------------------------------------------
def reset_commons_in_database
proc = Proc.new {|c| reset_commons_in_command(c)}
File.open("DReorder.txt", "a") do |f|
# 通用处理
translate_troop_events(f, proc)
translate_common_events(f, proc)
# 处理特技公共事件
s = false
log = ""
for skill in $data_skills
if skill != nil
if @mod_common_ids.has_key?(skill.common_event_id)
s = true
log += sprintf(" □ 特技 %s 的公共事件: %d -> %d\n", skill.name,
skill.common_event_id, @mod_common_ids[skill.common_event_id])
skill.common_event_id = @mod_common_ids[skill.common_event_id]
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 特技\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_skills, "Data/Skills.rxdata")
end
# 处理物品公共事件
s = false
log = ""
for item in $data_items
if item != nil
if @mod_common_ids.has_key?(item.common_event_id)
s = true
log += sprintf(" □ 物品 %s 的公共事件: %d -> %d\n", item.name,
item.common_event_id, @mod_common_ids[item.common_event_id])
item.common_event_id = @mod_common_ids[item.common_event_id]
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 物品\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_items, "Data/Items.rxdata")
end
end
end
#--------------------------------------------------------------------------
# ● 刷新地图引用（公共事件）
#--------------------------------------------------------------------------
def reset_commons_in_maps
proc = Proc.new {|c| reset_commons_in_command(c)}
regexs = [/(\$data_common_events\[)([0-9]+)(\])/,
/(common_event_id[ <=>!]+)([0-9]+)()/]
File.open("DReorder.txt", "a") do |f|
translate_map_events(f, proc, @mod_common_ids, regexs)
end
end
end
[/pre][/fold]
[fold=Data_Reorder (分割定义14) 属性数据][pre lang="ruby"]#==============================================================================
# ■ Data_Reorder (分割定义 14)
#------------------------------------------------------------------------------
# 数据库重排工具 by SailCat
# 该程序能够将数据库内容ID重新排列，包括插入空序列，紧密重排，交换，重设等
#==============================================================================
class Data_Reorder
#--------------------------------------------------------------------------
# ● 插入属性序号
# position: 插入位置
# count: 插入的数目
#--------------------------------------------------------------------------
def insert_element(position, count)
# 初始化被修改的ID表
@mod_element_ids.clear
# 从最后一个开始
element_id = $data_system.elements.size - 1
# 循环每一个大于position的ID
while element_id >= position
element_name = $data_system.elements[element_id]
# 如果该属性存在
if element_name != nil
$data_system.elements[element_id + count] = element_name
$data_system.elements[element_id] = ""
# 设置修改标记
@mod_element_ids[element_id] = element_id + count
end
element_id -= 1
end
# 刷新属性ID的引用
reset_elements
end
#--------------------------------------------------------------------------
# ● 交换属性序号
# element_id1: 属性序号1
# element_id2: 属性序号2
#--------------------------------------------------------------------------
def swap_element(element_id1, element_id2)
# 初始化被修改的ID表
@mod_element_ids.clear
# 取得2个属性
element_name1 = $data_system.elements[element_id1]
element_name2 = $data_system.elements[element_id2]
# 两个属性都存在的情况下
if element_name1 != nil and element_name2 != nil
$data_system.elements[element_id1] = element_name2
$data_system.elements[element_id2] = element_name1
# 设置修改标记
@mod_element_ids[element_id1] = element_id2
@mod_element_ids[element_id2] = element_id1
end
# 刷新属性ID的引用
reset_elements
end
#--------------------------------------------------------------------------
# ● 设置新的属性序号
# old_element_ids: 原属性序号
# new_element_id: 新属性序号
#--------------------------------------------------------------------------
def set_element_id(old_element_ids, new_element_id)
# 初始化被修改的ID表
@mod_element_ids.clear
# 单个调整的情况下，转换为区段调整
if old_element_ids.is_a?(Integer)
old_element_ids = old_element_ids..old_element_ids
end
offset = new_element_id - old_element_ids.first
range = old_element_ids.last - old_element_ids.first
range += 1 unless old_element_ids.exclude_end?
return if offset == 0
# 取得原属性
element_names = $data_system.elements[old_element_ids].clone
# 移位操作
if offset > 0
shift_range_before = old_element_ids.first + range...new_element_id + range
shift_range_after = old_element_ids.first...new_element_id
else
shift_range_before = new_element_id...old_element_ids.first
shift_range_after = new_element_id + range...old_element_ids.first + range
end
$data_system.elements[shift_range_after] = $data_system.elements[shift_range_before]
new_element_ids = new_element_id...new_element_id + range
$data_system.elements[new_element_ids] = element_names
# 标记移位情况
shift_range_before.each do |id|
@mod_element_ids[id] = id + (offset > 0 ? -range: range)
end
old_element_ids.each do |id|
@mod_element_ids[id] = id + offset
end
# 刷新属性ID的引用
reset_elements
end
#--------------------------------------------------------------------------
# ● 重排属性序号(从1开始连续排)
#--------------------------------------------------------------------------
def sort_element
# 初始化被修改的ID表
@mod_element_ids.clear
# 从1开始
new_element_id = 1
# 循环每个ID
for i in 1...$data_system.elements.size
element_name = $data_system.elements
# 如果该属性存在且不为空
if element_name != nil and element_name != ""
# 如果属性已经移位
if i != new_element_id
# 跟着前移
$data_system.elements[new_element_id] = element_name
# 设置修改标记
@mod_element_ids = new_element_id
end
new_element_id += 1
end
end
$data_system.elements.delete_at(new_element_id) until $data_system.elements.size == new_element_id
# 刷新属性ID的引用
reset_elements
end
#--------------------------------------------------------------------------
# ● 扩展属性序号
# num: 新的属性个数
#--------------------------------------------------------------------------
def expand_element(num)
l = $data_system.elements.size
if l <= num
for i in l..num
$data_system.elements = ""
end
save_data($data_system, "Data/System.rxdata")
end
end
#--------------------------------------------------------------------------
# ● 刷新属性ID的引用
#--------------------------------------------------------------------------
def reset_elements
# 刷新数据库引用
reset_elements_in_database
# 刷新地图引用
reset_elements_in_maps
# 保存修改
save_data($data_system, "Data/System.rxdata")
end
#--------------------------------------------------------------------------
# ● 刷新事件引用（属性）
# command: 指令
#--------------------------------------------------------------------------
def reset_elements_in_command(command)
log = ""
regex1 = /(\$data_system\.elements\[)([0-9]+)(\])/
regex2 = /(\.element_rate\()([0-9]+)(\))/
case command.code
when 111 # 条件分歧
if command.parameters[0] == 12 # 脚本
log = translate_text(command.parameters[1], @mod_element_ids, regex1)
log += translate_text(command.parameters[1], @mod_element_ids, regex2)
end
if log != ""
log = sprintf("条件分歧:%s\n", log)
end
when 209 # 设置移动路线
# 循环强制移动指令
for movecommand in command.parameters[1].list
# 脚本
if movecommand.code == 45
log = translate_text(movecommand.parameters[0], @mod_element_ids, regex1)
log += translate_text(movecommand.parameters[0], @mod_element_ids, regex2)
end
end
if log != ""
log = sprintf("设置移动路线:%s\n", log)
end
when 355, 655 # 脚本
log = translate_text(command.parameters[0], @mod_element_ids, regex1)
log += translate_text(command.parameters[0], @mod_element_ids, regex2)
if log != ""
log = sprintf("脚本:%s\n", log)
end
end
return log
end
#--------------------------------------------------------------------------
# ● 刷新数据库引用（属性）
#--------------------------------------------------------------------------
def reset_elements_in_database
proc = Proc.new {|c| reset_elements_in_command(c)}
File.open("DReorder.txt", "a") do |f|
# 通用处理
translate_troop_events(f, proc)
translate_common_events(f, proc)
# 处理职业属性
s = false
log = ""
for klass in $data_classes
if klass != nil
next if klass.element_ranks.xsize == 1
original_element_ranks = klass.element_ranks.clone
size = $data_system.elements.size
klass.element_ranks.resize(size) if klass.element_ranks.xsize < size
@mod_element_ids.each_key do |k|
klass.element_ranks[k] = 3
end
@mod_element_ids.each do |k, v|
s = true
if original_element_ranks[k] != nil
klass.element_ranks[v] = original_element_ranks[k]
else
klass.element_ranks[v] = 3
end
end
klass.element_ranks.resize(size) if klass.element_ranks.xsize > size
log += sprintf(" □ 职业 %s 的属性有效度已重排\n", klass.name) if s
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 职业\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_classes, "Data/Classes.rxdata")
end
# 处理特技属性
s = false
log = ""
for skill in $data_skills
if skill != nil
for i in 0...skill.element_set.size
if @mod_element_ids.has_key?(skill.element_set)
s = true
log += sprintf(" □ 特技 %s 的属性: %d -> %d\n", skill.name,
skill.element_set, @mod_element_ids[skill.element_set])
skill.element_set = @mod_element_ids[skill.element_set]
end
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 特技\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_skills, "Data/Skills.rxdata")
end
# 处理物品属性
s = false
log = ""
for item in $data_items
if item != nil
for i in 0...item.element_set.size
if @mod_element_ids.has_key?(item.element_set)
s = true
log += sprintf(" □ 物品 %s 的属性: %d -> %d\n", item.name,
item.element_set, @mod_element_ids[item.element_set])
item.element_set = @mod_element_ids[item.element_set]
end
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 物品\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_items, "Data/Items.rxdata")
end
# 处理武器属性
s = false
log = ""
for weapon in $data_weapons
if weapon != nil
for i in 0...weapon.element_set.size
if @mod_element_ids.has_key?(weapon.element_set)
s = true
log += sprintf(" □ 武器 %s 的属性: %d -> %d\n", weapon.name,
weapon.element_set, @mod_element_ids[weapon.element_set])
weapon.element_set = @mod_element_ids[weapon.element_set]
end
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 武器\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_weapons, "Data/Weapons.rxdata")
end
# 处理防具属性
s = false
log = ""
for armor in $data_armors
if armor != nil
for i in 0...armor.guard_element_set.size
if @mod_element_ids.has_key?(armor.guard_element_set)
s = true
log += sprintf(" □ 防具 %s 的防御属性: %d -> %d\n", armor.name,
armor.guard_element_set, @mod_element_ids[armor.guard_element_set])
armor.guard_element_set = @mod_element_ids[armor.guard_element_set]
end
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 防具\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_armors, "Data/armors.rxdata")
end
# 处理敌人属性
s = false
log = ""
for enemy in $data_enemies
if enemy != nil
next if enemy.element_ranks.xsize == 1
original_element_ranks = enemy.element_ranks.clone
size = $data_system.elements.size
enemy.element_ranks.resize(size) if enemy.element_ranks.xsize < size
@mod_element_ids.each_key do |k|
enemy.element_ranks[k] = 3
end
@mod_element_ids.each do |k, v|
s = true
if original_element_ranks[k]
enemy.element_ranks[v] = original_element_ranks[k]
else
enemy.element_ranks[v] = 3
end
end
enemy.element_ranks.resize(size) if enemy.element_ranks.xsize > size
log += sprintf(" □ 敌人 %s 的属性有效度已重排\n", enemy.name) if s
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 敌人\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_enemies, "Data/Enemies.rxdata")
end
# 处理状态属性
s = false
log = ""
for state in $data_states
if state != nil
for i in 0...state.guard_element_set.size
if @mod_element_ids.has_key?(state.guard_element_set)
s = true
log += sprintf(" □ 状态 %s 的防御属性: %d -> %d\n", state.name,
state.guard_element_set, @mod_element_ids[state.guard_element_set])
state.guard_element_set = @mod_element_ids[state.guard_element_set]
end
end
end
end
if s
f.write("-----------------------------------------------------\n")
f.write(" ■ 状态\n")
f.write("-----------------------------------------------------\n")
f.write(log)
save_data($data_states, "Data/States.rxdata")
end
end
end
#--------------------------------------------------------------------------
# ● 刷新地图引用（属性）
#--------------------------------------------------------------------------
def reset_elements_in_maps
proc = Proc.new {|c| reset_elements_in_command(c)}
regexs = [/(\$data_system\.elements\[)([0-9]+)(\])/,
/(\.element_rate\()([0-9]+)(\))/]
File.open("DReorder.txt", "a") do |f|
translate_map_events(f, proc, @mod_element_ids, regexs)
end
end
end
[/pre][/fold]
范例工程，可能有点小贵，支持下猫子吧，毕竟好几千行的代码和反复测试，不愿意下载就按我上面说的操作，实际上是一样的：
（友情提示，如果你只有一类或几类数据需要重排，你可以只插入分割定义1和那些类数据的分割定义，不过那样zap指令就不能用了）
Data Reorder.zip
(253.56 KB, 下载次数: 107, 售价: 10 星屑)
|
评分
-
查看全部评分
|
写轮眼
发表于 2016-1-28 02:06:22
提升卡
沉默号角
喧嚣号角
变色卡
升龙剑
发表于 2016-1-28 11:14:36
