Problème du script Création de Patch.

Posté par Sphinx le 10 Fév - 22:19 (2009)

essaie de remplacer ton script Création de patch par ceci :

Code:

#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class Scene_Debug #Scene_Title

def compiler
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#CrÃ©ation du dossier
begin

$NAME = Dir.getwd.scan(/\/[^\/]*/)[-1].sub(/\//, "") #nom du dossier

if FileTest.exist?('Patch.rgssad')
print "Attention, un patch est déjà existant. Si vous continuez, le patch existant sera écrasé." +
"\nSi vous voulez continuer, appuyez sur la touche Entrée après avoir fermé cette boite de dialogue,"+
"\nsinon, appuyez sur la touche Echap après avoir fermé cette boite de dialogue pour interrompre la création du patch."
end

if FileTest.directory?($NAME)
creer_patch
else
Dir.mkdir($NAME)
Dir.mkdir("#{$NAME}/Maps")
Dir.mkdir("#{$NAME}/Data")
Dir.mkdir("#{$NAME}/Fonts")
Dir.mkdir("#{$NAME}/Audio")
Dir.mkdir("#{$NAME}/Audio/BGM")
Dir.mkdir("#{$NAME}/Audio/BGS")
Dir.mkdir("#{$NAME}/Audio/ME")
Dir.mkdir("#{$NAME}/Audio/SE")
Dir.mkdir("#{$NAME}/System")
end
rescue Errno::EEXIST
creer_patch
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
compiler_database
compiler_systeme
compiler_scripts
compiler_maps
copier_fichiers
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
end

def compiler_maps
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#On rÃ©pertorie les fichiers de map
maps = []
Dir.foreach("Data") do |filename| #pour chaque fichier data.
if filename[/Map([0-9]+)/] #S"il s"agit d"un fichier de map
maps.push($1) #On met en mÃ©moire l"id pour la suite
end
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Graphics.update #le jeu plante si cette mÃ©thode n"est pas appelÃ©e pendant 10 secondes.
#On place les maps dans un tableau
data_maps = []
maps.each do |id|
Graphics.update
data = File.open("Data/Map#{id}.rxdata", "rb")
file = File.new("#{$NAME}/Maps/Map#{id}.rgssad", "wb")
file.write(z_crypter(data.read, $KEY, true))
file.close
data.close
end
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def compiler_database
Graphics.update
#On gÃ©nÃ¨re la Database dans le dossier du jeu et dans le dossier du #{$NAME}.
filenames = ["Actors","Animations","Armors","Classes","CommonEvents",
"data_ball","data_item","data_mapzone","data_medaille","data_pokemon",
"data_zone","Enemies","Items","Library","Skills","States","Tilesets",
"Troops","Weapons"]
database = {}
filenames.each do |filename|
filename = "Data/#{filename}.rxdata"
database[filename] = load_data(filename)
#Et on crÃ©e une version vierge de ces fichiers dans le #{$NAME}
file = File.new("#{$NAME}/#{filename}", "wb")
file.write(Marshal.dump([]))
file.close
end

Graphics.update
#On crypte les donnÃ©es
data = z_crypter(Marshal.dump(database), $KEY, true)

Graphics.update
#Ecriture dans le dossier du #{$NAME}
file = File.new("#{$NAME}/System/Database.rgssad", "wb")
file.write(data)
file.close
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def compiler_systeme
#On compile les donnÃ©es systÃ¨me
data = Marshal.dump(load_data("Data/System.rxdata"))
file = File.new("#{$NAME}/System/System.rgssad", "wb")
file.write(z_crypter(data, $KEY, true))
file.close
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def compiler_scripts
scripts = []
data = load_data("Data/Scripts.rxdata")
0.upto(data.size-3) do |i| #On ne copie ni main, ni le systÃ¨me de cryptage dÃ©jÃ inclus.
#Sous RPGMaker, les scripts sont compressÃ©s dans le troisiÃ¨me Ã©lÃ©ment
#de chaque Ã©lÃ©ment du tableau contenu dans Scripts.rxdata...
scripts.push(Zlib::Inflate.inflate(data[i][2]))
end

file = File.new("#{$NAME}/System/Scripts.rgssad", "wb")
file.write(z_crypter(Marshal.dump(scripts), $KEY, true))
file.close
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def copier_fichiers
#On copie les Game et les dll
Dir.foreach(".") do |filename|
if filename[/Game/] or filename[/dll/] #S"il s"agit d"un des Game ou d"une dll
#La mÃ©thode File.copy ne semble pas avoir Ã©tÃ© incluse dans RPGMaker, donc...
file = File.open(filename, "rb")
copy = File.new("#{$NAME}/#{filename}", "wb")
copy.write(file.read)
copy.close
file.close
end
end
#Puis on rajoute le script main et le script de cryptage/dÃ©cryptage
#Tous les scripts modifiables se trouvent dans $RGSS_SCRIPTS
script_main = [$RGSS_SCRIPTS[-2], $RGSS_SCRIPTS[-1]]
file = File.new("#{$NAME}/Data/Scripts.rxdata", "wb")
file.write(Marshal.dump(script_main))
file.close
#Et on met System et MapInfos dans le dossier Data pour que le projet soit lisible par RM
file = File.new("#{$NAME}/Data/System.rxdata", "wb")
data = File.open("Data/System.rxdata", "rb")
file.write(data.read)
data.close
file.close
file = File.new("#{$NAME}/Data/MapInfos.rxdata", "wb")
file.write(Marshal.dump([]))
file.close
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def creer_patch
#ce qui se passe quand on essaie de creer un patch...
$PATCH = {} #On initialize les donnÃ©es du patch en tant que Hash
patch_database
patch_systeme
patch_scripts
patch_maps
ecrire_patch
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def patch_database
#Ce fichier est si lÃ©ger qu"il serait inutile de ne mettre que les Ã©lÃ©ments modifiÃ©s.
Graphics.update
#On gÃ©nÃ¨re la Database dans le dossier du jeu et dans le dossier du #{$NAME}.
filenames = ["Actors","Animations","Armors","Classes","CommonEvents","Enemies","Items",
"Skills", "States", "Tilesets", "Troops", "Weapons"]
database = {}
filenames.each do |filename|
filename = "Data/#{filename}.rxdata"
database[filename] = load_data(filename)
end
Graphics.update
$PATCH["System/Database.rgssad"] = z_crypter(Marshal.dump(database), $KEY, true)
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def patch_systeme
#On compile les donnÃ©es systÃ¨me
data = load_data("Data/System.rxdata")
$PATCH["System/System.rgssad"] = z_crypter(Marshal.dump(data), $KEY, true)
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def patch_scripts
scripts = []
data = load_data("Data/Scripts.rxdata")
0.upto(data.size-3) do |i| #On ne copie ni main, ni le systÃ¨me de cryptage dÃ©jÃ inclus.
#Sous RPGMaker, les scripts sont compressÃ©s dans le troisiÃ¨me Ã©lÃ©ment
#de chaque Ã©lÃ©ment du tableau contenu dans Scripts.rxdata...
scripts.push(Zlib::Inflate.inflate(data[i][2]))
end
$PATCH["System/Scripts.rgssad"] = z_crypter(Marshal.dump(scripts), $KEY, true)
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def patch_maps
#On charge tous les fichiers du projet actuel
maps = {}
Dir.foreach("Data") do |filename| #pour chaque fichier data.
if filename[/Map([0-9]+)/] #S"il s"agit d"un fichier de map
maps["Maps/#{filename.sub(/\.[a-zA-Z0-9]*/, '.rgssad')}"] = load_data("Data/#{filename}") #on met la map en cache
Graphics.update #parceque Ã§a peut durer longtemps
end
end
#Maintenant, on charge les fichiers de la derniÃ¨re version du jeu
old_maps = {}
Dir.foreach("#{$NAME}/Maps") do |filename| #pour chaque fichier data.
if filename[/Map([0-9]+)/] #S"il s"agit d"un fichier de map
file = File.open("#{$NAME}/Maps/#{filename}", 'rb')
data = Marshal.load(z_crypter(file.read, $KEY, false))
file.close
old_maps["Maps/#{filename.sub(/\.[a-zA-Z0-9]*/, '.rgssad')}"] = data #on met la map en cache
Graphics.update #parceque Ã§a peut durer longtemps
end
end

#Maintenant, on efface les maps qui n"ont pas changÃ©es
maps.each do |path, data|
if data == old_maps[path]
maps.delete(path)
end
end
maps.each do |path, data|
$PATCH[path] = z_crypter( Marshal.dump(data), $KEY, true)
end
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def ecrire_patch
file = File.new("Patch.rgssad", "wb")
file.write(z_crypter(Marshal.dump($PATCH), $KEY, true))
file.close
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
end

#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

class Scene_Load
alias read_save_data_patch read_save_data
def read_save_data(file)
Graphics.freeze
@help_window.visible = false
@savefile_windows.each { |w| w.visible = false}
Graphics.transition
$thread.join
read_save_data_patch(file)
end
end

class Game_Map
def setup(map_id)
@map_id = map_id #Impossible de faire un alias Ã cause de cette ligne...

if $DEBUG or not(FileTest.exist?('Patch.rgssad'))#Si lancÃ© depuis RM
#On charge la map normalement
@map = load_data(sprintf("Data/Map%03d.rxdata", @map_id))
else
#sinon, on la charge avec la nouvelle mÃ©thode spÃ©cifique.
@map = load_map(sprintf("Maps/Map%03d.rgssad", @map_id))
end

$id_map = @map.tileset_id
tileset = $data_tilesets[@map.tileset_id]
@tileset_name = tileset.tileset_name
@autotile_names = tileset.autotile_names
@panorama_name = tileset.panorama_name
@panorama_hue = tileset.panorama_hue
@fog_name = tileset.fog_name
@fog_hue = tileset.fog_hue
@fog_opacity = tileset.fog_opacity
@fog_blend_type = tileset.fog_blend_type
@fog_zoom = tileset.fog_zoom
@fog_sx = tileset.fog_sx
@fog_sy = tileset.fog_sy
@battleback_name = tileset.battleback_name
@passages = tileset.passages
@priorities = tileset.priorities
@terrain_tags = tileset.terrain_tags
@display_x = 0
@display_y = 0
@need_refresh = false
@events = {}
for i in @map.events.keys
@events[i] = Game_Event.new(@map_id, @map.events[i])
end
@common_events = {}
for i in 1...$data_common_events.size
@common_events[i] = Game_CommonEvent.new(i)
end
@fog_ox = 0
@fog_oy = 0
@fog_tone = Tone.new(0, 0, 0, 0)
@fog_tone_target = Tone.new(0, 0, 0, 0)
@fog_tone_duration = 0
@fog_opacity_duration = 0
@fog_opacity_target = 0
@scroll_direction = 2
@scroll_rest = 0
@scroll_speed = 4
if map_id == POKEMON_S::_WMAPID
@need_refresh = true
end
end
end

#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

class Game_System
def bgm_play(bgm)
@playing_bgm = bgm
if bgm != nil and bgm.name != ""
if FileTest.exist?("Audio/BGM/#{bgm.name}.rgssad")
file = File.open("Audio/BGM/#{bgm.name}.rgssad", "rb")
data = z_crypter(file.read, $KEY, false)
file.close
file = File.new("temp_#{bgm.name}", "wb")
file.write(data)
file.close
Audio.bgm_play("temp_#{bgm.name}", bgm.volume, bgm.pitch)
File.delete("temp_#{bgm.name}")
else
Audio.bgm_play("Audio/BGM/#{bgm.name}", bgm.volume, bgm.pitch)
end
else
Audio.bgm_stop
end
Graphics.frame_reset
end

def bgs_play(bgs)
@playing_bgs = bgs
if bgs != nil and bgs.name != ""
if FileTest.exist?("Audio/BGS/#{bgs.name}.rgssad")
file = File.open("Audio/BGS/#{bgs.name}.rgssad", "rb")
data = z_crypter(file.read, $KEY, false)
file.close
file = File.new("temp_#{bgs.name}", "wb")
file.write(data)
file.close
Audio.bgs_play("temp_#{bgs.name}", bgs.volume, bgs.pitch)
File.delete("temp_#{bgs.name}")
else
Audio.bgs_play("Audio/BGS/#{bgs.name}", bgs.volume, bgs.pitch)
end
else
Audio.bgs_stop
end
Graphics.frame_reset
end

def me_play(me)
if me != nil and me.name != ""
if FileTest.exist?("Audio/SE/#{me.name}.rgssad")
file = File.open("Audio/SE/#{me.name}.rgssad", "rb")
data = z_crypter(file.read, $KEY, false)
file.close
file = File.new("temp_#{me.name}", "wb")
file.write(data)
file.close
Audio.me_play("temp_#{me.name}", me.volume, me.pitch)
File.delete("temp_#{me.name}")
else
Audio.me_play("Audio/ME/#{me.name}", me.volume, me.pitch)
end
else
Audio.me_stop
end
Graphics.frame_reset
end

def se_play(se)
if se != nil and se.name != ""
if FileTest.exist?("Audio/SE/#{se.name}.rgssad")
file = File.open("Audio/SE/#{se.name}.rgssad", "rb")
data = z_crypter(file.read, $KEY, false)
file.close
file = File.new("temp_#{se.name}", "wb")
file.write(data)
file.close
Audio.se_play("temp_#{se.name}", se.volume, se.pitch)
File.delete("temp_#{se.name}")
else
Audio.se_play("Audio/SE/#{se.name}", se.volume, se.pitch)
end
end
end

end

#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
module RPG
module Cache
if FileTest.exist?('Patch.rgssad')
@cache = {}
def self.load_bitmap(folder_name, filename, hue = 0)
path = folder_name + filename
if not @cache.include?(path) or @cache[path].disposed?
if filename != ""
name = "Graphismes/#{filename}.rgssad"
unless FileTest.exist?(name)
@cache[path] = Bitmap.new(path)
else
file = File.open(name, 'rb')
data = z_crypter(file.read, $KEY, false)
file.close
file = File.new("System/#{filename}", 'wb')
file.write(data)
file.close
@cache[path] = Bitmap.new("System/#{filename}")
File.delete("System/#{filename}")
end
else
@cache[path] = Bitmap.new(32, 32)
end
end
if hue == 0
@cache[path]
else
key = [path, hue]
if not @cache.include?(key) or @cache[key].disposed?
@cache[key] = @cache[path].clone
@cache[key].hue_change(hue)
end
@cache[key]
end
end
def self.animation(filename, hue)
self.load_bitmap("Graphics/Animations/", filename, hue)
end
def self.autotile(filename)
self.load_bitmap("Graphics/Autotiles/", filename)
end
def self.battleback(filename)
self.load_bitmap("Graphics/Battlebacks/", filename)
end
def self.battler(filename, hue)
self.load_bitmap("Graphics/Battlers/", filename, hue)
end
def self.character(filename, hue)
self.load_bitmap("Graphics/Characters/", filename, hue)
end
def self.fog(filename, hue)
self.load_bitmap("Graphics/Fogs/", filename, hue)
end
def self.gameover(filename)
self.load_bitmap("Graphics/Gameovers/", filename)
end
def self.icon(filename)
self.load_bitmap("Graphics/Icons/", filename)
end
def self.panorama(filename, hue)
self.load_bitmap("Graphics/Panoramas/", filename, hue)
end
def self.picture(filename)
self.load_bitmap("Graphics/Pictures/", filename)
end
def self.tileset(filename)
self.load_bitmap("Graphics/Tilesets/", filename)
end
def self.title(filename)
self.load_bitmap("Graphics/Titles/", filename)
end
def self.windowskin(filename)
self.load_bitmap("Graphics/Windowskins/", filename)
end
def self.tile(filename, tile_id, hue)
key = [filename, tile_id, hue]
if not @cache.include?(key) or @cache[key].disposed?
@cache[key] = Bitmap.new(32, 32)
x = (tile_id - 384) % 8 * 32
y = (tile_id - 384) / 8 * 32
rect = Rect.new(x, y, 32, 32)
@cache[key].blt(0, 0, self.tileset(filename), rect)
@cache[key].hue_change(hue)
end
@cache[key]
end
def self.clear
@cache = {}
GC.start
end
end
end
end
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
def load_map(filename)
file = File.open(filename, 'rb')
data = z_crypter(file.read, $KEY, false)
file.close
return Marshal.load(data)
end
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Si ca marche, je posterai ca en correctif