Pierwszy plugin do gry Minecraft w IntelliJ.

Witajcie

Na internecie, jest wiele poradników o tym, jak rozpocząć swoją przygodę z pisaniem wtyczek do Minecrafta.
Jednak zdecydowana większość pokazuje, jak robić to z pomocą IDE o nazwie Eclipse.
Dzisiaj, pokażę jak robić to z pomocą innego programu, mianowicie IntelliJ.

Zaczynajmy!

Minecraft pierwotnie został napisany w języku programowania, który nazywa się Java.
Silnik serwera tej gry, również napisany jest w tym języku i to właśnie Javy będziemy używali do tworzenia pluginów.
Przed rozpoczęciem, należy jednak zapoznać się z podstawami tego języka, naprawdę, będzie Ci o wiele łatwiej
Oto kilka kursów w języku polskim:

• https://javastart.pl/static/darmowy-kurs-java/
• https://kobietydokodu.pl/kurs-javy/

Po zapoznaniu się z kursami i napisaniu kilku podstawowych programów, przejdźmy do części właściwej.

1) Instalacja JRE oraz JDK.
Przed rozpoczęciem tworzenia czegokolwiek w Javie, musimy ją zainstalować.

JRE (Java Runtime Environmen) to środowisko, które pozwala uruchamiać programy napisane w Javie.
Pobieramy je tutaj: https://www.java.com/pl/download/

JDK (Java Development Kit) jest to pakiet, niezbędny do programowania w tym języku. 
Pobieramy je tutaj: http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

Po pobraniu, po prostu je instalujemy. Instalacja jest bardzo intuicyjna.
Sprawdźmy teraz, czy wszystko zrobiliśmy dobrze.
Uruchamiamy wiersz poleceń. (Win + R, a następnie wpisujemy cmd i klikamy Enter)
W oknie, które się ukaże wpisujemy java. Jeśli dobrze zainstalowaliśmy JRE, powinniśmy ujrzeć coś takiego:

Sprawdźmy teraz JDK. Wpisujemy javac. Widzimy coś takiego:

Co teraz? Musimy dodać ścieżkę folderu \bin\ dla JDK do zmiennej środowiskowej Path. 
Jak to zrobić? Na początek, musimy skopiować ścieżkę folderu \bin\.
Wchodzimy w Mój Komputer > Dysk C; > Program Files > Java > jdknumer_wersji > bin i kopiujemy ścieżkę:

Teraz klikamy PPM na Mój Komputer > Właściwości > Zaawansowane Ustawienia Systemu > Zaawansowane > Zmienne Środowiskowe.
Teraz musimy znaleźć zmienną Path. Następnie zaznaczamy ją i klikamy Edytuj.
( Uwaga! Przed jakąkolwiek zmianą radzę zapisać aktualną ścieżkę! )
Teraz, na końcu dopisujemy ; i wklejamy skopiowaną ścieżkę i klikamy Ok > Ok.
Tutaj mały schemat:

Teraz ponownie uruchamiamy wiersz poleceń i wpisujemy javac.
Jeśli zobaczymy coś takiego, to zakończyliśmy instalacje JRE i JDK.

2) Instalacja i uruchomienie IntelliJ.
Intellij pobieramy ze strony https://www.jetbrains.com/idea/. (Wybieramy wersje Community)
Następnie instalujemy pobrany program, tutaj również instalacja jest bardzo intuicyjna. 

Po instalacji, przyszła pora na pierwsze uruchomienie.
Uruchamiamy nasze IDE.
W pierwszym okienku zaznaczamy Do not import settings i klikamy OK.
Następnie według własnego upodobania, wybieramy UI, ciemne lub jasne. Ja wybiorę ciemne.
Teraz wystarczy kliknąć Next i Start using IntelliJ IDEA.
Ukaże nam się takie okno:

Brawo! Przejdźmy do następnej części.

3) Tworzenie projektu.

Klikamy Create New Project. W następnym okienku wybieramy Java.
Teraz musimy wskazać programowi SDK. Klikamy New i podajemy ścieżkę do katalogu z JDK. (C:\Program Files\Java\jdknumer_wersji\)
Klikamy dwa razy Next. Teraz wpisujemy nazwę naszego projektu i podajemy ścieżkę, gdzie zostanie zapisany.
Ja swój projekt nazwę Poradnik.
Klikamy Finish.
Ujrzymy takie oto okno.

Po lewej stronie znajduje się source tree. To właśnie tu będziemy tworzyć wszystkie pliki.
Teraz musimy dodać bibliotekę, będzie nią spigot. Pobieramy go stąd: https://yivesmirror.com/downloads/spigot
Wybieramy wersję, pod którą będziemy pisali. Ja wybiorę 1.13.2.
Teraz musimy dodać to do naszego projektu.
Klikamy File > Project Structure i z menu po lewej stronie wybieramy Libraries.
Następnie klikamy na zielony +, wybieramy Java, podajemy ścieżkę do naszej biblioteki i klikamy OK.
Jeśli wszystko zrobiliśmy dobrze, będzie wyglądać to tak:

Klikamy OK, następnie Apply i OK.
Świetnie! Możemy teraz zacząć pisać

4) Pierwsza komenda.
Na początek stwórzmy package. Jest to tak jakby połka, na której coś trzymamy - klasy. Każda ma unikalną nazwę. 
Stwórzmy go. Klikamy PPM na src, New > Package.
Package nazywamy małymi literami w następujący sposób.
Przypuśćmy, że posiadasz domenę example.com. Twój package będzie nazywał się com.example.poradnik.
Jeśli nie posiadasz lub nie chcesz nazywać packagów domeną, nazwij go po prostu me.twojnick.poradnik.
Ja posiadam domenę ixidi.pl, więc package nazwę pl.ixidi.poradnik.
Wpisujemy nazwę swojego package i kliknij OK.
Jak widzisz, w twoim source tree pojawił się nowy package  

Stwórzmy teraz klasę. Klikamy PPM na nasz package New > Class.
Klasy z kolei nazywamy Wielką literą.
Istnieją dwie szkoły nazywania głównych klas.

1. Main
2. NazwapluginuPlugin, w moim przypadku PoradnikPlugin

Ja nazwę moją główną klasę, PoradnikPlugin.
Wpisujemy nazwę, klikamy i OK. Wszystko powinno wyglądać tak:

Rozszerzmy teraz naszą klasę główną, o klasę JavaPlugin. W tym celu

public class PoradnikPlugin

zmieniamy na 

public class PoradnikPlugin extends JavaPlugin

Ale zaraz, czemu słowo JavaPlugin świeci się na czerwono?
Znaczy to, że musimy zaimportować klasę JavaPlugin.
W tym celu przechodzimy kursorem na czerwone słowo, klikamy LPM, a następnie używamy skrótu ALT + Enter i wybieramy Import class.
Tak właśnie importuje się klasy. Skrót ten przydaje się też w wielu innych rzeczach, warto go zapamiętać 
Dodajmy teraz dwie metody (tak w Javie nazywamy funkcje), dziedziczone z klasy JavaPlugin - onEnable i onDisable.
Jak sama nazwa mówi, wykonują kolejno podczas włączenia i wyłączenia pluginu.
Zacznijmy pisać onEn i tutaj widzimy jedną z wielu zalet Intellij. Podpowiada nam o jaką metodę może nam chodzić.
Wybierzmy public void onEnable() {...} i kliknijmy Enter.
Tak samo zróbmy z onDisable.
Teraz zróbmy coś wewnątrz metod. Wyślijmy np. wiadomości do konsoli.
Służy do tego np. metoda info() klasy Logger. Wywołujemy ją w następujący sposób.

this.getLogger().info("Wiadomosc");

Nasz kod powinien wyglądać tak:

package twojpackage;

import org.bukkit.plugin.java.JavaPlugin;

public class PoradnikPlugin extends JavaPlugin {

    @Override
    public void onEnable() {
        this.getLogger().info("Wiadomosc przy wlaczeniu.");
    }

    @Override
    public void onDisable() {
        this.getLogger().info("Wiadomosc przy wylaczeniu.");
    }
    
}

Ale po co nam plugin, który tylko wysyła wiadomość do konsoli?
Dodamy teraz komendę.
Przejdźmy kursorem pod metodę onDisable, i zacznijmy pisać onCom. Jak widać, tutaj również nasze IDE pomaga.
Metoda o którą nam chodzi to onCommand. Wybierzmy ją. Nasz kod wygląda tak:
 

package twojpackage;

import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.plugin.java.JavaPlugin;

public class PoradnikPlugin extends JavaPlugin {

    @Override
    public void onEnable() {
        this.getLogger().info("Wiadomosc przy wlaczeniu.");
    }

    @Override
    public void onDisable() {
        this.getLogger().info("Wiadomosc przy wylaczeniu.");
    }

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        return true;
    }
}

Tutaj widzimy, że po słowie public, zamiast void, występuje boolean. Znaczy to, że metoda musi zwracać wartość boolean. (Przybiera ona dwie wartości true lub false)
Słowo, które  zatrzymuje dalszą część metody to return.
Jeśli metoda coś zwraca, po słowie return musi pojawić się zwracana wartość.

Metoda onCommand zostanie wywołana gdy ktoś (nie ważne czy gracz, czy konsola) użyje komendy.
Powiedzmy, że chcemy sprawdzić, czy wysyłający jest graczem czy konsolą i wysłać odpowiedni komunikat.
Najpierw sprawdźmy, czy komenda, którą wpisał gracz, to właśnie ta o którą nam chodzi.
Użyjmy do tego metody equalsIgnoreCase() klasy String. Porównuje ona dwa Stringi, bez względu na wielkość liter.
Jako parametr, podajemy ciąg znaków (String), z którym chcemy porównać wartość.
Nazwijmy więc naszą komendę sprawdz. 
Nazwę wpisanej komendy uzyskujemy przez

command.getName()

a więc kod który sprawdzi, czy wpisana komenda to sprawdz będzie wyglądał następujaca

if (command.getName().equalsIgnoreCase("sprawdz")) {
            
}

Wiemy już że komenda się zgadza, sprawdźmy teraz czy wysyłający jest graczem.
Służy do tego słówko instanceof.
Aby więc sprawdzić czy wysyłający jest graczem używamy kodu:

if (sender instanceof Player) {
  
}

Słówko Player świeci się na czerwono. Co musimy zrobić? Zaimportować, tak samo jak robiliśmy to z JavaPlugin.
Wiemy już, że komenda się zgadza, a wysyłający jest graczem.
Wyślijmy teraz wiadomość informującą. Do wysłania wiadomości służy metoda sendMessage().
Aby wysłać więc wiadomość użyjemy kodu:

sender.sendMessage("Jestes graczem!");

Brawo! Chcemy jednak, że jeśli wysyłający jest konsolą, to wyśle się inna wiadomość.
Zastosujemy tutaj else. Kod po else wykonuje się, jeśli warunek w if nie jest spełniony.
Kod na wysłanie wiadomości do konsoli, wygląda tak samo. Musimy zmienić tylko treść.
Nasz kod powinien wyglądać teraz tak:
 

package twojpackage;

import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;

public class PoradnikPlugin extends JavaPlugin {

    @Override
    public void onEnable() {
        this.getLogger().info("Wiadomosc przy wlaczeniu.");
    }

    @Override
    public void onDisable() {
        this.getLogger().info("Wiadomosc przy wylaczeniu.");
    }

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if (command.getName().equalsIgnoreCase("sprawdz")) {
            if (sender instanceof Player) {
                sender.sendMessage("Jestes graczem!");
            } else {
                sender.sendMessage("Jestes konsola!");
            }
        }
        return true;
    }
}

Świetnie! Właśnie skończyliśmy pisać kod.
Teraz stwórzmy plik plugin.yml. Zawiera on informacje potrzebne serwerowi przy ładowaniu pluginu.
Kliknijmy PPM na nasz projekt (nie na src!) New > File i nazwijmy go plugin.yml. Klikamy OK.
Plik plugin.yml musi zawierać trzy podstawowe informacje:

• Nazwę pluginu name
• Wersje pluginu version
• Ścieżkę do klasy main main

Oprócz wymaganych informacji, może również zawierać informacje dodatkowe.
Więcej o tym pliku tutaj: https://bukkit.gamepedia.com/Plugin_YAML/pl
Tak więc mój plugin.yml powinien wyglądać tak:

name: PoradnikPlugin
version: 1.0
main: pl.ixidi.poradnik.PoradnikPlugin

Z racji, iż stworzyliśmy komendę, musimy pokazać serwerowni przy ładowaniu pluginu, że takowa istnieje.
Dodajemy więc następującą frazę:

commands:
  sprawdz:
    description: "Plugin pokazujacy czy jestes graczem"
    aliases: [spr, spraw]
    permission: sprawdz.sprawdz
    permission-message: "Nie masz uprawnien!"

Wymagana jest tylko część do słowa sprawdz. Dodałem tu jednak często używane elementy.
Oznaczają one:

• description - Opis naszej komendy.
• aliases - Aliasy komendy, możemy ją wywołać przez wpisanie sprawdz, spr lub spraw.
• permission - Uprawnienie wymagane do użycia komendy.
• permission-message - Wiadomość, wysyłana jeśli nie posiada się uprawnienia.

Nasz plugin.yml, source tree oraz PoradnikPlugin.java powinny wyglądać tak:

5) Kompilacja

Możemy teraz przejść do czegoś, co wiele osób uważa w Intellij za trudne - kompilacji.
Najprościej mówiąc jest to zamiana kodu źródłowego, na kod maszynowy.
Aby to zrobić, klikamy File > Project Structure. Z menu po lewej stronie wybieramy Artifacts.
Następnie klikamy na zielony +,  JAR > From modules with dependencies.
Wybieramy nasz projekt i klikamy OK.
Teraz wybierzmy ścieżkę, gdzie zostanie zapisany nasz skompilowany plugin.
Po niżej widzimy dwa okienka:

• W pierwszym od lewej, widzimy co będzie zawierał nasz skompilowany plik jar.
• W drugim znajdują się elementy, które możemy dodać.

Na początek usuńmy z naszego jara bibliotekę spigota, jest on naszym serwerem, nie potrzebujemy go skompilowanego w projekcie.
Klikamy na niego PPM > - Remove.
Teraz musimy dodać do projektu nasz plik plugin.yml.
Klikamy na zielony + > File i wybieramy nasz plik plugin.yml.
Powinno wyglądać to tak:

Następnie klikamy Apply i OK.

Stworzyliśmy artefakt, teraz pozostaje tylko skompilować.
Klikamy Build > Build Artifacts wybieramy nasz projekt i klikamy Build.
Teraz musimy chwileczkę poczekać. Kiedy kompilacja dobiegnie końca, w lewym dolnym rogu zobaczymy taki oto napis:

Brawo!
Teraz wystarczy tylko wrzucić nasz skompilowany plik do katalogu plugins naszego serwera i sprawdzić działanie

To by było na tyle, powodzenia