Compilation pour expédition

Bonjour,

Si je compile mon jeu, enfin la bribe que j'en ai fait, sans les RTP, le fichier résultant pèse environ 140K. Avec les RTP 200 000K.
Si ma banque me rapportait autant....

Donc, en première intension, je pencherai pour le "sans RTP". Mais....
Comme j'utilise, pour le moment, les objets de base pour mes cartes et mes persos, le jeu sera-t-il jouable sur une machine qui n'a pas RPGM installée ?

Comme on ne peut pas supprimer les fichiers issus des RTP, il est certain que je récupère des tonnes de "trucs" totalement inutiles.

La solution serait-elle d'exporter ce dont j'ai besoin et de le réintroduire sous un autre nom afin de pouvoir compiler sans RTP ?
Si c'est le cas, j'aimerai le savoir vite, je n'ai pas envie de repasser sur tous les évènement pour changer l'adresse des fichiers utilisés. Pas plus que de refaire plus de cartes que strictement nécessaire.

Merci d'avance.

Sans les RTP, il faudra que la personne les télécharge elle-même et les installe dans le dossier du jeu pour pouvoir y jouer au minimum.

Sinon, si j'ai bien compris, c'est la taille des fichiers qui te gène? A priori la seul solution est de faire un tri dans les RTP et de ne garder que ceux qui t'intéresse. Pour les tileset par exemple, il faudra découper les ressources qui t'intéressent et récréer un fichier qui ne contiennent que ces dernières (faisable relativement facilement avec un logiciel comme paint ou gimp)

PS: j'ai pas compris quand tu as dit que les RTP sont pas supprimables. En fait tu peut les trier. Lors de la création du projet, tout les RTP sont recopiés dans le projet de ton jeu et à ce moment, tu peut ajouter/supprimer ceux qui t'intéressent (manuellement par contre, je crois).

Disons que dans le gestionnaire de ressources, on ne peut pas les supprimer. Bouton grisé, contrairement aux ressources que l'on a importé personnellement.
Donc on est bien d'accord, le meilleur moyen c'est de se faire ses propres ressources, même à partir d'export du RTP d'origine et ensuite virer les RTP d'une manière ou d'une autre.

Comme je me sers pas mal des évènements et des dialogues entre persos, j'ai intérêt à réaliser la remise en forme de mes ressources très vite dans le projet pour ne pas avoir trop d'évènements ni de messages à corriger au niveau de l'affichage des persos.

J'utilise The Gimp depuis pas mal d'année, depuis une époque où il existait pas encore sous Window$, mais uniquement sous Linux.
Donc pas de soucis pour cut et crop.

Merci des infos. Je me mets à ma réorganisation des ressources.

Salut, si tu coche sans RTP, les personnes pour lancer ton jeu, devra installer RPG Maker VX Ace juste les RTP pas le logiciel, gratuitement.
Pour supprimer des fichiers RTP ces dans le dossier rpg maker, Projet.

Shamugan a écrit:Lors de la création du projet, tout les RTP sont recopiés dans le projet de ton jeu et à ce moment, tu peut ajouter/supprimer ceux qui t'intéressent (manuellement par contre, je crois).

C'est vrai pour MV, mais pas pour VXace.

Pour en revenir au sujet. Se que tu peux faire, c'est compiler ton jeu et l'installer toi même (admettons, sur le bureau). Une fois le tout extrait de l'installateur, tu vas pourvoir faire un tri, et une fois ton tri fini, tu met ton jeu dans une archive zip. Non seulement t'as fais un tri, et en plus ça compresse.

Yamashi a écrit:
C'est vrai pour MV, mais pas pour VXace.

Les RTP de base sont recopiés sur ace, à moins que j'ai ait une manipulation inconsciente lorsque j'ai crée un projet, mais par défaut, je crois qu'il sont toujours recopiés.

Par contre, les RTP non basiques, non. Enfin, je crois que c'est ça, dis-moi si je me trompe?

Non c'est ca, lorsque qu'on crée un projet vierge, les RTP sont inclut dedans de base.

Sauf pour MV ou seulement la moitier des RTP sont présent, l'autre moitier est a entrer manuellement et n'est disponible que si on a une version officielle (ou si qqu'un a mis en ligne l'autre moitier) pour limiter la casse des crack du logiciel.

Exactement on a les RTP médieval, l'autre partie SF est a mettre manuellement

M'enfin, même avec une version officiele on a pas tous, surtout du coter des batler c'est pauvre(on a même pas tout les actors), je suspecte enterbrain de nous sortir des DLC avec ces batlers plus tard.

J'ai une version officielle de VXace, je confirme qu'il ne recopie pas les rtps (vous savez, je suis un vieux de la vieille sur VXace  ). A ma connaissance, seul MV fait cela.
Se qui est complètement con d'ailleurs, ça te bouffe de l'espace inutilement et c'est vachement plus pratique que le logiciel charge tout depuis le dossier natif du log (et non, je refuse de croire que c'est pour "économiser la RAM", VXace est très peu gourmand et MV est mal optimisé à mon goût).

Ok, je viens de comprendre. J'ai confondu la gestion des ressources et l'endroit où elles sont stockés. En fait quand t'édite le projet, tu utilise les ressources qui sont dans le dossier RPG maker vxace mais en même, le game.exe de ton jeu est dans le dossier de ton jeu. Et puis après, lors de la compil, ça recopie (ou non) les ressources, c'est ça?

C'est ça, le "Game.exe" se copie, une fois que tu compiles le tout (en cochant "inclure les rtp"), tout se copie dans le dossier final.

Bon, à vue de nez, il ressort de toutes ces informations que si on veut n'avoir que le strict minimum dans le produit fini on a intérêt à incorporer à la main juste ce dont on a besoin. Ce qui veut dire par exemple, d'éclater les facesets en 8 fichiers unitaires, de n'inclure que les tronches vraiment utilisées, de référencer les persos par rapport à ces fichiers "persos" et de compiler sans les RTP pour pas qu'il ajoute les 7 "faces" dont on a pas besoin. et pareil pour tous les fichiers contenant plusieurs items différents.

Un beau boulot en perspective mais qui, à l'usage sera payant puisque le découpage ne doit se faire qu'une fois. De plus, les fichiers éclatés peuvent être utilisés par tout le monde.

Je vois bien le principe.

Merci de tout ça.

Au fait, perso je bosse sous VX Ace, alors, toujours perso, la gestion par MV.... je m'en badigeonne le nombril avec le pinceau de l'indifférence.

Ajout : Je viens de créer quelques fichiers unitaires issus des facesets et que j'ai nommés suivant le nom du héros. Ben c'est plus clair dans les scripts évènements, au lieu de :

Afficher un message : "Actor2", 6, Normal, Haut
j'ai
Afficher un message : "Badger", 0, Normal, Haut

Je retrouve plus facilement qui parle. Et dans les multi-logues où j'ai 6 ou 8 personnages qui interviennent, c'est beaucoup plus clair.

J'essai de remettre à jour mon outils de listage des ressources, que j'avais fait pour la version XP, dès que j'ai un peu de temps. En lui ajoutant la possibilité de copier les fichiers directement des RTP vers le projet.
Faut juste que je trouve le temps de le faire.

Merci beaucoup Tonyryu.

Pas de panique, en ce qui me concerne rien n'est jamais urgent (sauf les dépannages en cas de blocage).
Pour le moment, je jongle entre Gimp pour les "têtes" de personnages, Audacity pour les bruits d'ambiance, Firefox pour trouver des scripts utiles, RPGM VX Ace pour avancer dans le projet, Hex Editor Neo pour piger la structure des .rvdata2, et j'en oublie certainement.

Alors tu vois que, pour ma part, les urgences sont très relatives.

Le boulot que tu fais, quelque soit la date de finalisation, sera toujours très apprécié et je t'en remercie d'ors et déjà.

C'est super de trouver des membres de forums réactifs et productifs. Ça me change de ce que j'ai vu ailleurs.

Salut. Tu peux utiliser ce script qui copie juste les ressources nécessaire de ton projet.

Code:

=begin
#==============================================================================
 ** Resource Checker
 Author: Tsukihime
 Date: Jul 27, 2012
------------------------------------------------------------------------------
 ** Change log
 Jul 27
  - initial release
------------------------------------------------------------------------------ 
 This script goes through all of the data files in the data folder and
 displays a list of graphics and audio used.
 
 It performs a very simple resource check and copy: if it's defined in your
 database or in any event, it is assumed you are using it.
 
 I have not written anything sophisticated such as checking whether the
 particular resource is ever referenced.
 
 This script also does not support custom scripts that reference RTP
 resources; if you have custom scripts and you know they use RTP materials,
 you should consider copying everything related to that script over manually.
 
 To use, simply press F5 (configurable)
#==============================================================================
=end
$imported = {} if $imported.nil?
$imported["Tsuki_Resource_Checker"] = true
#==============================================================================
# ** Configuration
#==============================================================================
module Tsuki
  module Resource_Checker
   
    # Copy your RTP path here.
    # Don't forget the trailing slash (I don't check it)
    RTP_Directory = "C:/Program Files (x86)/Enterbrain/RPG Maker VX.Ace/RTP/"
   
    # Set it to false if you only want a list of resources you use
    Copy_Files_Over = true
   
    # change this if you need to
    Check_Key = :F5
#==============================================================================
# ** Rest of the script
#==============================================================================
    Graphics_Dirs = [:Animations, :Battlebacks1, :Battlebacks2, :Battlers,
                    :Characters, :Faces, :Parallaxes, :Pictures, :System,
                    :Tilesets, :Titles1, :Titles2]
    Audio_Dirs = [:BGM, :BGS, :ME, :SE]
    Font_Dirs = [:Fonts]
  end
end

# just add it somewhere

class Game_Player < Game_Character
 
  alias tsuki_Resource_Checker_update update
  def update
    tsuki_Resource_Checker_update
    if Input.trigger?(Tsuki::Resource_Checker::Check_Key)
      r = Resource_Finder.new
      r.run
    end
  end
end
#~ 
# generic parser class. Subclasses should implement the methods if needed
class Data_Parser
 
  def initialize
    @data_animations = load_data("Data/Animations.rvdata2")
  end
 
  def parse_actors
  end
 
  def parse_classes
  end
 
  def parse_skills
  end
 
  def parse_items
  end
 
  def parse_weapons
  end
 
  def parse_armors
  end
 
  def parse_states
  end
 
  def parse_enemies
  end
 
  def parse_troops
  end
 
  def parse_animations
  end
 
  def parse_tilesets
  end
 
  def parse_system
  end
 
  def parse_fonts
  end
 
  # takes a vehicle object stored in System.rvdata2
  def parse_vehicle(vehicle)
  end
 
  def parse_terms
  end
 
  # map parsing
 
  def parse_datamaps
  end
 
  # pass in a map ID
  def parse_map(map_id)
  end
 
  # takes an RPG::Map::Encounter object
  def parse_encounters(encounters)
  end
 
  # event parsers
 
  def parse_event_commands(list)
  end
 
  def parse_event_page(page)
  end
 
  def parse_event(event)
  end
 
  def parse_map_events(events)
  end
 
  def parse_common_events
  end
 
  def parse_data_files
    parse_actors
    parse_classes
    parse_skills
    parse_items
    parse_weapons
    parse_armors
    parse_enemies
    parse_troops
    parse_states
    parse_animations
    parse_tilesets
    parse_common_events
    parse_system
    parse_terms
    parse_datamaps
    parse_fonts
  end
end

class Resource_Finder < Data_Parser

  def initialize
    super
    @resources = {}
  end
 
  def init_category(category)
    @resources[category] = []
  end
 
  def add_resource(category, name)
    init_category(category) if @resources[category].nil?
    return unless name && !name.empty?
    @resources[category] |= [name]
  end
 
  def parse_actors
    actors = load_data("Data/Actors.rvdata2")
    actors.each {|actor|
      next unless actor
      add_resource(:Characters, actor.character_name)
      add_resource(:Faces, actor.face_name)
    }
  end 
 
  def parse_enemies
    enemies = load_data("Data/Enemies.rvdata2")
    enemies.each {|enemy|
      next unless enemy
      add_resource(:Battlers, enemy.battler_name)
    }
  end
 
  def parse_animations
    anims = load_data("Data/Animations.rvdata2")
    anims.each {|anim|
      next unless anim
      add_resource(:Animations, anim.animation1_name)
      add_resource(:Animations, anim.animation2_name)
    }
  end
 
  def parse_tilesets
    tilesets = load_data("Data/Tilesets.rvdata2")
    tilesets.each {|tileset|
      next unless tileset
      tileset.tileset_names.each {|name|
        add_resource(:Tilesets, name)
      }
    }
  end
 
  def parse_common_events
    events = load_data("Data/CommonEvents.rvdata2")
    events.each {|evt|
      next unless evt
      parse_command_list(evt.list)
    }
  end
 
  def parse_system
    system = load_data("Data/System.rvdata2")
    add_resource(:BGM, system.title_bgm.name)
    add_resource(:BGM, system.battle_bgm.name)
    add_resource(:ME, system.battle_end_me.name)
    add_resource(:ME, system.gameover_me.name)
   
    # add system sounds
    system.sounds.each {|sound|
      add_resource(:SE, sound.name)
    }
   
    # test battle and editor related
    add_resource(:Battlebacks1, system.battleback1_name)
    add_resource(:Battlebacks2, system.battleback2_name)
    add_resource(:Battlers, system.battler_name)   
   
    # vehicles
    parse_vehicle(system.boat)
    parse_vehicle(system.ship)
    parse_vehicle(system.airship)
   
    # titles
    add_resource(:Titles1, system.title1_name)
    add_resource(:Titles2, system.title2_name)
   
    # some default stuff
    add_resource(:System, "BattleStart")
    add_resource(:System, "GameOver")
    add_resource(:System, "IconSet")
    add_resource(:System, "Shadow")
    add_resource(:System, "Window")
  end
 
  def parse_vehicle(vehicle)
    add_resource(:Characters, vehicle.character_name)
    add_resource(:BGM, vehicle.bgm.name)
  end
 
  # just hardcoded...
  def parse_fonts
    add_resource(:Fonts, "VL-Gothic-Regular")
    add_resource(:Fonts, "VL-PGothic-Regular")
  end
 
  # map parser
 
  def parse_datamaps
   
    infos = load_data("Data/MapInfos.rvdata2")
    infos.each {|id, map|
      next unless map
      parse_map(id)
    }
  end
 
  def parse_map(map_id)
    map = load_data(sprintf("Data/Map%03d.rvdata2", map_id))
    add_resource(:Parallaxes, map.parallax_name)
    add_resource(:Battlebacks1, map.battleback1_name)
    add_resource(:Battlebacks2, map.battleback2_name)
    add_resource(:BGM, map.bgm.name)
    add_resource(:BGS, map.bgs.name)
    parse_map_events(map.events)
  end
 
  # event parsing
 
  def check_event_resources(cmd)
    code, params = cmd.code, cmd.parameters
    case code
    when 101 # show text
      add_resource(:Faces, params[0]) # face name
    when 212 # show animation
    when 213 # show balloon
      add_resource(:System, "Balloon")
    when 231 # show picture
      add_resource(:Pictures, params[1])
    when 241 # play BGM
      add_resource(:BGM, params[0].name)
    when 245 # play BGS
      add_resource(:BGS, params[0].name)
    when 249 # play ME
      add_resource(:ME, params[0].name)
    when 250 # play SE
      add_resource(:SE, params[0].name)
    when 261 # play movie
    when 282 # change tileset
      tset_id = params[0]
    when 283 # change battleback
      add_resource(:Battlebacks1, params[0])
      add_resource(:Battlebacks2, params[1])
    when 284 # change parallax
      add_resource(:Parallaxes, params[0])
    when 322 # Change Actor Graphic
      add_resource(:Characters, params[1])
      add_resource(:Faces, params[3])
    when 323 # Change Vehicle Graphic
      add_resource(:Characters, params[1])
    when 335 # Enemy appear
    when 336 # Enemy transform
    when 337 # Show battle animation
      add_resource(:Animations, @data_animations[params[1]].name)
    end
  end
 
  def parse_command_list(list)
    list.each {|cmd|
      check_event_resources(cmd)
    }
  end
 
  def parse_event_page(page)
   
    add_resource(:Characters, page.graphic.character_name)
    parse_command_list(page.list)
  end
 
  def parse_event(event)
    event.pages.each {|page|
      parse_event_page(page)
    }
  end
 
  def parse_map_events(events)
    events.each {|id, evt|
      parse_event(evt)
    }
  end
 
  def run
    parse_data_files
    export
  end
 
  def export
    r = Resource_Exporter.new(@resources)
    r.run
  end
end

class Resource_Exporter
 
  def initialize(data)
    @data = data
    @outfile = nil
  end
 
  def rtp_directory
    Tsuki::Resource_Checker::RTP_Directory
  end
 
  def rtp_directory_valid?
    return false unless File.directory?(rtp_directory)
    return false unless File.directory?(rtp_directory + "Graphics")
    return false unless File.directory?(rtp_directory + "Audio")
    return false unless File.directory?(rtp_directory + "Fonts")
    return true
  end
 
  def create_outfile(name="resources.txt")
    File.open(name, "w")
  end
 
  def make_category_folder(category)
    if Tsuki::Resource_Checker::Graphics_Dirs.include?(category)
      name = "Graphics%s%s" %[File::Separator, category]
    elsif Tsuki::Resource_Checker::Audio_Dirs.include?(category)
      name = "Audio%s%s" %[File::Separator, category]
    elsif Tsuki::Resource_Checker::Font_Dirs.include?(category)
      return
    end
    Dir.mkdir(name) unless File.directory?(name)
  end
 
  def make_path(category, name)
    outName = "" #Tsuki::Resource_Checker::RTP_Directory
    if Tsuki::Resource_Checker::Graphics_Dirs.include?(category)
      name += ".png"
      outName += sprintf("Graphics%s%s%s", File::Separator, category, File::Separator)
    elsif Tsuki::Resource_Checker::Audio_Dirs.include?(category)
      name += ".ogg"
      outName += sprintf("Audio%s%s%s", File::Separator, category, File::Separator)
    elsif Tsuki::Resource_Checker::Font_Dirs.include?(category)
      name += ".ttf"
      outName += sprintf("Fonts%s", File::Separator)
    end
    return outName + name
  end
 
  # horrible way to copy files. The OS should be doing this not me.
 
  # just read/write
  def copy_file(srcPath, destPath)
    File.open(srcPath, 'rb') {|src_file|
      File.open(destPath, 'wb') {|dest_file|
        dest_file.write(src_file.read)
      }
    }
  end
 
  # using fileUtil
  def copy_file2(srcPath, destPath)
    FileUtils.cp(srcPath, destPath)
  end
 
  def make_file(path)
    begin
      if FileTest.exist?(path)
        # nothing. Don't clutter the console
      elsif !FileTest.exist?(rtp_directory + path)
        p "%s isn't an RTP file" %path
      else
        copy_file(Tsuki::Resource_Checker::RTP_Directory + path, path)
        #copy_file2(Tsuki::Resource_Checker::RTP_Directory + path, path)
       
        p "%s - copied successfully" %path
      end
    rescue
      $game_message.add("Something went wrong! Just be careful")
    end
  end
 
  def write_heading(name)
    @outfile.puts("== %s == " %name)
  end
 
  def write_data(category, list)
    list.sort.each {|name|
      path = make_path(category, name)
      @outfile.puts(sprintf("%s", path))
    }
    @outfile.puts("\n")
  end
 
  # write the log out
  def export_log
    @outfile = create_outfile
    @data.each {|category, list|
      write_heading(category)
      write_data(category, list)
    }
    @outfile.close
  end
 
  # lol inefficient but I like it separated
  def copy_files
   
    t1 = Time.now
    # check RTP folder exists
    unless rtp_directory_valid?
      $game_message.add("Your RTP directory is invalid or inaccessible")
      return
    end
    # basic folders
    Dir.mkdir("Graphics") unless File.directory?("Graphics")
    Dir.mkdir("Audio") unless File.directory?("Audio")
    Dir.mkdir("Fonts") unless File.directory?("Fonts")
    Dir.mkdir("Movies") unless File.directory?("Movies")
    Dir.mkdir("System") unless File.directory?("System")
   
    @data.each {|category, list|
      make_category_folder(category)
      list.each { |name|
        path = make_path(category, name)
        make_file(path)
      }
    }
    t2 = Time.now
    $game_message.add("File copy complete in %f seconds." %(t2 - t1))
  end
 
  def run
    export_log
    copy_files if Tsuki::Resource_Checker::Copy_Files_Over
  end
end

class Game_Interpreter
 
  def build_resource_list
    r = Resource_Finder.new
    r.run
  end
end

Fonctionnement :

Code:

RTP_Directory = "C:/Program Files (x86)/Enterbrain/RPG Maker VX.Ace/RTP/"

(ligne 37) : tu indique l'adresse du dossier des rtp du logiciel

Code:

Copy_Files_Over = true

(ligne 40) : tu mets true pour que les ressources soient copié dans ton projet ou false pour juste avoir un fichier qui te dis lesquelles il te faut.

Code:

Check_Key = :F5

(ligne 43) : C'est la touche pour faire fonctionner le script.
Dans ton fichier game.ini enlève aussi RTP=RPGVXAce en RTP=

Waouuuuuu

Ça c'est de la balle. Merci infiniment pour ce script. Je pense qu'en plus de ma modeste personne, il pourrait être très utile à bien des gens.
Je vais tester ça tout de suite.

Encore merci, sincèrement. Ça c'est de la participation. Ça vaut des points un tel partage.

PS: Le fait que des membres connaissent ce genre de choses me conforte dans mon idée de la GBS, (Grande Bibliothèque de Scripts) qui pourrait être vraiment une mine de trésors pour tous les makeurs. Shua a déjà commencé à mettre en œuvre une bibliothèque, il est peut-être temps de réfléchir sur l'organisation d'une structure permettant d'accueillir toutes formes de bibliothèque. Si chacun organise sa structure dans son coin, on risque de ne faire qu'augmenter la dispersion au lieu d'organiser le savoir commun.

PPS : Tonyryu, cela ne vient pas du tout te couper l'herbe sous les pieds mais, au contraire, peut te donner des idées pour la réalisation en cours ou d'autres à venir.

Ajout :
Comme annoncé j'ai testé immédiatement. Voilà le premier "bilan" de la fonction de listage.

Code:

   # Set it to false if you only want a list of resources you use
    Copy_Files_Over = false

Pour les utilisateurs de Steam sur machine 64 bits, voilà le chemin :

Code:

   # Copy your RTP path here.
    # Don't forget the trailing slash (I don't check it)
    RTP_Directory = "C:/Program Files(x86)/Steam/steamapps/common/RPGVXAce/rtp/"

Dans le fichier "unused_resources.txt" j'ai bien retrouvé des ressources que j'avais moi-même chargé et que je n'utilisais pas encore, par contre, dans le fichier "used_resources.txt" il y a un paquet de ressources que je n'utilise pas, comme les animations de bataille contre toutes les bestioles possibles alors que je n'ai, pour le moment, qu'un petit affrontement contre des slimes pour tester la compatibilité des modules ajoutés. Je ne pense pas que l'emploi de ces ressources vienne d'un script ajouté.
Peut-être y-a-t-il des réglages à faire dans ce script.

Je n'ai pas testé la fonction d'ajout, j'avoue que je n'ai pas très bien compris comment m'en servir.
Mais ça viendra.

Comme je disais Zoltic, je compte bien faire une bibliothèque par thème et m'attaquer aux scripts aussi. L'organisation du forum ne permet peut être pas de créer un nouvel espace mais je compte bien investir les espaces déjà existants. :p

Je demanderais sans doute de l'aide à ce moment là, car les scripts et moi... =x

Autant me parler japonais ! ><

Alors en fait il y a toujours deux trois ressources que tu ne te sers pas mais qui se copie comme le graphisme system. Je ne sais pas pas trop pourquoi j'avoue mais je n'est jamais eu de problème avec le script. Faut dire que moi je copie les ressources directement (je n'ai jamais fais une simple liste sans import).

EDIT : le script ne prends les ressources que TU utilise mais les ressources dans la BDD. Si tu utilise les compétence 1 à 10 mais que tu n'efface pas les autres il les prends quand même. Donc faut faire un tri dans ta BDD

OK, Shua, je te laisse piloter tout le projet, pas de soucis. Tu sais où me trouver en cas de besoin.

Crakerwood, j'ai bien compris le principe. C'est l'application que je pige pas. Comment faire pour qu'il ne mette que les ressources "utiles" ?
Compiler "sans RTP" et passer le script après ? Mais dans ce cas là comment faire qu'il sache dans quel ".exe" il doit les rajouter ?
Compiler "avec RTP" et il retire l'inutile ? Même problème que précédemment.
Passer le script avant de compiler pour qu'il copie les RTP utiles comme si c'était des ressources personnelles et ainsi "truander" le système en compilant "sans RTP" ?

J'ai pas encore eu le temps de tout tester. Sans plus.

Ca ne me coupe nullement l'herbe sous le pied. En effet, j'avais commencé a adapter mon script de la version XP sur VxAce, mais j'étais encore loin du bouchon.

Par contre, je vais quant même allé au bout de ma démarche, et voir si ma façon de voir les ressources du projet et mieux ou moins bien que le script précédement proposé.

Tu mets le script puis tu fais F5 quand tu veux dans le jeu. Il te prendra que les ressources necessaire copié dans ton jeu

Bonjour,

Tonyryu, j'ai eu peur, un instant, que tu abandonnes. Ben oui, on ne se connait pas et je n'ai aucune idée de tes réactions dans un cas pareil. Pour moi, tu as la meilleure attitude. C'est pas parce qu'un autre a déjà inventé la roue qu'il faut pas inventer le pneu.
Comme l'a dit Crackerwood :

Alors en fait il y a toujours deux trois ressources que tu ne te sers pas mais qui se copie comme le graphisme system. Je ne sais pas pas trop pourquoi j'avoue

Quand ça marche et qu'on sait pas pourquoi, quand ça plante on sait pas pourquoi non plus. . Quelque part ça me gène un peu.

Crackerwood, je dois avouer que parfois je fais l'âne pour avoir du son. Dans mon post, j'avais évoqué trois fonctionnement différents, c'était avant tout pour avoir la certitude que la solution "imaginée" en 3 était la bonne.
Je pense à la mise à disposition plus large de ce genre de produit, la "bibliothèque" dont je parle dans pas mal de posts. Elle ne sera efficace que si il y a un "mode d'emploi" précis et complet de chaque produit. Balancer un truc et dire "allez y, essayez, vous verrez bien" c'est pas la bonne solution, à mon avis. Donc je cherche le plus de précisions possible pour que l'utilisateur "lambda" qui se dira ; "Oh, ça c'est utile pour moi" puisse mettre le script en œuvre dans les meilleures conditions.
Pour retrouver des "trucs" stockés et gérés par un système de bibliothèque, il faut, non seulement ranger les "trucs" mais aussi établir un index qui explique à quoi ils servent. C'est à cet index que je pense en posant mes questions.

Il va falloir vous y faire, quand je pose un question, j'ai une idée derrière la tête, et souvent même une autre idée encore derrière l'idée derrière la tête.

En tout cas, un grand merci à vous deux, vous me permettez d'imaginer le temps béni où le moindre débutant pourra avancer en confiance et trouver ce dont il a besoin sans passer des jours à refaire les recherches que d'autres ont faites dans des langues (anglais, allemand et parfois même japonais) qu'il ne maitrise pas parfaitement.

Bonne journée, et comme c'est bientôt la saison.... Paix sur la planète RPG Maker aux scripteurs de bonne volonté.

Premier jet du portage :

Code:

#==============================================================================
# ■ Scan_Ressource
#------------------------------------------------------------------------------
# Script permettant de générer un fichier texte contenant le récapitulatif des
#  Ressources utilisées dans le projet.
# Créateur : Tonyryu
# Version : 1.00 : 14/11/2016 : Portage VxAce
#
#==============================================================================
class Scan_Ressource

  
  #--------------------------------------------------------------------------
  # ● initialize
  #--------------------------------------------------------------------------
  def initialize

    # initialiser la base de données
    $data_actors        = load_data("Data/Actors.rvdata2")
    $data_skills        = load_data("Data/Skills.rvdata2")
    $data_items         = load_data("Data/Items.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_animations    = load_data("Data/Animations.rvdata2")
    $data_tilesets      = load_data("Data/Tilesets.rvdata2")
    $data_common_events = load_data("Data/CommonEvents.rvdata2")
    $data_system        = load_data("Data/System.rvdata2")
    $data_mapinfos      = load_data("Data/MapInfos.rvdata2")
    $data_scripts       = load_data("Data/Scripts.rvdata2")

    # initialiser données du jeu
=begin    
    $game_temp          = Game_Temp.new
    $game_system        = Game_System.new
    $game_switches      = Game_Switches.new
    $game_variables     = Game_Variables.new
    $game_self_switches = Game_SelfSwitches.new
    $game_screen        = Game_Screen.new
    $game_actors        = Game_Actors.new
    $game_party         = Game_Party.new
    $game_troop         = Game_Troop.new
    $game_map           = Game_Map.new
    $game_player        = Game_Player.new
=end
    
    #tableaux de ressource
    @tab_O_Animations = []
    @tab_O_Tilesets = []
    
    @tab_G_Animations = []
    @tab_G_Battlebacks1 = []
    @tab_G_Battlebacks2 = []
    @tab_G_Battlers = []
    @tab_G_Characters = []
    @tab_G_Faces = []
    @tab_G_Parallaxes = []
    @tab_G_Pictures = []
    @tab_G_System = []
    @tab_G_Tilesets = []
    @tab_G_Titles1 = []
    @tab_G_Titles2 = []
    @tab_A_BGM = []
    @tab_A_BGS = []
    @tab_A_ME = []
    @tab_A_SE = []
    @tab_M_Movies = []
    
    # Rechercher dans les fichiers de la base de données
    rechercher_actors
    rechercher_skills
    rechercher_items
    rechercher_weapons
    rechercher_armors
    rechercher_ennemies
    rechercher_event_group_ennemies
    rechercher_annimations
    rechercher_tilesets
    rechercher_common_events
    rechercher_system
    rechercher_map_infos
    rechercher_scripts
    
    
    # Ecrire le compte-rendu
    ecrire_fic
    
  end
  
  #--------------------------------------------------------------------------
  # ● rechercher_actors
  #--------------------------------------------------------------------------  
  def rechercher_actors
    for i in 1...$data_actors.size
      obj_scan = $data_actors[i]
      ajouter_Characters( obj_scan.character_name )
      ajouter_Faces( obj_scan.face_name )
    end
  end
  
  #--------------------------------------------------------------------------
  # ● rechercher_skills
  #--------------------------------------------------------------------------  
  def rechercher_skills
    for i in 1...$data_skills.size
      obj_scan = $data_skills[i]
      #ajouter_Icons( obj_scan.icon_name ) if obj_scan.icon_name != ""
      #ajouter_SE( obj_scan.menu_se.name ) if obj_scan.menu_se.name != ""
      ajouter_ObjAnimations( obj_scan.animation_id )
    end
  end

  #--------------------------------------------------------------------------
  # ● rechercher_items
  #--------------------------------------------------------------------------  
  def rechercher_items
    for i in 1...$data_items.size
      obj_scan = $data_items[i]
      #ajouter_Icons( obj_scan.icon_name ) if obj_scan.icon_name != ""
      #ajouter_SE( obj_scan.menu_se.name ) if obj_scan.menu_se.name != ""
      ajouter_ObjAnimations( obj_scan.animation_id )
    end
  end
  
  #--------------------------------------------------------------------------
  # ● rechercher_weapons
  #--------------------------------------------------------------------------  
  def rechercher_weapons
    for i in 1...$data_weapons.size
      obj_scan = $data_weapons[i]
      #ajouter_Icons( obj_scan.icon_name ) if obj_scan.icon_name != ""
      ajouter_ObjAnimations( obj_scan.animation_id )
    end
  end

  #--------------------------------------------------------------------------
  # ● rechercher_armors
  #--------------------------------------------------------------------------  
  def rechercher_armors
    for i in 1...$data_armors.size
      obj_scan = $data_armors[i]
      #ajouter_Icons( obj_scan.icon_name ) if obj_scan.icon_name != ""
    end
  end
  
  #--------------------------------------------------------------------------
  # ● rechercher_ennemies
  #--------------------------------------------------------------------------  
  def rechercher_ennemies
    for i in 1...$data_enemies.size
      obj_scan = $data_enemies[i]
      ajouter_Battlers( obj_scan.battler_name )
    end
  end
  
  #--------------------------------------------------------------------------
  # ● rechercher_event_groupe_ennemies
  #--------------------------------------------------------------------------  
  def rechercher_event_group_ennemies
    for i in 1...$data_troops.size
      troop_scan = $data_troops[i]
      for page in troop_scan.pages
        scaner_page_event( page.list )
      end
    end
  end
  
  #--------------------------------------------------------------------------
  # ● rechercher_annimations
  #--------------------------------------------------------------------------  
  def rechercher_annimations
    for i in 1...$data_animations.size
      animation_scan = $data_animations[i]
      ajouter_Animations( animation_scan.animation1_name )
      ajouter_Animations( animation_scan.animation2_name )
      
      for timing in animation_scan.timings
        ajouter_SE( timing.se.name )
      end
    end
  end

  #--------------------------------------------------------------------------
  # ● rechercher_tilesets
  #--------------------------------------------------------------------------  
  def rechercher_tilesets
    for i in 1...$data_tilesets.size
      tileset_scan = $data_tilesets[i]
      for j in 1...tileset_scan.tileset_names.size
        ajouter_Tilesets( tileset_scan.tileset_names[j] )
      end

      #ajouter_Panoramas( tileset_scan.panorama_name )
      #ajouter_Fogs( tileset_scan.fog_name )
      #ajouter_Battlebacks( tileset_scan.battleback_name )
    end
  end
  
  #--------------------------------------------------------------------------
  # ● rechercher_common_events
  #--------------------------------------------------------------------------  
  def rechercher_common_events
    for i in 1...$data_common_events.size
      scaner_page_event( $data_common_events[i].list )
    end
  end

  #--------------------------------------------------------------------------
  # ● rechercher_system
  #--------------------------------------------------------------------------  
  def rechercher_system
    #ajouter_Windowskins($data_system.windowskin_name)
    ajouter_Characters($data_system.boat.character_name)
    ajouter_BGM($data_system.boat.bgm.name)
    ajouter_Characters($data_system.ship.character_name)
    ajouter_BGM($data_system.ship.bgm.name)
    ajouter_Characters($data_system.airship.character_name)
    ajouter_BGM($data_system.airship.bgm.name)
    ajouter_Titles1($data_system.title1_name)
    ajouter_Titles2($data_system.title2_name)
    
    #ajouter_Gameovers($data_system.gameover_name)
    #ajouter_Transitions($data_system.battle_transition)
    ajouter_BGM($data_system.title_bgm.name)
    ajouter_BGM($data_system.battle_bgm.name)
    ajouter_ME($data_system.battle_end_me.name)
    ajouter_ME($data_system.gameover_me.name)
    
    for i in 1...$data_system.sounds.size
      ajouter_SE($data_system.sounds[i].name)
    end

  end

  #--------------------------------------------------------------------------
  # ● rechercher_map_infos
  #--------------------------------------------------------------------------  
  def rechercher_map_infos
    for i in 0...$data_mapinfos.size
      
      #charger la carte correspondante
      # nom de la map
      nomFichierMap = sprintf("Data/Map%03d.rvdata2", i + 1)
      
      if FileTest.exist?( nomFichierMap )
        map_a_scanner = load_data(nomFichierMap)
        ajouter_BGM( map_a_scanner.bgm.name )
        ajouter_BGS( map_a_scanner.bgs.name )
        ajouter_ObjTilesets(map_a_scanner.tileset_id)
        
        ajouter_Battlebacks1( map_a_scanner.battleback1_name )  
        ajouter_Battlebacks2( map_a_scanner.battleback2_name )
        ajouter_Parallaxes( map_a_scanner.parallax_name)

        # Récupérer le tableau d'événement de la map
        map_a_scanner.events.each { | id, event|
          for page in event.pages
            ajouter_Characters(page.graphic.character_name)
            scaner_page_event( page.list )
          end
        }
      end
    end
  end

  #--------------------------------------------------------------------------
  # ● rechercher_scripts
  #--------------------------------------------------------------------------  
  def rechercher_scripts
    for i in 1...$data_scripts.size
      script_scan = Zlib::Inflate.inflate($data_scripts[i][2])
      scaner_script(script_scan)
      
    end
  end
    
  #--------------------------------------------------------------------------
  # ● scaner_page_event
  # param :
  # - list_cmd : liste des commandes d'une page d'évent
  #--------------------------------------------------------------------------  
  def scaner_page_event(liste_cmd)
    
    for index in 0...liste_cmd.size
      # Parametres de la commande
      parameters = liste_cmd[index].parameters
      
      # Selon la commande de l'event
      case liste_cmd[index].code
      when 111  # Conditions...
        if parameters[0] == 12
          scaner_script(parameters[1])
        end
      
      when 132  # Changer la musique de combat...
        ajouter_BGM( parameters[0].name )
        
      when 133  # Changer la musique de victoire...
        ajouter_ME( parameters[0].name )
        
        
      when 212  # Afficher annimation
        ajouter_ObjAnimations(parameters[1])
        
      when 222  # Exécuter la transition...
        ajouter_Transitions( parameters[0] )
        
      when 231  # Afficher une image...
        ajouter_Pictures( parameters[1] )
        
      when 241  # Jouer un fond musical (BGM)...
        ajouter_BGM( parameters[0].name )
        
      when 245  # Jouer un fond sonore (BGS)...
        ajouter_BGS( parameters[0].name )
        
      when 249  # Jouer un effet musical (ME)...
        ajouter_ME( parameters[0].name )
        
      when 250  # Jouer un effet sonore (SE)...
        ajouter_SE( parameters[0].name )
        
      when 261  # Jouer un film
        ajouter_Movie( parameters[0] )
        
      when 283  # Changer Battleback
        ajouter_Battlebacks1( parameters[0] )
        ajouter_Battlebacks2( parameters[1] )
        
      when 284  # Changer Panorama
        ajouter_Parallaxes(parameters[0])
        
      when 322  # Modifier l'apparence d'un héros...
        ajouter_Characters( parameters[1] )
        ajouter_Faces( parameters[3] )
        
      when 323  # Modifier l'apparence d'un véhicule...
        ajouter_Characters( parameters[1] )
        
      when 337  # Afficher annimation de bataille
        ajouter_ObjAnimations(parameters[1])
        
      when 355  # Script
        scaner_script( parameters[0] )
      
      when 655  # Script suite
        scaner_script( parameters[0] )

      end
    end
  end
  
  
  #--------------------------------------------------------------------------
  # ● scaner_script
  # param :
  # - script : texte du script à scaner
  #--------------------------------------------------------------------------  
  def scaner_script(script)
    # position dans le script
    position = 0
        #bitmap = Cache.system("Iconset")
    # recherche de l'utilisation des modules de ressource graphique "RPG::Cache::" sans utilisation de variable
    script.scan(/Cache\.(.*)\(\"(.*)\".*\)/) {
    
      case $1
      when "animation"
        ajouter_Animations( $2 )
      when "battleback1"
        ajouter_Battlebacks1( $2 )
      when "battleback2"
        ajouter_Battlebacks2( $2 )
      when "battler"
        ajouter_Battlers( $2 )
      when "character"
        ajouter_Characters( $2 )
      when "face"
        ajouter_Faces( $2 )
      when "parallax"
        ajouter_Parallaxes( $2 )
      when "picture"
        ajouter_Pictures( $2 )
      when "system"
        ajouter_Systems( $2 )
      when "tileset"
        ajouter_Tilesets( $2 )
      when "title1"
        ajouter_Titles1( $2 )
      when "title2"
        ajouter_Titles2( $2 )
      when "load_bitmap"
        print "load_bitmap " + $2
      end
    }
    
    # TODO load_bitmap
    
    # Recherche de l'utilisation des fonctions de chargement de musique sans utilisation de variable
    script.scan(/$game_system\.(.*)\(\"(.*)\"\)/) {
      case $1
      when "bgm_play"
        ajouter_BGM( $2 )
      when "bgs_play"
        ajouter_BGS( $2 )
      when "se_play"
        ajouter_SE( $2 )
      when "me_play"
        ajouter_ME( $2)
      end
    }
  end

  
  #--------------------------------------------------------------------------
  # ● ajouter_Animations
  #--------------------------------------------------------------------------
  def ajouter_Animations( nom_ressource )
    @tab_G_Animations.push( nom_ressource ) if !@tab_G_Animations.include?(nom_ressource) and nom_ressource != ""
  end

  #--------------------------------------------------------------------------
  # ● ajouter_Battlebacks1
  #--------------------------------------------------------------------------
  def ajouter_Battlebacks1( nom_ressource )
    @tab_G_Battlebacks1.push( nom_ressource ) if !@tab_G_Battlebacks1.include?(nom_ressource) and nom_ressource != ""
  end
  
  #--------------------------------------------------------------------------
  # ● ajouter_Battlebacks2
  #--------------------------------------------------------------------------
  def ajouter_Battlebacks2( nom_ressource )
    @tab_G_Battlebacks2.push( nom_ressource ) if !@tab_G_Battlebacks2.include?(nom_ressource) and nom_ressource != ""
  end

  #--------------------------------------------------------------------------
  # ● ajouter_Battlers
  #--------------------------------------------------------------------------
  def ajouter_Battlers( nom_ressource )
    @tab_G_Battlers.push( nom_ressource ) if !@tab_G_Battlers.include?(nom_ressource) and nom_ressource != ""
  end

  #--------------------------------------------------------------------------
  # ● ajouter_Characters
  #--------------------------------------------------------------------------
  def ajouter_Characters( nom_ressource )
    @tab_G_Characters.push( nom_ressource ) if !@tab_G_Characters.include?(nom_ressource) and nom_ressource != ""
  end
  
  #--------------------------------------------------------------------------
  # ● ajouter_Faces
  #--------------------------------------------------------------------------
  def ajouter_Faces( nom_ressource )
    @tab_G_Faces.push( nom_ressource ) if !@tab_G_Faces.include?(nom_ressource) and nom_ressource != ""
  end

  #--------------------------------------------------------------------------
  # ● ajouter_Parallaxes
  #--------------------------------------------------------------------------
  def ajouter_Parallaxes( nom_ressource )
    @tab_G_Parallaxes.push( nom_ressource ) if !@tab_G_Parallaxes.include?(nom_ressource) and nom_ressource != ""
  end
  
  #--------------------------------------------------------------------------
  # ● ajouter_Pictures
  #--------------------------------------------------------------------------
  def ajouter_Pictures( nom_ressource )
    @tab_G_Pictures.push( nom_ressource ) if !@tab_G_Pictures.include?(nom_ressource) and nom_ressource != ""
  end

  #--------------------------------------------------------------------------
  # ● ajouter_Systems
  #--------------------------------------------------------------------------
  def ajouter_Systems( nom_ressource )
    @tab_G_System.push( nom_ressource ) if !@tab_G_System.include?(nom_ressource) and nom_ressource != ""
  end
  
  
  #--------------------------------------------------------------------------
  # ● ajouter_Tilesets
  #--------------------------------------------------------------------------
  def ajouter_Tilesets( nom_ressource )
    @tab_G_Tilesets.push( nom_ressource ) if !@tab_G_Tilesets.include?(nom_ressource) and nom_ressource != ""
  end

  #--------------------------------------------------------------------------
  # ● ajouter_Titles1
  #--------------------------------------------------------------------------
  def ajouter_Titles1( nom_ressource )
    @tab_G_Titles1.push( nom_ressource ) if !@tab_G_Titles1.include?(nom_ressource) and nom_ressource != ""
  end
  
  #--------------------------------------------------------------------------
  # ● ajouter_Titles2
  #--------------------------------------------------------------------------
  def ajouter_Titles2( nom_ressource )
    @tab_G_Titles2.push( nom_ressource ) if !@tab_G_Titles2.include?(nom_ressource) and nom_ressource != ""
  end

  #--------------------------------------------------------------------------
  # ● ajouter_BGM
  #--------------------------------------------------------------------------
  def ajouter_BGM( nom_ressource )
    @tab_A_BGM.push( nom_ressource ) if !@tab_A_BGM.include?(nom_ressource) and nom_ressource != ""
  end

  #--------------------------------------------------------------------------
  # ● ajouter_BGS
  #--------------------------------------------------------------------------
  def ajouter_BGS( nom_ressource )
    @tab_A_BGS.push( nom_ressource ) if !@tab_A_BGS.include?(nom_ressource) and nom_ressource != ""
  end

  #--------------------------------------------------------------------------
  # ● ajouter_ME
  #--------------------------------------------------------------------------
  def ajouter_ME( nom_ressource )
    @tab_A_ME.push( nom_ressource ) if !@tab_A_ME.include?(nom_ressource) and nom_ressource != ""
  end

  #--------------------------------------------------------------------------
  # ● ajouter_SE
  #--------------------------------------------------------------------------
  def ajouter_SE( nom_ressource )
    @tab_A_SE.push( nom_ressource ) if !@tab_A_SE.include?(nom_ressource) and nom_ressource != ""
  end
  
  #--------------------------------------------------------------------------
  # ● ajouter_Movie
  #--------------------------------------------------------------------------
  def ajouter_Movie( nom_ressource )
    @tab_M_Movies.push( nom_ressource ) if !@tab_M_Movies.include?(nom_ressource) and nom_ressource != ""
  end
  
  
  #--------------------------------------------------------------------------
  # ● ajouter_ObjAnimations
  #--------------------------------------------------------------------------
  def ajouter_ObjAnimations( nom_ressource )
    @tab_O_Animations.push( nom_ressource ) if !@tab_O_Animations.include?(nom_ressource) and nom_ressource != ""
  end
  
  #--------------------------------------------------------------------------
  # ● ajouter_ObjTilesets
  #--------------------------------------------------------------------------
  def ajouter_ObjTilesets( nom_ressource )
    @tab_O_Tilesets.push( nom_ressource ) if !@tab_O_Tilesets.include?(nom_ressource) and nom_ressource != ""
  end
  

  #--------------------------------------------------------------------------
  # ● ecrire_fic
  #--------------------------------------------------------------------------
  def ecrire_fic
    
    # Si dossier existe
    if Dir["Ressources"] != ["Ressources"]
      # Créer le dossier
      Dir.mkdir("Ressources")
    end
    
    # Sauvegarder le dossier du projet
    dossier_racine = Dir.pwd
    
    # ouvrir un nouveau fichier
    @file_ressource = File.new("Ressources/Ressources.txt", "w")
    @file_ressource.write("Récapitulatif des ressources utilisées par le projet, (*) signifie que les ressources sont déjà dans le dossier du projet :\n\n\n")
    
    @file_ressource.write("** Ressources Graphiques **\n")
    tab_graphic = [ ["Animations", @tab_G_Animations ],
                    ["Battlebacks1", @tab_G_Battlebacks1 ],
                    ["Battlebacks2", @tab_G_Battlebacks2 ],
                    ["Battlers", @tab_G_Battlers ],
                    ["Characters", @tab_G_Characters ],
                    ["Faces", @tab_G_Faces ],
                    ["Parallaxes", @tab_G_Parallaxes ],
                    ["Pictures", @tab_G_Pictures ],
                    ["Tilesets", @tab_G_Tilesets ],
                    ["System", @tab_G_System ],
                    ["Titles1", @tab_G_Titles1 ],
                    ["Titles2", @tab_G_Titles2 ]]
                    
                    
    for ress_graphique in tab_graphic
      @file_ressource.write("\n\n- " + ress_graphique[0] + " :\n\n")
      # changer de dossier
      Dir.chdir(dossier_racine + "/Graphics/" + ress_graphique[0] + "/" )
      
      for nom_ressource in ress_graphique[1]

        # vérifier la présence du fichier dans le dossier
        @file_ressource.write("* ") if Dir[nom_ressource + ".*"].size != 0
        @file_ressource.write("#{nom_ressource}\n")
      end
    end
    

    @file_ressource.write("\n\n** Ressources Audio **\n\n")
    tab_audio = [ ["BGM", @tab_A_BGM ],
                ["BGS", @tab_A_BGS ],
                ["ME", @tab_A_ME ],
                ["SE", @tab_A_SE ] ]

    for ress_audio in tab_audio
      @file_ressource.write("\n\n- " + ress_audio[0] + " :\n\n")
      # changer de dossier
      Dir.chdir(dossier_racine + "/Audio/" + ress_audio[0] + "/" )
    
      for nom_ressource in ress_audio[1]

        # vérifier la présence du fichier dans le dossier
        @file_ressource.write("* ") if Dir[nom_ressource + ".*"].size != 0
        @file_ressource.write("#{nom_ressource}\n")
      end
    end

    @file_ressource.close
    Dir.chdir(dossier_racine)
  end
  
  #--------------------------------------------------------------------------
  # ● dispose
  #--------------------------------------------------------------------------
  def dispose
    
    # destruction des données utilisées
    $data_actors        = nil
    $data_skills        = nil
    $data_items         = nil
    $data_weapons       = nil
    $data_armors        = nil
    $data_enemies       = nil
    $data_troops        = nil
    $data_states        = nil
    $data_animations    = nil
    $data_tilesets      = nil
    $data_common_events = nil
    $data_system        = nil
    $data_map_infos     = nil
    $data_scripts       = nil
    $game_temp          = nil
    $game_system        = nil
    $game_switches      = nil
    $game_variables     = nil
    $game_self_switches = nil
    $game_screen        = nil
    $game_actors        = nil
    $game_party         = nil
    $game_troop         = nil
    $game_map           = nil
    $game_player        = nil
    @tab_G_Animations = nil
    @tab_G_Battlebacks1 = nil
    @tab_G_Battlebacks2 = nil
    @tab_G_Battlers = nil
    @tab_G_Characters = nil
    @tab_G_Faces = nil
    @tab_G_Parallaxes = nil
    @tab_G_Pictures = nil
    @tab_G_System = nil
    @tab_G_Tilesets = nil
    @tab_G_Titles1 = nil
    @tab_G_Titles2 = nil
    @tab_A_BGM = nil
    @tab_A_BGS = nil
    @tab_A_ME = nil
    @tab_A_SE = nil
  end
  
end




#--------------------------------------------------------------------------
# ● chercher_ressource
# param :
#--------------------------------------------------------------------------
def chercher_ressource
  scan = Scan_Ressource.new
  scan.dispose
end

a mettre au dessus de main, et ajouter l'instruction

Code:

 chercher_ressource

au dessus de

Code:

 rgss_main { SceneManager.run }

ça créera un dossier Ressources, avec un fichier Ressources.txt

Bon, ben j'ai testé.

Ça marche. Enfin, ça plante pas.

Je rigole, ce script fait ce qu'on lui demande. Mais.........
Comme dans le script testé précédemment, il inclus des "trucs" bizarres.

Il ne m'indique que les 3 musiques effectivement utilisées dans le jeu, mais toutes les animations de bataille alors que j'en utilise pas des masses. En tout cas je suis certain que j'utilise jamais les "Gun", "Water", "Wind", etc ... Cela vient peut-être du fait que je n'ai pas retiré de la base de données les "méchants" qui sont sensés les utiliser. Je vérifierai.

Sinon, rien à dire, il fait bien une liste.

Éventuellement, si chaque sous-liste, comme "Animations", pouvaient être triées par ordre alphabétique, comme dans le gestionnaire de ressources, ce serait un plus.

Et puis, "(*) signifie que les ressources sont déjà dans le dossier du projet", je pense que ce serait plus clair en indiquant que ce ne sont pas des ressources issues du RTP. Donc des ressources qui seront dans le produit fini, même en cas de compilation sans RTP. Mais, bon, c'est vraiment de la cosmétique et une compréhension personnelle de la phrase.

Comparaison entre le script de Tsuki Hime et celui de Tonyryu.

Liste identique

Tsuki Hime classe par ordre alphabétique.
Tonyryu indique les ressources "hors RTP".

Un mix des deux serait parfait.

j'ai déjà intégré le comptage des utilisations d'animations et Tilesets, il faut que les utilise dans le listing final. Pour l'ordre alphabétique, effectivement, ça tombe sous le sens.

Voir, je peux ajouter une option, pour copier automatiquement les ressources RTP dans le projet.

Tu es du genre : On te demande la main, tu offres le bras.

Ce qui me gène le plus dans le principe RTP c'est que si tu utilises 1 item, genre 1 héros d'un Faceset, il te copie TOUT le bloc de 8. Pour les Tilesets c'est pire. Tu prends 1 cailloux et il te fourgue toute la déco, même les trucs sous la neige dont tu as absolument pas besoin.
J'ai éclaté les Facesets et intégré seulement les "tronches" dont j'avais besoin pour réduire la taille. Mais éclater TOUS le RTP c'est un boulot de titan.

Ceci dit, fais comme tu le sens, mais ne te crois pas obligé d'aller toujours plus loin.