Ressourcenzähler

[KD]

Ressourcenzähler-Script

Ich hab mir gedacht, dass es langsam Zeit wird auch mal ein Script zu veröffentlichen =P Mein Scriptordner ist voll von irgendwelchen Scripten, die ich auf Anfragen im Rubyforum geschrieben hab. Allerdings ist keines in einem Zustand, den ich als fertig ausgearbeitetes Script bezeichnen würde. Also hab ich meinen Scriptordner nach dem erstbesten, vielversprechenden Script durchsucht und es etwas ausgebessert.

Was kann er?

Der Ressourcenzähler kann nach Ressourcen innerhalb eines Projektes suchen. Er kann nach importierten Ressourcen Ausschau halten, aber er stellt auch fest, welche Ressourcen aus dem RTP stammen, welche Ressourcen genutzt werden und welche ungenutzt im Projektordner vergammeln. Gerade letzteres stellt die Hauptfunktion des Scriptes dar. Es kommt oft genug vor, dass man neue Grafiken oder Musikdateien importiert, die man am Ende aber gar nicht verwendet. Dadurch bläht sich das Projekt auf, was den armen Modemnutzern nachher auf die Füße fällt.
Der Ressourcenzähler kann überprüfen, ob es im Projekt ungenutzte Ressourcen gibt und diese aus dem Projekt entfernen. Dies geschieht, in dem er alle Mapdateien und die Database genau analysiert.
Neben dieser Hauptfunktion beherrscht der Ressourcenzähler noch einige weitere Features. Er kann Logdateien erzeugen und so eine genaue Übersicht über die verwendeten Ressourcen geben. Er kann aber auch Ressourcen von einem Projekt ins andere kopieren oder verschieben. Er kann die Dateigröße eurer Ressourcen feststellen und vieles mehr.
Der Ressourcenzähler bietet ein umfangreiches Management über eure Ressourcen. Weitere denkbare Anwendungsgebiete währen beispielsweise, diejenigen Ressourcen aus dem RTP ins eigene Projekt zu kopieren, die das Projekt verwendet (auf diese Weise wird das Projekt unabhängig von RTP-Grafiken/Sounddateien).

Was kann er nicht?

Der Ressourcenzähler kann Ressourcen, die Umlaute enthalten, nicht erkennen. Er hat desweiteren Probleme wenn ein Projekt in einem Pfad, der Umlaute enthält, liegt. Diese Einschränkungen hab ich ~16 Stunden lang zu umgehen versucht (klappte auch teilweise. Nur mit dem Pfad, dass hab ich net hingekriegt), bis ich aufgegeben habe. Meines Erachtens sollte man Dateien/Ordnern keine Umlaute als Namen geben. Das führt spätestens dann zu Problemen, wenn sie von Ausländern genutzt werden (ich wollte mal ein polnisches Rm2k Spiel spielen - keine Chance! Es ließ sich wegen den Sonderzeichen nicht ausführen). Aus dem Grund gilt: Entweder ihr lasst eure Umlaute weg, oder ihr könnt das Script nicht nutzen.

Wie verwendet man ihn, ohne Rubykenntnisse zu haben?

Das Script besteht aus zwei Teilen, die nacheinander in ein leeres Script an eine belebige Stelle des Scripteditors eingefügt werden müssen. Wichtig ist nur, dass der erste Teil über dem Zweiten eingefügt wird.
Um das Script zu starten, ruft man in einem CallRubyScript die Codezeile

Ressourcen.automatik

auf. Daraufhin werden die grundlegensten Funktionen des Scriptes in eurem Projekt ausgeführt. Diese sind:

• Loggen aller verwendeten Ressourcen
• Loggen aller importierten, aber ungenutzten Ressourcen
• Verschieben der ungenutzten Ressourcen in einen externen Ordner

(Anmerkung: Das Script löscht grundsätzlich keine Dateien. Aus dem Grund werden ungenutzte Dateien nur verschoben. Sie können dann manuell gelöscht werden. Dies ist aus Sicherheitsgründen, damit niemand versehentlich seine Dateien löscht)

Wer diese Features noch konfigurieren will, kann das im zweiten Teil des Scriptes tun. Dort gibt es weit oben eine Sektion, welche die Überschrift "Konstanten" hat. Dort stehen verschiedene Konstanten und deren Wert. Alles was unter "#Konstanten für den Automatik-Vorgang" steht kann verändert werden.
LOGGEN wenn man true hinschreibt, werden die genutzten Ressourcen geloggt. Will man dies nicht, so schreibt man false hin.
MULTI_FILE Schreibt man hier true hin, dann wird für jeden Ressourcentyp (Picture, BGM, Characters usw.) eine eigene Textdatei angelegt. Dies ist nur zu empfehlen, wenn man wirklich sehr viele Ressourcen im Projektordner hat. Ansonsten schreibt man false hin.
LOG_UNUSED Hier wird festgelegt, ob ungenutzte Ressourcen geloggt werden sollen. true für ja, false für nein.
LOESCHEN wenn hier true steht, werden ungenutzte Ressourcen in einen Lösch-Ordner verschoben. Ansonsten false,
EXIT Wenn hier true steht, wird das Programm nach Ausführen des Ressourcenscriptes beendet. Ansonsten false.
LOG_ORDNER Hier schreibt man in Anführungszeichen den Ordnernamen des Ordners, wo die Logdateien der genutzten Ressourcen rein sollen.
UNUSEDNAME Das gleiche nochmal, nur für die ungenutzten Dateien.

Man kann auch die Standard-Einstellungen lassen. Diese loggt alles in eine Textdatei und verschiebt keine Ressourcen.

Wie verwendet man ihn, mit einfachen Rubykenntnissen?

Der Automatik-Vorgang dient nur dazu, ohne Scherereien die grundlegenden Funktionen des Scriptes nutzen zu können. Wer das Script aber weitreichender nutzen will, sollte zumindest einige wenige Rubykenntnisse haben, oder wenigstens etwas Gefühl für das Scripten.

Erzeugen eines Ressourcenobjektes:

Als erstes erzeugt man ein Ressourcenobjekt über die new Methode oder über Konstruktoren.

meine_ressourcen = Ressourcen.new

Damit erzeugt man ein leeres Ressourcenobjekt im Projektordner. Da man mit einem leeren Ressourcenobjekt wenig anfangen kann, ist es sinnvoll gleich einige Konstruktormethoden zu nutzen. Alle Methoden die innerhalb der Sektion "Konstruktormethoden" stehen, kann man nutzen. Es gibt folgende zur Auswahl:

• genutzte_ressourcen --> Erzeugt ein Ressourcenobjekt aus allen Ressourcen, die man benutzt hat (auch genutzte RTP-Dateien)
• importierte_ressourcen --> Erzeugt ein Ressourcenobjekt aus allen Ressourcen, die im Projektordner vorkommen (ohne RTP)
• ungenutzte_ressourcen --> Erzeugt ein Ressourcenobjekt aus allen Ressourcen, die sich im Projektordner befinden, im Spiel aber keine Verwendung finden

Die weiteren Konstruktoren finden seltener Gebrauch, daher zähl ich sie nur kurz auf. durchsuche_map(pfad_zur_map) sucht nach Ressourcen, die innerhalb einer Map (mitsamt ihren Events) genutzt werden. durchsuche_maps sucht in allen Maps. durchsuche_database zählt alle Ressourcen auf, die in der Database festgelegt sind und noch einige andere, die man selbst im Script nachlesen kann (die aber eher für interne Funktionen genutzt werden).

Man kann desweiteren als Parameter den Projektpfad angeben. So ist es möglich, auch die Ressourcen anderer Projekte aufzusuchen oder sogar das RTP zu durchsuchen.

rtp = Ressourcen.importierte_ressourcen("C:/rpgmakerxp/rtp")
meine_ressourcen = Ressourcen.genutzte_ressourcen("C:/rpgmakerxp/games/projekt2")
ressis = Ressourcen.new("C:/rpgmaker/games/kroetenstuhlsaga")

Wird kein Projektpfad angegeben, so wird automatisch das Projekt, in dem das Script ausgeführt wird, verwendet.

Bearbeiten eines Ressourcenobjektes:

Man kann Konstruktoren auch nutzen, um bestehende Ressourcendateien zu erweitern.

meine_ressourcen = Ressourcen.durchsuche_map("data/Map002.rxdata")
meine_ressourcen.durchsuche_map("data/Map005.rxdata")

(In diesem Fall hätte man ein Ressourcenobjekt, welches alle Ressourcen der Maps 2 und 5 enthält)

Neue Ressourcen lassen sich auch manuell hinzufügen (was aber nicht empfohlen wird!). Hierfür nutzt man die Syntax ressourcenobjekt.ressourcentyp.add(dateiname)

ressi = Ressourcen.new
ressi.pictures.add("mauszeiger")

Genauso lassen sich auch Ressourcen wieder entfernen, mit delete.

ressi = Ressourcen.new
ressi.bgm.delete("meine_entchen")

Man kann Ressourcenobjekte untereinander addieren (concat), subtrahieren (drop) und gemeinsame Dateien erfassen (compare).

rtp = Ressourcen.importierte_ressourcen("C:/rpgmakerxp/rtp")
ressi = Ressourcen.genutzte_ressourcen
genutzte_rtp_dateien = ressi.compare(rtp)
ressi.drop(rtp)

In Zeile drei haben wir ein neues Ressourcenobjekt erzeugt, welches aus den Ressourcen besteht, die sowohl im Projekt, als auch in der RTP vorkommen. In Zeile 4 haben wir alle Ressourcen aus dem RTP aus unseren Projektressourcen entfernt (nützlich zum Loggen, damit man weiß, welche Ressourcen auch wirklich importiert und genutzt werden).

Abfragen von Daten eines Ressourcenobjektes:

Mit ressourcenobjekt.typ kann man alle Dateien eines typs auslesen. Mit ressourcen.metaordner lassen sich alle Ressourcen eines Metaordners auslesen. Hierzu muss gesagt werden, dass Typen im Script die Unterordner (Pictures, BGM, Titles usw.) sind. Metaordner sind die Oberordner wie Graphics und Audio.

ressis = Ressourcen.importierte_ressourcen
print ressis.audio
print ressis.pictures

Mit ressourcen.printable_size wird die Dateigröße aller Ressourcen als String ausgegeben. Will man nur einen bestimmten Ressourcentyp haben, gibt man diesen als Parameter an.

ressis = Ressourcen.importierte_ressourcen
print ressis.printable_size
print ressis.printable_size(:pictures)
print ressis.printable_size("audio")

Anmerkung: Viele Abfragemethoden lassen sich nur für Ressourcen nutzen, die sich auch wirklich im Projektordner befinden. RTP-Dateien beispielsweise sind davon nicht betroffen und werden einfach ignoriert. Will man auch die Dateigröße verwendeter RTP-Dateien überprüfen, kann man die bereits besprochenen Hilfsmittel nutzen:

ressis = Ressourcen.genutzte_ressourcen
rtp_ressis = Ressourcen.importierte_ressourcen("C:/rpgmakerxp/rtp")
rtp_in_projekt = rtp_ressis.compare(ressis)
print rtp_in_projekt.printable_size

Will man den Dateipfad einer Datei haben, nutzt man die Path Methode.

ressi = Ressourcen.importierte_ressourcen
ressi.path("mauszeiger") #ergibt "C:/rpgmakerxp/games/mein_projekt/graphics/pictures/mauszeiger.png"

Der Ressourcenzähler nutzt den Mixin Enumerable und ist daher in der Lage, seine Elemente zu iterieren/sortieren etc. Eine Besonderheit ist, dass man der each-Methode als Parameter einen Metaordner oder Typ zuweisen kann, um nur bestimmte Elemente zu iterieren.

ressi = Ressourcen.importierte_ressourcen
ressi.each(:pictures) {|picture| print picture, " ist ein Picture"}
#ist das selbe wie
ressi-pictures.each {|picture| print picture, " ist ein Picture"}

Kopieren/Verschieben und Loggen von Daten eines Ressourcenobjektes:

Jetzt wirds wieder interessant =P
Mit den Methoden verschiebe und kopiere kann man Ressourcen zwischen Projekten austauschen. Als Parameter gibt man den Zielpfad an.

rtp = Ressourcen.importierte_ressourcen("C:/rpgmakerxp/rtp")
ressis = Ressourcen.genutzte_ressourcen
rtp_in_projekt = rtp.compare(ressis)
rtp_in_projekt.kopiere(ressis.root)

Auf diese Weise lassen sich alle RTP-Dateien, die man im Projekt nutzt, ins Projekt kopieren.
Anmerkung: Mit root ruft man den Projektordner des Ressourcenobjektes auf

Verschieben funktioniert praktisch identisch (wird aber sicherlich seltener gebraucht).

Mit loggen und loggen_one kann man Logdateien für ein Ressourcenobjekt erstellen. loggen erstellt für jeden Typ eine eigene Textdatei, loggen_one schreibt alles in eine Textdatei.

rtp = Ressourcen.importierte_ressourcen("C:/rpgmakerxp/rtp")
rtp.loggen

Schreibt eine Textdatei, die alle Ressourcen des RTPs enthält.

Erweitern des Ressourcenzählers:

Der Ressourcenzähler ist so geschrieben, dass er sioch problemlos erweitern lässt. Solltet ihr also andere Rubyscripte einfügen, welche euch neue Datentypen ermöglichen, so lässt sich der Ressourcenzähler entsprechend anpassen.

In der Sektion "Erzeugt Dateiendungen" kann man neue Dateiendungen hinzufügen. Dies funktioniert über die Syntax

extensions_for(typ, endung, endung2, endung3, ...)
extensions_for(:animations, "gif")

Untere Zeile ermöglicht z.B. dem Script, auch gif-Dateien für Animations zuzulassen. Für typ kann auch ein Metaordner angegeben werden.

Neue Metaordner lassen sich bei Attribute erstellen:

METADIRECTORY['movie'] = [:intro, :outro, :cutscenes]

Wäre beispielsweise der Code, um ein Metaordner "Movie" mit den unterordnern "intro", "outro" und "cutscenes" hinzuzufügen.
Neue Metaordner müssen über der Zeile "TYPEN = METADIRECTORY.values.flatten" festgelegt werden!

Natürlich kann die Methode genutzte_ressourcen nicht feststellen, ob ihr irgendwelche Videodateien in eurem Projekt benutzt. Ihr könnt das Script aber entsprechend erweitern.
Die Methode durchsuche_script überprüft die Call-Script Befehle. Die Methode durchsuche_message durchsucht die Show Text Befehle und durchsuche_comment durchsucht die Kommentare in euren Events.

Beispiel für das UMS (Universal Message System):

Das Universal-Message System nutzt Facesets (die aber als Picture importiert werden). In den Messages werden Facesets mit dem Befehl

\face[mein_faceset]

angezeigt. Daher schreibt man die durchsuche_message Methode um:

def durchsuche_message(string)
  string.scan(/\\face\[.+\]/).each {|s| 
    s =~ /\[(.+)\]/ 
    pictures.add($1) 
  }
  self
end

Man kann das Faceset aber auch über ein CallScript ändern, mit $game_system.face_graphic = "t1_11"

Daher ändert man auch noch die Methode durchsuche_script

def durchsuche_script(string)
  string.scan(/\$game_system\.face_graphic\s*=\s*?".*?"/).each {|s|
    s =~ /"(.+)"/
    pictures.add($1) if $1
  }
end

Wer Probleme damit hat, das Script an andere Scripte anzupassen, kann mir auch eine PM schreiben.

Credits

Normalerweise nutzt der Autor eines Makerspiels dieses Script, nicht der Spieler. Daher kann ich eh nicht nachprüfen, wer das Script benutzt hat. Im Grunde genommen ist es mir auch nicht so wichtig. Ich freue mich, wenn es Makerer gibt, denen das Script gefällt. Ob sie das über einen Creditseintrag, oder einen Post in diesem Thread zum Ausdruck bringen, ist mir eigentlich relativ egal ^^

Nun aber zum eigentlichen Script. Da es nicht unwahrscheinlich ist, dass ich einige Fehler übersehen habe, würde ich mich freuen wenn Bugs mitsamt Fehlermeldung und Codezeile gepostet werden.

[KD]

Teil 1

#--------------------------------------------------------------------------
# * Benötigte Methoden
#--------------------------------------------------------------------------
class Class
  #--------------------------------------------------------------------------
  # * Erzeugt alternative Namen für eine Methode -KD
  #--------------------------------------------------------------------------
  def link(methode, *namen)
    namen.each {|n| define_method(n) {|*a| method(methode).call(*a)}}
  end
  def link_classmethod(methode, *namen)
    $methode = methode
    namen.each {|n| 
      $n = n
      class << self
        methode, n = $methode, $n
        define_method(n) {|*a| self.method(methode).call(*a)} 
      end
    }
    $methode = nil
    $n = nil
  end
end
class Array
  #--------------------------------------------------------------------------
  # * Addiert zwei Arrays ohne doppelte o. leere Elemente hinzuzufügen -KD
  #--------------------------------------------------------------------------
  def add(*args)
    args.each {|e| push(e) unless include?(e) or e.empty?} 
  end
end
class Hash
  #--------------------------------------------------------------------------
  # * Sucht nach einem passenden Key für einen Value/Suchblock -KD
  #--------------------------------------------------------------------------
  def key_for_value(search_value)
    key = nil
    ergebnis = each_pair {|key, value|
      break if if block_given? then
        yield(value, search_value)
      else
        value == search_value
      end
      true
    }
    if ergebnis then false else key end
  end
end
class Symbol
  #--------------------------------------------------------------------------
  # * Macht ein Symbol zu einem Instanzvariablensymbol -KD
  #--------------------------------------------------------------------------
  def to_isym
    return ('@' + self.to_s).to_sym
  end
end

class Fixnum
  #--------------------------------------------------------------------------
  # * Liefert einen String mit einer n-stellen Zahl. -KD
  #--------------------------------------------------------------------------
  def zu_nstelligen_string(n)
    vor = ""
    (n-1).downto(0) {|stelle| vor = vor.concat('0') if self < 10**stelle }
    vor.concat(self.to_s)
  end
end

class Float
  #--------------------------------------------------------------------------
  # * Gibt Datengröße an. -KD
  #--------------------------------------------------------------------------
  EINHEITEN = ["byte", "kb", "mb", "gb"]
  def datasize
    size = self; counter = 0
    while counter < EINHEITEN.size-1 and (a=size / 1024) >= 0.1
      size = a; counter += 1;
    end
    size.to_s + ' ' + EINHEITEN[counter]
  end
end

class File
  #--------------------------------------------------------------------------
  # * Überprüft, ob der Dateiname auf eine Ressourcendatei zeigt -KD
  #--------------------------------------------------------------------------
  def self.ressource?(pfad, *possible_endings)
    pfad =~ /.+\.(.+)/
    !(possible_endings.find {|e| e == $1}).nil?
  end
  #--------------------------------------------------------------------------
  # * Erzeugt einen Ordner - WATANABE, Hirofumi (Ruby Standard Library)
  #--------------------------------------------------------------------------
  def self.makedirs(*dirs)
    verbose = if dirs[-1].is_a? String then false else dirs.pop end
    mode = 0755
    for dir in dirs
      parent = dirname(dir)
      next if parent == dir or directory? dir
      makedirs parent unless directory? parent
      $stderr.print "mkdir ", dir, "\n" if verbose
      if basename(dir) != ""
        begin
          Dir.mkdir dir, mode
        rescue SystemCallError
          raise unless directory? dir
        end
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Sucht nach Dateien - (Ruby Standard Library)
  #--------------------------------------------------------------------------
  def self.find(*paths)
    paths.collect!{|d| d.dup}
    while file = paths.shift
      catch(:prune) do
        yield file.dup.taint
        next unless File.exist? file
        begin
          if File.lstat(file).directory? then
            d = Dir.open(file)
            begin
              for f in d
                next if f == "." or f == ".."
                if File::ALT_SEPARATOR and 
                file =~ /^(?:[\/\\]|[A-Za-z]:[\/\\]?)$/ then
                  f = file + f
                elsif file == "/" then
                  f = "/" + f
                else
                  f = File.join(file, f)
                end
                paths.unshift f.untaint
              end
            ensure
              d.close
            end
          end
        rescue Errno::ENOENT, Errno::EACCES
        end
      end
    end
  end
  
  def self.prune
    throw :prune
  end
  #--------------------------------------------------------------------------
  # * Kopiert Dateien -Ruby Standard Library
  #--------------------------------------------------------------------------
  BUFSIZE = 8 * 1024
  def self.catname(from, to)
    if directory? to
      join to.sub(%r([/\\]$), ''), basename(from)
    else
      to
    end
  end
  def self.syscopy(from, to)
    to = catname(from, to)
    fmode = stat(from).mode
    tpath = to
    not_exist = !exist?(tpath)
    from = open(from, "rb")
    to = open(to, "wb")
    begin
      while true do to.syswrite from.sysread(BUFSIZE) end
    rescue EOFError
      ret = true
    rescue
      ret = false
    ensure
      to.close
      from.close
    end
    chmod(fmode, tpath) if not_exist
    ret
  end
end

Teil 2

#==============================================================================
# ** Ressourcen - von KD
#------------------------------------------------------------------------------
#  Diese Klasse speichert Ressourcennamen und liest diese aus Projekten aus
#==============================================================================
class Ressourcen
  include(Enumerable)
  #--------------------------------------------------------------------------
  # * Konstanten
  #--------------------------------------------------------------------------
  ORDNER = "Data/"                  #Ordner wo die Daten sich befinden
  MAPS = "Map"                      #Dateiname der Maps
  ENDUNG = ".rxdata"                #Dateiendung der Daten 
  LOGPFAD = "/log/"                 #Pfad der Logdateien
  LOGNAME = "ressourcen"            #Dateiname der Logdatei
  LOGENDING = '.log'                #Dateiendung der Logdateien
  LOESCHPFAD = "/nicht_benoetigt/"  #Pfad für verschobene Ressourcendateien
  
  #Konstanten für den Automatik-Vorgang
  LOGGEN      = true      #Genutzte Ressourcen werden geloggt
  MULTI_FILE  = false     #Ressourcen werden in mehreren Textdateien geloggt
  LOG_UNUSED  = true      #Ungenutzte Ressourcen werden extra geloggt
  LOESCHEN    = false     #nicht benötigte Ressourcen werden gelöscht
  EXIT        = true      #Nach Ausführen des Vorgangs wird Programm beendet
  LOG_ORDNER  = '/unused/'#Logordner für ungenutzte Ressourcen
  UNUSEDNAME  = 'unused'  #Dateiname für ungenutzte-Ressourcenlogdatei
  #--------------------------------------------------------------------------
  # * Attribute
  #-------------------------------------------------------------------------- 
  METADIRECTORY = Hash.new
  METADIRECTORY['graphics'] = [:characters, :windowskins, :transitions,
             :fogs, :battlebacks, :panoramas, :windowskins, :characters,
             :animations, :autotiles, :battlers, :gameovers, :icons,
             :pictures, :tilesets, :titles]
  METADIRECTORY['audio'] = [:se, :bgs, :me, :bgm]
  TYPEN = METADIRECTORY.values.flatten
  #Attribut Readers -> Metadirectories, Typen, root
  METADIRECTORY.each_key {|meta| define_method(meta.to_sym) {
    result = Array.new
    METADIRECTORY[meta].each {|m| result << self.method(m).call}
    result.flatten
  }}
  attr_reader(:root, *TYPEN)
  #============================================================================
  #            ***Initialisierung der Instanzvariablen***
  #  root#String : Gibt den Pfad zum Projektordner an
  #============================================================================
  def initialize(root='.')
    TYPEN.each {|typ|
      self.instance_variable_set(typ.to_isym, Array.new)
    }
    @root = root
  end
  #============================================================================
  #                         ***Klassenmethoden***
  #============================================================================
  #--------------------------------------------------------------------------
  # * Definiert Dateiendungen für einen Typ o. Metaordner
  #  klassifizierung#String/Symbol : Metaordner oder Typ der Dateiendung
  #  *extensions#Strings : Name der Dateiendung
  #--------------------------------------------------------------------------
  @@extensions = Hash.new
  def self.extensions_for(klassifizierung, *extensions)
    k = klassifizierung.to_s.downcase
    if @@extensions[k] then
      @@extensions[k].add(extensions)
    else
      @@extensions[k] = extensions
    end
  end
  #--------------------------------------------------------------------------
  # * Erzeugt Dateiendungen
  #--------------------------------------------------------------------------
  extensions_for('audio', 'mid', 'ogg', 'wav', 'mp3', 'wma')
  extensions_for('graphics', 'png', 'bmp', 'jpg')
  #--------------------------------------------------------------------------
  # * Gib Dateiendungen für bestimmten Typ/Metaordner zurück => Array
  #  typ#String/Symbol : Metaordner oder Typ, der gesuchte Dateiendung hat
  #                      Standardmäßig werden alle Dateiendungen ausgegeben
  #--------------------------------------------------------------------------
  def self.extensions(typ=true)
    if (typ==true) then return @@extensions.values.flatten end
    key = typ.to_s.downcase
    if @@extensions.has_key?(key) then
      @@extensions[key]
    elsif @@extensions.has_key?(n=metadirectory_for(typ).to_s.downcase)
      @@extensions[n]
    else
      []
    end
  end
  def extensions(t=true); Ressourcen.extensions(t); end
  #--------------------------------------------------------------------------
  # * Gibt den Metaordner für einen Typ aus => nil oder String
  #  typ#Symbol : Typ, dessen Metaordner gesucht wird
  #--------------------------------------------------------------------------
  def self.metadirectory_for(typ)
    if typ then
      typ = typ.to_s.downcase.to_sym
      METADIRECTORY.key_for_value(typ) {|h, s| h.include?(s)}
    else
      nil
    end
  end
  def metadirectory_for(typ); Ressourcen.metadirectory_for(typ); end
  #--------------------------------------------------------------------------
  # * Sucht nach Ressourcen, loggt diese und löscht ggf. nicht benötigte
  #--------------------------------------------------------------------------
  def self.automatik()
    ressourcen = genutzte_ressourcen.sort!
    if MULTI_FILE then ressourcen.loggen else ressourcen.loggen_one end if LOGGEN
    if LOG_UNUSED or LOESCHEN then 
      unused = Ressourcen.ungenutzte_ressourcen(ressourcen)
    end
    if LOG_UNUSED then
      if MULTI_FILE then 
        unused.loggen(LOG_ORDNER) 
      else 
        unused.loggen_one(LOGPFAD, UNUSEDNAME)
      end
    end
    if LOESCHEN then unused.verschiebe end
    exit if EXIT
  end
  
  #--------------------------------------------------------------------------
  # * Erzeugt Construktor-Methoden
  #  methode#Symbol : Methode, für die ein Constructor erzeugt wird
  #--------------------------------------------------------------------------
  def self.constructor(methode)
    $methode = methode
    class << self; m = $methode; define_method(m) {|*a|
      root=if a[0].class==String and self.instance_method(m).arity.abs < a.size 
        a.shift else "." 
      end
      r = self.new(root)
      r.method(m).call(*a)
      r
    } end
    $methode = nil
  end
  #--------------------------------------------------------------------------
  # * Erzeugt Constructor und alternative Methodennamen
  #  name#Symbol : Methode, die behandelt wird
  #  *alternatives#Symbole : Alternative Methodennamen
  #--------------------------------------------------------------------------
  def self.constructor_and_alternatives(name, *alternatives)
    constructor(name) #erzeuge Konstructor für Methode
    link(name, *alternatives) #alternative namen für Methode
    link_classmethod(name, *alternatives) #alternative namen für Konstruktor
  end
  #============================================================================
  #              ***Constructor Methoden*** => Ressourcenobjekt
  #  Als Klassenmethoden genutzt erzeugen sie neue Ressourcen-Objekte
  #    root#String : Erzeugt ein Ressourcenobjekt in diesem Projektordner
  #  Als Instanzmethoden genutzt fügen sie dem Objekt neue Ressourcen hinzu
  #============================================================================
  #--------------------------------------------------------------------------
  # * Erzeugt ein Ressourcenobjekt aus genutzten Ressourcen eines Projektes
  #--------------------------------------------------------------------------
  def genutzte_ressourcen()
    durchsuche_maps
    durchsuche_database
    self
  end
  constructor_and_alternatives(:genutzte_ressourcen, :used_ressources)
  #--------------------------------------------------------------------------
  # *  Erzeugt ein Ressourcenobjekt aus importierten Ressourcen eines Projektes
  #--------------------------------------------------------------------------
  def importierte_ressourcen()
    pfad = @root + '/'
    #Durchsuche alle Metaordner
    directories = METADIRECTORY.keys.collect {|e| pfad + e.to_s}
    dirs = ""
    METADIRECTORY.keys.each {|d| dirs = dirs.concat('|' + d.to_s)}
    dirs = dirs.sub('|', '')
    pfad = ' ' + pfad
    while a = pfad =~ /[^\\]\./ do pfad[a+1] = '\\.'  end
    while a = pfad =~ /[^\\]\// do pfad[a+1] = '\\/'  end
    pfad[0] = ''
    regexp = Regexp.new(pfad+"(#{dirs})"+'\/(.+)\/(.+)\..+', true)
    File.find(*directories) {|pfad|
      #Wenn gefundene Datei die passende Dateiendung hat....
      pfad =~ regexp
      if File.ressource?(pfad.downcase, *extensions($2)) then
        #...soll sie in die Liste aufgenommen werden
        if method(methode=$2.downcase.to_sym) then
          method(methode).call.add($3)
        end
      end
    }
    self
  end
  constructor_and_alternatives(:importierte_ressourcen, :imported_ressources)
  #--------------------------------------------------------------------------
  # * Erzeugt ein Ressourcenobjekt aus nichtbenötigten Ressourcen des Projektes
  #  genutzte#Ressourcen : Prozess lässt sich beschleunigen, wenn das
  #                        genutzte-Ressourcenobjekt zuvor schon erzeugt wurde 
  #--------------------------------------------------------------------------
  def ungenutzte_ressourcen(genutzte=nil)
    genutzte = Ressourcen.genutzte_ressourcen(@root) unless genutzte
    importierte_ressourcen()
    drop(genutzte)
  end
  constructor_and_alternatives(:ungenutzte_ressourcen, :unused_ressources)
  #--------------------------------------------------------------------------
  # * Erzeugt ein Ressourcenobjekt aus einer Map
  #  mapdateiname#String : Pfad zur Mapdatei
  #--------------------------------------------------------------------------
  def durchsuche_map(mappfad)
    map = load_data(@root+'/'+mappfad)
    #Suche aus der Map alle Sounddateien heraus
    bgm.add(map.bgm.name) if map.autoplay_bgm
    bgm.add(map.bgs.name) if map.autoplay_bgs
    #Suche aus der Map alle Eventgrafiken heraus
    events = map.events
    events.each_value {|event|
      event.pages.each {|page|
        characters.add(page.graphic.character_name)
        #Suche alle Ressourcen aus MoveBefehlen heraus
        durchsuche_moveroute(page.move_route.list)
        #Suche alle Ressourcen aus Eventbefehlen heraus
        durchsuche_eventcommands(page.list)
      }
    }
    self
  end
  constructor_and_alternatives(:durchsuche_map, :scan_map)
  #--------------------------------------------------------------------------
  # * Erzeugt ein Ressourcenobjekt aus den Mapdaten
  #--------------------------------------------------------------------------
  def durchsuche_maps
    #Suche in den Maps nach verwendeten Ressourcen
    i = 1
    name = ORDNER + MAPS+i.zu_nstelligen_string(3)+ENDUNG
    while File.exist?(@root + "/" + name)
      durchsuche_map(name)
      i += 1
      name = ORDNER + MAPS+i.zu_nstelligen_string(3)+ENDUNG
    end
    self
  end
  constructor_and_alternatives(:durchsuche_maps, :scan_maps)
  #--------------------------------------------------------------------------
  # * Erzeugt ein Ressourcenobjekt aus den Move-Routes
  #  move_list#RPG::MoveCommand-Array : Move-Commands die durchsucht werden
  #--------------------------------------------------------------------------
  def durchsuche_moveroute(move_liste)
    move_liste.each {|befehl|
      case befehl.code
        when 41
          characters.add(befehl.parameters[0])
        when 44
          bgs.add(befehl.parameters[0].name)
        when 45
          durchsuche_script(befehl.parameters[0])
        end
    }
    self
  end
  constructor_and_alternatives(:durchsuche_moveroute, :scan_moveroute)
  #--------------------------------------------------------------------------
  # * Erzeugt ein Ressourcenobjekt aus den Event Commands
  #  liste#RPG::EventCommand-Array : EventCommands die durchsucht werden
  #--------------------------------------------------------------------------
  def durchsuche_eventcommands(liste)
    rubystring = ""
    messagestring = ""
    commentstring = ""
    liste.each {|befehl|
      case befehl.code
        when 101, 401
          messagestring += "\n" + befehl.parameters[0]
        when 108, 408
          commentstring += "\n" + befehl.parameters[0]
        when 111
          if befehl.parameters[4] == 12
            rubystring + "\n" + befehl.parameters[1]
          end
        when 131
          windowskins.add(befehl.parameters[0])
        when 132
          bgm.add(befehl.parameters[0].name)
        when 133
          me.add(befehl.parameters[0].name)
        when 204
          case befehl.parameters[0]
            when 0 then panoramas.add(befehl.parameters[1])
            when 1 then fogs.add(befehl.parameters[1])
            when 2 then battlebacks.add(befehl.parameters[1])
          end
        when 209
          durchsuche_moveroute(befehl.parameters[1].list)
        when 222
          transitions.add(befehl.parameters[0])
        when 231
          pictures.add(befehl.parameters[1])
        when 241
          bgm.add(befehl.parameters[0].name)
        when 245
          bgs.add(befehl.parameters[0].name)
        when 249
          me.add(befehl.parameters[0].name)
        when 250
          se.add(befehl.parameters[0].name)
        when 322
          characters.add(befehl.parameters[1])
          battlers.add(befehl.parameters[3])
        when 355
          rubystring.concat(befehl.parameters[0])
        when 655
          rubystring.concat(befehl.parameters[0])
      end
    }
    durchsuche_script(rubystring)
    durchsuche_message(messagestring)
    durchsuche_comment(commentstring)
    self
  end
  constructor_and_alternatives(:durchsuche_eventcommands, :scan_eventcommands)
  #--------------------------------------------------------------------------
  # * Erzeugt ein Ressourcenobjekt aus den Rubyscripts (unvollständig)
  #  string#String : String aus Rubyscripten, der durchsucht wird
  #--------------------------------------------------------------------------
  def durchsuche_script(string)
    self
  end
  constructor_and_alternatives(:durchsuche_script, :scan_script)
  #--------------------------------------------------------------------------
  # * Erzeugt ein Ressourcenobjekt aus den Messagescripts (unvollständig)
  #  string#String : String aus Messages, der durchsucht wird
  #--------------------------------------------------------------------------
  def durchsuche_message(string)
    self
  end
  constructor_and_alternatives(:durchsuche_script, :scan_script)
  #--------------------------------------------------------------------------
  # * Erzeugt ein Ressourcenobjekt aus den Commentcripts (unvollständig)
  #  string#String : String aus Comments, der durchsucht wird
  #--------------------------------------------------------------------------
  def durchsuche_comment(string)
    self
  end
  constructor_and_alternatives(:durchsuche_script, :scan_script)
  #--------------------------------------------------------------------------
  # * Erzeugt ein Ressourcenobjekt aus den Informationen der Database
  #--------------------------------------------------------------------------
  def durchsuche_database
    #Actors
    datei = load_data("[email protected]}/Data/Actors.rxdata")
    datei.each {|actor|
      next unless actor
      characters.add(actor.character_name)
      battlers.add(actor.battler_name)
    }
    #Skills und Items
    datei = load_data("[email protected]}/Data/Skills.rxdata") +
      load_data("[email protected]}/Data/Items.rxdata")
    datei.each {|e|
      next unless e
      icons.add(e.icon_name)
      se.add(e.menu_se.name)
    }
    #Weapons und armors
    datei = load_data("[email protected]}/Data/Weapons.rxdata") +
      load_data("[email protected]}/Data/Armors.rxdata")
    datei.each {|e| 
      next unless e
      icons.add(e.icon_name)
    }
    #Enemies
    datei = load_data("[email protected]}/Data/Enemies.rxdata")
    datei.each {|e| 
      next unless e
      battlers.add(e.battler_name)
    }
    #Battle-Events
    datei = load_data("[email protected]}/Data/Troops.rxdata")
    datei.each {|e|
      next unless e
      e.pages.each {|page|
        durchsuche_eventcommands(page.list)
      }
    }
    #Animations
    datei = load_data("[email protected]}/Data/Animations.rxdata")
    datei.each {|e|
      next unless e
      animations.add(e.animation_name)
      e.timings.each {|time| se.add(time.se.name)}
    }
    #Tilesets
    datei = load_data("[email protected]}/Data/Tilesets.rxdata")
    datei.each {|e|
      next unless e
      tilesets.add(e.tileset_name)
      autotiles.add(*e.autotile_names)
      panoramas.add(e.panorama_name)
      fogs.add(e.fog_name)
      battlebacks.add(e.battleback_name)
    }
    #CommonEvents
    datei = load_data("[email protected]}/Data/CommonEvents.rxdata")
    datei.each {|e| 
      next unless e
      durchsuche_eventcommands(e.list)
    }
    #System
    datei = load_data("[email protected]}/Data/System.rxdata")
    windowskins.add(datei.windowskin_name)
    titles.add(datei.title_name)
    gameovers.add(datei.gameover_name)
    windowskins.add(datei.windowskin_name)
    transitions.add(datei.battle_transition)
    bgm.add(datei.title_bgm.name)
    bgm.add(datei.battle_bgm.name)
    me.add(datei.battle_end_me.name)
    me.add(datei.gameover_me.name)
    se.add(datei.cursor_se.name)
    se.add(datei.decision_se.name)
    se.add(datei.cancel_se.name)
    se.add(datei.buzzer_se.name)
    se.add(datei.equip_se.name)
    se.add(datei.shop_se.name)
    se.add(datei.save_se.name)
    se.add(datei.load_se.name)
    se.add(datei.battle_start_se.name)
    se.add(datei.escape_se.name)
    se.add(datei.actor_collapse_se.name)
    se.add(datei.enemy_collapse_se.name)
    battlebacks.add(datei.battleback_name)
    battlers.add(datei.battler_name)
    self
  end
  constructor_and_alternatives(:durchsuche_database, :scan_database)
  #============================================================================
  #                     ***Öffentliche Instanzmethoden***
  #============================================================================
  #--------------------------------------------------------------------------
  # * Sortiert ein Ressourcenobjekt => Ressourcen
  #--------------------------------------------------------------------------
  def sort!
    TYPEN.each {|typ|
      array = self.instance_variable_get(typ.to_isym)
      array.sort!
    }
    self
  end
  #--------------------------------------------------------------------------
  # * Gibt jene Ressourcentypen zurück, die nicht leer sind => Symbol-Array
  #--------------------------------------------------------------------------
  def typen
    TYPEN.find_all {|t| !self.instance_variable_get(t.to_isym).empty?}
  end
  #--------------------------------------------------------------------------
  # * Addition zweier Ressourcenobjekte => Ressourcen
  #  other#Ressourcen : Summant, mit dem das Ressourcenobjekt addiert wird
  #--------------------------------------------------------------------------
  def concat(other)
    TYPEN.each {|typ| 
      typ = typ.to_isym
      self.instance_variable_get(typ).add(*other.instance_variable_get(typ))
    }
    self
  end
  #--------------------------------------------------------------------------
  # * Subtraktion zweier Ressourcenobjekte => Ressourcen
  #  other#Ressourcen : Subtrahend , mit dem subtrahiert wird
  #--------------------------------------------------------------------------
  def drop(other)
    TYPEN.each {|typ| 
      typ = typ.to_isym
      v = self.instance_variable_get(typ) - other.instance_variable_get(typ)
      self.instance_variable_set(typ, v)
    }
    self
  end
  #--------------------------------------------------------------------------
  # * Schnittmenge zweier Ressourcenobjekte => Ressourcen
  #  other#Ressourcen : Vergleichsressourcenobjekt
  #--------------------------------------------------------------------------
  def compare(other)
    ressi = Ressourcen.new(@root)
    TYPEN.each {|typ| ressi.method(typ).call.add(
      *method(typ).call & other.method(typ).call)
    }
    ressi
  end
  #--------------------------------------------------------------------------
  # * Loggt die Ressourcen in verschiedenen Textdateien
  #  ordner#String : Pfad zum Log-Ordner
  #  dateiende#String : Dateiende der Logdateien
  #--------------------------------------------------------------------------
  def loggen(ordner=LOGPFAD, dateiende=LOGENDING)
    File.makedirs(@root + '/' + ordner)
    TYPEN.each {|typ|
      liste = self.instance_variable_get(typ.to_isym)
      next if liste.empty?
      File.open(path + ordner + typ.to_s + dateiende, 'w+') {|file|
        liste.each {|name|
          file.write(name + "\n")
        }
      }
    }
  end
  #--------------------------------------------------------------------------
  # * Loggt die Ressourcen in einer Textdatei
  #  ordner#String : Pfad zum Log-Ordner
  #  dname#String : Name der Logdatei
  #  dateiende#String : Dateiende der Logdatei
  #--------------------------------------------------------------------------
  def loggen_one(ordner=LOGPFAD, dname=LOGNAME, dateiende=LOGENDING)
    File.makedirs(@root+'/' + ordner)
    sortierer = Proc.new {|a,b| a.to_s <=> b.to_s}
    File.open(@root + '/' + ordner + dname + dateiende, 'w+') {|file|
      TYPEN.sort(&sortierer).each {|typ|
        liste = self.instance_variable_get(typ.to_isym)
        next if liste.empty?
        file.write(typ.to_s.capitalize + "\n")
        liste.each {|name|
          file.write(name + "\n")
        }
        file.write("\n")
      }
    }
  end
  #--------------------------------------------------------------------------
  # * Erzeugt die Ordner und ermitteln dest und src Pfade (Privat!)
  #--------------------------------------------------------------------------
  def ordner_erzeugen(path, *args, &block)   
    #Iteriere jeden Metaordner
    METADIRECTORY.each_pair {|ordner, typen|
      next if method(ordner.to_sym).call.empty?
      #Lege einen Ordner für diesen META an, falls noch nicht geschehen
      File.makedirs(dest_pfad = (path+'/'+ordner.capitalize))
      src_pfad = @root + '/' + ordner.capitalize
      #Iteriere die Typen jedes Metaordners
      typen.each {|typ|
        next if (inhalt=method(typ).call).empty?
        styp = typ.to_s.capitalize
        #Lege einen Ordner für diesen Typ an, falls noch nicht geschehen
        File.makedirs(dest_typpfad = dest_pfad + '/' + styp)
        src_typpfad = src_pfad + '/' + styp
        #Iteriere die Ressourcen eines Types
        inhalt.each {|e|
          #Ermittle vollständigen Dateinamen der Ressource
          src_name = src_typpfad + "/" + e
          endung = ""
          next if Ressourcen.extensions(typ).each {|endung|
            if File.exist?(src_name + '.' + endung) then break end
          }
          src_name = src_name + '.' + endung
          dest_name = dest_typpfad + '/' + e + '.' + endung
          #Führe den Proc aus
          block.call(src_name, dest_name, *args) 
        }
      }
    }
  end
  private(:ordner_erzeugen)
  #--------------------------------------------------------------------------
  # * Verschiebt Ressourcen in einen extra Ordner
  #  lpfad#String : Pfad zum Ordner, zu dem verschoben wird
  #--------------------------------------------------------------------------  
  def verschiebe(lpfad=LOESCHPFAD)
    lpfad = lpfad.root if lpfad.instance_of?(Ressourcen)
    ordner_erzeugen(@root + '/' + lpfad) {|src, dest| 
      File.rename(File.expand_path(src), File.expand_path(dest))
    }
  end
  link(:verschiebe, :move)
  #--------------------------------------------------------------------------
  # * Kopiert Ressourcen in ein anderes Projekt
  #  zielpfad#String/Ressourcen : Zielordner, in das Ressourcen kopiert werden
  #                               Ressourcenobjekt, in dessen Root kopiert wird 
  #-------------------------------------------------------------------------- 
  def kopiere(zielpfad)
    zielpfad = zielpfad.root if zielpfad.instance_of?(Ressourcen)
    ordner_erzeugen(zielpfad) {|src, dest|
      File.syscopy(File.expand_path(src), File.expand_path(dest))
    }
  end
  #--------------------------------------------------------------------------
  # * Erhält Größe der Ressourcendateien => String o. Float
  #--------------------------------------------------------------------------
  def size(special=false) #=> gibt Float zurück
    groesse = 0
    self.each(special) {|r| groesse += FileTest.size(path(r)) }
    groesse.to_f
  end
  def printable_size(special=false) #=> gibt einen lesbaren String zurück
    size(special).datasize
  end
  #--------------------------------------------------------------------------
  # * Sucht Pfad einer Datei => String
  # name#String : Name der gesuchten Datei
  # typ#Symbol : Typ der gesuchten Datei
  # meta#String : Metaordner, in dem sich die Datei befindet
  # endung#String : Endung der Datei
  # Angaben bis auf name können weggelassen werden, verzögern aber den Prozess
  #--------------------------------------------------------------------------
  def path(name, typ=false, meta=false, endung=false)
    dmeta = if meta then meta elsif typ then meta(typ) else meta(name) end
    dtyp = (if typ then typ else typ(name) end).to_s
    return false unless (dmeta and dtyp)
    path = "[email protected]}/#{dmeta}/#{dtyp}/#{name}"
    dendung = if endung then endung else endung(name, dtyp.to_sym, dmeta) end
    return false unless dendung
    path + '.' + dendung
  end
  #--------------------------------------------------------------------------
  # * Sucht Metaordner einer Datei => String
  #  angabe#String/Symbol: Entweder Dateiname oder Dateityp
  #-------------------------------------------------------------------------- 
  def meta(angabe)
    typ = if TYPEN.include?(angabe.to_sym) then angabe else typ(angabe) end
    Ressourcen.metadirectory_for(typ)
  end
  #--------------------------------------------------------------------------
  # * Sucht Typ einer Datei => Symbol
  #  name#String: Dateiname
  #-------------------------------------------------------------------------- 
  def typ(name)
    typ = nil
    if (TYPEN.each {|typ| break if method(typ).call.include?(name)}).nil? then
      typ else nil end
    end
  #--------------------------------------------------------------------------
  # * Sucht Endung einer Datei => String
  #  name#String : Dateiname
  #  typ#Symbol : Typ der gesuchten Datei
  #  meta#String : Metaordner der Datei
  # Angaben bis auf name können weggelassen werden, verzögern aber den Prozess
  #-------------------------------------------------------------------------- 
  def endung(name, typ=false, meta=false)
    typ = typ(name) unless typ
    meta = meta(typ) unless meta
    path = "[email protected]}/#{meta}/#{typ}/#{name}"
    e = nil
    if (Ressourcen.extensions(typ).each {|e|
        if File.exist?(path + '.' + e) then break end
      }) then nil else e 
    end
  end
  #--------------------------------------------------------------------------
  # * Gibt alle Pfade aus, die den Angaben entsprechen => String-Array
  #  dname#String: Dateiname; dtyp#Symbol : Dateityp; dmeta#String : Metaordner
  #  dendung#String : Endung der Datei
  # Wenn Angaben weggelassen werden, werden alle Pfade ausgegeben
  # Wenn Block angegeben, werden die einzelnen Pfade iteriert
  #--------------------------------------------------------------------------
  def paths(dname=false, dtyp=false, dmeta=false, dendung=false)
    typen = if dtyp then dtyp.to_a
      elsif dmeta then METADIRECTORY[dmeta]
      else typen()
    end
    result = Array.new
    typen.each {|typ|
      method(typ).call.each {|name| 
        if dendung or (dendung = endung(name, typ)) then
          result << path(name, typ, false, dendung)
        end
      }
    }
    result.each{|e| yield(e)} if block_given?
    result
  end
  #--------------------------------------------------------------------------
  # * Iteriert Ressourcennamen (Enumerable Modul)
  #  special#Symbol/String : Nur Inhalt des Metaordners/Typs wird iteriert
  #  Wenn kein special angegeben, wird jeder Ressourcenname iteriert
  #-------------------------------------------------------------------------- 
  def each(special=false, &block)
    if special then 
      self.method(special.to_sym).call.each(&block)
    else 
       (TYPEN.collect {|typ| self.method(typ).call}).flatten.each(&block)
    end
  end
end