Envision, Create, Share

Welcome to HBGames, a leading amateur game development forum and Discord server. All are welcome, and amongst our ranks you will find experts in their field from all aspects of video game design and development.
Register

APD - Abt Ploutôn Database [Review]

Latest Post

hanmac

Member

128
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

  • 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
[/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
 

hanmac

Member

128
i use this to make scripts for both makers

but my scripts to "bugy" to show something, this stuff is still under development
 

hanmac

Member

128
as sample:
an cs for Input.update
Code: 
 

module Input

#---------------------------------------------------------------------------

# * Alias #---------------------------------------------------------------------------

  class << self

    alias_method(:apd_update, :update) unless method_defined?(:apd_update)

  end

#--------------------------------------------------------------------------

# * Aktualisiert alle Teile

#--------------------------------------------------------------------------

  def self.update

    apd_update

    APD.cs_input_update #<<<< the new cs

  end

end

notic that the method APD.cs_input_update dont exist
the method need "cs_" at first to be a Code Sniplet

to use it:

define methods with include the name of the cs
like "aqs_cs_input_update"
Code: 
 

module APD

def self.aqs_cs_input_update

#code

end

end


and if you run APD.cs_input_update it also run APD.aqs_cs_input_update

PS: with APD["cs_position"] you can set in witch order of CS are started (default = 0)
 
You must log in or register to reply here.

Share this page

Thank you for viewing

HBGames is a leading amateur video game development forum and Discord server open to all ability levels. Feel free to have a nosey around!

Discord

Join our growing and active Discord server to discuss all aspects of game making in a relaxed environment. Join Us

RPG Maker

  • Support & Help
    •
  • Tutorials
    •
  • Plugins - MZ, MV
    •
  • Scripts - Ace, VX, XP
    •
  • Resources
    •

    Content

  • Our Games
    •
  • Games in Development
    •  Emoji by Twemoji.
    Top