Files
2026-10-29 21:59:06 +04:00

1242 lines
43 KiB
Ruby
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#==============================================================================
# This script has been altered by Kslander for the need of LonaRPG
#==============================================================================
#==============================================================================
# ** DataManager
#------------------------------------------------------------------------------
# This module manages the database and game objects. Almost all of the
# global variables used by the game are initialized by this module.
#==============================================================================
module DataManager
$debug_dataloading=false #flag for debug in this file
#--------------------------------------------------------------------------
# * Module Instance Variables
#--------------------------------------------------------------------------
@last_savefile_index = 0 # most recently accessed file
@customLoadName = 0 # Name for custom game Load
#--------------------------------------------------------------------------
# * Initialize Module
#--------------------------------------------------------------------------
def self.init
boot_tick("Периферия")
load_peripheral_devices #must on top
boot_tick("Язык")
load_FirstTimeLaunchLangSetup
boot_tick("Управление")
InputUtils.load_input_settings
load_FirstTimeLaunchGamePadUiSetup
boot_tick("Основные данные")
load_core_data(false)
end
#--------------------------------------------------------------------------
# * Load Database
#--------------------------------------------------------------------------
def self.load_peripheral_devices
#Graphics.load_fullscreen_settings if !ARGV.include?("gamescopemode")
p "DataManager -load_peripheral_devices- Check GameLona.ini"
if $LonaINI["LonaRPG"]["StartingSetted"] != 1
p "DataManager First time? Load Default setup."
$LonaINI["LonaRPG"]["StartingSetted"] = 1
$LonaINI["LonaRPG"]["SNDvol"] = 100
$LonaINI["LonaRPG"]["BGMvol"] = 100
#$LonaINI["LonaRPG"]["PrtFocusMode"] = 1 #Unused
$LonaINI["LonaRPG"]["MapBgMode"] = 1
$LonaINI["Screen"]["Fullscreen"] = 0
$LonaINI["Screen"]["FullscreenRatio"] = 0
$LonaINI["Screen"]["WindowedRatio"] = 1
$LonaINI["Screen"]["ScreenScale"] = "16:9"
$LonaINI["LonaRPG"]["COMPRESSED"] = 0
$LonaINI["LonaRPG"]["WRITING_LIST"] = 0
$LonaINI["Cache"]["PrecacheLonaPoseBitmaps"] = 0
$LonaINI["Cache"]["PrecacheLonaChcgBitmaps"] = 0
$LonaINI["Cache"]["PrecacheLonaAllBitmaps"] = 0
$LonaINI["Cache"]["PrecacheNpcPrtBitmaps"] = 0
$LonaINI["Cache"]["DisablePartsClear"] = 0
$LonaINI["Cache"]["DisableChsMaterialClear"] = 0
$LonaINI["Cache"]["DisableChsDataCacheClear"] = 0
$LonaINI["GamePlay"]["oev_OutDress_always_parallel"] = 0
$LonaINI["GameOptions"]["ui_opt_warping"] = 1
$LonaINI["GameOptions"]["ui_opt_warping_mouse_off"] = 1
$LonaINI.save
InputUtils.load_MouseDefautKeys_to_ini
Graphics.toggle_ratio if !ARGV.include?("gamescopemode")
end
#if ["Steam Runtime","Linux"].include?(DataManager.get_os_id) && $LonaINI["Linux"] == {}
# $LonaINI["Linux"]["GameScope"] = 0
# $LonaINI["Linux"]["Height"] = 0
# $LonaINI["Linux"]["Width"] = 0
# $LonaINI.save
#end
p "DataManager -load_peripheral_devices- Sound setting"
$data_BGMvol = DataManager.get_vol_constant("BGMvol")
$data_SNDvol = DataManager.get_vol_constant("SNDvol")
Mouse.setup
Mouse.enable if DataManager.get_constant("LonaRPG","MouseEnable",1) == 1
end
def self.load_core_data(create_objects = true)
p "DataManager load_core_data"
update_Lang
@last_savefile_index = 0
load_database
create_game_objects if create_objects
$loading_screen.finish_progress("Загрузка завершена") if $loading_screen && $loading_screen.respond_to?(:progress_active?) && $loading_screen.progress_active?
end
def self.boot_tick(text)
$loading_screen.step_progress(text) if $loading_screen && $loading_screen.respond_to?(:step_progress)
end
def self.load_FirstTimeLaunchGamePadUiSetup
p "DataManager BuildInput UI data from game.ini"
if [0,"",nil].include?(DataManager.get_text_constant("LonaRPG","GamePadUImode",16))
if WolfPad.plugged_in?
DataManager.write_constant("LonaRPG","GamePadUImode","XB")
$data_GamePadUImode = "XB"
else
DataManager.write_constant("LonaRPG","GamePadUImode","KB")
$data_GamePadUImode = "KB"
end
end
end
def self.load_FirstTimeLaunchLangSetup
p "DataManager Lang set is #{get_lang_constant}"
if !createLangArray.include?(get_lang_constant) #get_lang_constant == "\x00 "
$langFirstPick = true
$lang = "ENG"
write_lang_constant
p "DataManager Lang NoT found! Lang set to #{$lang}"
return update_Lang
end
end
def self.get_lang_constant
$lang = $LonaINI["LonaRPG"]["Language"]
$lang
end
#def self.get_font_name
# selectedFont = nil
# fontList=FileGetter.getFileList("Fonts/SYS-*")
# system_font_list = Array.new
# fontList.each{|fileName|
# p "DataManager.create_font_data FondListed #{fileName}"
# fileName = fileName[10..-1]
# fileName = fileName.chomp('.ttf')
# fileName = fileName.chomp('.otf')
# system_font_list << fileName
# }
# tmpLang = get_lang_constant
# tmpLang = "ENG" if ["XHT",nil].include?(tmpLang)
# point_format=/(#{tmpLang}-)(.+)/
# system_font_list.each{|fileName|
# next if !fileName.split(point_format)[2]
# selectedFont = fileName.split(point_format)[2]
# }
# if selectedFont
# p "Font Found!! #{tmpLang} now using #{selectedFont}"
# p "Script.rvdata2 will force default.font to #{selectedFont}"
# else
# selectedFont = "Noto Sans CJK TC Black"
# p "Font NOT Found!! #{tmpLang} now using #{selectedFont}"
# end
# selectedFont
#end
def self.get_font_name
$data_fonts = FontUtils.scan_fonts if !$data_fonts || $data_fonts.empty?
tmpLang = get_lang_constant
$data_fonts[tmpLang]
end
def self.update_Lang
$game_text = Text.new("Text/#{$lang}")
$mod_manager.link_texts
end
def self.load_database
load_normal_database
check_player_location
#load_notetags_aee #moved to ItemConfig.rb
end
#--------------------------------------------------------------------------
# * Load Normal Database
#--------------------------------------------------------------------------
def self.load_normal_database
boot_tick("Актёры / Классы / Навыки")
$data_actors = load_data("Data/Actors.rvdata2")
$data_classes = load_data("Data/Classes.rvdata2")
$data_skills = load_data("Data/Skills.rvdata2")
$data_weapons = load_data("Data/Weapons.rvdata2")
$data_armors = load_data("Data/Armors.rvdata2")
#$data_enemies = load_data("Data/Enemies.rvdata2")
#$data_troops = load_data("Data/Troops.rvdata2")
$data_states = load_data("Data/States.rvdata2")
$data_items = load_data("Data/Items.rvdata2")
#$data_animations = load_data("Data/Animations.rvdata2")
#$data_tilesets = load_data("Data/Tilesets.rvdata2")
boot_tick("Наборы тайлов / Общие события")
$data_tilesets = load_tilesets
$data_common_events = load_common_events
$data_common_parallel = $data_common_events.values.select{|event|event.parallel?}
$data_common_auto = $data_common_events.values.select{|event|event.autorun?}
boot_tick("Система / Карты / Настроение")
$data_system = load_data("Data/System.rvdata2") #RPG::System.new #
load_system_term_configs #overwrite system
$data_mapinfos = load_data("Data/MapInfos.rvdata2")
$data_LonaMood = FileGetter.load_mood
boot_tick("Настройки предметов")
load_skills_to_SkillHash
load_items_to_ItemHash #create $data_ItemName
load_state_to_StateHash #create $data_StateHash
load_itemconfigs
load_itemconfigs_actors
load_itemconfigs_classes
boot_tick("Графика персонажей")
$chs_data = load_chs_datas
boot_tick("Неигровые персонажи")
$data_npcs = load_npcs
$data_tag_maps = {}
$data_region_maps = {}
boot_tick("Боевая система / События / Рецепты")
$data_arpgskills = FileGetter.load_skill_data
$data_EventLib = FileGetter.read_EventLib
$data_barters = FileGetter.load_barter_settings_from_dir
$data_AlchemyRecipes = FileGetter.load_alchemy_recipes_from_dir
load_tag_and_reg_maps #
boot_tick("Портреты персонажей")
$data_npc_portraits = FileGetter.load_npc_portraits
boot_tick("Портреты Лоны")
$data_lona_portrait = FileGetter.load_lona_portrait # data composition : [name_order,parts] , note this is a relatively ancient one
#$data_npcLayered_portrait = FileGetter.load_NPC_layered_portrait # data composition : [name_order,parts] , note this is a relatively ancient one
$data_BGMvol = get_vol_constant("BGMvol")
$data_SNDvol = get_vol_constant("SNDvol")
$data_PrtFocusMode = get_constant("LonaRPG","PrtFocusMode",1) #0 auto #1 Skip when combat #2 except EV #unused
$data_ToneMode = get_map_background_color_constant #get_constant("LonaRPG","MapBgMode",1)
$data_GamePadUImode = get_text_constant("LonaRPG","GamePadUImode",16)
boot_tick("Моды")
load_mod_database #create MOD loader
InputUtils.update_padSYM_in_UI
dbg_itemDataBase if $TEST
dbg_skillsDataBase if $TEST
dbg_statesDataBase if $TEST
dbg_eventlib if $TEST
dbg_dump_mapinfo_tree if $TEST
#dbg_barters if $TEST
Cache.precache_lona_prt_bitmap("pose") if $LonaINI["Cache"]["PrecacheLonaPoseBitmaps"] == 1 && $LonaINI["Cache"]["PrecacheLonaAllBitmaps"] != 1
Cache.precache_lona_prt_bitmap("chcg") if $LonaINI["Cache"]["PrecacheLonaChcgBitmaps"] == 1 && $LonaINI["Cache"]["PrecacheLonaAllBitmaps"] != 1
Cache.precache_lona_prt_bitmap("all") if $LonaINI["Cache"]["PrecacheLonaAllBitmaps"] == 1
Cache.precache_npc_prt_bitmap if $LonaINI["Cache"]["PrecacheNpcPrtBitmaps"] == 1
end
def self.load_mod_database
#empty so u can mod
end
def self.load_skills_to_SkillHash
$data_SkillName = Hash.new
p "DataManager.load_skills_to_SkillHash generate SkillHash"
p "$data_skills generate SkillHash"
$data_skills.each{|skill|
next if !skill
next if !skill.name
$data_SkillName[skill.name] = skill
}
p "DataManager.load_skills_to_SkillHash Finished"
end
def self.load_items_to_ItemHash
$data_ItemName = Hash.new
p "DataManager.load_items_to_ItemHash generate ItemHash"
p "$data_weapons generate ItemHash"
$data_weapons.each{|item|
next if !item
next if !item.name
$data_ItemName[item.name] = item
}
p "$data_armors generate ItemHash"
$data_armors.each{|item|
next if !item
next if !item.name
$data_ItemName[item.name] = item
}
p "$data_items generate ItemHash"
$data_items.each{|item|
next if !item
next if !item.name
$data_ItemName[item.name] = item
}
p "DataManager.load_items_to_ItemHash Finished"
end
def self.load_state_to_StateHash
$data_StateName = Hash.new
p "DataManager.load_states_to_StateHash generate StateHash"
p "$data_skills generate SkillHash"
$data_states.each{|state|
next if !state
next if !state.name
$data_StateName[state.name] = state
}
p "DataManager.load_states_to_StateHash Finished"
end
def self.createLangArray
langIndex = 0
langFolderCheck = Array.new
Dir.entries('Text').select { |file|
next if file == '.'
next if file == '..'
next if !File.directory?(File.join('Text', file))
tmpTarLang = file.to_s
langIndex +=1
#break if langIndex >4
langFolderCheck << tmpTarLang
}
langFolderCheck
end
def self.get_text_constant(tmpFolder="LonaRPG",tmpName,tmpBuffer)
info = $LonaINI[tmpFolder][tmpName]
return info if info
return ""
end
def self.write_lang_constant
$LonaINI["LonaRPG"]["Language"] = $lang
$LonaINI.save
end
def self.get_rec_constant(tmpRec)
info = $LonaINI["LonaRPG_Rec"][tmpRec]
return info if info
return 0
end
def self.write_rec_constant(tmpRec,tmpVol)
$LonaINI["LonaRPG_Rec"][tmpRec] = tmpVol
$LonaINI.save
end
def self.get_constant(tmpFolder="LonaRPG",tmpName,tmpBuffer)
info = $LonaINI[tmpFolder][tmpName]
return info if info
return 0
end
def self.write_constant(tmpFolder="LonaRPG",tmpName,tmpVol)
$LonaINI[tmpFolder][tmpName] = tmpVol
$LonaINI.save
end
def self.get_map_background_color_constant
# Array with file names only
result = get_map_background_color_result
file_names = result.keys
info = $LonaINI["LonaRPG"]["MapBgMode"]
result[info]
end
#will make hash with files {filename=>path/name.png}
def self.get_map_background_color_result
files = Dir.glob("Graphics/System/MapBackgroundColor/*.png")
# Create hash from files
result = Hash[files.map { |f| [File.basename(f, ".png"), f] }]
# Set default value if key not found
result.default = "nil"
result
end
def self.get_vol_constant(tmpRec)
info = $LonaINI["LonaRPG"][tmpRec]
return info if info
return 100
end
def self.write_vol_constant(tmpRec,tmpVol)
$LonaINI["LonaRPG"][tmpRec] = tmpVol
$LonaINI.save
end
def self.load_tag_and_reg_maps
#$data_MapFilename = {} if !$data_MapFilename
if FileGetter::COMPRESSED && File.file?("Data/TagRegionMaps.rvdata2")
cached = load_data("Data/TagRegionMaps.rvdata2")
$data_tag_maps = cached[:tag_maps] || cached["tag_maps"] || {}
$data_region_maps = cached[:region_maps] || cached["region_maps"] || {}
($data_mapinfos || {}).keys.each{|key|
filename = sprintf("Data/Map%03d.rvdata2", key)
next unless $data_mapinfos[key]
$data_mapinfos[key].id = key
$data_mapinfos[key].filename = filename
}
return
end
mapinfo = $data_mapinfos || load_data("Data/MapInfos.rvdata2")
mapinfo.keys.each{|key|
begin
filename = sprintf("Data/Map%03d.rvdata2", key)
map = load_data(filename)
add_data=Note.get_data(map.note)
set_tag_maps(key,add_data)
set_region_maps(key,add_data)
$data_mapinfos[key].id = key if $data_mapinfos[key]
$data_mapinfos[key].filename = filename if $data_mapinfos[key]
#$data_MapFilename[filename] = $data_mapinfos[key]
rescue =>ex
msgbox "Error on map #{sprintf("Data/Map%03d.rvdata2", key)}, need attention, exception:#{ex.message}"
end
}
save_data({:tag_maps => $data_tag_maps, :region_maps => $data_region_maps}, "Data/TagRegionMaps.rvdata2") if FileGetter::WRITING_LIST
prp "aft load_tag_and_reg_maps"
end
def self.set_tag_maps(map_id,add_data)
return if add_data["event"].nil?
events=add_data["event"].split(",")
events.each{
|event|
$data_tag_maps[event]=Array.new if $data_tag_maps[event].nil?
$data_tag_maps[event] << map_id
}
end
def self.set_region_maps(map_id,add_data)
return if add_data["region"].nil?
regions=add_data["region"].split(",")
regions.each{|reg|
$data_region_maps[reg.to_i]=Array.new if $data_region_maps[reg.to_i].nil?
$data_region_maps[reg.to_i] << map_id
}
end
def self.extra_map_register(mapname,filename)
#$data_MapFilename = {} if !$data_MapFilename
#tgtID = $data_mapinfos.keys.max+1
tgtID = 0
$data_mapinfos.each{|k, v| tgtID = v.id if v.id > tgtID }
tgtID = tgtID+1
$data_mapinfos[filename] = RPG::MapInfo.new
$data_mapinfos[filename].name = mapname
$data_mapinfos[filename].filename = filename
$data_mapinfos[filename].id = tgtID
#map = load_data(filename)
#add_data=Note.get_data(map.note)
#set_tag_maps(tgtID,add_data)
#set_region_maps(tgtID,add_data)
#$data_MapFilename[filename] = $data_mapinfos[filename]
end
def self.load_npcs
return load_data("Data/NonPlayerCharacters.rvdata2") if FileGetter::COMPRESSED && File.file?("Data/NonPlayerCharacters.rvdata2")
return FileGetter.load_NPCs_from_dir(tmpDir="Data/NPCdata/")
end
def self.load_system_term_configs
prp "DataManager.load_system_term_configs"
$data_system.airship = nil
$data_system.test_battlers = nil
$data_system.elements = nil
$data_system.battle_end_me = nil
$data_system.ship = nil
$data_system.sounds = nil
$data_system.gameover_me = nil
$data_system.terms = nil
$data_system.title_bgm = nil
$data_system.battle_bgm = nil
$data_system.starting_equip = nil
$data_system.gear_stats_update_flow = nil
data = FileGetter.load_system_term_configs
data.each do |hashName,hashData|
p "data.json"
p "overwrite $data_system #{hashName}"
eval("$data_system.#{hashName} = hashData")
end
$data_system.equip_type = $data_system.equip_type.transform_keys(&:to_i)
$data_system.equip_type_name = $data_system.equip_type.map { |id, (name, removable, optimize)| [name, id] }.to_h #reverse it to [name,id]
############################################################################################# xx
if FONT_MOD::INI.nil? || FONT_MOD::INI == FONT_MOD::LNG # xx
$data_system.equip_type.each do |key, value| # xx
name, *rest = value # xx
if FONT_MOD::REPLACE_EQ.key?(name) # xx
$data_system.equip_type[key] = [FONT_MOD::REPLACE_EQ[name], *rest] # xx
end # xx
end # xx
end # xx
############################################################################################# xx
prp "load_system_term_configs end"
end
def self.load_itemconfigs
prp "DataManager.load_itemconfigs"
$data_itemconfigs = {}
order=0
data_type=["Items","Weapons","Armors","States"]
[$data_items,$data_weapons,$data_armors,$data_states,$data_skills].each{|dataSet|
order+=1
num=-1
dataSet.each{|data|
num+=1
next if data.nil?
begin
data.load_additional_data
rescue =>ex
p "num #{num} of type : #{data_type[order-1]} name=#{data.name}"
end
}
}
end
def self.load_itemconfigs_actors
prp "DataManager.load_itemconfigs_actors"
$data_actors.each{|data|
next if data.nil?
data.load_additional_data
}
end
def self.load_itemconfigs_classes
prp "DataManager.load_itemconfigs_classes"
$data_classes.each{|data|
next if data.nil?
data.load_additional_data
}
end
def self.load_chs_datas
return load_data("Data/CHS_Data.rvdata2") if FileGetter::COMPRESSED && File.file?("Data/CHS_Data.rvdata2")
chs_datas=FileGetter::load_chs_settings_from_dir
save_data(chs_datas,"Data/CHS_Data.rvdata2") if FileGetter::WRITING_LIST
chs_datas
end
def self.load_tilesets(file="Data/Tilesets.rvdata2")
exportHash = {}
sourceData = load_data(file)
sourceData.each_index{|i|
exportHash[i] = sourceData[i]
next if sourceData[i].nil?
next if sourceData[i].name == ""
exportHash[sourceData[i].name] = sourceData[i]
}
exportHash
end
def self.load_extra_tilesets(file,bmpPath)
exportHash = {}
sourceData = load_data(file)
sourceData.each_index{|i|
next if sourceData[i].nil?
next if sourceData[i].name == ""
sourceData[i].tileset_names.each_index{|tileNameI|
next if sourceData[i].tileset_names[tileNameI].nil?
next if sourceData[i].tileset_names[tileNameI] == ""
#p FileTest.exist?(bmpPath + sourceData[i].tileset_names[tileNameI] + ".png")
#p "../../" + bmpPath + sourceData[i].tileset_names[tileNameI] + ".png"
#msgbox "Asdaslkjdalskjdasd"
next unless FileTest.exist?(bmpPath + sourceData[i].tileset_names[tileNameI] + ".png")
sourceData[i].tileset_names[tileNameI] = "../../" + bmpPath + sourceData[i].tileset_names[tileNameI]
}
exportHash[sourceData[i].name] = sourceData[i]
}
exportHash
end
def self.load_common_events
prp "DataManager.load_common_events"
return load_data("Data/CommonEventsHash.rvdata2") if FileGetter::COMPRESSED && File.file?("Data/CommonEventsHash.rvdata2")
exportHash = {}
sourceData = FileGetter.load_common_events_from_dir
sourceData.each{|tgtData|
newEV = RPG::CommonEvent.new
newEV.load_common_event_data(tgtData)
exportHash[tgtData["name"].to_sym] = newEV
}
save_data(exportHash, "Data/CommonEventsHash.rvdata2") if FileGetter::WRITING_LIST
exportHash
end
#$data_weapons = load_data_weapons ######################################################################################3
#load_itemconfigs_weapons ######################################################################################3
#def self.load_data_weapons
# exportHash = {}
# fileNamelist = FileGetter.getFileListFileOnly("Data/Effects/Weapons/*.json")
# filelistWithPath = FileGetter.getFileList("Data/Effects/Weapons/*.json")
# fileNamelist.each.with_index(0) do |fileName, index|
# json_file = File.open(filelistWithPath[index])
# json_data = JSON.decode(json_file.read)
# tgtID = index + 1
# puts "Processing file ##{tgtID}: #{fileName} #{json_data["item_name"]}"
# tgtWeapon = RPG::Weapon.new
# tgtWeapon.id = tgtID
# tgtWeapon.addData = {} if !tgtWeapon.addData
# tgtWeapon.addData["eff_cfg"] = fileName
# exportHash[json_data["item_name"]] = tgtWeapon
# end
# exportHash
#end
#def self.load_itemconfigs_weapons
# $data_weapons.each{|hashName,data|
# $data_weapons[hashName].load_additional_data(data.base_folder + "/" + data.addData["eff_cfg"])
# }
#end
#--------------------------------------------------------------------------
# * Check Player Start Location Existence
#--------------------------------------------------------------------------
def self.check_player_location
if $data_system.start_map_id == 0
msgbox(Vocab::PlayerPosError)
exit
end
end
#--------------------------------------------------------------------------
# * Create Game Objects
#--------------------------------------------------------------------------
def self.create_game_objects
$story_stats = Story_Stats.new
$game_date = Game_Date.new(1772,3,1,1)
$game_temp = Game_Temp.new
$game_system = Game_System.new
$game_timer = Game_Timer.new
$game_message = Game_Message.new
$game_switches = Game_Switches.new
$game_variables = Game_Variables.new
$game_self_switches = Game_SelfSwitches.new
$game_actors = Game_Actors.new
$game_NPCLayerMain = Game_NPC_Actor.new("NPCLayerMain") # to class actors.
$game_NPCLayerSub = Game_NPC_Actor.new("NPCLayerSub") # to class actors.
$game_portraits = Portrait_System.new # automatically grabs existing $data_npc_portraits & $data_lona_portrait
$game_party = Game_Party.new
#$game_troop = Game_Troop.new #remove in future
$game_map = Game_Map.new
$game_player = Game_Player.new
$dialog_timer = Dialog_Timer.new
$game_text = Text.new("Text/#{$lang}")
$mail_text = MailText.new("Text/#{$lang}/mail/")
$game_boxes = IMP1_Game_Boxes.new
$game_pause = false
$hudForceHide = false
$balloonForceHide = false
load_mod_game_objects
update_Lang
end
def self.load_mod_game_objects
#empty so u can mod
end
#--------------------------------------------------------------------------
# * Set Up New Game
#--------------------------------------------------------------------------
def self.setup_new_game(tmp_tomap=true,tagName="NoerSewer")
create_game_objects
create_temp_graphics
$game_party.setup_starting_members
$game_map.force_setup=true
$game_pause = false
if tmp_tomap
$game_map.setup($data_tag_maps[tagName].sample)
$game_player.moveto(0, 0)
end
#$game_actors[1].setup(1) #setup twice
$game_player.actor.post_setup
$game_player.actor.prtmood("normal") #Lona portrait loaded here ,must fix
$game_player.actor.update_state_frames
$game_player.refresh
$game_map.set_light
#$game_temp.reserve_story("BIOS")
Graphics.frame_count = 0
$game_map.interpreter.new_game_setting ##29_Functions_417
$game_player.actor.setup_inheritance($inheritance)
$game_map.interpreter.new_game_SetFetishLevel ##29_Functions_417
$story_stats["VerInfo"] = export_full_ver_info
$game_player.actor.refresh_equip_part_covered
$game_player.actor.refresh
end
#--------------------------------------------------------------------------
# * Maximum Number of Save Files
#--------------------------------------------------------------------------
#--------------------------------------------------------------------------
# * Determine Existence of Save File
#--------------------------------------------------------------------------
def self.saveFileMAX
System_Settings::SAVE_FILE_MAX
end
def self.userDataPath
System_Settings::USER_DATA_PATH
end
def self.userDataPath_FileSaveDoom
System_Settings::USER_DATA_PATH_FILE_SAVE_DOOM
end
def self.userDataPath_FileSaveAuto_E
System_Settings::USER_DATA_PATH_FILE_SAVE_AUTO_E
end
def self.userDataPath_FileSaveAuto_S
System_Settings::USER_DATA_PATH_FILE_SAVE_AUTO_S
end
def self.saveFileExistsRGSS? #basic game saves
!Dir.glob(userDataPath+'Save*.rvdata2').empty?
end
def self.saveFileExistsRGSS_slot?(slot)#basic game saves for LOAD/SAVE UI
!Dir.glob(userDataPath+'Save0'+"#{slot}"+".rvdata2").empty?
end
def self.saveFileExistsDOOM?
FileTest.exist?(userDataPath_FileSaveDoom)
end
def self.saveFileExistsAUTO_E?
FileTest.exist?(userDataPath_FileSaveAuto_E)
end
def self.saveFileExistsAUTO_S?
FileTest.exist?(userDataPath_FileSaveAuto_S)
end
def self.saveFileDeleteDoom
return if !self.saveFileExistsDOOM?
File.delete(userDataPath_FileSaveDoom)
end
def self.make_filename(index)
sprintf(userDataPath+"Save%02d.rvdata2", index + 1)
end
def self.make_filename_screenshot(index)
sprintf(userDataPath+"Save%02d.png", index + 1)
end
def self.make_filenameDoom
sprintf(userDataPath_FileSaveDoom)
end
#--------------------------------------------------------------------------
# * Execute Save
#--------------------------------------------------------------------------
def self.save_game(index)
return if $story_stats["Setup_Hardcore"] >= 2
begin
save_game_without_rescue(index)
rescue => ex
msgbox("exception during save")
p ex
delete_save_file(index)
false
end
end
def self.doomModeSave
begin
save_doom_without_header
rescue => ex
msgbox("exception during save")
p ex
saveFileDeleteDoom
false
end
end
def self.doAutoSave(tmpDepose=false,doomOnly=false)
return if $story_stats["MenuSysSavegameOff"] >= 1
SceneManager.scene.dispose_spriteset if tmpDepose
if $story_stats["Setup_Hardcore"] >= 2
doomModeSave
else
if $game_date.dateAmt.even?
save_custom_without_header("SavAutoE") if !doomOnly
else
save_custom_without_header("SavAutoS") if !doomOnly
end
#save_custom_without_header("SavAuto") if !doomOnly
end
SceneManager.scene.create_spriteset if tmpDepose
end
#--------------------------------------------------------------------------
# * Execute Load
#--------------------------------------------------------------------------
def self.load_game(index)
load_game_without_rescue(index) rescue false
end
def self.doomModeLoad
load_doom_without_rescue rescue false
end
def self.customModeLoad(tmpName)
load_custom_without_rescue(tmpName) rescue false
end
#--------------------------------------------------------------------------
# * Load Save Header
#--------------------------------------------------------------------------
def self.load_header(index)
load_header_without_rescue(index) rescue nil
end
#--------------------------------------------------------------------------
# * Execute Save (No Exception Processing)
#--------------------------------------------------------------------------
def self.make_save_screenshot(index)
bmp=Bitmap.new(264,160)
x_origin=Graphics.width/2 - bmp.width/2
y_origin= Graphics.height/2 - bmp.height/2
bmp.blt(0,0,SceneManager.background_bitmap,Rect.new(x_origin,y_origin,bmp.width,bmp.height))
begin
bmp.export(make_filename_screenshot(index))
rescue => ex
p "DataManager failed to export file #{make_filename_screenshot(index)}"
end
bmp.dispose
end
def self.save_game_without_rescue(index)
return false if $story_stats["Setup_Hardcore"] >= 2
$story_stats["record_GameSaved"] += 1
make_save_screenshot(index)
File.open(make_filename(index), "wb") do |file|
$game_system.on_before_save
$game_map.clear_cached_npc_skills
Marshal.dump(make_save_header, file)
Marshal.dump(make_save_contents, file)
@last_savefile_index = index
end
return true
end
def self.save_doom_without_header
File.open(make_filenameDoom, "wb") do |file|
$game_system.on_before_save
$game_map.clear_cached_npc_skills
Marshal.dump(make_DoomSave_header, file)
Marshal.dump(make_save_contents, file)
end
return true
end
def self.save_custom_without_header(tmpName)
tmpTar = sprintf(userDataPath+"#{tmpName}.rvdata2")
File.open(tmpTar, "wb") do |file|
$game_system.on_before_save
$game_map.clear_cached_npc_skills
Marshal.dump(make_DoomSave_header, file)
Marshal.dump(make_save_contents, file)
end
return true
end
#--------------------------------------------------------------------------
# * Execute Load (No Exception Processing)
#--------------------------------------------------------------------------
def self.load_game_without_rescue(index)
return false if !FileTest.exist?(make_filename(index))
DataManager.create_game_objects #to clearn up all key and data remain
File.open(make_filename(index), "rb") do |file|
header = DataManager.load_header(index) #temp
header = Hash.new("ERR") if !header
return false if header[:doom_mode] && header[:doom_mode] != "ERR"
Marshal.load(file)
extract_save_contents(Marshal.load(file))
@last_savefile_index = index
$hudForceHide = false
$balloonForceHide = false
end
return true
end
def self.load_doom_without_rescue
File.open(make_filenameDoom, "rb") do |file|
Marshal.load(file)
extract_save_contents(Marshal.load(file))
$hudForceHide = false
$balloonForceHide = false
end
return true
end
def self.load_custom_without_rescue(tmpName)
tmpTar = sprintf(userDataPath+"#{tmpName}.rvdata2")
File.open(tmpTar, "rb") do |file|
Marshal.load(file)
extract_save_contents(Marshal.load(file))
$hudForceHide = false
$balloonForceHide = false
end
return true
end
def self.customLoadName
@customLoadName
end
def self.customLoadNameSet(tmpVal)
@customLoadName = tmpVal
end
#--------------------------------------------------------------------------
# * Load Save Header (No Exception Processing)
#--------------------------------------------------------------------------
def self.load_header_without_rescue(index)
File.open(make_filename(index), "rb") do |file|
return Marshal.load(file)
end
return nil
end
#--------------------------------------------------------------------------
# * Delete Save File
#--------------------------------------------------------------------------
def self.delete_save_file(index)
File.delete(make_filename(index)) rescue nil
end
#--------------------------------------------------------------------------
# * Create Save Header
#--------------------------------------------------------------------------
def self.export_full_ver_info
"#{$GameINI["Game"]["Title"]}.#{$data_system.version_id.to_s(16).upcase}"
end
def self.make_save_header
header = {}
if $story_stats["VerInfo"] == export_full_ver_info
header[:ver] = export_full_ver_info
else
header[:ver] = "#{$story_stats["VerInfo"]}"
end
header[:date] = "#{$game_date.date[0]}.#{$game_date.date[1]}.#{$game_date.date[2]}"
header[:characters] = "#{$game_party.characters_for_savefile}"
header[:playtime_s] = "#{$game_system.playtime_s}"
header[:stat_lv] = "Lv#{$game_player.actor.level}"
header[:stat_health] = "#{$game_player.actor.health.round}"
header[:stat_sta] = "#{$game_player.actor.sta.round}"
header[:stat_sat] = "#{$game_player.actor.sat.round}"
header[:stat_mood] = "#{$game_player.actor.mood.round}"
header[:stat_atk] = "#{$game_player.actor.atk.round(2)}"
header[:stat_def] = "#{$game_player.actor.def.round(2)}"
header[:stat_combat] = "#{$game_player.actor.combat.round(2)}"
header[:stat_scoutcraft] = "#{$game_player.actor.scoutcraft.round(2)}"
header[:stat_wisdom] = "#{$game_player.actor.wisdom.round(2)}"
header[:stat_constitution] = "#{$game_player.actor.constitution.round(2)}"
header[:stat_survival] = "#{$game_player.actor.survival.round(2)}"
header[:stat_sexy] = "#{$game_player.actor.sexy.round(2)}"
header[:stat_weak] = "#{$game_player.actor.weak.round(2)}"
header[:stat_morality] = "#{$game_player.actor.morality.round(2)}"
header[:title] = "DataTitle:#{$game_player.actor.record_lona_title}"
header[:mod_data] = $mod_manager.output_data_to_array
header
end
def self.make_DoomSave_header
header = {}
if $story_stats["VerInfo"] == export_full_ver_info
header[:ver] = export_full_ver_info
else
header[:ver] = "#{$story_stats["VerInfo"]}"
end
header[:doom_mode] = true
header
end
#--------------------------------------------------------------------------
# * Create Save Contents
#--------------------------------------------------------------------------
def self.make_save_contents
contents = {}
contents[:system] = $game_system
contents[:timer] = $game_timer
contents[:message] = $game_message
contents[:switches] = $game_switches #will be remove
contents[:variables] = $game_variables #will be remove
contents[:self_switches] = $game_self_switches #will be remove
contents[:actors] = $game_actors
contents[:party] = $game_party
#contents[:troop] = $game_troop
contents[:map] = $game_map
contents[:player] = $game_player
contents[:game_NPCLayerMain]= $game_NPCLayerMain
contents[:game_NPCLayerSub] = $game_NPCLayerSub
contents[:date] = $game_date
contents[:story] = $story_stats
contents[:game_pause] = $game_pause
contents[:imp_boxes] = $game_boxes
#contents[:mod_data ] = $mod_manager.output_data_to_array # in make_save_header
contents
end
#--------------------------------------------------------------------------
# * Extract Save Contents
#--------------------------------------------------------------------------
def self.extract_save_contents(contents)
create_temp_graphics
$game_system = contents[:system]
$game_timer = contents[:timer]
$game_message = contents[:message]
$game_switches = contents[:switches] #will be remove
$game_variables = contents[:variables] #will be remove
$game_self_switches = contents[:self_switches] #will be remove
$game_actors = contents[:actors]
$game_party = contents[:party]
#$game_troop = contents[:troop]
$game_map = contents[:map]
$game_player = contents[:player]
$game_NPCLayerMain = contents[:game_NPCLayerMain]
$game_NPCLayerSub = contents[:game_NPCLayerSub]
$game_date = contents[:date]
$game_pause = contents[:game_pause]
$story_stats = contents[:story]
$game_boxes = contents[:imp_boxes]
$game_portraits.getPortrait("Lona").base_char = $game_actors[1]
$game_portraits.getPortrait("NPCLayerMain").base_char = $game_NPCLayerMain
$game_portraits.getPortrait("NPCLayerSub").base_char = $game_NPCLayerSub
$game_map.starting_events = [] if $game_map.starting_events.nil? #antiLag
$game_player.actor.actStat.actor = $game_player.actor
end
def self.create_temp_graphics
$cg = TempCG.new(["nil"])
$cg.erase
$bg = TempBG.new(["nil"])
$bg.erase
end
#--------------------------------------------------------------------------
# * Reload Map if Data Is Updated
#--------------------------------------------------------------------------
def self.reload_map_if_updated
if $game_system.version_id != $data_system.version_id
$game_map.setup($game_map.map_id)
$game_player.center($game_player.x, $game_player.y)
$game_player.make_encounter_count
end
end
#--------------------------------------------------------------------------
# * Get Update Date of Save File
#--------------------------------------------------------------------------
def self.savefile_time_stamp(index)
File.mtime(make_filename(index)) rescue Time.at(0)
end
#--------------------------------------------------------------------------
# * Get File Index with Latest Update Date
#--------------------------------------------------------------------------
def self.latest_savefile_index
saveFileMAX.times.max_by {|i| savefile_time_stamp(i) }
end
#--------------------------------------------------------------------------
# * Get Index of File Most Recently Accessed
#--------------------------------------------------------------------------
def self.last_savefile_index
@last_savefile_index
end
#debug function
def self.dbg_exportTXT(data)
open("_asdasdasd.txt","w")do|file|
info= data
file.print(info)
end
end
def self.dbg_eventlib
open("_EventLib.txt","w")do
|file|
file.print("EventLib: \n")
file.print("Date : #{Time.now.strftime("%Y/%m/%d %H:%M:%S")} \n")
$data_EventLib.each{|evID,evData|
next if !evID
next if !evData
info= "#{evData[0]} X:#{evData[1].x} Y:#{evData[1].y} #{evID} "
file.print(info+"\n")
}
end
p "Log generated at _EventLib.txt"
end
# def self.dbg_mapids
# open("_MapIdList.txt", "w") do |file|
# file.print("MapInfo: \n")
# file.print("Date : #{Time.now.strftime("%Y/%m/%d %H:%M:%S")} \n")
#
# # Separate integer and non-integer keys
# int_keys = $data_mapinfos.select { |k, _| k.is_a?(Integer) }.sort
# str_keys = $data_mapinfos.select { |k, _| k.is_a?(String) }.sort
#
# # Process integer keys first
# int_keys.each do |k, v|
# info = sprintf("id:%-3d name: %s", k, v.name)
# p info
# file.print(info + "\n")
# end
#
# # Process string keys next
# str_keys.each do |k, v|
# info = sprintf("id:%-3s name: %s", k, v.name)
# p info
# file.print(info + "\n")
# end
# end
# p "Log generated at _MapIdList.txt"
# end
def self.dbg_itemDataBase
open("_ItemDataBase.txt","w")do
|file|
file.print("$data_ItemName ItemList: \n")
file.print("Date : #{Time.now.strftime("%Y/%m/%d %H:%M:%S")} \n")
$data_ItemName.each{|wut,item|
next if !item
next if !item.id
next if !item.item_name
itemType = "Unknow"
itemType = "0 RPG::Item" if item.class == RPG::Item
itemType = "1 RPG::Armor" if item.class == RPG::Armor
itemType = "2 RPG::Weapon" if item.class == RPG::Weapon
info= "#{itemType} #{item.id} #{item.item_name}"
#info= "class =>#{itemType} id=>#{item.id} item_name#{item.item_name}"
p info
file.print(info+"\n")
}
end
p "Log generated at _itemDataBase.txt"
end
def self.dbg_name_order_scan
log_file = "_NameOrderScanLog.txt"
open(log_file, "w") do |file|
file.puts "Name Order Scan Report"
file.puts "Date : #{Time.now.strftime("%Y/%m/%d %H:%M:%S")}"
file.puts "-" * 60
base_path = "Data/Pconfig/Pconfig_lona/poses/"
Dir.glob("#{base_path}*/").each do |folder|
mismatches = FileGetter.debug_scan_name_order(folder)
# Console + Msgbox feedback
#msgbox("Scanned folder: #{File.basename(folder)}\nCheck your console + log file.")
p "Scanning #{folder}"
if mismatches.empty?
result = "✔ Folder #{File.basename(folder)} has no mismatches."
p result
file.puts result
else
result = "✘ Folder #{File.basename(folder)} has #{mismatches.size} mismatches."
p result
file.puts result
mismatches.each { |m| file.puts " - #{m}" }
end
file.puts "-" * 40
end
end
p "Log generated at #{log_file}"
end
def self.dbg_name_order_scan
log_file = "_NameOrderScanLog.txt"
open(log_file, "w") do |file|
file.puts "Name Order Scan Report"
file.puts "Date : #{Time.now.strftime("%Y/%m/%d %H:%M:%S")}"
file.puts "-" * 60
# case 1: Pconfig_lona scans subfolders
folderList = Dir.glob("Data/Pconfig/Pconfig_lona/poses/*/")
folderList += [
"Data/Pconfig/Pconfig_LayeredNPC/poses/",
"Data/CHSConfig/CHSconfigs_ActorHLayer/",
"Data/CHSConfig/CHSconfigs_ActorLayer/"
]
folderList.each do |folder|
mismatches = FileGetter.debug_scan_name_order(folder)
#msgbox("Scanned folder: #{File.basename(folder)}\nCheck your console + log file.")
p "Scanning #{folder}"
if mismatches.empty?
result = "✔ Folder #{folder} has no mismatches."
p result
file.puts result
else
result = "✘ Folder #{folder} has #{mismatches.size} mismatches."
p result
file.puts result
mismatches.each { |m| file.puts " - #{m}" }
end
file.puts "-" * 40
end
end
p "Log generated at #{log_file}"
end
def self.dbg_skillsDataBase
open("_SkillDataBase.txt","w")do
|file|
file.print("$data_SkillName SkillList: \n")
file.print("Date : #{Time.now.strftime("%Y/%m/%d %H:%M:%S")} \n")
$data_SkillName.each{|wut,item|
next if !item
next if !item.id
next if !item.item_name
info= " #{item.id} #{item.item_name}"
p info
file.print(info+"\n")
}
end
p "Log generated at _SkillDataBase.txt"
end
def self.dbg_statesDataBase
open("_StateDataBase.txt","w")do
|file|
file.print("$data_StateName SkillList: \n")
file.print("Date : #{Time.now.strftime("%Y/%m/%d %H:%M:%S")} \n")
$data_StateName.each{|wut,state|
next if !state
next if !state.id
next if !state.item_name
info= " #{state.id} #{state.item_name}"
p info
file.print(info+"\n")
}
end
p "Log generated at _StateDataBase.txt"
end
def self.dbg_dump_mapinfo_tree(path = "_MapInfoTree.txt", ascending = true)
# 可先在腳本最前面 $data_mapinfos = load_data(...),這裡就不用再載
infos = $data_mapinfos || load_data("Data/MapInfos.rvdata2") # {id => RPG::MapInfo}
# 分開整數 ID 與字串 ID
int_infos = infos.select { |k, _| k.is_a?(Integer) }
str_infos = infos.select { |k, _| k.is_a?(String) }
# ---------- 建立 children 關係(只處理整數 ID) ----------
children = Hash.new { |h, k| h[k] = [] }
int_infos.each do |id, info|
next unless info
children[info.parent_id] << [id, info]
end
# ---------- 依 order 排序 ----------
sorter = ascending ? ->(pair) { pair[1].order } : ->(pair) { -pair[1].order }
children.each_value { |ary| ary.sort_by!(&sorter) }
File.open(path, "w") do |file|
# ----- 標頭 -----
file.puts "MapInfo:"
file.puts "Date : #{Time.now.strftime('%Y/%m/%d %H:%M:%S')}"
file.puts
# ----- 走訪整數 ID 樹狀 -----
walker = lambda do |node_id, info, depth|
file.puts "#{' ' * depth}id:#{node_id} => \"#{info.name}\""
children[node_id].each { |cid, cinfo| walker.call(cid, cinfo, depth + 1) }
end
children[0].each { |rid, rinfo| walker.call(rid, rinfo, 0) }
# ----- 在最下面列出字串 ID(模組地圖) -----
unless str_infos.empty?
file.puts
file.puts "# ---- Modded maps (string IDs) ----"
str_infos.sort_by { |k, _| k }.each do |sid, sinfo|
file.puts "id:#{sid} => \"#{sinfo.name}\""
end
end
end
puts "Log generated at #{path}"
end
#for mod api
#$data_AlchemyRecipes.insert( darkPot_find_item_index("ItemCarbon")+1,your_REcipe_data)
#this insert ur recipe under ItemCarbon.
def self.darkPot_find_item_index(recipe_name, ary=$data_AlchemyRecipes)
index = ary.find_index { |item| item["export_name"] == recipe_name }
if index
puts "#{recipe_name} found at index #{index}"
else
return msgbox "#{recipe_name} not found"
end
index
end
end