APD - Abt Ploutôn DatabaseVersion: 0.9.0
By: Abt Ploutôn & Hanmac
Introduction
this is a dynamic script managment system for both makers
Features
Screenshots
no one
Script
[/b]
Compatibility
you can use it with VX and XP
and with SDK and with MACL
please Post this under the sdk scripts and above your scripts
Credits and Thanks
credits at me and Abt Ploutôn
Author's Notes
it is still in development so if you use it please notic that you use it on your own risk
Terms and Conditions
you can use it in free games if you credit us
Source:
http://www.rpg-studio.de/itzamna/node/44
By: Abt Ploutôn & Hanmac
Introduction
this is a dynamic script managment system for both makers
Features
- Plugin support
- SDK and MACL support
- MULTI language
- code-points (like a dynamic alias)
Screenshots
no one
Script
Code:
#==============================================================================
# ** APD - Abt Ploutôn Database V0.9.0
# von Abt Ploutôn & Hanmac (07.02.09)
#------------------------------------------------------------------------------
# [url=http://www.rpg-studio.de/itzamna/node/44]http://www.rpg-studio.de/itzamna/node/44[/url]
#==============================================================================
Â
module APD
Â
  #--------------------------------------------------------------------------
  # * Setzt benötigte Variablen
  #--------------------------------------------------------------------------
  def self.core_config
Â
    #benötigte Variablen
    @core_modules = {}
    @core_config = {}
  @core_config_save = {}
  @core_config_proc = {}
    @cs = {}
    @cs_cache = {}
  @core_api = {}
    @core_last_modul = nil #letzes registieres modul
    $APD_install = true #legt variable an, damit module auf APD zugreifen können.
   Â
    self["core_info_print"] = true #bei infotexten in log schreiben?
    self["core_error_print"] = true #bei fehlertexten in log schreiben?
    self["core_error_show"] = true #fehlertexte anzeigen?
    self["core_path"] = "" #pfad für alle Dateien
    self["core_log"] = "log.txt" #name der textdatei
    self["core_log_time"] = "[%H:%M:%S] " #zeitformat
    self["core_log_clear"] = true #log beim Start löschen?
    self["core_log_header"] = "Mein Spiel V0.2"
    self["core_log_body"] = "Beschreibung"
    self["core_lang"] = "en" #anpassen!
    self["core_vx"] = core_vx_install #wird der vx genutzt?Â
    self["core_info_show"] = self["core_vx"] ? $TEST : $DEBUG #infotexte anzeigen?
    self["core_file_ext"] = self["core_vx"] ? "rvdata" : "rxdata"
 Â
    self["sdk_install"] = self.core_sdk_install #Ist das SDK installiert?
    self["sdk_version"] = SDK::Version if self["sdk_install"] #wichtig für spezifische befehle
    self["sdk_register"] = true #wenn das SDK installiert ist, sollen alle APD Module beim SDK registiert werden?
    self["sdk_mod_activ"] = true #soll beim SDK nachgefragt werden ob das Script activ sein darf?
    self["macl_install"] = Object.const_defined?("MACL")
    self["macl_register"] = true # wenn das MACL installiert ist, sollen alle APD Module beim MACL registert werden?
    self["sdk_registered_module"] = [] #enthält die SDK-sripte, ist dafür da das man sdk methoden nicht mehrfach registieren kann.
    self["macl_registered_module"] = [] #enthält die Macl-sripte, die werden hier nicht überprüft
   Â
    self["cs_register_last_modul"] = true # wenn man an die register_cs methode kein modul übergibt, nimmt die das letzte modul.
    self["cs_register_in_modul"] = true # sagt ob die Code-Stelle auch im Modul an gegeben werden soll, wenn ein modul angegeben wurde.
    self["cs_must_registered"] = false # sagt ob eine Code-Stelle registiert sein muss.
    self["cs_can_overwrite"] = {} # gibt an ob eine codestelle überschrieben werden kann.
  self["cs_can_overwrite"].default = false
  self["cs_position"] = {}
  self["cs_position"].default = 0
    self["core_lang_add_auto"] = false # gibt an ob spachen die nicht hinzugefügt würden, automatisch erstellt werden sollen.
 Â
    self["core_lang_default_constant_modul"] = "Vocab" # das standart modul in dem die constanten sind die ersetzt werden., setze die auf false oder nil um sie zu deaktivieren.   Â
    #zb "Math::Physics::ALPHA"
    self["core_lang_set_const"] = false #sagt ob die letzte konstante "ALHPA" erstellt werden soll
    self["core_lang_create_const"] = false #false, nil, Class oder Module, wenn Class oder Module angegeben, wird "Physics" als Instanz davon erstellt.
 Â
  self["core_lang_constants"] = {}
    #sprachen hinzufügen
    L.add_lang("de","Deutsch")
    L.add_lang("en","English")
  end
  #--------------------------------------------------------------------------
  # * Setzt benötigte Sprachvariablen
  #--------------------------------------------------------------------------
  def self.core_lang
    #syncro hinzufügen
    L.default = ["en","de"]Â
    #sachen hinzufügen
    L["apd_core_register_hl"] = "Moduleregistration abortive","Modulregistrierung fehlgeschlagen."
    L["apd_core_register_body"] = "The module #001# is already registered and cannot be registered again. ","Das Modul #001# ist schon registriert und kann nicht nochmal registiert werden."
    L["apd_core_register_old_body"] = "The module #001# must be updated, to use it. ","Das Modul #001# muss zuerst aktualisiert werden, bevor es benutzt werden kann. "
   Â
    L["apd_core_think_exist_apd"] = "APD - Module #001# V#002# missing.","APD - Modul #001# V#002# fehlt."
  L["apd_core_think_exist_apdv"] = "APD - Module #001# missing.","APD - Modul #001# fehlt."
    L["apd_core_think_exist_class"] = "Class #001# missing.","Klasse #001# fehlt."
    L["apd_core_think_exist_const"] = "Constant #001# missing.","Konstante #001# fehlt."
    L["apd_core_think_exist_module"] = "Module #001# missing.","Modul #001# fehlt."  Â
    L["apd_core_think_exist_file"] = "File #001# is missing.","Datei #001# fehlt."
    L["apd_core_think_exist_font"] = "Font #001# is missing.","Schriftart #001# fehlt."
    L["apd_core_think_exist_condition"] = "Condition #001# is not fulfilled.","Bedingung #001# ist nicht erfüllt."
    L["apd_core_think_exist_sdk"] = "SDK - Module #001# missing.","SDK - Modul #001# fehlt."
    L["apd_core_think_exist_g_v"] = "Global Variable #001# missing.","Globale Variable #001# fehlt."
    L["apd_core_think_exist_cs"] = "Code Snipplet #001# is missing.","Code-Stelle #001# fehlt."
    L["apd_core_think_exist_macl"] = "MACL - Module #001# missing.","MACL - Modul #001# fehlt."
    L["apd_core_think_exist_maker"] = "RPGMaker #001# missing.","RPGMaker #001# fehlt."
Â
    L["apd_core_think_exist_apd_no"] = "APD - Module #001# V#002# exist.","APD - Modul #001# V#002# ist vorhanden."
  L["apd_core_think_exist_apdv_no"] = "APD - Module #001# exist.","APD - Modul #001# ist vorhanden."
    L["apd_core_think_exist_class_no"] = "Class #001# exist.","Klasse #001# ist vorhanden."
    L["apd_core_think_exist_const_no"] = "Constant #001# exist.","Konstante #001# exist."
    L["apd_core_think_exist_module_no"] = "Module #001# exist.","Modul #001# ist vorhanden."   Â
    L["apd_core_think_exist_file_no"] = "File #001# exist.","Datei #001# ist vorhanden."
    L["apd_core_think_exist_font_no"] = "Font #001#exist.","Schriftart #001# ist vorhanden."
    L["apd_core_think_exist_condition_no"] = "Condition #001# is fulfilled.","Bedingung #001# ist erfüllt."
    L["apd_core_think_exist_sdk_no"] = "SDK - Module #001# exist.","SDK - Modul #001# ist vorhanden."
    L["apd_core_think_exist_g_v_no"] = "Global Variable #001# exist.","Globale Variable #001# ist vorhanden."
    L["apd_core_think_exist_cs_no"] = "Code Snipplet #001# is exist.","Code-Stelle #001# ist vorhanden."
    L["apd_core_think_exist_macl_no"] = "MACL - Module #001# exist.","MACL - Modul #001# ist vorhanden."
    L["apd_core_think_exist_maker_no"] = "RPGMaker #001# exist.","RPGMaker #001# ist vorhanden."
   Â
    L["apd_core_think_exist_unkown"] = "Unkown Condition. - #001#", "Unbekannte Bedingung. - #001#"
   Â
    L["apd_core_think_exist_body"] = "The module cannot be activated, since a condition is missing. If you want to use the module, guarantee that all conditions are fulfilled.","Das Modul kann nicht aktiviert werden, da eine Voraussetzung fehlt. Wenn Sie das Modul nutzen wollen, stellen Sie sicher, dass alle Bedingungen erfüllt sind."
   Â
    L["apd_core_info"] = "? - Information","? - Information"
    L["apd_core_error_hl"] = "? - Conflict","? - Konflikt"
    L["apd_core_error_body"] = "The game is terminated now, all unsaved data are lost.","Das Spiel wird nun beendet, alle ungespeicherten Spielstände gehen verloren."
    L["apd_core_error_log"] = "Game exit.","Spiel beendet."
   Â
    L["apd_core_meldung_modul"] = "Used modules:","Verwendete Module:"  Â
   Â
    L["apd_method_missing_hl"] = "Unknown method called. - #001#","Unbekannte Methode aufgerufen. - #001#"
    L["apd_method_missing_exist"] = "The APD module #001# missing.","Das APD Modul #001# fehlt."
    L["apd_method_missing_deactivated"] = "The module #001# is deactivated. The call of this method is not possible.","Das Modul #001# ist deaktiviert. Der Aufruf dieser Methode ist nicht möglich."
    L["apd_method_missing_activated"] = "The module #001# is activated, it knows however not the method. Examine the version of the module.","Das Modul #001# ist zwar aktiviert, es kennt aber nicht die Methode. Überprüfen Sie die Version des Moduls."
    L["apd_method_missing_other"] = "An unknown method was called. Examine the way of writing of the method and whether the module is installed.","Es wurde eine unbekannte Methode aufgerufen. Überprüfen Sie die Schreibweise der Methode und ob das Modul installiert ist."
    L["apd_method_missing_nil"] = " The standard parameter nil is given back."," Der Standardparameter nil wird zurück gegeben."
Â
    L["apd_lang_double_hl"] = "Doubled language variable.","Doppelte Sprachvariable."
    L["apd_lang_double_body"] = "In the language '#001#' is the entry '#002#' already occupied with '#003#'. It is to be occupied however now again with '#004#'. The procedure was broken off.","In der Sprache '#001#' ist der Eintrag '#002#' schon mit '#003#' belegt. Er soll aber nun wieder mit '#004#' belegt werden. Der Vorgang wurde abgebrochen."
   Â
    L["apd_cs_double_hl"] = "Doubled Code Snipplet.", "Doppelte Code-Stelle."
    L["apd_cs_double_body"] = "The Code Snipplet '#001#' is already registered and cannot be registered again.  ", "Die Code-Stelle '#001#' ist schon registriert und kann nicht nochmal registiert werden."
   Â
    L["apd_cs_deactive_hl"] = "Code Snipplet deactive.","Code-Stelle deaktivert."
    L["apd_cs_deactive_body"] = "The Code Snipplet #001# cannot be run, because the module #002# is deactivated.","Die Code-Stelle #001# kann nicht ausgeführt werden, da das zugehörige Modul #002# deaktivert ist."
    L["apd_cs_unregisterd_hl"] = "Code Snipplet not registed.","Code-Stelle ist unregistiert."
    L["apd_cs_unregisterd_body"] = "The Code Snipplet #001# cannot be run, because the it is not registed.","Die Code-Stelle #001# kann nicht ausgeführt werden, da das sie nicht registiert wurde."
    L["core_error_double_register_hl"] = "#001#-Registration abortive","#001#-Registrierung fehlgeschlagen."
    L["core_error_double_register_body"] = "The module #001# is already registered into the #002# and cannot be registered again. ","Das Modul #001# ist schon im #002# registriert und kann nicht nochmal registiert werden."
    L["core_lang_set_error_hl"] = "Language set error.", "Sprachsetzungsfehler."
    L["core_lang_set_not_set"] ="You cannot set '#001#' as language, because you have not define the language.","Du kannst '#001#' nicht als Sprache setzen, da du diese Sprache nicht definiert hast."
    L["core_lang_set_no_lang"] = "No valid language was found. The language are not changed.","Es wurde keine gültige Sprache gefunden. Die Sprache wurde nicht geändert."
    L["core_lang_set_lkeys_hl"] = "Assignation error.", "Zuweisungsfehler."
    L["core_lang_set_lkeys_more"] = "?void? more", "Es würden zuviele l-Schlüssel übergeben. es können nur #001# von #002# gesetzt werden."
    L["core_lang_set_lkeys_less"] = "?void? less", "Es würden zuwenige l-Schlüssel übergeben. es können nur #001# von #002# gesetzt werden."
    L["core_lang_no_const_hl"] = "Constant #001# missing.", "Konstante #001# fehlt."
    L["core_lang_no_const_body"] ="The Constant #001# is missing and cannot set with '#002#'.", "Die Konstante #001# fehlt und kann deswegen nicht mit '#002#' gesetzt werden."
Â
  end
  #--------------------------------------------------------------------------
  # * Gibt den Wert einer Variable zurück, die im Speicher ist
  # Sinnvoll für Werte die nach außen erreichbar sein sollen/sich ändern.
  #--------------------------------------------------------------------------
  def self.[] (id,save=nil,&block)
  if block_given?
   @core_config_proc[id] = block
  end
  unless save.nil?
   @core_config_save[id] = save
  end
  #was drin?
  begin
   return @core_config[id].dup if @core_config_save[id]
  ensure
   return @core_config[id]
  end
  end
  #--------------------------------------------------------------------------
  # * Speichert einen Wert
  #--------------------------------------------------------------------------
  def self.[]=(id, *args)
  return if args.size == 0
  value = args.pop
  if args.size  == 1 && !args[0].nil?
   @core_config_save[id] = args[0]
  end
  return if @core_config.has_key?(id) && @core_config_save[id]
    if !@core_config.has_key?(id) || @core_config[id] != value
   @core_config_proc[id].call if @core_config_proc[id].is_a?(Proc)
   APD.cs_change_config(id,value)
  end
  @core_config[id] = value
  end
  #--------------------------------------------------------------------------
  # * Gibt die APD Version wieder
  #--------------------------------------------------------------------------
  def self.core_version
    return @core_modules["core"].version
  end
  #--------------------------------------------------------------------------
  # * Gibt die APD-Modul wieder (für manuelle registierung)
  #--------------------------------------------------------------------------Â
  def self.module(name)
    return @core_modules[name]
  end
  #--------------------------------------------------------------------------
  # * registert Code-Stellen
  #--------------------------------------------------------------------------
  def self.core_register_cs(name,modul=nil)
    modul = @core_last_modul if modul.nil? && APD["cs_register_last_modul"]
    if @cs.has_key?(name) && !APD["cs_can_overwrite"][name]
      core_info(L["apd_cs_double_hl"],L.d("apd_cs_double_body",name),modul)
    else
      @cs[name] = modul
      @core_modules[modul].add_cs(name) if !modul.nil? && APD["cs_register_in_modul"]
    end
  end
Â
 def self.core_api_add(lib,method,import,export)
  @core_api[[lib,method]] = Win32API.new(lib,method,import,export)
 end
Â
 def self.core_api_call(lib,method,*args)
  @core_api[[lib,method]].call(*args)
 end
Â
  #--------------------------------------------------------------------------
  # * prüft ob Code-Stelle registert ist
  #--------------------------------------------------------------------------Â
  def self.core_cs_registered?(name)
    if (temp = @cs.has_key?(name))
      temp = core_activ?(@cs[name]) unless @cs[name].nil? #cs ist keinem modul zu geordnet
    end
    return temp
  end
  #--------------------------------------------------------------------------
  # * Registiert ein neues Modul
  #--------------------------------------------------------------------------
  def self.core_register(kurzname,version,fix,name=nil,autor=nil,homepage=nil)
    #fix für Scipte < 0.4
    if fix.is_a?(String)
      core_info(L["apd_core_register_hl"],L.d("apd_core_register_old_body",kurzname),kurzname)
      return
    end
    #modul schon vorhanden?
    unless @core_modules[kurzname].nil?
      #neueres modul?, wenn ja fehler und schüss
      if @core_modules[kurzname].version > version or (@core_modules[kurzname].version == version and @core_modules[kurzname].fix >= fix)
        core_info(L["apd_core_register_hl"],L.d("apd_core_register_body",kurzname),kurzname)
        @core_modules[kurzname].activ = false
        return
      end
      #update
    end
    #als letzes eintragen
    @core_last_modul = kurzname
    #neu anlegen
    @core_modules[kurzname] = APD_core_Modul.new(kurzname,version,fix,name,autor,homepage)
    @core_modules[kurzname].sdk_register if self["sdk_install"] && self["sdk_register"]
    @core_modules[kurzname].macl_register if self["macl_install"] && self["macl_register"]
    return @core_modules[kurzname]
  end
  #--------------------------------------------------------------------------
  # * Überprüft ob was exisitert
  # typ -> APD,class,file,font,condition,SDK,g_v (globale variablen),MACL,maker -> Procs
  # never = beziehung umdrehen, wenn true meldung zurück
  #--------------------------------------------------------------------------
  def self.core_think_exist?(typ,kurzname=nil,version=nil,never=false,&block)
    exist = false
    #nach typ filtern
    typ.downcase!
    case typ
    when "apd"
      #modul schon vorhanden?
      unless @core_modules[kurzname].nil?
        #neues modul?, wenn ja alles ok
        exist = @core_modules[kurzname].activ
        case version
        when Numeric
          exist &&= (version == @core_modules[kurzname].version)
    when Range, Array
     exist &&= version.include?(@core_modules[kurzname].version)
        when nil#wenn nil wird version nicht beachtet
     typ += "v"
          if block_given?
            exist &&= (proc &block).call(@core_modules[kurzname].version)
          end
        when String
          exist &&= evals(@core_modules[kurzname].version.to_s+version)# damit du >= 0.4 zb eingeben kannst xD
        when Proc #oder hiermit
     typ += "v"
          exist &&= version.call(@core_modules[kurzname].version) # da brauchst du einen block ala {|i| i>=0.4}
        else
     typ += "v"
          exist &&= false #irgendwie falsche eingabe...
        end
      end
    when "class", "const", "module"
      obj = Object
      exist = nil
      exist = kurzname.split("::").each { |m|
        if obj.const_defined?(m)
          obj = obj.const_get(m)
        else
          break false
        end
      }
      exist = true if exist.nil?
    when "file"
      exist = File.exist?(kurzname)
    when "font"
      exist = Font.exist?(kurzname)
    when "condition"
      if kurzname.is_a?(Proc)
        exist = kurzname.call
      elsif block_given?
        exist = (proc &block).call
      else
        exist = evals(kurzname.to_s)
      end
    when "sdk"
      #sdk installiert?
      if self["sdk_install"]
        if self["sdk_version"] >= 2.0
          SDK.check_requirements(version, [1], kurzname)
          exist = SDK.enabled?(@core_last_modul)
        elsif self["sdk_version"] < 2.0
          exist = SDK.state(@core_last_modul) && SDK.state(kurzname)
        end
      end
    when "g_v"
      kurzname[0,0] = "$" unless kurzname[0] == "$"
      exist = global_variables.include?(kurzname)
    when "cs"
      exist = core_cs_registered?(kurzname)
    when "macl"
      #gibts MACL überhaupt?
      #wenn ja, auch das modul?
      exist = MACL::Loaded.include?(kurzname) if self["macl_install"]
    when "maker"
      kurzname = kurzname.upcase
      if kurzname == "VX" and APD["core_vx"] == true
        exist = true
      elsif kurzname == "XP" and APD["core_vx"] == false
        exist = true
      end
    else
      exist = false
    end
    #prüfen ob prüfung erfolgreich
    #umdrehen?
    return never == exist ? "apd_core_think_exist_" + typ.downcase : true
  endÂ
  #--------------------------------------------------------------------------
  # * Überprüft ob ein Modul nicht exisitert
  # typ -> APD -> file -> font -> SDK -> g_v (globale variablen)
  #--------------------------------------------------------------------------
  def self.core_not_exist?(typ,kurzname,version=nil,&block)   Â
    exist = core_think_exist?(typ,kurzname,version,true,&block)
    #aktuelles modul deaktivieren
    if exist != true and @core_last_modul != nil
      return exist
    else
      #meldung ausgeben
      @core_modules[@core_last_modul].activ = false
      if !L.exist?(temp = exist+"_no")
        temp = "apd_core_think_exist_unkown"
      endÂ
      core_info(L.d(temp,kurzname,version),L["apd_core_think_exist_body"],@core_last_modul)
    end
  end
  #--------------------------------------------------------------------------
  # * Überprüft ob ein Modul exisitert
  # typ -> APD -> file -> font -> SDK -> g_v (globale variablen) -> condition
  #--------------------------------------------------------------------------
  def self.core_exist?(typ,kurzname,version=nil,&block)
    exist = core_think_exist?(typ,kurzname,version,&block)
    #aktuelles modul deaktivieren
    if exist != true and @core_last_modul != nil
      #meldung ausgeben
      @core_modules[@core_last_modul].activ = false
      if !L.exist?(temp = exist)
        temp = "apd_core_think_exist_unkown"
      endÂ
      core_info(L.d(temp,kurzname,version),L["apd_core_think_exist_body"],@core_last_modul)
    end
    return exist
  endÂ
  #--------------------------------------------------------------------------
  # * Überprüft ob ein Modul aktiv ist
  # typ -> APD -> file -> SDK -> g_v (globale variablen)
  #--------------------------------------------------------------------------
  def self.core_activ?(kurzname=@core_last_modul)
    #sdk?
    if self["sdk_install"] and self["sdk_mod_activ"]
      if self["sdk_version"] <= 1.5
        return SDK.state(kurzname)
      else self["sdk_version"] >= 2.0
        return SDK.enabled?(kurzname)
      end
    end
    #modul schon vorhanden?
    unless @core_modules[kurzname].nil?
      return @core_modules[kurzname].activ
    end
    return false
  end
  #--------------------------------------------------------------------------
  # * Gibt Infomeldungen aus
  #  modul = Name des Moduls, akzeptiert auch Arrays
  #--------------------------------------------------------------------------
  def self.core_info(hl,body,modul=nil)
    core_meldung(hl,body,modul,L["apd_core_info"],self["core_info_print"],self["core_info_show"])
  end
  #--------------------------------------------------------------------------
  # * Gibt Errormeldungen aus
  #  modul = Name des Moduls, akzeptiert auch Arrays
  #--------------------------------------------------------------------------
  def self.core_error(hl,body,modul=nil)
    body += "\n"+L["apd_core_error_body"]
    core_meldung(hl,body,modul,L["apd_core_error_hl"],self["core_error_print"],self["core_error_show"])
    if self["core_error_print"] == true
      #log füllen
      core_log("=")
      core_log(L["apd_core_error_log"])
      core_log("-")
    end
  end
  #--------------------------------------------------------------------------
  # * Gibt Meldungen aus
  #--------------------------------------------------------------------------
  def self.core_meldung(hl,body,modul,grund,print,show)
    # nachricht erstellen
    txt = "#{grund} - #{hl}\n"+
    "-------------------------------------------------------------\n#{body}"
    # module ermitteln
    unless modul.nil?
   temp = modul.collect {|m| @core_modules[m].nil? ? m : @core_modules[m].print }.join('\n')
      txt += "\n-------------------------------------------------------------\n"+
      L['apd_core_meldung_modul']+"\n#{temp}"
    end
    #ausgeben
    core_log("=") if print
    core_log(txt) if print
    print(txt) if show
  end
  #--------------------------------------------------------------------------
  # * Schreibt Infos in die Logdatei
  #--------------------------------------------------------------------------
  def self.core_log(text)
    #was ist es für ein typ?
    if text.is_a?(Array)
      for i in text
        core_log(i)
      end
      return
    end
    #wenn es kein string ist umwandeln  Â
    text = text.to_s if text.is_a?(String) == false
    #datei reseten?
    if text == "CLEAR"
      return File.open(self["core_path"] + self["core_log"], 'w').close
    end
    #datei reinschreiben
    txt = Time.new.strftime(self["core_log_time"]) + text
    txt = (text * (80/text.size)) if text.size == 1
    file = File.open(self["core_path"] + self["core_log"], 'a+')
    #mehre Dateien?
    txt = txt.split(/\/n/) if txt.include?("/n")
    file.puts(txt)
    file.close
  end
  #--------------------------------------------------------------------------
  # * ruft alle codestellen auf, die alle mod enthalten
  #--------------------------------------------------------------------------
  def self.core_cs(mod, *args)
    mod[0] = "" if mod[0] == "_"
    if !core_cs_registered?(mod) && APD["cs_must_registered"]
      if @cs.has_key?(mod) && !@cs[mod].nil?
        error = "apd_cs_deactive"
      else
        error = "apd_cs_unregisterd"
      end
      core_info(L[error+"_hl"],L.d(error+"_body",mod,@cs[mod]) + L["apd_method_missing_nil"],@cs[mod])
      return nil
    end
    unless @cs_cache.has_key?(mod)
      @cs_cache[mod] = methods.find_all { | m | m.include?("_"+mod) }
    end
    @cs_cache[mod].sort! { | a, b| APD["cs_position"][a] <=> APD["cs_position"][b] }
    @cs_cache[mod].each { |m| send(m, *args) }
  end
  #--------------------------------------------------------------------------
  # * leert den CS-Cache
  #--------------------------------------------------------------------------Â
  def self.core_cs_clear_cache(name=nil)
    if name.nil?
      @cs_cache.clear
    else
      name[0] = "" if name[0] == "_"
      @cs_cache.delete(name)
    end
  end
 Â
  #--------------------------------------------------------------------------
  # * verwaltet alle unbekannten methoden
  #--------------------------------------------------------------------------
  def self.method_undefined(methId, *args)
    method_missing(methId, *args)
  end
  #--------------------------------------------------------------------------
  # * verwaltet alle unbekannten methoden
  #--------------------------------------------------------------------------
  def self.method_missing(methId, *args)
    methId = methId.id2name
    #ist es eine codestelle?
    if methId.include?("cs_")
      core_cs(methId, *args) if core_activ?("core")
      return
    end  Â
    #ist es ein deaktiveres modul?
    #modul rausfinden
    kurzname = methId.split(/_/)[0]Â
    #modul schon vorhanden?
    if @core_modules[kurzname].nil?
      body = L.d("apd_method_missing_exist",kurzname)
    #deaktiviert?
    elsif @core_modules[kurzname].activ == false
      body = L.d("apd_method_missing_deactivated",kurzname)
    #aktiviert?
    elsif @core_modules[kurzname].activ == true
      body = L.d("apd_method_missing_activated",kurzname)
    #sonstiges?
    else
      body = L["apd_method_missing_other"] ## das kann doch nicht ausgeführt werden?
    end
   Â
    core_info(L.d("apd_method_missing_hl",methId),body + L["apd_method_missing_nil"])
    return nil
  end
  #--------------------------------------------------------------------------
  # * prüft ob das SDK installiert ist, Idee: OptimistShadow
  #--------------------------------------------------------------------------
  def self.core_sdk_install
    begin
      sdk = SDK::Version
      return true
    rescue
      return false
    end
  end
  #--------------------------------------------------------------------------
  # * prüft ob der VX benutzt wird
  #--------------------------------------------------------------------------
  def self.core_vx_install
    return true if File.exist?("Game.rvproj")
    return false if File.exist?("Game.rxproj")
    return true if File.exist?("Data\\System.rvdata")
    return false if File.exist?("Data\\System.rxdata")
    begin
      dummy = Graphics.width
      return true
    rescue
      return false
    end
  end
  #--------------------------------------------------------------------------
  # * ruft letzes config auf, wenn es exisitert
  #--------------------------------------------------------------------------
  def self.config(kurzname=@core_last_modul)
    #modul da und aktiv?
    return if kurzname.nil? or @core_modules[kurzname].nil? or @core_modules[kurzname].activ == false
   Â
    #set config
    if methods.include?(kurzname+"_config")
      send(kurzname+"_config")
    end
     Â
    #set lang
    if methods.include?(kurzname+"_lang")
      send(kurzname+"_lang")
    end  Â
  end
  #--------------------------------------------------------------------------
  # * startsprungstelle
  #--------------------------------------------------------------------------
  def self.core_cs_start
    core_log("CLEAR") if self["core_log_clear"]
    #schreib den kopf ins log.
    core_log("=")
    core_log(self["core_log_header"])
    core_log("-")
    core_log(self["core_log_body"])
    core_log("-")
    #set language
    L.default = self["core_lang"]
  end
 Â
  def self.core_cs_lang_change(l)
    APD["core_lang_constants"].each { | key, value |
      temp = key.clone # wird für error gebaucht
      key = key.split("::")
      key = [APD["core_lang_default_constant_modul"]] + key if key.size == 1 && APD["core_lang_default_constant_modul"]
      obj = Object
      key.each_index { |i|
        if i < key.size-1
          if obj.const_defined?(key[i])
            obj = obj.const_get(key[i])
          else
            if APD["core_lang_create_const"]
              obj.const_set(key[i],APD["core_lang_create_const"].new)
              obj = obj.const_get(key[i])
            else
              error = "core_lang_no_const"
              APD.core_info(L.d(error + "_hl",temp),L.d(error + "_body",temp,L[value]),nil)
              break
            end  Â
          end
        else
          if obj.const_defined?(key[i]) || APD["core_lang_set_const"]
            obj.const_set(key[i],L[value])
          else
            error = "core_lang_no_const"
            APD.core_info(L.d(error + "_hl",temp),L.d(error + "_body",temp,L[value]),nil)
          end
        end
      }
    }
  end Â
Â
Â
  #==============================================================================
  # ** APD_core_Modul
  #------------------------------------------------------------------------------
  #  Enthält Angaben zum Modul
  #==============================================================================
  class APD_core_Modul
    #--------------------------------------------------------------------------
    # * Public Instance Variables
    #--------------------------------------------------------------------------
    attr_accessor :name
    attr_reader   :kurzname
    attr_accessor :version
    attr_accessor :fix
    attr_accessor :autor
    attr_accessor :homepage
    attr_accessor :activ
    #--------------------------------------------------------------------------
    # * Object Initialization
    #--------------------------------------------------------------------------
    def initialize(kurzname,version,fix,name=nil,autor=nil,homepage=nil)
      @name = (name.nil?) ? kurzname : name
      @kurzname = kurzname
      @fix = fix
      @version = version
      @autor = autor
      @homepage = homepage
      @activ = true
      @cs = []
    end
    #--------------------------------------------------------------------------
    # * Gibt Angaben vom Modul aus
    #--------------------------------------------------------------------------
    def print
      txt = "#{@name} V#{@version}.#{@fix} (#{@activ})"
      txt += " - #{@autor}" unless @autor.nil?
      txt += " - #{@homepage}" unless @homepage.nil?
      return txt
    end
   Â
    def sdk_register
      if APD["sdk_install"]
        if !APD["sdk_registered_module"].include?(@kurzname)
          SDK.log(print, autor, version, '')
          APD["sdk_registered_module"] << @kurzname
        else
          error, typ = "core_error_double_register", "SDK"
          APD.core_info(L.d(error + "_hl",typ),L.d(error + "_body",kurzname,typ),kurzname)
        end
      else
        #error -> keine registerung möglich
      end
    end
   Â
    def macl_register
      if APD["macl_install"]
        if !MACL::Loaded.include?(@kurzname)
          MACL::Loaded << @kurzname
          APD["macl_registered_module"] << @kurznameÂ
        else
          error, typ = "core_error_double_register", "MACL"
          APD.core_info(L.d(error + "_hl",typ),L.d(error + "_body",kurzname,typ),kurzname)
        end
      else
        #error -> keine registerung möglich
   end
    end
   Â
    def add_cs(name)
      @cs << name unless @cs.include?(name)
    end
  end
 Â
end
Â
#--------------------------------------------------------------------------
# * Neue Klasse
#--------------------------------------------------------------------------
Â
module L #language
  @lang = {}
  #--------------------------------------------------------------------------
  # * Registiert neue Sprachen
  #--------------------------------------------------------------------------
  def self.add_lang(kurz,voll,standard=false)
    #exisitert die sprache schon?
    return unless @lang[kurz].nil?
    @lang[kurz] = { "lang_#{kurz}" => voll }
    APD.cs_lang_add(kurz)
    self.default = kurz if standard == true
  end
  #--------------------------------------------------------------------------
  # * Gibt die Standardsprache raus
  #--------------------------------------------------------------------------
  def self.default
    return @default
  end
  #--------------------------------------------------------------------------
  # * Setzt Standardsprache
  #--------------------------------------------------------------------------
  def self.default=(new)
    if @default.to_a != new.to_a
      new = new.to_a
      new.each_index { |n|
        unless @lang.has_key?(new[n])
          if APD["core_lang_add_auto"]
            add_lang(new[n],new[n])
          else
            APD.core_info(L["core_lang_set_error_hl"],L.d("core_lang_set_not_set",new[n]))
            new[n] = nil
          end
        end
        if new.nitems == 0
          APD.core_info(L["core_lang_set_error_hl"],L["core_lang_set_no_lang"])
          return
        end
      }
      APD.cs_lang_change(@default = new)
    end
  end
  #--------------------------------------------------------------------------
  # * Get langtext
  #--------------------------------------------------------------------------
  def self.[](id)
    return get(id)
  end
  #--------------------------------------------------------------------------
  # * Add langtext
  #--------------------------------------------------------------------------
  def self.[]=(id, value)
   Â
    #was ist es für ein wert?
    value = value.to_a
    default = self.default.to_a
    modul = APD.instance_variable_get("@core_last_modul")
    if value.size > default.size
      APD.core_info(L["core_lang_set_lkeys_hl"],L.d("core_lang_set_lkeys_more",default.size,value.size),modul)
    elsif value.size < default.size
      APD.core_info(L["core_lang_set_lkeys_hl"],L.d("core_lang_set_lkeys_less",value.size,default.size),modul)     Â
    end
    [value.size,default.size].min.times { |i|
      #schon voll?
      unless default[i].nil? # nil werte in der sprache werden übergangen
        if @lang[default[i]][id] != nil && @lang[default[i]][id] != value[i]
          APD.core_info(L["apd_lang_double_hl"],L.d("apd_lang_double_body",default[i],id,@lang[default[i]][id], value[i]),modul)
          next
        end
        @lang[default[i]][id] = value[i]
      end
    }
  end
  #--------------------------------------------------------------------------
  # * Get langliste
  #--------------------------------------------------------------------------
  def self.get_lang
    erg = []
    set = []
    for i in @lang.keys
      set.push(i)
      erg.push(get("lang_#{i}",i))
    end
    return erg,set
  end
  #--------------------------------------------------------------------------
  # * Get langteil
  #--------------------------------------------------------------------------
  def self.get(id,lang=nil, *arg)
    lang = self.default if lang.nil?
    lang = lang.find { | n | !n.nil? } if lang.is_a?(Array) # wählt erste gültige sprache
    #textladen
    if self.exist?(id,lang)
      text = @lang[lang][id].clone
      while text.include?(sprintf("#%.3d#",i = (i || 0) + 1))
      end # count #zahl#
      i-=1
    else
      text = "lang_"+id+"_?"
   n=0
      arg.each_index { |n| text += sprintf(", #%.3d#",n+1) }
      i=n
    end
    #ersetzen
    [i,arg.size].min.times { |n| text.gsub!(sprintf("#%.3d#",n+1)) { arg[n] } if arg[n] }
    #standardersetzungen
    #text.gsub!(/\\g\[([0-9]+)\]/) { $game_variables[$1.to_i] }
    APD.core_log(text) if self.exist?(id,lang) == false
    return text
  end
  #--------------------------------------------------------------------------
  # * exisitert das folgende?
  #--------------------------------------------------------------------------
  def self.exist?(id,lang=nil)
    lang = self.default if lang.nil?
    lang = lang.find { | n | !n.nil? } if lang.is_a?(Array) # wählt erste gültige sprache
    return !(@lang[lang].nil? or @lang[lang][id].nil?)
  end
  #--------------------------------------------------------------------------
  # * Change2
  #--------------------------------------------------------------------------
  def self.d(id, *arg)
    return get(id,nil, *arg)
  end
  #--------------------------------------------------------------------------
  # * Change
  #--------------------------------------------------------------------------
  def self.c(id, *arg)
    arg.collect! { |i| self[i] if i }
    return get(id,nil,*arg)
  end
end
Â
# eval protokollierung
def evals(code)
  return eval(code)
end
Â
#const setzen
APD.core_config
APD.core_lang
#registieren
APD.core_register("core",0.9,0,"APD - Abt Ploutôn Database","Abt Ploutôn & Hanmac","http://www.rpg-studio.de/itzamna/node/44")
APD.core_register_cs("cs_start","core")
APD.core_register_cs("cs_change_config","core")
APD.core_register_cs("cs_lang_add","core")
APD.core_register_cs("cs_lang_change","core")
#Graphicsaddon
if APD["core_vx"] == false
  module Graphics
    def self.width
      return 640
    end
    def self.height
      return 480
    end
  end
end
Compatibility
you can use it with VX and XP
and with SDK and with MACL
please Post this under the sdk scripts and above your scripts
Credits and Thanks
credits at me and Abt Ploutôn
Author's Notes
it is still in development so if you use it please notic that you use it on your own risk
Terms and Conditions
you can use it in free games if you credit us
Source:
http://www.rpg-studio.de/itzamna/node/44