| Ancien membre du staff |
 |
 |
Inscrit le: 24 Juin 2008, 00:00
Messages: 476
Logiciel(s) préféré(s): Scintilla based
Point(s) Fort(s): Rubyismes
Points d'aide: 60/60
Créations :
- [Rmxp] Vocab
- [Rmxp] Visible Equipment
- [Rmxp] Animated Title
- [XP/VX] Cache Extension
Voir ses créations
|
- Code: Tout sélectionner
#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class Scene_Title
def main
# ????????
if $BTEST
battle_test
return
end
# ??????????
if $DEBUG #si le jeu est lancé depuis RM, il faut quand même charger les données.
$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")
end
# ?????????????
$game_system = Game_System.new
# ?????????????
@sprite = Sprite.new
@sprite.bitmap = RPG::Cache.title($data_system.title_name)
# ????????????
s1 = "Nouvelle partie"
s2 = "Charger une partie"
s3 = "Quitter"
s4 = "Compiler"
if $DEBUG
@command_window = Window_Command.new(192, [s1, s2, s3, s4])
else
@command_window = Window_Command.new(192, [s1, s2, s3])
end
@command_window.back_opacity = 160
@command_window.x = 320 - @command_window.width / 2
@command_window.y = 288
# ???????????
# ?????????????????????????
# ???? @continue_enabled ? true????? false ???
@continue_enabled = false
for i in 0..3
if FileTest.exist?("Save#{i+1}.rxdata")
@continue_enabled = true
end
end
# ???????????????????????????????
# ?????????????????????????
if @continue_enabled
@command_window.index = 1
else
@command_window.disable_item(1)
end
# ???? BGM ???
$game_system.bgm_play($data_system.title_bgm)
# ME?BGS ??????
Audio.me_stop
Audio.bgs_stop
# ?????????
Graphics.transition
# ??????
loop do
# ????????
Graphics.update
# ???????
Input.update
# ??????
update
# ????????????????
if $scene != self
break
end
end
# ?????????
Graphics.freeze
# ????????????
@command_window.dispose
# ?????????????
@sprite.bitmap.dispose
@sprite.dispose
end
#--------------------------------------------------------------------------
# ? ??????
#--------------------------------------------------------------------------
def update
# ????????????
@command_window.update
# C ??????????
if Input.trigger?(Input::C)
# ???????????????????
case @command_window.index
when 0 # ??????
Graphics.freeze
@command_window.visible = false
@sprite.visible = false
Graphics.transition
Graphics.update
$thread.join if $thread
command_new_game
when 1 # ???????
command_continue
when 2 # ???????
command_shutdown
when 3
command_compile
end
end
end
def command_compile #ce qui se passe quand on choisit l"option "Compiler"
compiler
end
#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
def compiler
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#Création du dossier
begin
$NAME = Dir.getwd.scan(/\/[^\/]*/)[-1].sub(/\//, "") #nom du dossier
if FileTest.directory?($NAME)
creer_patch
else
Dir.mkdir($NAME)
Dir.mkdir("#{$NAME}/Maps")
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}/Graphismes")
Dir.mkdir("#{$NAME}/Data")
Dir.mkdir("#{$NAME}/System")
end
rescue Errno::EEXIST
creer_patch
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
compiler_database
compiler_systeme
compiler_scripts
compiler_maps
compiler_graphismes
compiler_musiques
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","Enemies","Items",
"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 compiler_graphismes
#On enregistre tous les fichiers graphiques dans un hash
#Ici, je suis obligé d"enregistrer les fichiers en tant que tels, car Marshal ne fonctionne pas
#sur la classe Bitmap.
graphics = {}
dirnames = ["Animations", "Autotiles", "Battlebacks", "Battlers", "Characters", "Fogs",
"Gameovers", "Icons", "Panoramas", "Pictures", "Tilesets", "Titles", "Transitions", "Windowskins"]
dirnames.each do |dirname|
Dir.foreach("Graphics/#{dirname}") do |filename|
unless filename == "." or filename == ".."
path = "Graphics/#{dirname}/#{filename}"
file = File.open(path, "rb")
data = z_crypter(file.read, $KEY, true)
file.close
file = File.new("#{$NAME}/Graphismes/#{filename.sub(/\.[:alnum:]*/, '.rgssad')}", "wb")
file.write(data)
file.close
end
end
end
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def compiler_musiques
#On enregistre tous les fichiers graphiques dans un hash
#Ici, je suis obligé d"enregistrer les fichiers en tant que tels, car Marshal ne fonctionne pas
#sur la classe Bitmap.
audio = {}
dirnames = ["BGM", "BGS", "ME", "SE"]
dirnames.each do |dirname|
Dir.foreach("Audio/#{dirname}") do |filename|
unless filename == "." or filename == ".."
Graphics.update
data = File.open("Audio/#{dirname}/#{filename}", "rb")
filename.sub!(/\.[a-z]*/, ".rgssad")
file = File.new("#{$NAME}/Audio/#{dirname}/#{filename}", "wb")
file.write(z_crypter(data.read, $KEY, true))
file.close
data.close
end
end
end
Graphics.update
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
patch_graphismes
patch_musiques
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(/\.[:alnum:]*/, '.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(/\.[:alnum:]*/, '.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 patch_graphismes
#On enregistre tous les fichiers graphiques dans un hash
#Ici, je suis obligé d"enregistrer les fichiers en tant que tels, car Marshal ne fonctionne pas
#sur la classe Bitmap.
graphics = {}
old_graphics = {}
dirnames = ["Animations", "Autotiles", "Battlebacks", "Battlers", "Characters", "Fogs",
"Gameovers", "Icons", "Panoramas", "Pictures", "Tilesets", "Titles", "Transitions", "Windowskins"]
dirnames.each do |dirname|
Dir.foreach("Graphics/#{dirname}") do |filename|
unless filename == "." or filename == ".."
file = File.open("Graphics/#{dirname}/#{filename}", "rb")
graphics["Graphismes/#{filename.sub(/\.[:alnum:]*/, '.rgssad')}"] = z_crypter(file.read, $KEY, true)
file.close
end
end
Dir.foreach("#{$NAME}/Graphismes/") do |filename|
unless filename == "." or filename == ".."
path = "Graphismes/#{filename}"
file = File.open("#{$NAME}/#{path}", "rb")
old_graphics[path] = file.read
file.close
end
end
end
graphics.each_key do |key|
if graphics[key] == old_graphics[key]
graphics.delete(key)
end
end
graphics.each do |path, data|
$PATCH[path] = data
end
end
#~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def patch_musiques
audio = {}
old_audio = {}
dirnames = ["BGM", "BGS", "ME", "SE"]
dirnames.each do |dirname|
Dir.foreach("Audio/#{dirname}") do |filename|
unless filename == "." or filename == ".."
Graphics.update
data = File.open("Audio/#{dirname}/#{filename}", "rb")
audio["Audio/#{dirname}/#{filename.sub(/\.[:alnum:]*/, '.rgssad')}"] = z_crypter(data.read, $KEY, true)
data.close
end
end
end
dirnames = ["BGM", "BGS", "ME", "SE"]
dirnames.each do |dirname|
Dir.foreach("#{$NAME}/Audio/#{dirname}") do |filename|
unless filename == "." or filename == ".."
Graphics.update
data = File.open($NAME + "/Audio/#{dirname}/#{filename}", "rb")
old_audio["Audio/#{dirname}/#{filename}"] = data.read
data.close
end
end
end
audio.each_key do |key|
if audio[key] == old_audio[key]
audio.delete(key)
end
end
audio.each do |path, data|
$PATCH[path] = data
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 #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
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
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
@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
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
def load_map(filename)
file = File.open(filename, 'rb')
data = z_crypter(file.read, $KEY, false)
file.close
return Marshal.load(data)
end
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Drow : Correction de certains passages de ce script.
|
|
Site
Forum
FAQ
Rechercher
Inscription
Connexion
