| 赞 | 349 |
| VIP | |
| 好人卡 | |
| 积分 | 301 |
| 经验 | |
| 最后登录 | 2026-11-7 |
| 在线时间 | 2428 小时 |
遠航の猫咪
- 梦石
- 3
- 星屑
- 27057
- 在线时间
- 2428 小时
- 注册时间
- 2005-10-15
- 回帖
- 989

|
加入我们,或者,欢迎回来。
您需要 登录 才可以下载或查看,没有账号?注册会员
×
本帖最后由 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文件中,可以打开查看。
以下为脚本:
Data_Reorder (分割定义1) 核心引擎- #==============================================================================
- # ■ 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[i]
- 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[i]
- 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[i]
- 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[i])
- log += sprintf(" □ 遇敌队伍: %d -> %d\n",
- map.encounter_list[i], @mod_troop_ids[map.encounter_list[i]])
- map.encounter_list[i] = @mod_troop_ids[map.encounter_list[i]]
- 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[i]
- # 如果该对象存在且不为空
- if object != nil and object.name != ""
- # 如果对象已经移位
- if i != new_id
- # 跟着前移
- object.id = new_id
- data_source[new_id] = object
- # 设置修改标记
- mod_ids[i] = 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
复制代码
Data_Reorder (分割定义2) 角色数据- #==============================================================================
- # ■ 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[i] = 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][i], @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[i])
- s = true
- log += sprintf(" □ 初期同伴: %d -> %d\n", $data_system.party_members[i],
- @mod_actor_ids[$data_system.party_members[i]])
- $data_system.party_members[i] = @mod_actor_ids[$data_system.party_members[i]]
- end
- end
- # 循环所有战斗测试员
- for i in 0...$data_system.test_battlers.size
- test_battler = $data_system.test_battlers[i]
- 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
复制代码
Data_Reorder (分割定义3) 职业数据- #==============================================================================
- # ■ 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[i] = 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
复制代码
Data_Reorder (分割定义4) 特技数据- #==============================================================================
- # ■ 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[i] = 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
复制代码
Data_Reorder (分割定义5) 物品数据- #==============================================================================
- # ■ 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[i] = 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
复制代码
Data_Reorder (分割定义6) 武器数据- #==============================================================================
- # ■ 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[i] = 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[i])
- s = true
- log += sprintf(" □ 职业 %s 的武器: %d -> %d\n", klass.name,
- klass.weapon_set[i], @mod_weapon_ids[klass.weapon_set[i]])
- klass.weapon_set[i] = @mod_weapon_ids[klass.weapon_set[i]]
- 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
复制代码
Data_Reorder (分割定义7) 防具数据- #==============================================================================
- # ■ 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[i] = 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[i])
- s = true
- log += sprintf(" □ 职业 %s 的防具: %d -> %d\n", klass.name,
- klass.armor_set[i], @mod_armor_ids[klass.armor_set[i]])
- klass.armor_set[i] = @mod_armor_ids[klass.armor_set[i]]
- 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
复制代码
Data_Reorder (分割定义8) 敌人数据- #==============================================================================
- # ■ 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[i] = 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
复制代码
Data_Reorder (分割定义9) 队伍数据- #==============================================================================
- # ■ 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[i] = 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
复制代码
Data_Reorder (分割定义10) 状态数据- #==============================================================================
- # ■ 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[i] = 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[i])
- s = true
- log += sprintf(" □ 特技 %s 的(+)状态: %d -> %d\n", skill.name,
- skill.plus_state_set[i], @mod_state_ids[skill.plus_state_set[i]])
- skill.plus_state_set[i] = @mod_state_ids[skill.plus_state_set[i]]
- end
- end
- for i in 0...skill.minus_state_set.size
- if @mod_state_ids.has_key?(skill.minus_state_set[i])
- s = true
- log += sprintf(" □ 特技 %s 的(-)状态: %d -> %d\n", skill.name,
- skill.minus_state_set[i], @mod_state_ids[skill.minus_state_set[i]])
- skill.minus_state_set[i] = @mod_state_ids[skill.minus_state_set[i]]
- 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[i])
- s = true
- log += sprintf(" □ 物品 %s 的(+)状态: %d -> %d\n", item.name,
- item.plus_state_set[i], @mod_state_ids[item.plus_state_set[i]])
- item.plus_state_set[i] = @mod_state_ids[item.plus_state_set[i]]
- end
- end
- for i in 0...item.minus_state_set.size
- if @mod_state_ids.has_key?(item.minus_state_set[i])
- s = true
- log += sprintf(" □ 物品 %s 的(-)状态: %d -> %d\n", item.name,
- item.minus_state_set[i], @mod_state_ids[item.minus_state_set[i]])
- item.minus_state_set[i] = @mod_state_ids[item.minus_state_set[i]]
- 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[i])
- s = true
- log += sprintf(" □ 武器 %s 的(+)状态: %d -> %d\n", weapon.name,
- weapon.plus_state_set[i], @mod_state_ids[weapon.plus_state_set[i]])
- weapon.plus_state_set[i] = @mod_state_ids[weapon.plus_state_set[i]]
- end
- end
- for i in 0...weapon.minus_state_set.size
- if @mod_state_ids.has_key?(weapon.minus_state_set[i])
- s = true
- log += sprintf(" □ 武器 %s 的(-)状态: %d -> %d\n", weapon.name,
- weapon.minus_state_set[i], @mod_state_ids[weapon.minus_state_set[i]])
- weapon.minus_state_set[i] = @mod_state_ids[weapon.minus_state_set[i]]
- 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[i])
- s = true
- log += sprintf(" □ 防具 %s 的防御状态: %d -> %d\n", armor.name,
- armor.guard_state_set[i], @mod_state_ids[armor.guard_state_set[i]])
- armor.guard_state_set[i] = @mod_state_ids[armor.guard_state_set[i]]
- 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[i])
- s = true
- log += sprintf(" □ 状态 %s 的(+)状态: %d -> %d\n", state.name,
- state.plus_state_set[i], @mod_state_ids[state.plus_state_set[i]])
- state.plus_state_set[i] = @mod_state_ids[state.plus_state_set[i]]
- end
- end
- for i in 0...state.minus_state_set.size
- if @mod_state_ids.has_key?(state.minus_state_set[i])
- s = true
- log += sprintf(" □ 状态 %s 的(-)状态: %d -> %d\n", state.name,
- state.minus_state_set[i], @mod_state_ids[state.minus_state_set[i]])
- state.minus_state_set[i] = @mod_state_ids[state.minus_state_set[i]]
- 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
复制代码
Data_Reorder (分割定义11) 动画数据- #==============================================================================
- # ■ 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[i] = 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
复制代码
Data_Reorder (分割定义12) 图块数据- #==============================================================================
- # ■ 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[i] = 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
复制代码
Data_Reorder (分割定义13) 公共事件数据- #==============================================================================
- # ■ 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[i] = 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
复制代码
Data_Reorder (分割定义14) 属性数据- #==============================================================================
- # ■ 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[i]
- # 如果该属性存在且不为空
- if element_name != nil and element_name != ""
- # 如果属性已经移位
- if i != new_element_id
- # 跟着前移
- $data_system.elements[new_element_id] = element_name
- # 设置修改标记
- @mod_element_ids[i] = 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[i] = ""
- 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[i])
- s = true
- log += sprintf(" □ 特技 %s 的属性: %d -> %d\n", skill.name,
- skill.element_set[i], @mod_element_ids[skill.element_set[i]])
- skill.element_set[i] = @mod_element_ids[skill.element_set[i]]
- 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[i])
- s = true
- log += sprintf(" □ 物品 %s 的属性: %d -> %d\n", item.name,
- item.element_set[i], @mod_element_ids[item.element_set[i]])
- item.element_set[i] = @mod_element_ids[item.element_set[i]]
- 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[i])
- s = true
- log += sprintf(" □ 武器 %s 的属性: %d -> %d\n", weapon.name,
- weapon.element_set[i], @mod_element_ids[weapon.element_set[i]])
- weapon.element_set[i] = @mod_element_ids[weapon.element_set[i]]
- 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[i])
- s = true
- log += sprintf(" □ 防具 %s 的防御属性: %d -> %d\n", armor.name,
- armor.guard_element_set[i], @mod_element_ids[armor.guard_element_set[i]])
- armor.guard_element_set[i] = @mod_element_ids[armor.guard_element_set[i]]
- 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[i])
- s = true
- log += sprintf(" □ 状态 %s 的防御属性: %d -> %d\n", state.name,
- state.guard_element_set[i], @mod_element_ids[state.guard_element_set[i]])
- state.guard_element_set[i] = @mod_element_ids[state.guard_element_set[i]]
- 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
复制代码
范例工程,可能有点小贵,支持下猫子吧,毕竟好几千行的代码和反复测试,不愿意下载就按我上面说的操作,实际上是一样的:
(友情提示,如果你只有一类或几类数据需要重排,你可以只插入分割定义1和那些类数据的分割定义,不过那样zap指令就不能用了)
Data Reorder.zip
(253.56 KB, 下载次数: 107, 售价: 10 星屑)
|
评分
-
查看全部评分
|