a.sk

Created by CoffeeRequired

Other available versions. Ordered by newest to oldest versions:

Just so you know, we don't know the file format for every file. If it's just a bunch of random characters, it's probably a .zip or .jar.

import:
    ch.njol.skript.ScriptLoader
    ch.njol.skript.ScriptLoader$ScriptInfo
    java.nio.file.Files
    java.io.File
    java.io.FilenameFilter
    ch.njol.skript.util.FileUtils
    java.nio.file.StandardCopyOption
    ch.njol.skript.log.RetainingLogHandler
    ch.njol.skript.log.TimingLogHandler
    ch.njol.util.OpenCloseable
    java.util.logging.Level
    java.nio.file.Paths
    ch.njol.skript.classes.Changer$ChangerUtils
    ch.njol.skript.classes.Changer$ChangeMode

options:
    static-sk-loader: ScriptLoader
    prefix: * &6eSK
    debug: false
    

expression:
    patterns:
        FOLDER
        FILE
        LOAD
        UNLOAD
        RELOAD
        PREFIX-DISABLED
    get:
        if pattern = 1:
            return "FOLDER"
        else if pattern = 2:
            return "FILE"
        else if pattern = 3:
            return "LOAD"
        else if pattern = 4:
            return "UNLOAD"
        else if pattern = 5:
            return "RELOAD"
        else if pattern = 6:
            return "-"

function esk_error_handler(error-handler: Object, s: sender = console):
    set {_file-regex} to "\s(?=\(.+(\.sk), )"
    set {_$} to "<##eeea04>"
    loop ...{_error-handler}.getErrors():
        if loop-value.getLevel() = Level.SEVERE:
            set {_$} to "<##a70808>"

        set {_file-e::*} to regex loop-value.toString() split at {_file-regex}
        set {_file-name} to (1st element of ((2nd element of ({_file-e::2} split at "(")) split at ", "))
        set {_line} to (1st element of ((2nd element of ({_file-e::2} split at "line ")) split at ":")) parsed as number
        set {_final-error::1} to (join {_$} and {_file-e::1})
        set {_final-error::2} to (join "&7" and {_file-e::2})
        set {_Path} to (join "plugins/", {_file-name}.replaceAll(".[.]\\", ""))
        set {_lines::*} to ...Files.readAllLines(Paths.get({_Path}))
        set {_final::1.0} to "&7(Line %{_line}-1%) &f%{_lines::%{_line}-1%} ? ""%"
        set {_final::1.1} to "&7(Line %{_line}%) <##dd641d>%{_lines::%{_line}%} ? ""%"
        set {_final::1.2} to "&7(Line %{_line}+1%) &f%{_lines::%{_line}+1%} ? ""%"
        set {_err} to {_error-handler}.getNumErrors()
        set {_err-m} to "An &c1&f error"
        set {_err-m} to "An &c%{_err}%&f errors" if {_err} > 1

        send "{@prefix} &c&l!&f -> %{_err-m}% in the skript &e%{_Path}%" to {_s}
        send "&c%{_file-e::1}%" to {_s}
        send "" to {_s}
        send formatted {_final::*} to {_s}
        send "","{@prefix} &a&l* &fLoaded &f%{_Path}% &7in &a%{ESK::TIMMING}.getTimeTaken()%ms &7with &c%{_err}%&7 error" to {_s}
        send "{@prefix} &a&l* &fSkript &e%{_Path}%&f &cwasn't &csuccessfully enabled" to {_s}





function esk_parser(file: Object, newfile: Object, s: sender, type: String = "LOAD") :: boolean:
    set {_HANDLER} to new RetainingLogHandler().start()
    set {ESK::TIMMING} to new TimingLogHandler().start()
    set {_OpenCloseable} to new OpenCloseable({_HANDLER}, {ESK::TIMMING})

    if {_type} = LOAD:
        Files.move({_file}.toPath(), {_newfile}.toPath(), StandardCopyOption.REPLACE_EXISTING)
        {@static-sk-loader}.loadScripts({@static-sk-loader}.loadStructure({_newfile}))
    if {_type} = RELOAD:
        set {_new} to new File(join "plugins\Skript\scripts\..\..\..\", "%{_newfile}%")
        {@static-sk-loader}.reloadScript({_new})
    if ({_HANDLER}.getNumErrors() > 0):
        esk_error_handler({_HANDLER}, {_s})
        return false
    return true



function esk_unload_script(loader: Object, enabled-file: Object, disabled-file: Object, s: sender):
    set {_new} to new File(join "plugins\Skript\scripts\..\..\..\", "%{_enabled-file}%")
    {_loader}.unloadScript({_new})
    Files.move({_enabled-file}.toPath(), {_disabled-file}.toPath(), StandardCopyOption.REPLACE_EXISTING)
    send "{@prefix} &c&l* &fSkript &e%{_disabled-file}.getPath()%&f unload &asuccessfully" to {_s}

    send last java exception to console



function esk_debug_loader(type: string, enabled: Object, disabled: Object, sender: sender):
    if {_type} = LOAD:
        send "load" to {_sender}
        send "&aEnabled: &f%{_enabled}%" to {_sender}
        send "&cDisabled: &f%{_disabled}%" to {_sender}
    if {_type} = UNLOAD:
        send "unload" to {_sender}
        send "&cDisabled: &f%{_disabled}%" to {_sender}
        send "&aEnabled: &f%{_enabled}%" to {_sender}
    if {_type} = RELOAD:
        send "reload" to {_sender}



effect esk (1:load|0:unload|2:reload) [custom] s(c|k)ript[[s] from] %string% [%sender%]:
    trigger:
        set {_f} to new File(expr-1)
        set {_TYPE} to FILE if expr-1 end with ".sk" else FOLDER
        if parse mark = 1:
            set {_STATUS} to LOAD
        else if parse mark = 0:
            set {_STATUS} to UNLOAD
        else if parse mark = 2:
            set {_STATUS} to RELOAD
        set {_s} to expr-2

        if {_TYPE} = FILE:
            if {_STATUS} = LOAD:
                #*
                #* @var {_disabledfile} representing the disabled file
                #* @var {_enabledfile} representing the new enabled / loaded file
                #*
                set {_enabledfile} to {_f}
                set {_disabledfile} to new File(join {_f}.getParent(), "/", PREFIX-DISABLED,{_f}.getName())

                loop ...new File({_enabledfile}.getParent()).listFiles():
                    if loop-value.getName().matches(".*.*\.sk$"):
                        if loop-value.getName() = {_disabledfile}.getName():
                            if esk_parser({_disabledfile}, {_enabledfile}, {_s}) = true:
                                if {-foundError} = true:
                                    send "{@prefix} &a&l* &fSkript &e%{_enabledfile}.getName()%&f wasn't successfully enabled" to {_s}
                                else:
                                    send "{@prefix} &a&l* &fSkript &e%{_enabledfile}.getName()%&f was successfully enabled" to {_s}
                        else:
                            send "{@prefix} &c&l! &fThis skript &e%{_enabledfile}.getPath()%&f is already enabled" to {_s}


                esk_debug_loader(LOAD, {_enabledfile}, {_disabledfile}, {_s}) if {@debug} = true

        
            if {_STATUS} = UNLOAD:
                #*
                #* @var {_disabledfile} representing the disabled file
                #* @var {_enabledfile} representing the new enabled / loaded file
                #*
                set {_enabledfile} to {_f}
                set {_disabledfile} to new File(join {_f}.getParent(), "/", PREFIX-DISABLED,{_f}.getName())

                loop ...new File({_enabledfile}.getParent()).listFiles():
                    if loop-value.getName().matches(".*.*\.sk$"):
                        if loop-value.getName() = {_enabledfile}.getName():
                            esk_unload_script({@static-sk-loader},{_enabledfile},{_disabledfile}, {_s})
                        else:
                            send "{@prefix} &c&l! &fThis skript &e%{_disabledfile}.getPath()%&f is already &cdisabled" to {_s} 

                esk_debug_loader(UNLOAD, {_enabledfile}, {_disabledfile}, {_s}) if {@debug} = true

            if {_STATUS} = RELOAD:
                #*
                #* @var {_disabledfile} representing the disabled file
                #* @var {_enabledfile} representing the new enabled / loaded file
                #*
                set {_enabledfile} to {_f}
                set {_disabledfile} to new File(join {_f}.getParent(), "/", PREFIX-DISABLED,{_f}.getName())
                if esk_parser({_disabledfile}, {_enabledfile}, {_s}, RELOAD) = true:
                    send "{@prefix} &a&l* &fReloaded skript &e%{_enabledfile}.getName()%&f was successfully enabled" to {_s}
        


                    
        if {_TYPE} = FOLDER:
            if {_STATUS} = LOAD:
                #*
                #* @var {_disabledfile} representing the disabled file
                #* @var {_enabledfile} representing the new enabled / loaded file
                #*
                
                loop ...new File(expr-1).listFiles():
                    if loop-value.getName().matches(".*.*\.sk$"):
                        if loop-value.getName() start with PREFIX-DISABLED:
                            set {_disabledfile} to loop-value
                            set {_enabledfile} to new File(join loop-value.getParent(), "/", loop-value.getName().replaceAll(PREFIX-DISABLED, ""))
                            esk_parser({_disabledfile}, {_enabledfile}, {_s}) = true:
                                send "{@prefix} &a&l* &fSkript &e%{_enabledfile}.getName()%&f was &asuccessfully enabled" to {_s}
                        else:
                            send "{@prefix} &c&l! &fThis skript &e%loop-value.getPath()%&f is already enabled" to {_s}

            if {_STATUS} = UNLOAD:
                #*
                #* @var {_disabledfile} representing the disabled file
                #* @var {_enabledfile} representing the new enabled / loaded file
                #*
                
                loop ...new File(expr-1).listFiles():
                    if loop-value.getName().matches(".*.*\.sk$"):
                        if loop-value.getName() doesn't start with PREFIX-DISABLED:
                            set {_enabledfile} to loop-value
                            set {_disabledfile} to new File(join loop-value.getParent(), "/", PREFIX-DISABLED, loop-value.getName())
                            esk_unload_script({@static-sk-loader},{_enabledfile},{_disabledfile}, {_s})
                        else:
                            send "{@prefix} &c&l! &fThis skript &e%loop-value.getPath()%&f is already &cdisabled" to {_s}

            if {_STATUS} = RELOAD:
                #*
                #* @var {_disabledfile} representing the disabled file
                #* @var {_enabledfile} representing the new enabled / loaded file
                #*
                set {-un} to true
                loop ...new File(expr-1).listFiles():
                    if loop-value.getName().matches(".*.*\.sk$"):
                        if loop-value.getName() doesn't start with PREFIX-DISABLED:
                            set {-enabledfile} to loop-value
                            set {_disabledfile} to new File(join loop-value.getParent(), "/", PREFIX-DISABLED, loop-value.getName())

                            if esk_parser({_disabledfile}, {-enabledfile}, {_s}, RELOAD) = false:
                                set {-un} to false

                if {-un} = true:
                    send "{@prefix} &a&l* &fAll Skripts in the folder &e%{-enabledfile}.getParent()%&f was &asuccessfully reloaded" to {_s}
                else:
                    send "{@prefix} &a&l* &fAll Skripts in the folder &e%{-enabledfile}.getParent()%&f wasn't &csuccessfully reloaded" to {_s}
        send last java exception to {_s}