<00:46:46> "LordToxik": package me.marwex.main;

import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerLevelChangeEvent;
import org.bukkit.scheduler.BukkitRunnable;

public class Level implements Listener {

    @EventHandler
    public void onLevelChange(PlayerLevelChangeEvent event) {
        //PROSTE TO TVOJE HEHE

        new BukkitRunnable() {

            @Override
            public void run() {
                //Something what do you want
            }
        }.runTaskLater(Main.instance, 1);

        Main.instance.getConfig();
    }
}
<00:56:17> "LordToxik": package me.marwex.main.xdd;

import org.bukkit.Bukkit;
import org.bukkit.event.Listener;
import org.bukkit.plugin.java.JavaPlugin;
import org.w3c.dom.stylesheets.LinkStyle;

public class Main2 extends JavaPlugin implements Listener {

    public Level2 level2;
    private GUI gui;
    public GUI gui2;

    public void onEnable() {

        Bukkit.getPluginManager().registerEvents(this, this);

        level2 = new Level2(this);
        gui = new GUI(this);
        this.gui2 = gui;
    }

    //alt + insert

    public GUI getGUI() {
        return gui;
    }
}
<00:56:22> "LordToxik": package me.marwex.main.xdd;

import org.bukkit.Bukkit;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerLevelChangeEvent;
import org.bukkit.scheduler.BukkitRunnable;

public class Level2 implements Listener {

    private Main2 main;

    public Level2(Main2 main) {

        this.main = main;

        Bukkit.getPluginManager().registerEvents(this, main);
    }

    @EventHandler
    public void onChhh(PlayerLevelChangeEvent event) {

        new BukkitRunnable() {
            @Override
            public void run() {
                main.getGUI().open(event.getPlayer());
                main.gui2.open(event.getPlayer());
            }
        }.runTaskLater(main, 2);

    }
}
<00:56:26> "LordToxik": package me.marwex.main.xdd;

import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.inventory.Inventory;

public class GUI {

    private Main2 main;

    public GUI(Main2 main) {

        this.main = main;
    }

    public void open(Player player) {

        Inventory inv = Bukkit.createInventory(null, 9*1, "Ahoj More");

        player.openInventory(inv);
    }
}
<01:04:34> "LordToxik": čum
<01:04:34> "LordToxik": anydesk
<01:04:50> "MarweX": xd
<01:06:15> "LordToxik":
    @EventHandler
    public void fallDamage(final EntityDamageEvent event) {
        if((event.getEntity() instanceof Player)) {
            if (event.getCause() == DamageCause.FALL){
                event.setCancelled(true);
            }
        }
    }
<01:06:27> "LordToxik":
    @EventHandler
    public void onCreature(CreatureSpawnEvent event) {
        if(event.getEntityType() != EntityType.ARMOR_STAND ||
        event.getEntityType() != EntityType.PLAYER ||
        event.getEntityType() != EntityType.ARROW ||
        event.getEntityType() != EntityType.ITEM_FRAME) {
            event.setCancelled(true);
        }
    }
<01:07:05> "LordToxik":
    @EventHandler
    public void death(PlayerDeathEvent event) {
        Player deathPlayer = (Player) event.getEntity();
        Player killer = (Player) deathPlayer.getKiller();

        event.setDeathMessage("");
        deathPlayer.setFireTicks(0);
        event.setDroppedExp(0);
        event.getDrops().clear();
        deathPlayer.setVelocity(new Vector());

        addDeath(deathPlayer);

        if(killer != null) {
            deathPlayer.setHealth(20);
            deathPlayer.teleport(spawnLocation);

            killer.setLevel(killer.getLevel()+1);
            killer.playSound(killer.getLocation(), Sound.LEVEL_UP, 0.5F, 0.2F);

            checkClass(killer);
            addKill(killer);
            killer.sendMessage(Commands.prefix + "§7Zabil jsi hrace §b" + deathPlayer.getName());
            deathPlayer.sendMessage(Commands.prefix + "§7Byl jsi zabit hracem §b" + killer.getName());
        }
        if(killer == null) {
            deathPlayer.sendMessage(Commands.prefix + "§7Byl jsi zabit padem do vody.");
        }

        if(deathPlayer.getLevel() >= 2) {
            deathPlayer.setLevel(deathPlayer.getLevel()-1);
        }


        new BukkitRunnable() {
            @Override
            public void run() {
                checkClass(deathPlayer);
            }
        }.runTaskLater(this, 1L);
    }
<01:07:13> "LordToxik":
    @EventHandler
    public void deathOnWater(PlayerMoveEvent event) {
        if (event.getPlayer().getLocation().getBlock().isLiquid()) {
            event.getPlayer().setHealth(0);
            event.getPlayer().setHealth(20);
            event.getPlayer().setVelocity(new Vector());
            event.getPlayer().teleport(spawnLocation);
            checkClass(event.getPlayer());
        }
    }
<01:08:48> "LordToxik":
    public static void checkClass(Player player) {
        if(UsersData.playerClasses.get(player).equals(CLASS1)) {
            Class1.checkLevel(player);
        }
        if(UsersData.playerClasses.get(player).equals(CLASS2)) {
            Class2.checkLevel(player);
        }
        if(UsersData.playerClasses.get(player).equals(CLASS3)) {
            Class3.checkLevel(player);
        }
    }
<01:10:59> "LordToxik": package me.LordToxik.API.basics.mysql.objects;

import me.LordToxik.API.basics.logs.Logger;
import me.LordToxik.API.basics.mysql.interfaces.IMySQL;
import me.LordToxik.API.basics.timers.objects.Timer;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.TimerTask;

public class MySQL implements IMySQL {

    private Connection connection;
    private String host, password, database, username;
    private Integer port;
    private MySQL thisClass;
    private Timer timer;

    public MySQL(String host, String database, String username, String password, Integer port) {

        thisClass = this;
        this.host = host;
        this.database = database;
        this.username = username;
        this.password = password;
        this.port = port;
        this.timer = new Timer();
    }

    @Override
    public String getHost() {
        return this.host;
    }

    @Override
    public String getDatabase() {
        return this.database;
    }

    @Override
    public String getUsername() {
        return this.username;
    }

    @Override
    public Integer getPort() {
        return this.port;
    }


    @Override
    public Connection getConnection() {
        synchronized (this) {
            try {
                if(connection == null ||
                connection.isClosed()) {
                    connect();
                }
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
            return this.connection;
        }
    }

    @Override
    public void disconnect() {

        try {
            synchronized (this) {
                if(connection != null && !connection.isClosed()) {
                    Logger.highConnectionLog("Odpojeny z mysql serveru '" + host + ":" + port + "' cez uzivatela '" + username + "' z databazi '" + database + "'");
                    connection.close();
                    timer.cancel();
                } else {
                    Logger.highWarningLog("Aktualne si odpojeny z mysql serveru '" + host + ":" + port + "' z uzivatela '" + username + "' z databazi '" + database + "'");
                }
            }
        } catch (SQLException ex) {
            Logger.highErrorLog("Nastala chyba v pripojeni na MySQL '" + host + ":" + port + "' cez uzivatela '" + username + "' a do databazi '" + database + "'");
        }
    }

    @Override
    public void connect() {

        try {
            synchronized (this) {
                if (connection != null && !connection.isClosed()) {
                    return;
                }

                Class.forName("com.mysql.jdbc.Driver");
                this.connection = DriverManager.getConnection("jdbc:mysql://" + host + ":" + port + "/" + database + "?autoReconnect=true&useUnicode=yes", username, password);
                Logger.highConnectionLog("Pripojeny na MySQL server '" + host + ":" + port + "' cez uzivatela '" + username + "' na databazu '" + database + "'");
                keepAlive();
            }
        } catch (SQLException | ClassNotFoundException ex) {
            Logger.highErrorLog("Nastala chyba pri pripojeny na mysql server '" + host + ":" + port + "' cez uzivatela '" + username + "' do databaze '" + database + "'");
        }
    }

    public void keepAlive() {
        timer.cancel();
        timer.setTask(new TimerTask() {
            @Override
            public void run() {
                getConnection();
            }
        }).startAsyncTask(60*60*1000, 60*60*1000);
    }
}
<01:11:03> "LordToxik": package me.LordToxik.API.basics.mysql.objects;

import me.LordToxik.API.basics.mysql.interfaces.IMySQLReflection;
import me.LordToxik.API.basics.timers.objects.Timer;
import org.bukkit.entity.Player;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.*;

public class MySQLReflection implements IMySQLReflection {

    @Override
    public ArrayList<Object> getValues(Connection connection, String table, String whereColum, Object whereObject, String... colums) {
        return getValues(connection, table, whereColum, whereObject, Arrays.asList(colums));
    }

    @Override
    public ArrayList<Object> getValues(Connection connection, String table, String whereColum, Object whereObject, List<String> colums) {
        ArrayList<Object> temp = new ArrayList<>();
        try {

            PreparedStatement statement = connection.prepareStatement("SELECT * FROM `" + table + "` WHERE `" + whereColum + "`='" + whereObject + "'");

            ResultSet result = statement.executeQuery();
            result.next();
            for(String s : colums) {
                temp.add(result.getObject(s));
            }

            result.close();
            statement.close();

            return temp;
        } catch (SQLException ignored) {}

        return temp;
    }

    @Override
    public HashMap<String, Object> getValuesInHash(Connection connection, String table, String whereColum, Object whereObject, String... colums) {
        return getValuesInHash(connection, table, whereColum, whereObject, Arrays.asList(colums));
    }

    @Override
    public HashMap<String, Object> getValuesInHash(Connection connection, String table, String whereColum, Object whereObject, List<String> colums) {
        HashMap<String, Object> temp = new HashMap<>();
        try {

            PreparedStatement statement = connection.prepareStatement("SELECT * FROM `" + table + "` WHERE `" + whereColum + "`='" + whereObject + "'");

            ResultSet result = statement.executeQuery();
            result.next();
            for(String s : colums) {
                temp.put(s, result.getObject(s));
            }

            result.close();
            statement.close();

            return temp;
        } catch (SQLException ignored) {}

        return temp;
    }

    @Override
    public Object getValue(Connection connection, String table, String whereColum, Object whereObject, String fromColum) {

        try {

            PreparedStatement statement = connection.prepareStatement("SELECT * FROM `" + table + "` WHERE `" + whereColum + "`='" + whereObject + "'");

            ResultSet result = statement.executeQuery();
            result.next();

            Object value;
            value = result.getObject(fromColum);

            result.close();
            statement.close();

            return value;
        } catch (SQLException ignored) {}

        return 0;
    }

    @Override
    public boolean ifDataExists(Connection connection, String table, String colum, Object value) {

        try {

            PreparedStatement statement = connection.prepareStatement("SELECT * FROM `" + table + "` WHERE `" + colum + "`='" + value + "'");

            ResultSet result = statement.executeQuery();
            if (result.next()) {
                result.close();
                statement.close();

                return true;
            }

            result.close();
            statement.close();
        } catch (SQLException ex) {
            return true;
        }

        return false;
    }

    @Override
    public void substractNumber(Connection connection, String table, String whereColum, Object whereObject,String colum, Object value) {
        new Timer(new TimerTask() {
            @Override
            public void run() {
                try {

                    PreparedStatement statement = connection.prepareStatement( "UPDATE `" + table + "` SET `" + colum + "`=`" +
                            colum + "`-'" + value + "' WHERE `" + whereColum + "`='" + whereObject + "'");

                    statement.executeUpdate();
                    statement.close();
                } catch (SQLException ignored) {}
            }
        }).startOnlyDelayed(10);
    }

    @Override
    public void setValues(Connection connection, String table, String whereColum, Object whereObject, HashMap<String, Object> values) {
        new Timer(new TimerTask() {
            @Override
            public void run() {
                try {
                    if(values.isEmpty()) return;

                    StringBuilder builder = new StringBuilder("");
                    for(String s : values.keySet()) {
                        builder.append("`" + s + "`='" + values.get(s) + "', ");
                    }

                    String query = builder.toString();
                    if(query.endsWith(", ")) {
                        query = query.substring(0, builder.length()-2);
                    }
                    PreparedStatement statement = connection.prepareStatement( "UPDATE `" + table + "` SET " + query + " WHERE `" + whereColum + "`='" + whereObject + "'");

                    statement.executeUpdate();
                    statement.close();
                } catch (SQLException ignored) {}
            }
        }).startOnlyDelayed(10);
    }

    @Override
    public void setObject(Connection connection, String table, String whereColum, Object whereObject,String colum, Object value) {
        new Timer(new TimerTask() {
            @Override
            public void run() {
                try {

                    PreparedStatement statement = connection.prepareStatement( "UPDATE `" + table + "` SET `" + colum + "`='" + value + "' WHERE `" + whereColum + "`='" + whereObject + "'");

                    statement.executeUpdate();
                    statement.close();
                } catch (SQLException ignored) {}
            }
        }).startOnlyDelayed(10);
    }

    @Override
    public void addNumber(Connection connection, String table, String whereColum, Object whereObject,String colum, Object value) {
        new Timer(new TimerTa
<01:11:10> "LordToxik":
    @Override
    public void addNumber(Connection connection, String table, String whereColum, Object whereObject,String colum, Object value) {
        new Timer(new TimerTask() {
            @Override
            public void run() {
                try {

                    PreparedStatement statement = connection.prepareStatement( "UPDATE `" + table + "` SET `" + colum + "`=`" +
                            colum + "`+'" + value + "' WHERE `" + whereColum + "`='" + whereObject + "'");

                    statement.executeUpdate();
                    statement.close();
                } catch (SQLException ignored) {}
            }
        }).startOnlyDelayed(10);
    }


    @Override
    public Object getMaxNumber(Connection connection, String table, String colum) {

        try {

            PreparedStatement statement = connection.prepareStatement("SELECT MAX(" + colum + ") as " + colum + " FROM " + table);

            ResultSet result = statement.executeQuery();

            Object number = 0;

            while(result.next()) {
                number = result.getObject(colum);
            }

            result.close();
            statement.close();

            if(number == null) {
                number = 0;
            }
            return number;
        } catch (SQLException ignored) {
        }

        return 0;
    }

    @Override
    public void createTable(Connection connection, String table_name, HashMap<String, String> values) {
        new Timer(new TimerTask() {
            @Override
            public void run() {

                StringBuilder builder = new StringBuilder("CREATE TABLE IF NOT EXISTS `" + table_name +"` (");

                int i = 1;

                for(String s : values.keySet()) {
                    String nulled = "NOT NULL";
                    if(s.endsWith("NULL")) {
                        nulled = "NULL";
                    }
                    builder.append("`" + s + "` " + values.get(s) + " " + nulled);

                    if(i != values.size()) {
                        builder.append(", ");
                    }

                    i++;
                }
                builder.append(")");
                try {
                    PreparedStatement statement = connection.prepareStatement(builder.toString());

                    statement.execute();
                    statement.close();
                } catch (SQLException ignored) {}

            }
        }).startOnlyDelayed(10);
    }

}
<01:12:08> "LordToxik":
    @Override
    public void substractNumber(Connection connection, String table, String whereColum, Object whereObject,String colum, Object value) {
        new BukkitRunnable() {
            @Override
            public void run() {

                try {

                    PreparedStatement statement = connection.prepareStatement( "UPDATE `" + table + "` SET `" + colum + "`=`" +
                            colum + "`-'" + value + "' WHERE `" + whereColum + "`='" + whereObject + "'");

                    statement.executeUpdate();
                    statement.close();
                } catch (SQLException ignored) {}
            }
        }.runTaskLater(Main.instance, 1);
        new Timer(new TimerTask() {
            @Override
            public void run() {
                try {

                    PreparedStatement statement = connection.prepareStatement( "UPDATE `" + table + "` SET `" + colum + "`=`" +
                            colum + "`-'" + value + "' WHERE `" + whereColum + "`='" + whereObject + "'");

                    statement.executeUpdate();
                    statement.close();
                } catch (SQLException ignored) {}
            }
        }).startOnlyDelayed(10);
    }
<01:12:27> "LordToxik": public MySQL mysql;
<01:12:39> "LordToxik": mysql = new MySQL("", "", "", "", 3306);
<01:13:03> "LordToxik":
        HashMap<String, String> hash = new HashMap<>();
        hash.put("NICKNAME","text");
        hash.put("KILLS", "bigint(255)");
        hash.put("DEATHS", "bigint(255)");
        hash.put("M_LEVEL", "bigint(255)");
        reflection.createTable(Library.getInstance().getMySQL().getConnection(), "GunGame_STATS", hash);
<01:13:50> "LordToxik": new MySQLReflection().createTable

v hash.put("M_LEVEL", "bigint(255)");
        reflection.createTable(Library.getInstance().getMySQL().getConnection(), "GunGame_STATS", hash);
<01:13:50> "LordToxik": new MySQLReflection().createTable
<01:14:05> "LordToxik":
    public static HashMap<Player, Integer> playerClasses = new HashMap<>();

    public static HashMap<Player, Long> playerKills = new HashMap<>();
    public static HashMap<Player, Long> playerDeaths = new HashMap<>();
    public static HashMap<Player, Long> playerMaxLevel = new HashMap<>();

    public static void checkUserData(Player player) {
        IUser user = Library.getInstance().getUserManager().getUser(player);
        if(!Main.reflection.ifDataExists(Library.getInstance().getMySQL().getConnection()
                , "GunGame_STATS", "NICKNAME", user.getNick())) {
            try {
                PreparedStatement statement = Library.getInstance().getMySQL().getConnection()
                        .prepareStatement("INSERT INTO `GunGame_STATS` (`NICKNAME`, `KILLS`, `DEATHS`, `M_LEVEL`) VALUES ('" + user.getNick() + "', '0', '0','1')");
                statement.execute();
                statement.close();

                playerKills.put(player, 0L);
                playerDeaths.put(player, 0L);
                playerMaxLevel.put(player, 1L);

            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        }
        else {
            HashMap<String, Object> playerDatas = Main.reflection.getValuesInHash(Library.getInstance().getMySQL().getConnection()
                    , "GunGame_STATS", "NICKNAME", user.getNick(), "KILLS", "DEATHS", "M_LEVEL");
            playerKills.put(player, Long.valueOf(playerDatas.get("KILLS").toString()));
            playerDeaths.put(player, Long.valueOf(playerDatas.get("DEATHS").toString()));
            playerMaxLevel.put(player, Long.valueOf(playerDatas.get("M_LEVEL").toString()));
        }
    }

    public static void saveUserData(Player player) {
        HashMap<String, Object> playerDatas = new HashMap<>();
        IUser user = Library.getInstance().getUserManager().getUser(player);
        playerDatas.put("KILLS", playerKills.get(player));
        playerDatas.put("DEATHS", playerDeaths.get(player));
        playerDatas.put("M_LEVEL", playerMaxLevel.get(player));
        Main.reflection.setValues(Library.getInstance().getMySQL().getConnection()
                , "GunGame_STATS", "NICKNAME", user.getNick(), playerDatas);
        if(playerKills.containsKey(player)) {
            playerKills.remove(player);
        }
        if(playerDeaths.containsKey(player)) {
            playerDeaths.remove(player);
        }
        if(playerMaxLevel.containsKey(player)) {
            playerMaxLevel.remove(player);
        }
    }


}
<01:15:25> "LordToxik": if(Main.playerDeaths.containsKey(player)) {
  Main.playerDeaths.put(player, Main.playerDeaths.get(player)+1);
} else {
  Main.playerDeaths.put(player, 1);
}
<01:16:54> "LordToxik": if(Main.playerMaxLevel.containsKey(player)) {
  if(Main.playerMaxLevel.get(player) < player.getLevel()) {
     Main.playerMaxLevel.put(player, player.getLevel());
  }
} else {
  Main.playerMaxLevel.put(player, 1);
}
<01:17:15> "LordToxik": Main.checkUserData(player);
<01:17:27> "LordToxik": Main.saveUserData(player);