Script --> Ressourcenzahler

[-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ären 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("#{@root}/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("#{@root}/Data/Skills.rxdata") +
load_data("#{@root}/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("#{@root}/Data/Weapons.rxdata") +
load_data("#{@root}/Data/Armors.rxdata")
datei.each {|e|
next unless e
icons.add(e.icon_name)
}
#Enemies
datei = load_data("#{@root}/Data/Enemies.rxdata")
datei.each {|e|
next unless e
battlers.add(e.battler_name)
}
#Battle-Events
datei = load_data("#{@root}/Data/Troops.rxdata")
datei.each {|e|
next unless e
e.pages.each {|page|
durchsuche_eventcommands(page.list)
}
}
#Animations
datei = load_data("#{@root}/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("#{@root}/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("#{@root}/Data/CommonEvents.rxdata")
datei.each {|e|
next unless e
durchsuche_eventcommands(e.list)
}
#System
datei = load_data("#{@root}/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 = "#{@root}/#{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 = "#{@root}/#{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

[Expresseon]

1. !!!
:confused: :confused: :confused:
Gutes Skript, auch wenn ich den Zweck nicht verstanden habe!
Ich würde sowieso nur die beiden Großskripte verwenden, denn es ist ziemlich mühsam, die schlappen 10 Einzelteile an verschiedenen Stellen einzufügen!

[-KD-]

Die Einzelteile sind nur Beispiele wie man das Script verwendet. Das eigentliche Script sind die beiden unteren Codeblöcke im zweiten Post.

Der Zweck: Das Script durchsucht dein Projekt nach Dateien, die nicht verwendet werden. Beispielsweise du hast 40 Character-Sets importiert, in deinem Projekt werden aber nur 30 verschiedene genutzt. Dann befinden sich 10 Character-Dateien in deinen Projektordner, die überhaupt nicht gebraucht werden, aber 'ne Menge Platz wegnehmen (okay, bei Characters ist das wohl weniger gravierend. Anders dagegen bei Mp3-Dateien). Wenn du das Script einsetzt (und bei löschen true angibst) werden diese überflüssigen Dateien aus deinem Projekt entfernt.
Ansonsten kann das Projekt noch einige andere Sachen machen, beispielsweise kannst du alle Ressourcen von einem Projekt in ein anderes kopieren. Oder du kannst auch alle RTP-Dateien, die dein Projekt verwendet, in dein Projekt kopieren, um es unabhängig von der RTP zu machen usw.

[Schromp]

Sieht sehr vielversprechend aus, werds auf jeden fall benutzen... bei dem Chaos das in meinem Projekt herrscht, mit den ganzen vergammelnden zeug in meinem Makerchaos... und so... :D

[Expresseon]

@ -KD-

Cool! Brauch ich aber nicht, da ich noch ziemlich am Anfang meiner Projekte bin.

[Aldinsys]

Sehr schönes Script und soweit ich dass auf den ersten Blick beurteilen kann ist es sehr aufgeräumt und gut kommentiert.
Ich werde es auf jeden Fall benutzen. Danke dir vielmals für diese gelungene Arbeit.