Jak dodać wspomaganie skript dla pluginu

Najpierw w buildpathu, jak do zwykłego pluginu, dodajemy zwykły plik z pluginem Skript.jar

Później robimy sobie najlepiej dwie klasy, niech to będą Main i SkIntegrateEffect
W klasie main robimy zwykłe onEnable() i po tym dodajemy to:

Skript.registerAddon(this);
Skript.registerEffect([druga klasa].class, "[wzór]");    

W miejsce [wzór] dajemy jak effect ma być wpisywany w skripcie, dla przykładu niech to bedzie "daj jablko %player%"
(W miejsce %player% można dać inne zmienne takie jak %number%, %string% itd.(W sumie chyba można dać wszystko bo później to definiujemy))
W miejsce [druga klasa] dajemy klasę, która połączy plugin ze skriptem, u nas to będzie "SkIntegrateEffect
No i mamy 

Skript.registerEffect(SkIntegrateEffect.class, "daj jablko %player%");

Później w drugiej klasie usuwamy wszystko oprócz package i zaczynamy "public class [druga klasa] extends Effect{". Gdy wpiszemy nazwę naszej klasy w miejsce [druga klasa] i klikniemy na końcu enter pokaże nam się możliwość importu nie zaimplementowanych metod, zamiast je implementować wklejamy to:

    private Expression<Player> player; //AD1
    @SuppressWarnings("unchecked")
    @Override
    public boolean init(Expression<?>[] expr, int matchedPattern, Kleenean paramKleenean, ParseResult paramParseResult) {
        player = (Expression<Player>) expr[0];  //AD2
           return true;
    }
    @Override
    public String toString(@Nullable Event e, boolean b) {
        return null;
    }
    @Override
    protected void execute(Event e) {
//         AD3
    }

AD1: Tutaj w podobny sposób musimy wpisać wszystkie nasze zmienne, np. dla stringa "private Expression<String>s;" robi nam stringa z nazwą "s"
AD2: Tutaj nadajemy wartości naszym zmiennym, np. "s = (Expression<String>) expr[0];" ustawia nam stringa "s" na wartość wyrażenia pierwszego, tj. jak mamy "powiedz %string% dla %player%" to expr[0] jest String, expr[1] jest Player
AD3: Tutaj wpisujemy nasz kod, czyli to co ma się nam wykonywać gdy w skripcie zostanie to napisane.

Dla przykładu dajmy graczowi jabłko, nasz kod będzie wyglądał tak:

@Override
protected void execute(Event e) {
    Player p = (Player) player.getSingle(e); //Zamieniamy wyrazenie na gracza
    p.getInventory().addItem(new ItemStack(Material.APPLE));
}    

Więc jak teraz w skripcie napiszemy "daj jablko arg-1" to jak zrobiliśmy komendę to jeśli arg-1 jest graczem to da mu jabłko (jak nie to wywali błąd)
Jeśli ktoś nie zrozumiał to daje cały kod tych dwóch klas:
(do zmienienia tylko nazwy klas i package oraz skript w buildpathie)

package me.lloydpl.skaddon;
import org.bukkit.plugin.java.JavaPlugin;
import ch.njol.skript.Skript;
public class Main extends JavaPlugin{
    @Override
    public void onEnable(){
        Skript.registerAddon(this);
        Skript.registerEffect(SkIntegrateEffect.class, "daj jablko %player%");
    }
}

package me.lloydpl.skaddon;
import javax.annotation.Nullable;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.Event;
import org.bukkit.inventory.ItemStack;
import ch.njol.skript.lang.Effect;
import ch.njol.skript.lang.Expression;
import ch.njol.skript.lang.SkriptParser.ParseResult;
import ch.njol.util.Kleenean;
public class SkIntegrateEffect extends Effect{
    private Expression<Player> player;
    @SuppressWarnings("unchecked")
    @Override
    public boolean init(Expression<?>[] expr, int matchedPattern, Kleenean paramKleenean, ParseResult paramParseResult) {
        player = (Expression<Player>) expr[0];
        return true;
    }
    @Override
    public String toString(@Nullable Event e, boolean b) {
        return null;
    }
    @Override
    protected void execute(Event e) {
        Player p = (Player) player.getSingle(e); //Zamieniamy wyrazenie na gracza
        p.getInventory().addItem(new ItemStack(Material.APPLE));
    }
}

Tak samo jak w effectach konfigurujemy buildpatha. (zwykły bukkit i .jar pluginu Skript)

Później robimy sobie dwie klasy Main i SkIntegrateCondition i w onEnable() dajemy:

    Skript.registerAddon(this);
    Skript.registerCondition([druga klasa].class, [wzór]);

W miejscu [druga klasa] dajemy nazwe naszej klasy co będzie łączyć nasz plugin ze skriptem, czyli w naszym przypadku SkIntegrateCondition, a we wzorze dajemy jak nasz warunek będzie wyglądać, zróbmy sobie czy liczba x będzie podzielna przez y czyli "%number% is divisible by %number%". 

Czyli będzie to wyglądać tak:

    Skript.registerAddon(this);
    Skript.registerCondition(SkIntegrateCondition.class, "%number% is divisible by %number%");

Później w z drugiej klasy usuwamy wszystko oprócz package i wklejamy public class [druga klasa] extends Condition{
Po wpisaniu nazwy klasy w polu [druga klasa] i kliknięcia na końcu enterem, zamiast implementować i zmieniać można wkleić to:

    private Expression<Number> num1;  //AD1
    private Expression<Number> num2;  //AD1
    @SuppressWarnings("unchecked")
    @Override
    public boolean init(Expression<?>[] expr, int i, Kleenean kl, ParseResult pr) {
        num1 = (Expression<Number>) expr[0];  //AD2
        num2 = (Expression<Number>) expr[1];  //AD2
        return true;
    }
    @Override
    public String toString(@Nullable Event e, boolean b) {
        return null;
    }
    @Override
    public boolean check(Event e){
//      AD3
    }

AD1. Tutaj wpisujemy wszystkie nasze zmienne jakie uwzględniliśmy w kodzie skripta, np.   "private Expression<Number> num1;" tworzy nam liczbę z nazwą num1
AD2. Tutaj ustawiamy wartości naszych zmiennych, np. "num1 = (Expression<Number>) expr[0];" ustawia nam zmienną num1 na wartość wyrażenia expr[0], tj. Jak mamy "powiedz %string% razy %number%" to naszym expr[0] jest String, a expr[1] jest number (Uwzględniamy to przy tworzeniu zmiennej)
AD3. Tutaj wpisujemy nasz kod, który będzie porównywał to co mu zadamy, mieliśmy sprawdzić czy liczba x jest podzielna przez y więc kod będzie wyglądał tak:
(Możemy też porównywać jedną wartość np. czy n > 0 to wtedy nam zreturnuje true, a jak n < 0 to zreturnuje nam false)

    public boolean check(Event e){
        int n1 = num1.getSingle(e).intValue();  //Zamieniamy wyrażenia na inty
        int n2 = num2.getSingle(e).intValue();
        if(n1 % n2 == 0) {
            return true;
        }
        else {
            return false;
    }

I jak wpiszemy w skripcie "if arg-1 is divisible by arg-2" to sprawdzi nam czy argument 1 jest podzielny przez 2, jak damy arg-1 na 21 i arg-2 na 3 to zreturnuje nam true, a jak arg-1 na 21 i arg-2 na 4 to zreturnuje nam false

Znowu, jak ktoś nie nie zrozumiał to macie całe klasy:
(do zmienienia tylko nazwy klas i package oraz skript w buildpathie)

package me.lloydpl.skaddon;
import org.bukkit.plugin.java.JavaPlugin;
import ch.njol.skript.Skript;
public class Main extends JavaPlugin{
    @Override
    public void onEnable(){
        Skript.registerAddon(this);
        Skript.registerCondition(SkIntegrateCondition.class, "%number% is divisible by %number%");
    }
}

package me.lloydpl.skaddon;
import javax.annotation.Nullable;
import org.bukkit.event.Event;
import ch.njol.skript.lang.Condition;
import ch.njol.skript.lang.Expression;
import ch.njol.skript.lang.SkriptParser.ParseResult;
import ch.njol.util.Kleenean;
public class SkIntegrateCondition extends Condition{
    private Expression<Number> num1;
    private Expression<Number> num2;
    @SuppressWarnings("unchecked")
    @Override
    public boolean init(Expression<?>[] expr, int i, Kleenean kl, ParseResult pr) {
        num1 = (Expression<Number>) expr[0];
        num2 = (Expression<Number>) expr[1];
        return true;
    }
    @Override
    public String toString(@Nullable Event e, boolean b) {
        return null;
    }
    @Override
    public boolean check(Event e){
        int n1 = num1.getSingle(e).intValue();
        int n2 = num2.getSingle(e).intValue();
        if(n1 % n2 == 0) {
            return true;
        }else {
            return false;
        }
    }
}

Do buildpathów dodajemy plik .jar (zwykły plugin skript), tworzymy dwie klasy np. Main i SkIntegrateEvents. W klasie main musimy zarejestrować event i jego składnię tym kodem, który wpiszemy w onEnable():

Skript.registerEvent("[nazwa eventu]", SimpleEvent.class, [klasa eventu].class, "[składnia eventu]");

W polu [nazwa eventu] najlepiej wpisać nazwę eventu, dla przykładu zrobimy sobie event "sheep shear" więc w to pole wpisujemy tą nazwę.
W polu [klasa eventu] dodajemy klasę eventu, który chcemy zintegrować ze skriptem, na naszym przykładzie "sheep shear" czyli ścinanie wełny z owcy klasa eventu nazywa się PlayerShearEntityEvent, więc to tam wpisujemy (Nazwa klasy eventu jest ta sama jakbyśmy chcieli zrobić normalny event w pluginie, różnica jest taka że nie musimy implementować Listenera i registerować eventów w bukkicie)
W polu [składnia eventu] wpisujemy składnię, jaką będziemy pisać w skripcie, dla naszego przykładu niech to będzie "sheep shear" ("on" nie trzeba wpisywać, sam skript to doda)

Klasa Main będzie wyglądać mniej więcej tak, ale wrócimy jeszcze do niej:

package me.lloydpl.skaddon;
import org.bukkit.plugin.java.JavaPlugin;
import ch.njol.skript.Skript;
import ch.njol.skript.lang.util.SimpleEvent;
import org.bukkit.event.player.PlayerShearEntityEvent;
public class Main extends JavaPlugin{
    @Override
    public void onEnable(){
        Skript.registerAddon(this);    
        Skript.registerEvent("sheep shear", SimpleEvent.class, PlayerShearEntityEvent.class, "(sheep|) shear(ing|)");
    }    
}

Teraz w klasie SkIntegrateEvents (czyli naszej drugiej) dodajemy "extends Event", czyli będzie to wyglądać tak:

"public class SkIntegrateEvents extends Event{"

Zamiast "SkIntegrateEvent" powinna być nazwa klasy, w której ów kod piszecie.

Klikamy na końcu tej linijki enter i IDE będzie chciało od nas implementacji niezbędnych rzeczy, możemy to zrobić ponieważ nie będzie nam to zawadzać, a resztę kodu i tak będziemy musieli sami napisać.

Gdy już zaimplementujemy metode getHandlers() (Jeśli tego nie masz to skopiuj to sobie z całej klasy która będzie niżej) to piszemy w niej to:

    public static void registerNewEvents(){

To będzie nam potrzebne gdy będziemy chcieli aktywować kod z tej klasy. W klasie Main dopisujemy linijkę:

SkIntegrateEvents.registerNewEvents();

(Jesteśmy w klasie Main i robimy to dla drugiej klasy o nazwie SkIntegrateEvents)

Teraz w drugiej klasie w metodzie "registerNewEvents()" dopisujemy to:

        EventValues.registerEventValue([klasa eventu].class, [return].class, new Getter<[return], [klasa eventu]>(){
            @Override
            public [return] get([klasa eventu] e) {
                return e.get[return]();
            }
        }, 0);

W polu [klasa eventu] wpisujemy klasę eventu który chcemy zarejestrować, chcieliśmy zrobić event "on sheep shear" to dajemy zwykłą bukkitową klasę "PlayerShearEntityEvent"
W polu [return] wpisujemy to co chcemy aby nam skript returnował. Zreturnować można to co można pobrać z eventu, lista returnów pojawi nam się kiedy w linijce
return e.get[return]();" wpiszemy "return e" i dopiszemy do tego ".get", IDE powinno pokazać listę rzeczy które można zgetować - czyli później zreturnować. Dla przykładu jak piszemy "return e.get" to IDE nam pokaże dużo rzeczy, dla przykładu, jeśli wybraliście event z klasy "PlayerShearEntityEvent" to powinien być Player, IDE wyświetli nam linijkę
"getPlayer(): Player - PlayerEvent". To drugie co nam wypisze IDE to rzecz którą możemy zreturnować, zatwierdzamy enterem i wpisujemy ją w każde pozostałe pole [return].
Jak chcemy zreturnować Playera to kod będzie wyglądał tak:

        EventValues.registerEventValue(PlayerShearEntityEvent.class, Player.class, new Getter<Player, PlayerShearEntityEvent>(){
            @Override
            public Player get(PlayerShearEntityEvent e) {
                return e.getPlayer();
            }
        }, 0);

Z tego eventu możemy zreturnować także Entity, do tego kopiujemy i wklejamy to samo jak poprzednio tylko zmieniamy pola [klasa eventu] na "PlayerShearEntityEvent", a pola [return] na "Entity", a w linijce "return e.get[return]();" wpisujemy "return e.getEntity();"

Będzie to wyglądać tak:

        EventValues.registerEventValue(PlayerShearEntityEvent.class, Entity.class, new Getter<Entity, PlayerShearEntityEvent>(){
            @Override
            public Entity get(PlayerShearEntityEvent e) {
                return e.getEntity();
            }
        }, 0);
        EventValues.registerEventValue(PlayerShearEntityEvent.class, Player.class, new Getter<Player, PlayerShearEntityEvent>(){
            @Override
            public Player get(PlayerShearEntityEvent e) {
                return e.getPlayer();
            }
        }, 0);

Ten kod będzie nam rejestrował event strzyżenia owiec i będziemy pobrać z niego Entity i Player'a.
Cały kod z dwóch klas (Do zmiany package):

package me.lloydpl.skaddon;
import org.bukkit.plugin.java.JavaPlugin;
import ch.njol.skript.Skript;
import ch.njol.skript.lang.util.SimpleEvent;
import org.bukkit.event.player.PlayerShearEntityEvent;
public class Main extends JavaPlugin{
    @Override
    public void onEnable(){
        Skript.registerAddon(this);        
        Skript.registerEvent("sheep shear", SimpleEvent.class, PlayerShearEntityEvent.class, "sheep shear");
        SkIntegrateEvents.registerNewEvents();
    }    
}

package me.lloydpl.skaddon;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import org.bukkit.event.player.PlayerShearEntityEvent;
import ch.njol.skript.registrations.EventValues;
import ch.njol.skript.util.Getter;
public class SkIntegrateEvents extends Event{
    @Override
    public HandlerList getHandlers() {
        return null;
    }    
    public static void registerNewEvents(){
        EventValues.registerEventValue(PlayerShearEntityEvent.class, Entity.class, new Getter<Entity, PlayerShearEntityEvent>(){
            @Override
            public Entity get(PlayerShearEntityEvent e) {
                return e.getEntity();
            }
        }, 0);
        EventValues.registerEventValue(PlayerShearEntityEvent.class, Player.class, new Getter<Player, PlayerShearEntityEvent>(){
            @Override
            public Player get(PlayerShearEntityEvent e) {
                return e.getPlayer();
            }
        }, 0);
    }
}

Konfigurujemy buildpath jak na początku, tworzymy klasy np. Main i SkIntegrateExpression. Do klasy Main wklejamy to:

Skript.registerAddon(this);        
Skript.registerExpression([druga klasa].class, [return].class, ExpressionType.PROPERTY, [wzór]);

W miejscu [druga klasa] wpisujemy nazwę drugiej klasy, w naszym przypadku SkIntegrateExpression
W miejscu [return] wpisujemy nazwę obiektu, który będziemy returnować (np. String, Integer itp.)
W miejscu [wzór] wpisujemy jak nasze wyrażenie będzie wyglądać. Dla przykładu chcemy zrobić żeby losowało nam liczbę od 0 do n więc wpiszmy tam "rnd num %number%"(n będziemy mogli ustawić w skripcie(wiem że jest taka opcja, ale to tylko przykład))

Po tym powinno to wyglądać tak:

Skript.registerAddon(this);        
Skript.registerExpression(SkIntegrateExpression.class, Integer.class, ExpressionType.PROPERTY, "rnd num %number%");

W naszej drugiej klasie usuwamy wszystko oprócz package'a i wklejamy to:

public class  [druga klasa] extends SimpleExpression<[return]>{

    private Expression<Number> num1; //AD1
    
    @Override
    public Class<? extends [return]> getReturnType() {
        return [return].class;
    }
    @Override
    public boolean isSingle() {
        return true;
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public boolean init(Expression<?>[] expr, int i, Kleenean kl, SkriptParser.ParseResult pr) {
        num1 = (Expression<Number>) expr[0]; //AD2
        return true;
    }
    @Override
    public String toString(@Nullable Event e, boolean b) {
        return null;
    }
    @Override
    protected [return][] get(Event e) {
        //AD 3
        return new [return][]{[result]};
    }
}

W [return] wpisujemy to samo co wpisaliśmy w tym samym polu w klasie Main
AD1: Tutaj definiujemy zmienne. Zamiast private Expression<Number> num1; moze być private Expression<String> s; i wtedy robi nam zmienną która będzie Stringiem z nazwą s
AD2: Tutaj przypisujemy zmiennym wartości, na naszym przykładzie "rnd num %number%" %number% ma indeks 0, dlatego żeby ustawić zmienną num1 na %number% musimy wpisać to num1 = (Expression<Number>) expr[0];. Lub dla zmiennej  private Expression<String> s; wpiszemy  s = (Expression<String>) expr[0];
AD3. Tutaj wpisujemy to co chcemy żeby nam zrobiło ze zmiennymi, możemy je tutaj pobrać, modyfikować itd.
W polu [result] wpisujemy zmienną, która będzie wynikiem wyrażenia (Wynik wyrażenia musi być zmienną [result])

Chcieliśmy żeby nam wybierało losowe liczby z zakresu 0 do n, klasa będzie wyglądać tak:

public class SkIntegrateExpression extends SimpleExpression<Integer>{
    
    private Expression<Number> num1;
    
    @Override
    public Class<? extends Integer> getReturnType() {
        return Integer.class;
    }
    @Override
    public boolean isSingle() {
        return true;
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public boolean init(Expression<?>[] expr, int i, Kleenean kl, SkriptParser.ParseResult pr) {
        num1 = (Expression<Number>) expr[0];
        return true;
    }
    @Override
    public String toString(@Nullable Event e, boolean b) {
        return null;
    }
    @Override
    protected Integer[] get(Event e) {
        Random r = new Random();
        int i = r.nextInt(num1.getSingle(e).intValue()); //Tak się pobiera zmienne jeśli mamy je wyrażone w Expression [zmienna].getSingle(e).[odpowiednia metoda];
        return new Integer[]{i};
    }
}
	

Gotowe, obie klasy:

package me.lloydpl.skaddon;
import org.bukkit.plugin.java.JavaPlugin;
import ch.njol.skript.Skript;
import ch.njol.skript.lang.ExpressionType;
public class Main extends JavaPlugin{
    @Override
    public void onEnable(){
        Skript.registerAddon(this);        
        Skript.registerExpression(SkIntegrateExpression.class, Integer.class, ExpressionType.PROPERTY, "rnd num %number%");
    }    
}

package me.lloydpl.skaddon;
import java.util.Random;
import org.bukkit.craftbukkit.libs.jline.internal.Nullable;
import org.bukkit.event.Event;
import ch.njol.skript.lang.Expression;
import ch.njol.skript.lang.SkriptParser;
import ch.njol.skript.lang.util.SimpleExpression;
import ch.njol.util.Kleenean;
public class SkIntegrateExpression extends SimpleExpression<Integer>{
    
    private Expression<Number> num1;
    
    @Override
    public Class<? extends Integer> getReturnType() {
        return Integer.class;
    }
    @Override
    public boolean isSingle() {
        return true;
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public boolean init(Expression<?>[] expr, int i, Kleenean kl, SkriptParser.ParseResult pr) {
        num1 = (Expression<Number>) expr[0];
        return true;
    }
    @Override
    public String toString(@Nullable Event e, boolean b) {
        return null;
    }
    @Override
    protected Integer[] get(Event e) {
        Random r = new Random();
        int i = r.nextInt(num1.getSingle(e).intValue());
        return new Integer[]{i};
    }
}
	

Ten skrypt daje jabłko wykonującemu jeśli jest graczem lub argumentowi jeśli go wpisał

command /test [<player>]:
    trigger:
        if arg 1 is set:
            daj jablko arg-1
        else:
            if command executor is console:
                send "&cNie mozesz tego wykonac z konsoli!"
                stop
            daj jablko player

Ten skrypt sprawdza czy liczba z argumentu pierwszego jest podzielna przez argument drugi, jeśli tak to dodatek zreturnuje true i wyświetli się wiadomość że jest podzielne, a jeśli nie jest to zreturnuje false i skript wyświetli wiadomość że nie jest

        
command /test2 [<integer>] [<integer>]:
    trigger:
        if arg 1 is set:
            if arg 2 is set:
                if arg-1 is divisible by arg-2:
                    send "%arg-1% jest podzielne przez %arg-2%"
                else:
                    send "%arg-1% nie jest podzielne przez %arg-2%"

Ten skrypt podczas golenia owcy wyśle do gracza wiadomość "kappa", ustawi zmienną {_loc} na lokalizacje owcy i przeteleportuje gracza na lokalizację {_loc}

on sheep shear:
    send "kappa" to player
    set {_loc} to location of sheep
    teleport player to {_loc}

Ten skrypt wyśle do nas randomową liczbę od 0 do n czyli naszego argumentu

command /test3 [<integer>]:
    trigger:
        if arg 1 is set:
            send "%rnd num arg-1%"
            stop
        send "Wprowadz argument!"

Składnię rzeczy, które dodaliśmy możemy zmieniać. Chodzi mi o to że "shear sheep" zarejestruje event tylko w przypadku kiedy w skripcie wpiszemy "on shear sheep", lecz możemy też zrobić we wzorze składni takie coś "shear(ing|) (of sheep|sheep)", wtedy skript zarejestruje event w 6 przypadkach, gdy wpiszemy "on shear sheep", "on shearing sheep", "on shear of sheep", "on shearing of sheep", "on shear" i "on shearing".

Jeszcze tutaj dodam że niektórych eventów nie da się zacancelować. Event, który posłużył mi za przykład da się zcancelować w skripcie, ale są wyjątki takie jak SheepDyeWoolEvent których już się nie da. Niestety nie wiem czemu

W klasie Main, tam gdzie rejestrujemy addony polecam dać to:

if (Bukkit.getPluginManager().getPlugin("Skript") != null) {
    //Tutaj wpisuj Skript.registerAddon(this);
    //i inne żeby nie wczytywało tego jak nie ma pluginu Skript na serwerze
}

Takie dopowiedzenie co do returnowanych zmiennych w expressions, jak chcecie zreturnować liste tu musicie zrobić z niej tablice czyli np. "String[] list = { "xyz", "java"};" zrobi nam listę ze stringami "xyz" i "java", i aby je zreturnować w tym kodzie wpisujemy "return list;". Gdy rejestrujemy ten expression to w klasie returnowanej rzeczy dajemy typ listy jaką będzie nam to returnować, czyli dla listy stringów wpisujemy "String.class".

I jak chcemy pobrać zmienną to jeśli chcemy zgetować liste stringów to we wzorze piszemy "get list of %string%", a w klasie w której będziemy coś robić z tą listą bierzemy ją jako expression<String> i getujemy w ten sposób: "list.getAll().clone();" i to powinno nam dać tablice stringów (String[])

Jeśli nie zadziała wam Integer to dajcie Number