BLOCKFANTASY
/
LOOHP-Limbo
Template
mirror of https://github.com/LOOHP/Limbo.git
1
0
Fork 1
Code Issues Packages Projects Releases Wiki Activity

reupload

This commit is contained in:
LOOHP 2021-04-06 21:14:05 +08:00
parent 05cfdb73a9
commit 6d14314bd9
126 changed files with 191394 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

494
src/main/java/com/loohp/limbo/Console.java Normal file
View File

@ -0,0 +1,494 @@
package com.loohp.limbo;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.UUID;
import java.util.stream.Collectors;
import org.fusesource.jansi.Ansi;
import org.fusesource.jansi.Ansi.Attribute;
import org.jline.reader.Candidate;
import org.jline.reader.Completer;
import org.jline.reader.EndOfFileException;
import org.jline.reader.LineReader;
import org.jline.reader.LineReader.SuggestionType;
import org.jline.reader.LineReaderBuilder;
import org.jline.reader.ParsedLine;
import org.jline.reader.UserInterruptException;
import org.jline.terminal.Terminal;
import org.jline.terminal.TerminalBuilder;
import com.loohp.limbo.commands.CommandSender;
import com.loohp.limbo.consolegui.ConsoleTextOutput;
import com.loohp.limbo.utils.CustomStringUtils;
import jline.console.ConsoleReader;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.chat.BaseComponent;
public class Console implements CommandSender {
protected static final Map<ChatColor, String> REPLACEMENTS = new HashMap<>();
private final static String CONSOLE = "CONSOLE";
private final static String PROMPT = "> ";
protected final static String ERROR_RED = "\u001B[31;1m";
protected final static String RESET_COLOR = "\u001B[0m";
private Terminal terminal;
private LineReader tabReader;
private ConsoleReader reader;
private InputStream in;
@SuppressWarnings("unused")
private PrintStream out;
@SuppressWarnings("unused")
private PrintStream err;
protected PrintStream logs;
public Console(InputStream in, PrintStream out, PrintStream err) throws IOException {
String fileName = new SimpleDateFormat("yyyy'-'MM'-'dd'_'HH'-'mm'-'ss'_'zzz'.log'").format(new Date());
File dir = new File("logs");
dir.mkdirs();
File logs = new File(dir, fileName);
this.logs = new PrintStream(logs);
if (in != null) {
System.setIn(in);
this.in = System.in;
} else {
this.in = null;
}
System.setOut(new ConsoleOutputStream(this, out == null ? new PrintStream(new OutputStream() {
@Override
public void write(int b) {
//DO NOTHING
}
}) : out, this.logs));
this.out = System.out;
System.setErr(new ConsoleErrorStream(this, err == null ? new PrintStream(new OutputStream() {
@Override
public void write(int b) {
//DO NOTHING
}
}) : err, this.logs));
this.err = System.err;
reader = new ConsoleReader(in, out);
reader.setExpandEvents(false);
reader.setHandleUserInterrupt(false);
terminal = TerminalBuilder.builder().streams(in, out).system(true).jansi(true).build();
tabReader = LineReaderBuilder.builder().terminal(terminal).completer(new Completer() {
@Override
public void complete(LineReader reader, ParsedLine line, List<Candidate> candidates) {
String[] args = CustomStringUtils.splitStringToArgs(line.line());
List<String> tab = Limbo.getInstance().getPluginManager().getTabOptions(Limbo.getInstance().getConsole(), args);
for (String each : tab) {
candidates.add(new Candidate(each));
}
}
}).build();
tabReader.setAutosuggestion(SuggestionType.NONE);
}
@Override
public String getName() {
return CONSOLE;
}
@Override
public boolean hasPermission(String permission) {
return Limbo.getInstance().getPermissionsManager().hasPermission(this, permission);
}
@Override
public void sendMessage(BaseComponent component, UUID uuid) {
sendMessage(component);
}
@Override
public void sendMessage(BaseComponent[] component, UUID uuid) {
sendMessage(component);
}
@Override
public void sendMessage(String message, UUID uuid) {
sendMessage(message);
}
@Override
public void sendMessage(BaseComponent component) {
sendMessage(new BaseComponent[] {component});
}
@Override
public void sendMessage(BaseComponent[] component) {
sendMessage(String.join("", Arrays.asList(component).stream().map(each -> each.toLegacyText()).collect(Collectors.toList())));
}
@Override
public void sendMessage(String message) {
stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Info] " + message), true);
logs.println(ChatColor.stripColor("[" + date + " Info] " + message));
try {
reader.getOutput().append("[" + date + " Info] " + translateToConsole(message) + "\n");
reader.getOutput().flush();
} catch (IOException e) {
e.printStackTrace();
}
unstashLine();
}
protected void run() {
if (in == null) {
return;
}
while (true) {
try {
String command = tabReader.readLine(PROMPT).trim();
if (command.length() > 0) {
String[] input = CustomStringUtils.splitStringToArgs(command);
new Thread(() -> Limbo.getInstance().dispatchCommand(this, input)).start();
}
} catch (UserInterruptException e) {
System.exit(0);
} catch (EndOfFileException e) {
break;
}
}
}
protected void stashLine() {
try {
tabReader.callWidget(LineReader.CLEAR);
} catch (Exception ignore) {}
}
protected void unstashLine() {
try {
tabReader.callWidget(LineReader.REDRAW_LINE);
tabReader.callWidget(LineReader.REDISPLAY);
tabReader.getTerminal().writer().flush();
} catch (Exception ignore) {}
}
static {
REPLACEMENTS.put(ChatColor.BLACK, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.BLACK).boldOff().toString());
REPLACEMENTS.put(ChatColor.DARK_BLUE, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.BLUE).boldOff().toString());
REPLACEMENTS.put(ChatColor.DARK_GREEN, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.GREEN).boldOff().toString());
REPLACEMENTS.put(ChatColor.DARK_AQUA, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.CYAN).boldOff().toString());
REPLACEMENTS.put(ChatColor.DARK_RED, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.RED).boldOff().toString());
REPLACEMENTS.put(ChatColor.DARK_PURPLE, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.MAGENTA).boldOff().toString());
REPLACEMENTS.put(ChatColor.GOLD, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.YELLOW).boldOff().toString());
REPLACEMENTS.put(ChatColor.GRAY, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.WHITE).boldOff().toString());
REPLACEMENTS.put(ChatColor.DARK_GRAY, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.BLACK).bold().toString());
REPLACEMENTS.put(ChatColor.BLUE, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.BLUE).bold().toString());
REPLACEMENTS.put(ChatColor.GREEN, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.GREEN).bold().toString());
REPLACEMENTS.put(ChatColor.AQUA, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.CYAN).bold().toString());
REPLACEMENTS.put(ChatColor.RED, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.RED).bold().toString());
REPLACEMENTS.put(ChatColor.LIGHT_PURPLE, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.MAGENTA).bold().toString());
REPLACEMENTS.put(ChatColor.YELLOW, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.YELLOW).bold().toString());
REPLACEMENTS.put(ChatColor.WHITE, Ansi.ansi().a(Attribute.RESET).fg(Ansi.Color.WHITE).bold().toString());
REPLACEMENTS.put(ChatColor.MAGIC, Ansi.ansi().a(Attribute.BLINK_SLOW).toString());
REPLACEMENTS.put(ChatColor.BOLD, Ansi.ansi().a(Attribute.UNDERLINE_DOUBLE).toString());
REPLACEMENTS.put(ChatColor.STRIKETHROUGH, Ansi.ansi().a(Attribute.STRIKETHROUGH_ON).toString());
REPLACEMENTS.put(ChatColor.UNDERLINE, Ansi.ansi().a(Attribute.UNDERLINE).toString());
REPLACEMENTS.put(ChatColor.ITALIC, Ansi.ansi().a(Attribute.ITALIC).toString());
REPLACEMENTS.put(ChatColor.RESET, Ansi.ansi().a(Attribute.RESET).toString());
}
protected static String translateToConsole(String str) {
for (Entry<ChatColor, String> entry : REPLACEMENTS.entrySet()) {
str = str.replace(entry.getKey().toString(), entry.getValue());
}
str = str.replaceAll("(?i)" + ChatColor.COLOR_CHAR + "x(" + ChatColor.COLOR_CHAR + "[0-9a-f]){6}", "");
return str + RESET_COLOR;
}
public static class ConsoleOutputStream extends PrintStream {
private PrintStream logs;
private Console console;
public ConsoleOutputStream(Console console, OutputStream out, PrintStream logs) {
super(out);
this.logs = logs;
this.console = console;
}
@SuppressWarnings("resource")
@Override
public PrintStream printf(Locale l, String format, Object... args) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor(String.format(l, "[" + date + " Info]" + format, args)));
logs.printf(l, ChatColor.stripColor("[" + date + " Info]" + format), args);
PrintStream stream = super.printf(l, Console.translateToConsole("[" + date + " Info]" + format), args);
console.unstashLine();
return stream;
}
@SuppressWarnings("resource")
@Override
public PrintStream printf(String format, Object... args) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor(String.format("[" + date + " Info]" + format, args)));
logs.printf(ChatColor.stripColor("[" + date + " Info]" + format), args);
PrintStream stream = super.printf(ChatColor.stripColor("[" + date + " Info]" + format), args);
console.unstashLine();
return stream;
}
@Override
public void println() {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Info]"), true);
logs.println(ChatColor.stripColor("[" + date + " Info]"));
super.println(ChatColor.stripColor("[" + date + " Info]"));
console.unstashLine();
}
@Override
public void println(boolean x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Info] " + x), true);
logs.println(ChatColor.stripColor("[" + date + " Info]" + x));
super.println(ChatColor.stripColor("[" + date + " Info]" + x));
console.unstashLine();
}
@Override
public void println(char x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Info] " + x), true);
logs.println(ChatColor.stripColor("[" + date + " Info]" + x));
super.println(ChatColor.stripColor("[" + date + " Info]" + x));
console.unstashLine();
}
@Override
public void println(char[] x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Info] " + String.valueOf(x)), true);
logs.println(ChatColor.stripColor("[" + date + " Info]" + String.valueOf(x)));
super.println(ChatColor.stripColor("[" + date + " Info]" + String.valueOf(x)));
console.unstashLine();
}
@Override
public void println(double x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Info] " + x), true);
logs.println(ChatColor.stripColor("[" + date + " Info]" + x));
super.println(ChatColor.stripColor("[" + date + " Info]" + x));
console.unstashLine();
}
@Override
public void println(float x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Info] " + x), true);
logs.println(ChatColor.stripColor("[" + date + " Info]" + x));
super.println(ChatColor.stripColor("[" + date + " Info]" + x));
console.unstashLine();
}
@Override
public void println(int x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Info] " + x), true);
logs.println(ChatColor.stripColor("[" + date + " Info]" + x));
super.println(ChatColor.stripColor("[" + date + " Info]" + x));
console.unstashLine();
}
@Override
public void println(long x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Info] " + x), true);
logs.println(ChatColor.stripColor("[" + date + " Info]" + x));
super.println(ChatColor.stripColor("[" + date + " Info]" + x));
console.unstashLine();
}
@Override
public void println(Object x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Info] " + x), true);
logs.println(ChatColor.stripColor("[" + date + " Info]" + x));
super.println(ChatColor.stripColor("[" + date + " Info]" + x));
console.unstashLine();
}
@Override
public void println(String string) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Info] " + string), true);
logs.println(ChatColor.stripColor("[" + date + " Info] " + string));
super.println(ChatColor.stripColor("[" + date + " Info] " + string));
console.unstashLine();
}
}
public static class ConsoleErrorStream extends PrintStream {
private PrintStream logs;
private Console console;
public ConsoleErrorStream(Console console, OutputStream out, PrintStream logs) {
super(out);
this.logs = logs;
this.console = console;
}
@SuppressWarnings("resource")
@Override
public PrintStream printf(Locale l, String format, Object... args) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor(String.format(l, "[" + date + " Error]" + format, args)));
logs.printf(l, ChatColor.stripColor("[" + date + " Error]" + format), args);
PrintStream stream = super.printf(l, ERROR_RED + ChatColor.stripColor("[" + date + " Error]" + format + RESET_COLOR), args);
console.unstashLine();
return stream;
}
@SuppressWarnings("resource")
@Override
public PrintStream printf(String format, Object... args) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor(String.format("[" + date + " Error]" + format, args)));
logs.printf(ChatColor.stripColor("[" + date + " Error]" + format), args);
PrintStream stream = super.printf(ERROR_RED + ChatColor.stripColor("[" + date + " Error]" + format + RESET_COLOR), args);
console.unstashLine();
return stream;
}
@Override
public void println() {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Error]"), true);
logs.println(ChatColor.stripColor("[" + date + " Error]"));
super.println(ERROR_RED + ChatColor.stripColor("[" + date + " Error]") + RESET_COLOR);
console.unstashLine();
}
@Override
public void println(boolean x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Error] " + x), true);
logs.println(ChatColor.stripColor("[" + date + " Error]" + x));
super.println(ERROR_RED + ChatColor.stripColor("[" + date + " Error]" + x) + RESET_COLOR);
console.unstashLine();
}
@Override
public void println(char x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Error] " + x), true);
logs.println(ChatColor.stripColor("[" + date + " Error]" + x));
super.println(ERROR_RED + ChatColor.stripColor("[" + date + " Error]" + x) + RESET_COLOR);
console.unstashLine();
}
@Override
public void println(char[] x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Error] " + String.valueOf(x)), true);
logs.println(ChatColor.stripColor("[" + date + " Error]" + String.valueOf(x)));
super.println(ERROR_RED + ChatColor.stripColor("[" + date + " Error]" + String.valueOf(x)) + RESET_COLOR);
console.unstashLine();
}
@Override
public void println(double x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Error] " + x), true);
logs.println(ChatColor.stripColor("[" + date + " Error]" + x));
super.println(ERROR_RED + ChatColor.stripColor("[" + date + " Error]" + x) + RESET_COLOR);
console.unstashLine();
}
@Override
public void println(float x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Error] " + x), true);
logs.println(ChatColor.stripColor("[" + date + " Error]" + x));
super.println(ERROR_RED + ChatColor.stripColor("[" + date + " Error]" + x) + RESET_COLOR);
console.unstashLine();
}
@Override
public void println(int x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Error] " + x), true);
logs.println(ChatColor.stripColor("[" + date + " Error]" + x));
super.println(ERROR_RED + ChatColor.stripColor("[" + date + " Error]" + x) + RESET_COLOR);
console.unstashLine();
}
@Override
public void println(long x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Error] " + x), true);
logs.println(ChatColor.stripColor("[" + date + " Error]" + x));
super.println(ERROR_RED + ChatColor.stripColor("[" + date + " Error]" + x) + RESET_COLOR);
console.unstashLine();
}
@Override
public void println(Object x) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Error] " + x), true);
logs.println(ChatColor.stripColor("[" + date + " Error]" + x));
super.println(ERROR_RED + ChatColor.stripColor("[" + date + " Error]" + x) + RESET_COLOR);
console.unstashLine();
}
@Override
public void println(String string) {
console.stashLine();
String date = new SimpleDateFormat("HH':'mm':'ss").format(new Date());
ConsoleTextOutput.appendText(ChatColor.stripColor("[" + date + " Error] " + string), true);
logs.println(ChatColor.stripColor("[" + date + " Error] " + string));
super.println(ERROR_RED + ChatColor.stripColor("[" + date + " Error] " + string) + RESET_COLOR);
console.unstashLine();
}
}
}

577
src/main/java/com/loohp/limbo/Limbo.java Normal file
View File

@ -0,0 +1,577 @@
package com.loohp.limbo;
import java.awt.GraphicsEnvironment;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.URL;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.TreeMap;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.loohp.limbo.events.EventsManager;
import com.loohp.limbo.server.ServerConnection;
import com.loohp.limbo.server.packets.Packet;
import com.loohp.limbo.server.packets.PacketIn;
import com.loohp.limbo.server.packets.PacketOut;
import com.loohp.limbo.commands.CommandSender;
import com.loohp.limbo.consolegui.GUI;
import com.loohp.limbo.file.ServerProperties;
import com.loohp.limbo.location.Location;
import com.loohp.limbo.metrics.Metrics;
import com.loohp.limbo.permissions.PermissionsManager;
import com.loohp.limbo.player.Player;
import com.loohp.limbo.plugins.LimboPlugin;
import com.loohp.limbo.plugins.PluginManager;
import com.loohp.limbo.scheduler.LimboScheduler;
import com.loohp.limbo.scheduler.Tick;
import com.loohp.limbo.utils.CustomStringUtils;
import com.loohp.limbo.utils.ImageUtils;
import com.loohp.limbo.utils.NetworkUtils;
import com.loohp.limbo.world.DimensionRegistry;
import com.loohp.limbo.world.Environment;
import com.loohp.limbo.world.Schematic;
import com.loohp.limbo.world.World;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.chat.ComponentSerializer;
import net.querz.nbt.io.NBTUtil;
import net.querz.nbt.tag.CompoundTag;
public class Limbo {
private static Limbo instance;
public static boolean noGui = false;
public static void main(String args[]) throws IOException, ParseException, NumberFormatException, ClassNotFoundException, InterruptedException {
for (String flag : args) {
if (flag.equals("--nogui") || flag.equals("nogui")) {
noGui = true;
} else if (flag.equals("--help")) {
System.out.println("Accepted flags:");
System.out.println(" --nogui <- Disable the GUI");
System.exit(0);
} else {
System.out.println("Unknown flag: \"" + flag + "\". Ignoring...");
}
}
if (GraphicsEnvironment.isHeadless()) {
noGui = true;
}
if (!noGui) {
System.out.println("Launching Server GUI.. Add \"--nogui\" in launch arguments to disable");
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
GUI.main();
}
});
t1.start();
}
new Limbo();
}
public static Limbo getInstance() {
return instance;
}
//===========================
public final String serverImplementationVersion = "1.16.5";
public final int serverImplmentationProtocol = 754;
public final String limboImplementationVersion;
private AtomicBoolean isRunning;
private ServerConnection server;
private Console console;
private List<World> worlds = new ArrayList<>();
private Map<String, Player> playersByName = new HashMap<>();
private Map<UUID, Player> playersByUUID = new HashMap<>();
private ServerProperties properties;
private PluginManager pluginManager;
private EventsManager eventsManager;
private PermissionsManager permissionManager;
private File pluginFolder;
private File internalDataFolder;
private DimensionRegistry dimensionRegistry;
private Tick tick;
private LimboScheduler scheduler;
private Metrics metrics;
public AtomicInteger entityIdCount = new AtomicInteger();
@SuppressWarnings("deprecation")
private Unsafe unsafe = new Unsafe();
@SuppressWarnings("unchecked")
public Limbo() throws IOException, ParseException, NumberFormatException, ClassNotFoundException, InterruptedException {
instance = this;
isRunning = new AtomicBoolean(true);
if (!noGui) {
while (!GUI.loadFinish) {
TimeUnit.MILLISECONDS.sleep(500);
}
console = new Console(null, System.out, System.err);
} else {
console = new Console(System.in, System.out, System.err);
}
limboImplementationVersion = getLimboVersion();
console.sendMessage("Loading Limbo Version " + limboImplementationVersion + " on Minecraft " + serverImplementationVersion);
String spName = "server.properties";
File sp = new File(spName);
if (!sp.exists()) {
try (InputStream in = getClass().getClassLoader().getResourceAsStream(spName)) {
Files.copy(in, sp.toPath());
} catch (IOException e) {
e.printStackTrace();
}
}
properties = new ServerProperties(sp);
if (!properties.isBungeecord()) {
console.sendMessage("If you are using bungeecord, consider turning that on in the settings!");
} else {
console.sendMessage("Starting Limbo server in bungeecord mode!");
}
internalDataFolder = new File("internal_data");
if (!internalDataFolder.exists()) {
internalDataFolder.mkdirs();
}
String mappingName = "mapping.json";
File mappingFile = new File(internalDataFolder, mappingName);
if (!mappingFile.exists()) {
try (InputStream in = getClass().getClassLoader().getResourceAsStream(mappingName)) {
Files.copy(in, mappingFile.toPath());
} catch (IOException e) {
e.printStackTrace();
}
}
console.sendMessage("Loading packet id mappings from mapping.json ...");
InputStreamReader reader = new InputStreamReader(new FileInputStream(mappingFile), StandardCharsets.UTF_8);
JSONObject json = (JSONObject) new JSONParser().parse(reader);
reader.close();
String classPrefix = Packet.class.getName().substring(0, Packet.class.getName().lastIndexOf(".") + 1);
int mappingsCount = 0;
Map<Integer, Class<? extends PacketIn>> HandshakeIn = new HashMap<>();
for (Object key : ((JSONObject) json.get("HandshakeIn")).keySet()) {
int packetId = Integer.decode((String) key);
HandshakeIn.put(packetId, (Class<? extends PacketIn>) Class.forName(classPrefix + (String) ((JSONObject) json.get("HandshakeIn")).get(key)));
}
Packet.setHandshakeIn(HandshakeIn);
mappingsCount += HandshakeIn.size();
Map<Integer, Class<? extends PacketIn>> StatusIn = new HashMap<>();
for (Object key : ((JSONObject) json.get("StatusIn")).keySet()) {
int packetId = Integer.decode((String) key);
StatusIn.put(packetId, (Class<? extends PacketIn>) Class.forName(classPrefix + (String) ((JSONObject) json.get("StatusIn")).get(key)));
}
Packet.setStatusIn(StatusIn);
mappingsCount += StatusIn.size();
Map<Class<? extends PacketOut>, Integer> StatusOut = new HashMap<>();
for (Object key : ((JSONObject) json.get("StatusOut")).keySet()) {
Class<? extends PacketOut> packetClass = (Class<? extends PacketOut>) Class.forName(classPrefix + (String) key);
StatusOut.put(packetClass, Integer.decode((String) ((JSONObject) json.get("StatusOut")).get(key)));
}
Packet.setStatusOut(StatusOut);
mappingsCount += StatusOut.size();
Map<Integer, Class<? extends PacketIn>> LoginIn = new HashMap<>();
for (Object key : ((JSONObject) json.get("LoginIn")).keySet()) {
int packetId = Integer.decode((String) key);
LoginIn.put(packetId, (Class<? extends PacketIn>) Class.forName(classPrefix + (String) ((JSONObject) json.get("LoginIn")).get(key)));
}
Packet.setLoginIn(LoginIn);
mappingsCount += LoginIn.size();
Map<Class<? extends PacketOut>, Integer> LoginOut = new HashMap<>();
for (Object key : ((JSONObject) json.get("LoginOut")).keySet()) {
Class<? extends PacketOut> packetClass = (Class<? extends PacketOut>) Class.forName(classPrefix + (String) key);
LoginOut.put(packetClass, Integer.decode((String) ((JSONObject) json.get("LoginOut")).get(key)));
}
Packet.setLoginOut(LoginOut);
mappingsCount += LoginOut.size();
Map<Integer, Class<? extends PacketIn>> PlayIn = new HashMap<>();
for (Object key : ((JSONObject) json.get("PlayIn")).keySet()) {
int packetId = Integer.decode((String) key);
PlayIn.put(packetId, (Class<? extends PacketIn>) Class.forName(classPrefix + (String) ((JSONObject) json.get("PlayIn")).get(key)));
}
Packet.setPlayIn(PlayIn);
mappingsCount += PlayIn.size();
Map<Class<? extends PacketOut>, Integer> PlayOut = new HashMap<>();
for (Object key : ((JSONObject) json.get("PlayOut")).keySet()) {
Class<? extends PacketOut> packetClass = (Class<? extends PacketOut>) Class.forName(classPrefix + (String) key);
PlayOut.put(packetClass, Integer.decode((String) ((JSONObject) json.get("PlayOut")).get(key)));
}
Packet.setPlayOut(PlayOut);
mappingsCount += PlayOut.size();
console.sendMessage("Loaded all " + mappingsCount + " packet id mappings!");
dimensionRegistry = new DimensionRegistry();
worlds.add(loadDefaultWorld());
Location spawn = properties.getWorldSpawn();
properties.setWorldSpawn(new Location(getWorld(properties.getLevelName().getKey()), spawn.getX(), spawn.getY(), spawn.getZ(), spawn.getYaw(), spawn.getPitch()));
if (!NetworkUtils.available(properties.getServerPort())) {
console.sendMessage("");
console.sendMessage("*****FAILED TO BIND PORT [" + properties.getServerPort() + "]*****");
console.sendMessage("*****PORT ALREADY IN USE*****");
console.sendMessage("*****PERHAPS ANOTHER INSTANCE OF THE SERVER IS ALREADY RUNNING?*****");
console.sendMessage("");
System.exit(2);
}
String permissionName = "permission.yml";
File permissionFile = new File(permissionName);
if (!permissionFile.exists()) {
try (InputStream in = getClass().getClassLoader().getResourceAsStream(permissionName)) {
Files.copy(in, permissionFile.toPath());
} catch (IOException e) {
e.printStackTrace();
}
}
scheduler = new LimboScheduler();
tick = new Tick(this);
permissionManager = new PermissionsManager();
permissionManager.loadDefaultPermissionFile(permissionFile);
eventsManager = new EventsManager();
pluginFolder = new File("plugins");
pluginFolder.mkdirs();
File defaultCommandsJar = new File(pluginFolder, "LimboDefaultCmd.jar");
defaultCommandsJar.delete();
console.sendMessage("Downloading limbo default commands module from github...");
ReadableByteChannel rbc = Channels.newChannel(new URL("https://github.com/LOOHP/Limbo/raw/master/modules/LimboDefaultCmd.jar").openStream());
FileOutputStream fos = new FileOutputStream(defaultCommandsJar);
fos.getChannel().transferFrom(rbc, 0, Long.MAX_VALUE);
fos.close();
pluginManager = new PluginManager(pluginFolder);
try {
Method loadPluginsMethod = PluginManager.class.getDeclaredMethod("loadPlugins");
loadPluginsMethod.setAccessible(true);
loadPluginsMethod.invoke(pluginManager);
loadPluginsMethod.setAccessible(false);
} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
e.printStackTrace();
}
for (LimboPlugin plugin : Limbo.getInstance().getPluginManager().getPlugins()) {
console.sendMessage("Enabling plugin " + plugin.getName() + " " + plugin.getInfo().getVersion());
plugin.onEnable();
}
server = new ServerConnection(properties.getServerIp(), properties.getServerPort());
metrics = new Metrics();
Runtime.getRuntime().addShutdownHook(new Thread(() -> {
Limbo.getInstance().terminate();
}));
console.run();
}
@Deprecated
public Unsafe getUnsafe() {
return unsafe;
}
public Tick getHeartBeat() {
return tick;
}
public LimboScheduler getScheduler() {
return scheduler;
}
public DimensionRegistry getDimensionRegistry() {
return dimensionRegistry;
}
public PermissionsManager getPermissionsManager() {
return permissionManager;
}
public File getInternalDataFolder() {
return internalDataFolder;
}
public EventsManager getEventsManager() {
return eventsManager;
}
public File getPluginFolder() {
return pluginFolder;
}
public PluginManager getPluginManager() {
return pluginManager;
}
private World loadDefaultWorld() throws IOException {
console.sendMessage("Loading world " + properties.getLevelName() + " with the schematic file " + properties.getSchemFileName() + " ...");
File schem = new File(properties.getSchemFileName());
if (!schem.exists()) {
console.sendMessage("Schemetic file " + properties.getSchemFileName() + " for world " + properties.getLevelName() + " not found!");
console.sendMessage("Server will exit!");
System.exit(1);
return null;
}
World world = Schematic.toWorld(properties.getLevelName().getKey(), Environment.fromNamespacedKey(properties.getLevelDimension()), (CompoundTag) NBTUtil.read(schem).getTag());
console.sendMessage("Loaded world " + properties.getLevelName() + "!");
return world;
}
public void registerWorld(World world) {
if (!worlds.contains(world)) {
worlds.add(world);
} else {
throw new RuntimeException("World already registered");
}
}
public void unregisterWorld(World world) {
if (worlds.indexOf(world) == 0) {
throw new RuntimeException("World already registered");
} else if (!worlds.contains(world)) {
throw new RuntimeException("World not registered");
} else {
for (Player player : world.getPlayers()) {
player.teleport(properties.getWorldSpawn());
}
worlds.remove(world);
}
}
public ServerProperties getServerProperties() {
return properties;
}
public ServerConnection getServerConnection() {
return server;
}
public Console getConsole() {
return console;
}
public Metrics getMetrics() {
return metrics;
}
public Set<Player> getPlayers() {
return new HashSet<>(playersByUUID.values());
}
public Player getPlayer(String name) {
return playersByName.get(name);
}
public Player getPlayer(UUID uuid) {
return playersByUUID.get(uuid);
}
public void addPlayer(Player player) {
playersByName.put(player.getName(), player);
playersByUUID.put(player.getUniqueId(), player);
}
public void removePlayer(Player player) {
playersByName.remove(player.getName());
playersByUUID.remove(player.getUniqueId());
}
public List<World> getWorlds() {
return new ArrayList<>(worlds);
}
public World getWorld(String name) {
for (World world : worlds) {
if (world.getName().equalsIgnoreCase(name)) {
return world;
}
}
return null;
}
@SuppressWarnings("unchecked")
public String buildServerListResponseJson(String version, int protocol, BaseComponent[] motd, int maxPlayers, int playersOnline, BufferedImage favicon) throws IOException {
JSONObject json = new JSONObject();
JSONObject versionJson = new JSONObject();
versionJson.put("name", version);
versionJson.put("protocol", protocol);
json.put("version", versionJson);
JSONObject playersJson = new JSONObject();
playersJson.put("max", maxPlayers);
playersJson.put("online", playersOnline);
json.put("players", playersJson);
json.put("description", "%MOTD%");
if (favicon != null) {
if (favicon.getWidth() == 64 && favicon.getHeight() == 64) {
String base64 = "data:image/png;base64," + ImageUtils.imgToBase64String(favicon, "png");
json.put("favicon", base64);
} else {
console.sendMessage("Server List Favicon must be 64 x 64 in size!");
}
}
JSONObject modInfoJson = new JSONObject();
modInfoJson.put("type", "FML");
modInfoJson.put("modList", new JSONArray());
json.put("modinfo", modInfoJson);
TreeMap<String, Object> treeMap = new TreeMap<String, Object>(String.CASE_INSENSITIVE_ORDER);
treeMap.putAll(json);
Gson g = new GsonBuilder().create();
return g.toJson(treeMap).replace("\"%MOTD%\"", ComponentSerializer.toString(motd));
}
public String buildLegacyPingResponse(String version, BaseComponent[] motd, int maxPlayers, int playersOnline) {
String begin = "§1";
return String.join("\00", begin, "127", version, String.join("", Arrays.asList(motd).stream().map(each -> each.toLegacyText()).collect(Collectors.toList())), String.valueOf(playersOnline), String.valueOf(maxPlayers));
}
protected void terminate() {
isRunning.set(false);
console.sendMessage("Stopping Server...");
for (LimboPlugin plugin : Limbo.getInstance().getPluginManager().getPlugins()) {
console.sendMessage("Disabling plugin " + plugin.getName() + " " + plugin.getInfo().getVersion());
plugin.onDisable();
}
tick.waitAndKillThreads(5000);
for (Player player : getPlayers()) {
player.disconnect("Server closed");
}
while (!getPlayers().isEmpty()) {
try {
TimeUnit.MILLISECONDS.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
console.sendMessage("Server closed");
console.logs.close();
}
public void stopServer() {
System.exit(0);
}
public boolean isRunning() {
return isRunning.get();
}
public int getNextEntityId() {
if (entityIdCount.get() == Integer.MAX_VALUE) {
return entityIdCount.getAndSet(0);
} else {
return entityIdCount.getAndIncrement();
}
}
public void dispatchCommand(CommandSender sender, String str) {
String[] command;
if (str.startsWith("/")) {
command = CustomStringUtils.splitStringToArgs(str.substring(1));
} else {
command = CustomStringUtils.splitStringToArgs(str);
}
dispatchCommand(sender, command);
}
public void dispatchCommand(CommandSender sender, String... args) {
try {
Limbo.getInstance().getPluginManager().fireExecutors(sender, args);
} catch (Exception e) {
e.printStackTrace();
}
}
private String getLimboVersion() throws IOException {
Enumeration<URL> manifests = getClass().getClassLoader().getResources("META-INF/MANIFEST.MF");
while (manifests.hasMoreElements()) {
URL url = manifests.nextElement();
BufferedReader br = new BufferedReader(new InputStreamReader(url.openStream()));
Optional<String> line = br.lines().filter(each -> each.startsWith("Limbo-Version:")).findFirst();
br.close();
if (line.isPresent()) {
return line.get().substring(14).trim();
}
}
return "Unknown";
}
}

62
src/main/java/com/loohp/limbo/Unsafe.java Normal file
View File

@ -0,0 +1,62 @@
package com.loohp.limbo;
import java.lang.reflect.Constructor;
import com.loohp.limbo.entity.DataWatcher;
import com.loohp.limbo.entity.Entity;
import com.loohp.limbo.location.Location;
import com.loohp.limbo.player.Player;
import com.loohp.limbo.utils.GameMode;
import com.loohp.limbo.world.World;
@Deprecated
public class Unsafe {
private com.loohp.limbo.player.Unsafe playerUnsafe;
private com.loohp.limbo.world.Unsafe worldUnsafe;
protected Unsafe() {
try {
Constructor<com.loohp.limbo.player.Unsafe> playerConstructor = com.loohp.limbo.player.Unsafe.class.getDeclaredConstructor();
playerConstructor.setAccessible(true);
playerUnsafe = playerConstructor.newInstance();
playerConstructor.setAccessible(false);
Constructor<com.loohp.limbo.world.Unsafe> worldConstructor = com.loohp.limbo.world.Unsafe.class.getDeclaredConstructor();
worldConstructor.setAccessible(true);
worldUnsafe = worldConstructor.newInstance();
worldConstructor.setAccessible(false);
} catch (Exception e) {e.printStackTrace();}
}
@Deprecated
public void setPlayerGameModeSilently(Player player, GameMode mode) {
playerUnsafe.a(player, mode);
}
@Deprecated
public void setSelectedSlotSilently(Player player, byte slot) {
playerUnsafe.a(player, slot);
}
@Deprecated
public void setPlayerEntityId(Player player, int entityId) {
playerUnsafe.a(player, entityId);
}
@Deprecated
public void removeEntity(World world, Entity entity) {
worldUnsafe.a(world, entity);
}
@Deprecated
public DataWatcher getDataWatcher(World world, Entity entity) {
return worldUnsafe.b(world, entity);
}
@Deprecated
public void setPlayerLocationSilently(Player player, Location location) {
playerUnsafe.a(player, location);
}
}

7
src/main/java/com/loohp/limbo/commands/CommandExecutor.java Normal file
View File

@ -0,0 +1,7 @@
package com.loohp.limbo.commands;
public interface CommandExecutor {
public void execute(CommandSender sender, String[] args);
}

25
src/main/java/com/loohp/limbo/commands/CommandSender.java Normal file
View File

@ -0,0 +1,25 @@
package com.loohp.limbo.commands;
import java.util.UUID;
import net.md_5.bungee.api.chat.BaseComponent;
public interface CommandSender {
public void sendMessage(BaseComponent[] component, UUID uuid);
public void sendMessage(BaseComponent component, UUID uuid);
public void sendMessage(String message, UUID uuid);
public void sendMessage(BaseComponent[] component);
public void sendMessage(BaseComponent component);
public void sendMessage(String message);
public boolean hasPermission(String permission);
public String getName();
}

9
src/main/java/com/loohp/limbo/commands/TabCompletor.java Normal file
View File

@ -0,0 +1,9 @@
package com.loohp.limbo.commands;
import java.util.List;
public interface TabCompletor {
public List<String> tabComplete(CommandSender sender, String[] args);
}

22
src/main/java/com/loohp/limbo/consolegui/ConsoleTextOutput.java Normal file
View File

@ -0,0 +1,22 @@
package com.loohp.limbo.consolegui;
import com.loohp.limbo.Limbo;
public class ConsoleTextOutput {
public static void appendText(String string) {
if (!Limbo.noGui) {
GUI.textOutput.setText(GUI.textOutput.getText() + string);
GUI.scrollPane.getVerticalScrollBar().setValue(GUI.scrollPane.getVerticalScrollBar().getMaximum());
}
}
public static void appendText(String string, boolean isWriteLine) {
if (isWriteLine) {
appendText(string + "\n");
} else {
appendText(string);
}
}
}

220
src/main/java/com/loohp/limbo/consolegui/GUI.java Normal file
View File

@ -0,0 +1,220 @@
package com.loohp.limbo.consolegui;
import java.awt.Font;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextField;
import javax.swing.JTextPane;
import javax.swing.border.EmptyBorder;
import com.loohp.limbo.Limbo;
@SuppressWarnings("serial")
public class GUI extends JFrame {
public static JPanel contentPane;
public static JTextField commandInput;
public static JButton execCommand;
public static JTextPane textOutput;
public static JScrollPane scrollPane;
public static JLabel consoleLabel;
public static JLabel clientLabel;
public static JTextPane clientText;
public static JScrollPane scrollPane_client;
public static JLabel sysLabel;
public static JScrollPane scrollPane_sys;
public static JTextPane sysText;
public static List<String> history = new ArrayList<String>();
public static int currenthistory = 0;
public static boolean loadFinish = false;
/**
* Launch the application.
*/
public static void main() {
GUI frame = new GUI();
frame.setVisible(true);
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
SystemInfo.printInfo();
}
});
t1.start();
loadFinish = true;
}
/**
* Create the frame.
*/
public GUI() {
setTitle("Limbo Minecraft Server");
addWindowListener(new WindowAdapter() {
@Override
public void windowClosing(WindowEvent e) {
if (Limbo.getInstance().isRunning()) {
Limbo.getInstance().stopServer();
}
}
});
setBounds(100, 100, 1198, 686);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
GridBagLayout gbl_contentPane = new GridBagLayout();
gbl_contentPane.columnWidths = new int[]{243, 10, 36, 111, 0};
gbl_contentPane.rowHeights = new int[]{0, 160, 0, 10, 33, 33, 0};
gbl_contentPane.columnWeights = new double[]{0.0, 0.0, 1.0, 0.0, Double.MIN_VALUE};
gbl_contentPane.rowWeights = new double[]{0.0, 0.0, 0.0, 0.0, 1.0, 0.0, Double.MIN_VALUE};
contentPane.setLayout(gbl_contentPane);
sysLabel = new JLabel("System Information");
sysLabel.setFont(new Font("Arial", Font.BOLD, 11));
GridBagConstraints gbc_sysLabel = new GridBagConstraints();
gbc_sysLabel.fill = GridBagConstraints.BOTH;
gbc_sysLabel.insets = new Insets(0, 0, 5, 5);
gbc_sysLabel.gridx = 0;
gbc_sysLabel.gridy = 0;
contentPane.add(sysLabel, gbc_sysLabel);
consoleLabel = new JLabel("Console Output");
consoleLabel.setFont(new Font("Arial", Font.BOLD, 11));
GridBagConstraints gbc_consoleLabel = new GridBagConstraints();
gbc_consoleLabel.anchor = GridBagConstraints.WEST;
gbc_consoleLabel.insets = new Insets(0, 0, 5, 5);
gbc_consoleLabel.gridx = 2;
gbc_consoleLabel.gridy = 0;
contentPane.add(consoleLabel, gbc_consoleLabel);
commandInput = new JTextField();
commandInput.setToolTipText("Input a command");
commandInput.addKeyListener(new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
if (e.getKeyCode() == 10) {
String cmd = commandInput.getText();
if (!commandInput.getText().equals("")) {
history.add(cmd);
currenthistory = history.size();
}
Limbo.getInstance().dispatchCommand(Limbo.getInstance().getConsole(), cmd.trim().replaceAll(" +", " "));
commandInput.setText("");
} else if (e.getKeyCode() == 38) {
currenthistory--;
if (currenthistory >= 0) {
commandInput.setText(history.get(currenthistory));
} else {
currenthistory++;
}
} else if (e.getKeyCode() == 40) {
currenthistory++;
if (currenthistory < history.size()) {
commandInput.setText(history.get(currenthistory));
} else {
currenthistory--;
}
}
}
});
scrollPane_sys = new JScrollPane();
GridBagConstraints gbc_scrollPane_sys = new GridBagConstraints();
gbc_scrollPane_sys.insets = new Insets(0, 0, 5, 5);
gbc_scrollPane_sys.fill = GridBagConstraints.BOTH;
gbc_scrollPane_sys.gridx = 0;
gbc_scrollPane_sys.gridy = 1;
contentPane.add(scrollPane_sys, gbc_scrollPane_sys);
sysText = new JTextPane();
sysText.setFont(new Font("Consolas", Font.PLAIN, 12));
sysText.setEditable(false);
scrollPane_sys.setViewportView(sysText);
clientLabel = new JLabel("Connected Clients");
clientLabel.setFont(new Font("Arial", Font.BOLD, 11));
GridBagConstraints gbc_clientLabel = new GridBagConstraints();
gbc_clientLabel.anchor = GridBagConstraints.WEST;
gbc_clientLabel.insets = new Insets(0, 0, 5, 5);
gbc_clientLabel.gridx = 0;
gbc_clientLabel.gridy = 3;
contentPane.add(clientLabel, gbc_clientLabel);
scrollPane_client = new JScrollPane();
GridBagConstraints gbc_scrollPane_client = new GridBagConstraints();
gbc_scrollPane_client.fill = GridBagConstraints.BOTH;
gbc_scrollPane_client.gridheight = 2;
gbc_scrollPane_client.insets = new Insets(0, 0, 0, 5);
gbc_scrollPane_client.gridx = 0;
gbc_scrollPane_client.gridy = 4;
contentPane.add(scrollPane_client, gbc_scrollPane_client);
clientText = new JTextPane();
scrollPane_client.setViewportView(clientText);
clientText.setFont(new Font("Consolas", Font.PLAIN, 12));
clientText.setEditable(false);
scrollPane = new JScrollPane();
GridBagConstraints gbc_scrollPane = new GridBagConstraints();
gbc_scrollPane.gridheight = 4;
gbc_scrollPane.insets = new Insets(0, 0, 5, 0);
gbc_scrollPane.gridwidth = 2;
gbc_scrollPane.fill = GridBagConstraints.BOTH;
gbc_scrollPane.gridx = 2;
gbc_scrollPane.gridy = 1;
contentPane.add(scrollPane, gbc_scrollPane);
textOutput = new JTextPane();
scrollPane.setViewportView(textOutput);
textOutput.setFont(new Font("Consolas", Font.PLAIN, 12));
textOutput.setEditable(false);
commandInput.setFont(new Font("Tahoma", Font.PLAIN, 19));
GridBagConstraints gbc_commandInput = new GridBagConstraints();
gbc_commandInput.insets = new Insets(0, 0, 0, 5);
gbc_commandInput.fill = GridBagConstraints.BOTH;
gbc_commandInput.gridx = 2;
gbc_commandInput.gridy = 5;
contentPane.add(commandInput, gbc_commandInput);
commandInput.setColumns(10);
execCommand = new JButton("RUN");
execCommand.setToolTipText("Execute a command");
execCommand.addMouseListener(new MouseAdapter() {
@Override
public void mouseReleased(MouseEvent e) {
String cmd = commandInput.getText();
if (!commandInput.getText().equals("")) {
history.add(cmd);
currenthistory = history.size();
}
Limbo.getInstance().dispatchCommand(Limbo.getInstance().getConsole(), cmd.trim().replaceAll(" +", " "));
commandInput.setText("");
}
});
execCommand.setFont(new Font("Tahoma", Font.PLAIN, 19));
GridBagConstraints gbc_execCommand = new GridBagConstraints();
gbc_execCommand.fill = GridBagConstraints.BOTH;
gbc_execCommand.gridx = 3;
gbc_execCommand.gridy = 5;
contentPane.add(execCommand, gbc_execCommand);
}
}

49
src/main/java/com/loohp/limbo/consolegui/SystemInfo.java Normal file
View File

@ -0,0 +1,49 @@
package com.loohp.limbo.consolegui;
import java.lang.management.ManagementFactory;
import java.text.NumberFormat;
import java.util.concurrent.TimeUnit;
import com.loohp.limbo.Limbo;
public class SystemInfo {
public static void printInfo() {
if (!Limbo.noGui) {
while (true) {
Runtime runtime = Runtime.getRuntime();
NumberFormat format = NumberFormat.getInstance();
StringBuilder sb = new StringBuilder();
long maxMemory = runtime.maxMemory();
long allocatedMemory = runtime.totalMemory();
long freeMemory = runtime.freeMemory();
sb.append("Free Memory: " + format.format(freeMemory / 1024 / 1024) + " MB\n");
sb.append("Allocated Memory: " + format.format(allocatedMemory / 1024 / 1024) + " MB\n");
sb.append("Max Memory: " + format.format(maxMemory / 1024 / 1024) + " MB\n");
sb.append("Memory Usage: " + format.format((allocatedMemory - freeMemory) / 1024 / 1024) + "/" + format.format(maxMemory / 1024 / 1024) + " MB (" + Math.round((double) (allocatedMemory - freeMemory) / (double) (maxMemory) * 100) + "%)\n");
sb.append("\n");
try {
@SuppressWarnings("restriction")
com.sun.management.OperatingSystemMXBean operatingSystemMXBean = (com.sun.management.OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
@SuppressWarnings("restriction")
double processLoad = operatingSystemMXBean.getProcessCpuLoad();
@SuppressWarnings("restriction")
double systemLoad = operatingSystemMXBean.getSystemCpuLoad();
int processors = runtime.availableProcessors();
sb.append("Available Processors: " + processors + "\n");
sb.append("Process CPU Load: " + Math.round(processLoad * 100) + "%\n");
sb.append("System CPU Load: " + Math.round(systemLoad * 100) + "%\n");
GUI.sysText.setText(sb.toString());
} catch (Exception ignore) {}
try {TimeUnit.MILLISECONDS.sleep(1000);} catch (InterruptedException e) {}
}
}
}
}

135
src/main/java/com/loohp/limbo/entity/ArmorStand.java Normal file
View File

@ -0,0 +1,135 @@
package com.loohp.limbo.entity;
import java.util.UUID;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.entity.DataWatcher.WatchableField;
import com.loohp.limbo.entity.DataWatcher.WatchableObjectType;
import com.loohp.limbo.location.Location;
import com.loohp.limbo.utils.Rotation3f;
import com.loohp.limbo.world.World;
public class ArmorStand extends LivingEntity {
@WatchableField(MetadataIndex = 14, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x01)
protected boolean small = false;
@WatchableField(MetadataIndex = 14, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x04)
protected boolean arms = false;
@WatchableField(MetadataIndex = 14, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x08)
protected boolean noBasePlate = false;
@WatchableField(MetadataIndex = 14, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x10)
protected boolean marker = false;
@WatchableField(MetadataIndex = 15, WatchableObjectType = WatchableObjectType.ROTATION)
protected Rotation3f headRotation = new Rotation3f(0.0, 0.0, 0.0);
@WatchableField(MetadataIndex = 16, WatchableObjectType = WatchableObjectType.ROTATION)
protected Rotation3f bodyRotation = new Rotation3f(0.0, 0.0, 0.0);
@WatchableField(MetadataIndex = 17, WatchableObjectType = WatchableObjectType.ROTATION)
protected Rotation3f leftArmRotation = new Rotation3f(-10.0, 0.0, -10.0);
@WatchableField(MetadataIndex = 18, WatchableObjectType = WatchableObjectType.ROTATION)
protected Rotation3f rightArmRotation = new Rotation3f(-15.0, 0.0, 10.0);
@WatchableField(MetadataIndex = 19, WatchableObjectType = WatchableObjectType.ROTATION)
protected Rotation3f leftLegRotation = new Rotation3f(-1.0, 0.0, -1.0);
@WatchableField(MetadataIndex = 20, WatchableObjectType = WatchableObjectType.ROTATION)
protected Rotation3f rightLegRotation = new Rotation3f(1.0, 0.0, 1.0);
public ArmorStand(int entityId, UUID uuid, World world, double x, double y, double z, float yaw, float pitch) {
super(EntityType.ARMOR_STAND, entityId, uuid, world, x, y, z, yaw, pitch);
}
public ArmorStand(UUID uuid, World world, double x, double y, double z, float yaw, float pitch) {
this(Limbo.getInstance().getNextEntityId(), uuid, world, x, y, z, yaw, pitch);
}
public ArmorStand(World world, double x, double y, double z, float yaw, float pitch) {
this(Limbo.getInstance().getNextEntityId(), UUID.randomUUID(), world, x, y, z, yaw, pitch);
}
public ArmorStand(UUID uuid, Location location) {
this(Limbo.getInstance().getNextEntityId(), uuid, location.getWorld(), location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
}
public ArmorStand(Location location) {
this(Limbo.getInstance().getNextEntityId(), UUID.randomUUID(), location.getWorld(), location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
}
public boolean isSmall() {
return small;
}
public void setSmall(boolean small) {
this.small = small;
}
public boolean showArms() {
return arms;
}
public void setArms(boolean arms) {
this.arms = arms;
}
public boolean hasNoBasePlate() {
return noBasePlate;
}
public void setNoBasePlate(boolean noBasePlate) {
this.noBasePlate = noBasePlate;
}
public boolean isMarker() {
return marker;
}
public void setMarker(boolean marker) {
this.marker = marker;
}
public Rotation3f getHeadRotation() {
return headRotation;
}
public void setHeadRotation(Rotation3f headRotation) {
this.headRotation = headRotation;
}
public Rotation3f getBodyRotation() {
return bodyRotation;
}
public void setBodyRotation(Rotation3f bodyRotation) {
this.bodyRotation = bodyRotation;
}
public Rotation3f getLeftArmRotation() {
return leftArmRotation;
}
public void setLeftArmRotation(Rotation3f leftArmRotation) {
this.leftArmRotation = leftArmRotation;
}
public Rotation3f getRightArmRotation() {
return rightArmRotation;
}
public void setRightArmRotation(Rotation3f rightArmRotation) {
this.rightArmRotation = rightArmRotation;
}
public Rotation3f getLeftLegRotation() {
return leftLegRotation;
}
public void setLeftLegRotation(Rotation3f leftLegRotation) {
this.leftLegRotation = leftLegRotation;
}
public Rotation3f getRightLegRotation() {
return rightLegRotation;
}
public void setRightLegRotation(Rotation3f rightLegRotation) {
this.rightLegRotation = rightLegRotation;
}
}

178
src/main/java/com/loohp/limbo/entity/DataWatcher.java Normal file
View File

@ -0,0 +1,178 @@
package com.loohp.limbo.entity;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
public class DataWatcher {
private Entity entity;
private Map<Field, WatchableObject> values;
public DataWatcher(Entity entity) {
this.entity = entity;
this.values = new HashMap<>();
Class<?> clazz = entity.getClass();
while (clazz != null) {
for (Field field : clazz.getDeclaredFields()) {
WatchableField a = field.getAnnotation(WatchableField.class);
if (a != null) {
field.setAccessible(true);
try {
values.put(field, new WatchableObject(field.get(entity), a.MetadataIndex(), a.WatchableObjectType(), a.IsOptional(), a.IsBitmask(), a.Bitmask()));
} catch (IllegalArgumentException | IllegalAccessException e) {
e.printStackTrace();
}
}
}
clazz = clazz.getSuperclass();
}
}
public Entity getEntity() {
return entity;
}
public boolean isValid() {
return entity.isValid();
}
public synchronized Map<Field, WatchableObject> update() throws IllegalArgumentException, IllegalAccessException {
if (!isValid()) {
return null;
}
Map<Field, WatchableObject> updated = new HashMap<>();
for (Entry<Field, WatchableObject> entry : values.entrySet()) {
Field field = entry.getKey();
WatchableObject watchableObj = entry.getValue();
field.setAccessible(true);
Object newValue = field.get(entity);
if ((newValue == null && watchableObj.getValue() != null) || (newValue != null && watchableObj.getValue() == null) || (newValue != null && watchableObj.getValue() != null && !newValue.equals(watchableObj.getValue()))) {
watchableObj.setValue(newValue);
updated.put(field, watchableObj);
}
}
return updated;
}
public Map<Field, WatchableObject> getWatchableObjects() {
return Collections.unmodifiableMap(values);
}
public static class WatchableObject {
private int index;
private WatchableObjectType type;
private boolean optional;
private boolean isBitmask;
private int bitmask;
private Object value;
public WatchableObject(Object value, int index, WatchableObjectType type, boolean optional, boolean isBitmask, int bitmask) {
this.index = index;
this.type = type;
this.optional = optional;
this.isBitmask = isBitmask;
this.bitmask = bitmask;
this.value = value;
}
public WatchableObject(Object value, int index, WatchableObjectType type, boolean isBitmask, int bitmask) {
this(value, index, type, false, isBitmask, bitmask);
}
public WatchableObject(Object value, int index, WatchableObjectType type, boolean optional) {
this(value, index, type, optional, false, 0x00);
}
public WatchableObject(Object value, int index, WatchableObjectType type) {
this(value, index, type, false, false, 0x00);
}
public Object getValue() {
return value;
}
public void setValue(Object newValue) {
this.value = newValue;
}
public int getIndex() {
return index;
}
public WatchableObjectType getType() {
return type;
}
public boolean isOptional() {
return optional;
}
public boolean isBitmask() {
return isBitmask;
}
public int getBitmask() {
return bitmask;
}
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public static @interface WatchableField {
int MetadataIndex();
WatchableObjectType WatchableObjectType();
boolean IsOptional() default false;
boolean IsBitmask() default false;
int Bitmask() default 0x00;
}
public static enum WatchableObjectType {
BYTE(0),
VARINT(1, 17),
FLOAT(2),
STRING(3),
CHAT(4, 5),
SLOT(6),
BOOLEAN(7),
ROTATION(8),
POSITION(9, 10),
DIRECTION(11),
UUID(-1, 12),
BLOCKID(-1, 13),
NBT(14),
PARTICLE(15),
VILLAGER_DATA(16),
POSE(18);
int typeId;
int optionalTypeId;
WatchableObjectType(int typeId, int optionalTypeId) {
this.typeId = typeId;
this.optionalTypeId = optionalTypeId;
}
WatchableObjectType(int typeId) {
this(typeId, -1);
}
public int getTypeId() {
return typeId;
}
public int getOptionalTypeId() {
return optionalTypeId;
}
}
}

283
src/main/java/com/loohp/limbo/entity/Entity.java Normal file
View File

@ -0,0 +1,283 @@
package com.loohp.limbo.entity;
import java.util.UUID;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.entity.DataWatcher.WatchableField;
import com.loohp.limbo.entity.DataWatcher.WatchableObjectType;
import com.loohp.limbo.location.Location;
import com.loohp.limbo.world.World;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
public abstract class Entity {
@WatchableField(MetadataIndex = 0, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x01)
protected boolean onFire = false;
@WatchableField(MetadataIndex = 0, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x02)
protected boolean crouching = false;
@WatchableField(MetadataIndex = 0, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x04)
protected boolean unused = false;
@WatchableField(MetadataIndex = 0, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x08)
protected boolean sprinting = false;
@WatchableField(MetadataIndex = 0, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x10)
protected boolean swimming = false;
@WatchableField(MetadataIndex = 0, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x20)
protected boolean invisible = false;
@WatchableField(MetadataIndex = 0, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x40)
protected boolean glowing = false;
@WatchableField(MetadataIndex = 0, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x80)
protected boolean elytraFlying = false;
@WatchableField(MetadataIndex = 1, WatchableObjectType = WatchableObjectType.VARINT)
protected int air = 300;
@WatchableField(MetadataIndex = 2, WatchableObjectType = WatchableObjectType.CHAT, IsOptional = true)
protected BaseComponent[] customName = null;
@WatchableField(MetadataIndex = 3, WatchableObjectType = WatchableObjectType.BOOLEAN)
protected boolean customNameVisible = false;
@WatchableField(MetadataIndex = 4, WatchableObjectType = WatchableObjectType.BOOLEAN)
protected boolean silent = false;
@WatchableField(MetadataIndex = 5, WatchableObjectType = WatchableObjectType.BOOLEAN)
protected boolean noGravity = false;
@WatchableField(MetadataIndex = 6, WatchableObjectType = WatchableObjectType.POSE)
protected Pose pose = Pose.STANDING;
protected final EntityType type;
protected int entityId;
protected UUID uuid;
protected World world;
protected double x;
protected double y;
protected double z;
protected float yaw;
protected float pitch;
public Entity(EntityType type, int entityId, UUID uuid, World world, double x, double y, double z, float yaw, float pitch) {
this.type = type;
this.entityId = entityId;
this.uuid = uuid;
this.world = world;
this.x = x;
this.y = y;
this.z = z;
this.yaw = yaw;
this.pitch = pitch;
}
public Entity(EntityType type, UUID uuid, World world, double x, double y, double z, float yaw, float pitch) {
this(type, Limbo.getInstance().getNextEntityId(), uuid, world, x, y, z, yaw, pitch);
}
public Entity(EntityType type, World world, double x, double y, double z, float yaw, float pitch) {
this(type, Limbo.getInstance().getNextEntityId(), UUID.randomUUID(), world, x, y, z, yaw, pitch);
}
public Entity(EntityType type, UUID uuid, Location location) {
this(type, Limbo.getInstance().getNextEntityId(), uuid, location.getWorld(), location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
}
public Entity(EntityType type, Location location) {
this(type, Limbo.getInstance().getNextEntityId(), UUID.randomUUID(), location.getWorld(), location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
}
public EntityType getType() {
return type;
}
public Location getLocation() {
return new Location(world, x, y, z, yaw, pitch);
}
public void teleport(Location location) {
this.world = location.getWorld();
this.x = location.getX();
this.y = location.getY();
this.z = location.getZ();
this.yaw = location.getYaw();
this.pitch = location.getPitch();
}
public BaseComponent[] getCustomName() {
return customName;
}
public void setCustomName(String name) {
this.customName = name == null ? null : new BaseComponent[] {new TextComponent(name)};
}
public void setCustomName(BaseComponent component) {
this.customName = component == null ? null : new BaseComponent[] {component};
}
public void setCustomName(BaseComponent[] components) {
this.customName = components;
}
public boolean isOnFire() {
return onFire;
}
public void setOnFire(boolean onFire) {
this.onFire = onFire;
}
public boolean isCrouching() {
return crouching;
}
public void setCrouching(boolean crouching) {
this.crouching = crouching;
}
public boolean isSprinting() {
return sprinting;
}
public void setSprinting(boolean sprinting) {
this.sprinting = sprinting;
}
public boolean isSwimming() {
return swimming;
}
public void setSwimming(boolean swimming) {
this.swimming = swimming;
}
public boolean isInvisible() {
return invisible;
}
public void setInvisible(boolean invisible) {
this.invisible = invisible;
}
public boolean isGlowing() {
return glowing;
}
public void setGlowing(boolean glowing) {
this.glowing = glowing;
}
public boolean isElytraFlying() {
return elytraFlying;
}
public void setElytraFlying(boolean elytraFlying) {
this.elytraFlying = elytraFlying;
}
public int getAir() {
return air;
}
public void setAir(int air) {
this.air = air;
}
public boolean isCustomNameVisible() {
return customNameVisible;
}
public void setCustomNameVisible(boolean customNameVisible) {
this.customNameVisible = customNameVisible;
}
public boolean isSilent() {
return silent;
}
public void setSilent(boolean silent) {
this.silent = silent;
}
public boolean hasGravity() {
return !noGravity;
}
public void setGravity(boolean gravity) {
this.noGravity = !gravity;
}
public Pose getPose() {
return pose;
}
public void setPose(Pose pose) {
this.pose = pose;
}
public World getWorld() {
return world;
}
public void setWorld(World world) {
this.world = world;
}
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
public double getZ() {
return z;
}
public void setZ(double z) {
this.z = z;
}
public float getYaw() {
return yaw;
}
public void setYaw(float yaw) {
this.yaw = yaw;
}
public float getPitch() {
return pitch;
}
public void setPitch(float pitch) {
this.pitch = pitch;
}
public int getEntityId() {
return entityId;
}
public UUID getUniqueId() {
return uuid;
}
public boolean isValid() {
return world.getEntities().contains(this);
}
@SuppressWarnings("deprecation")
public void remove() {
Limbo.getInstance().getUnsafe().removeEntity(world, this);
}
@SuppressWarnings("deprecation")
public DataWatcher getDataWatcher() {
return Limbo.getInstance().getUnsafe().getDataWatcher(world, this);
}
}

397
src/main/java/com/loohp/limbo/entity/EntityType.java Normal file
View File

@ -0,0 +1,397 @@
package com.loohp.limbo.entity;
import java.util.HashMap;
import java.util.Map;
import com.loohp.limbo.location.Location;
import com.loohp.limbo.player.Player;
import com.loohp.limbo.utils.NamespacedKey;
import com.loohp.limbo.world.World;
public enum EntityType {
// These strings MUST match the strings in nms.EntityTypes and are case sensitive.
/**
* An item resting on the ground.
* <p>
* Spawn with {@link World#dropItem(Location, ItemStack)} or {@link
* World#dropItemNaturally(Location, ItemStack)}
*/
//DROPPED_ITEM("item", Item.class, 1, false),
/**
* An experience orb.
*/
//EXPERIENCE_ORB("experience_orb", ExperienceOrb.class, 2),
/**
* @see AreaEffectCloud
*/
//AREA_EFFECT_CLOUD("area_effect_cloud", AreaEffectCloud.class, 3),
/**
* @see ElderGuardian
*/
//ELDER_GUARDIAN("elder_guardian", ElderGuardian.class, 4),
/**
* @see WitherSkeleton
*/
//WITHER_SKELETON("wither_skeleton", WitherSkeleton.class, 5),
/**
* @see Stray
*/
//STRAY("stray", Stray.class, 6),
/**
* A flying chicken egg.
*/
//EGG("egg", Egg.class, 7),
/**
* A leash attached to a fencepost.
*/
//LEASH_HITCH("leash_knot", LeashHitch.class, 8),
/**
* A painting on a wall.
*/
//PAINTING("painting", Painting.class, 9),
/**
* An arrow projectile; may get stuck in the ground.
*/
//ARROW("arrow", Arrow.class, 10),
/**
* A flying snowball.
*/
//SNOWBALL("snowball", Snowball.class, 11),
/**
* A flying large fireball, as thrown by a Ghast for example.
*/
//FIREBALL("fireball", LargeFireball.class, 12),
/**
* A flying small fireball, such as thrown by a Blaze or player.
*/
//SMALL_FIREBALL("small_fireball", SmallFireball.class, 13),
/**
* A flying ender pearl.
*/
//ENDER_PEARL("ender_pearl", EnderPearl.class, 14),
/**
* An ender eye signal.
*/
//ENDER_SIGNAL("eye_of_ender", EnderSignal.class, 15),
/**
* A flying splash potion.
*/
//SPLASH_POTION("potion", ThrownPotion.class, 16, false),
/**
* A flying experience bottle.
*/
//THROWN_EXP_BOTTLE("experience_bottle", ThrownExpBottle.class, 17),
/**
* An item frame on a wall.
*/
//ITEM_FRAME("item_frame", ItemFrame.class, 18),
/**
* A flying wither skull projectile.
*/
//WITHER_SKULL("wither_skull", WitherSkull.class, 19),
/**
* Primed TNT that is about to explode.
*/
//PRIMED_TNT("tnt", TNTPrimed.class, 20),
/**
* A block that is going to or is about to fall.
*/
//FALLING_BLOCK("falling_block", FallingBlock.class, 21, false),
/**
* Internal representation of a Firework once it has been launched.
*/
//FIREWORK("firework_rocket", Firework.class, 22, false),
/**
* @see Husk
*/
//HUSK("husk", Husk.class, 23),
/**
* Like {@link #ARROW} but causes the {@link PotionEffectType#GLOWING} effect on all team members.
*/
//SPECTRAL_ARROW("spectral_arrow", SpectralArrow.class, 24),
/**
* Bullet fired by {@link #SHULKER}.
*/
//SHULKER_BULLET("shulker_bullet", ShulkerBullet.class, 25),
/**
* Like {@link #FIREBALL} but with added effects.
*/
//DRAGON_FIREBALL("dragon_fireball", DragonFireball.class, 26),
/**
* @see ZombieVillager
*/
//ZOMBIE_VILLAGER("zombie_villager", ZombieVillager.class, 27),
/**
* @see SkeletonHorse
*/
//SKELETON_HORSE("skeleton_horse", SkeletonHorse.class, 28),
/**
* @see ZombieHorse
*/
//ZOMBIE_HORSE("zombie_horse", ZombieHorse.class, 29),
/**
* Mechanical entity with an inventory for placing weapons / armor into.
*/
ARMOR_STAND("armor_stand", ArmorStand.class, 1),
/**
* @see Donkey
*/
//DONKEY("donkey", Donkey.class, 31),
/**
* @see Mule
*/
//MULE("mule", Mule.class, 32),
/**
* @see EvokerFangs
*/
//EVOKER_FANGS("evoker_fangs", EvokerFangs.class, 33),
/**
* @see Evoker
*/
//EVOKER("evoker", Evoker.class, 34),
/**
* @see Vex
*/
//VEX("vex", Vex.class, 35),
/**
* @see Vindicator
*/
//VINDICATOR("vindicator", Vindicator.class, 36),
/**
* @see Illusioner
*/
//ILLUSIONER("illusioner", Illusioner.class, 37),
/**
* @see CommandMinecart
*/
//MINECART_COMMAND("command_block_minecart", CommandMinecart.class, 40),
/**
* A placed boat.
*/
//BOAT("boat", Boat.class, 41),
/**
* @see RideableMinecart
*/
//MINECART("minecart", RideableMinecart.class, 42),
/**
* @see StorageMinecart
*/
//MINECART_CHEST("chest_minecart", StorageMinecart.class, 43),
/**
* @see PoweredMinecart
*/
//MINECART_FURNACE("furnace_minecart", PoweredMinecart.class, 44),
/**
* @see ExplosiveMinecart
*/
//MINECART_TNT("tnt_minecart", ExplosiveMinecart.class, 45),
/**
* @see HopperMinecart
*/
//MINECART_HOPPER("hopper_minecart", HopperMinecart.class, 46),
/**
* @see SpawnerMinecart
*/
//MINECART_MOB_SPAWNER("spawner_minecart", SpawnerMinecart.class, 47),
//CREEPER("creeper", Creeper.class, 50),
//SKELETON("skeleton", Skeleton.class, 51),
//SPIDER("spider", Spider.class, 52),
//GIANT("giant", Giant.class, 53),
//ZOMBIE("zombie", Zombie.class, 54),
//SLIME("slime", Slime.class, 55),
//GHAST("ghast", Ghast.class, 56),
//ZOMBIFIED_PIGLIN("zombified_piglin", PigZombie.class, 57),
//ENDERMAN("enderman", Enderman.class, 58),
//CAVE_SPIDER("cave_spider", CaveSpider.class, 59),
//SILVERFISH("silverfish", Silverfish.class, 60),
//BLAZE("blaze", Blaze.class, 61),
//MAGMA_CUBE("magma_cube", MagmaCube.class, 62),
//ENDER_DRAGON("ender_dragon", EnderDragon.class, 63),
//WITHER("wither", Wither.class, 64),
//BAT("bat", Bat.class, 65),
//WITCH("witch", Witch.class, 66),
//ENDERMITE("endermite", Endermite.class, 67),
//GUARDIAN("guardian", Guardian.class, 68),
//SHULKER("shulker", Shulker.class, 69),
//PIG("pig", Pig.class, 90),
//SHEEP("sheep", Sheep.class, 91),
//COW("cow", Cow.class, 92),
//CHICKEN("chicken", Chicken.class, 93),
//SQUID("squid", Squid.class, 94),
//WOLF("wolf", Wolf.class, 95),
//MUSHROOM_COW("mooshroom", MushroomCow.class, 96),
//SNOWMAN("snow_golem", Snowman.class, 97),
//OCELOT("ocelot", Ocelot.class, 98),
//IRON_GOLEM("iron_golem", IronGolem.class, 99),
//HORSE("horse", Horse.class, 100),
//RABBIT("rabbit", Rabbit.class, 101),
//POLAR_BEAR("polar_bear", PolarBear.class, 102),
//LLAMA("llama", Llama.class, 103),
//LLAMA_SPIT("llama_spit", LlamaSpit.class, 104),
//PARROT("parrot", Parrot.class, 105),
//VILLAGER("villager", Villager.class, 120),
//ENDER_CRYSTAL("end_crystal", EnderCrystal.class, 200),
//TURTLE("turtle", Turtle.class, -1),
//PHANTOM("phantom", Phantom.class, -1),
//TRIDENT("trident", Trident.class, -1),
//COD("cod", Cod.class, -1),
//SALMON("salmon", Salmon.class, -1),
//PUFFERFISH("pufferfish", PufferFish.class, -1),
//TROPICAL_FISH("tropical_fish", TropicalFish.class, -1),
//DROWNED("drowned", Drowned.class, -1),
//DOLPHIN("dolphin", Dolphin.class, -1),
//CAT("cat", Cat.class, -1),
//PANDA("panda", Panda.class, -1),
//PILLAGER("pillager", Pillager.class, -1),
//RAVAGER("ravager", Ravager.class, -1),
//TRADER_LLAMA("trader_llama", TraderLlama.class, -1),
//WANDERING_TRADER("wandering_trader", WanderingTrader.class, -1),
//FOX("fox", Fox.class, -1),
//BEE("bee", Bee.class, -1),
//HOGLIN("hoglin", Hoglin.class, -1),
//PIGLIN("piglin", Piglin.class, -1),
//STRIDER("strider", Strider.class, -1),
//ZOGLIN("zoglin", Zoglin.class, -1),
//PIGLIN_BRUTE("piglin_brute", PiglinBrute.class, -1),
/**
* A fishing line and bobber.
*/
//FISHING_HOOK("fishing_bobber", FishHook.class, -1, false),
/**
* A bolt of lightning.
* <p>
* Spawn with {@link World#strikeLightning(Location)}.
*/
//LIGHTNING("lightning_bolt", LightningStrike.class, -1, false),
PLAYER("player", Player.class, 106, false),
/**
* An unknown entity without an Entity Class
*/
UNKNOWN(null, null, -1, false);
private final String name;
private final Class<? extends Entity> clazz;
private final short typeId;
private final boolean independent;
private final boolean living;
private final NamespacedKey key;
private static final Map<String, EntityType> NAME_MAP = new HashMap<>();
private static final Map<Short, EntityType> ID_MAP = new HashMap<>();
static {
for (EntityType type : values()) {
if (type.name != null) {
NAME_MAP.put(type.name.toLowerCase(java.util.Locale.ENGLISH), type);
}
if (type.typeId > 0) {
ID_MAP.put(type.typeId, type);
}
}
// Add legacy names
/*
NAME_MAP.put("xp_orb", EXPERIENCE_ORB);
NAME_MAP.put("eye_of_ender_signal", ENDER_SIGNAL);
NAME_MAP.put("xp_bottle", THROWN_EXP_BOTTLE);
NAME_MAP.put("fireworks_rocket", FIREWORK);
NAME_MAP.put("evocation_fangs", EVOKER_FANGS);
NAME_MAP.put("evocation_illager", EVOKER);
NAME_MAP.put("vindication_illager", VINDICATOR);
NAME_MAP.put("illusion_illager", ILLUSIONER);
NAME_MAP.put("commandblock_minecart", MINECART_COMMAND);
NAME_MAP.put("snowman", SNOWMAN);
NAME_MAP.put("villager_golem", IRON_GOLEM);
NAME_MAP.put("ender_crystal", ENDER_CRYSTAL);
NAME_MAP.put("zombie_pigman", ZOMBIFIED_PIGLIN);
*/
}
private EntityType(String name, Class<? extends Entity> clazz, int typeId) {
this(name, clazz, typeId, true);
}
private EntityType(String name, Class<? extends Entity> clazz, int typeId, boolean independent) {
this.name = name;
this.clazz = clazz;
this.typeId = (short) typeId;
this.independent = independent;
this.living = clazz != null && LivingEntity.class.isAssignableFrom(clazz);
this.key = (name == null) ? null : NamespacedKey.minecraft(name);
}
/**
* Gets the entity type name.
*
* @return the entity type's name
* @deprecated Magic value
*/
@Deprecated
public String getName() {
return name;
}
public NamespacedKey getKey() {
return key;
}
public Class<? extends Entity> getEntityClass() {
return clazz;
}
/**
* Gets the entity network type id.
*
* @return the network type id
*/
public short getTypeId() {
return typeId;
}
/**
* Gets an entity type from its name.
*
* @param name the entity type's name
* @return the matching entity type or null
* @deprecated Magic value
*/
@Deprecated
public static EntityType fromName(String name) {
if (name == null) {
return null;
}
return NAME_MAP.get(name.toLowerCase(java.util.Locale.ENGLISH));
}
/**
* Gets an entity from its id.
*
* @param id the raw type id
* @return the matching entity type or null
* @deprecated Magic value
*/
@Deprecated
public static EntityType fromId(int id) {
if (id > Short.MAX_VALUE) {
return null;
}
return ID_MAP.get((short) id);
}
/**
* Some entities cannot be spawned using {@link
* World#spawnEntity(Location, EntityType)} or {@link
* World#spawn(Location, Class)}, usually because they require additional
* information in order to spawn.
*
* @return False if the entity type cannot be spawned
*/
public boolean isSpawnable() {
return independent;
}
public boolean isAlive() {
return living;
}
}

132
src/main/java/com/loohp/limbo/entity/LivingEntity.java Normal file
View File

@ -0,0 +1,132 @@
package com.loohp.limbo.entity;
import java.util.UUID;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.entity.DataWatcher.WatchableField;
import com.loohp.limbo.entity.DataWatcher.WatchableObjectType;
import com.loohp.limbo.inventory.EquipmentSlot;
import com.loohp.limbo.location.Location;
import com.loohp.limbo.world.BlockPosition;
import com.loohp.limbo.world.World;
public abstract class LivingEntity extends Entity {
@WatchableField(MetadataIndex = 7, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x01)
protected boolean handActive = false;
@WatchableField(MetadataIndex = 7, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x02)
protected boolean activeHand = false; //false = main hand, true = off hand
@WatchableField(MetadataIndex = 7, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x04)
protected boolean inRiptideSpinAttack = false;
@WatchableField(MetadataIndex = 8, WatchableObjectType = WatchableObjectType.FLOAT)
protected float health = 1.0F;
@WatchableField(MetadataIndex = 9, WatchableObjectType = WatchableObjectType.VARINT)
protected int potionEffectColor = 0;
@WatchableField(MetadataIndex = 10, WatchableObjectType = WatchableObjectType.BOOLEAN)
protected boolean potionEffectAmbient = false;
@WatchableField(MetadataIndex = 11, WatchableObjectType = WatchableObjectType.VARINT)
protected int arrowsInEntity = 0;
@WatchableField(MetadataIndex = 12, WatchableObjectType = WatchableObjectType.VARINT)
protected int absorption = 0;
@WatchableField(MetadataIndex = 13, WatchableObjectType = WatchableObjectType.POSITION, IsOptional = true)
protected BlockPosition sleepingLocation = null;
public LivingEntity(EntityType type, int entityId, UUID uuid, World world, double x, double y, double z, float yaw, float pitch) {
super(type, entityId, uuid, world, x, y, z, yaw, pitch);
}
public LivingEntity(EntityType type, UUID uuid, World world, double x, double y, double z, float yaw, float pitch) {
this(type, Limbo.getInstance().getNextEntityId(), uuid, world, x, y, z, yaw, pitch);
}
public LivingEntity(EntityType type, World world, double x, double y, double z, float yaw, float pitch) {
this(type, Limbo.getInstance().getNextEntityId(), UUID.randomUUID(), world, x, y, z, yaw, pitch);
}
public LivingEntity(EntityType type, UUID uuid, Location location) {
this(type, Limbo.getInstance().getNextEntityId(), uuid, location.getWorld(), location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
}
public LivingEntity(EntityType type, Location location) {
this(type, Limbo.getInstance().getNextEntityId(), UUID.randomUUID(), location.getWorld(), location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
}
public boolean isHandActive() {
return handActive;
}
public void setHandActive(boolean handActive) {
this.handActive = handActive;
}
public EquipmentSlot getActiveHand() {
return activeHand ? EquipmentSlot.OFFHAND : EquipmentSlot.MAINHAND;
}
public void setActiveHand(EquipmentSlot activeHand) {
if (activeHand.equals(EquipmentSlot.MAINHAND)) {
this.activeHand = false;
} else if (activeHand.equals(EquipmentSlot.OFFHAND)) {
this.activeHand = true;
} else {
throw new IllegalArgumentException("Invalid EquipmentSlot " + activeHand.toString());
}
}
public boolean isInRiptideSpinAttack() {
return inRiptideSpinAttack;
}
public void setInRiptideSpinAttack(boolean inRiptideSpinAttack) {
this.inRiptideSpinAttack = inRiptideSpinAttack;
}
public float getHealth() {
return health;
}
public void setHealth(float health) {
this.health = health;
}
public int getPotionEffectColor() {
return potionEffectColor;
}
public void setPotionEffectColor(int potionEffectColor) {
this.potionEffectColor = potionEffectColor;
}
public boolean isPotionEffectAmbient() {
return potionEffectAmbient;
}
public void setPotionEffectAmbient(boolean potionEffectAmbient) {
this.potionEffectAmbient = potionEffectAmbient;
}
public int getArrowsInEntity() {
return arrowsInEntity;
}
public void setArrowsInEntity(int arrowsInEntity) {
this.arrowsInEntity = arrowsInEntity;
}
public int getAbsorption() {
return absorption;
}
public void setAbsorption(int absorption) {
this.absorption = absorption;
}
public BlockPosition getSleepingLocation() {
return sleepingLocation;
}
public void setSleepingLocation(BlockPosition sleepingLocation) {
this.sleepingLocation = sleepingLocation;
}
}

34
src/main/java/com/loohp/limbo/entity/Pose.java Normal file
View File

@ -0,0 +1,34 @@
package com.loohp.limbo.entity;
public enum Pose {
STANDING(0),
FALL_FLYING(1),
SLEEPING(2),
SWIMMING(3),
SPIN_ATTACK(4),
SNEAKING(5),
DYING(6);
private static final Pose[] VALUES = values();
private int id;
Pose(int id) {
this.id = id;
}
public int getId() {
return id;
}
public static Pose fromId(int id) {
for (Pose pose : VALUES) {
if (id == pose.id) {
return pose;
}
}
return null;
}
}

9
src/main/java/com/loohp/limbo/events/Cancellable.java Normal file
View File

@ -0,0 +1,9 @@
package com.loohp.limbo.events;
public interface Cancellable {
public void setCancelled(boolean cancelled);
public boolean isCancelled();
}

5
src/main/java/com/loohp/limbo/events/Event.java Normal file
View File

@ -0,0 +1,5 @@
package com.loohp.limbo.events;
public abstract class Event {
}

14
src/main/java/com/loohp/limbo/events/EventHandler.java Normal file
View File

@ -0,0 +1,14 @@
package com.loohp.limbo.events;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface EventHandler {
EventPriority priority() default EventPriority.NORMAL;
}

37
src/main/java/com/loohp/limbo/events/EventPriority.java Normal file
View File

@ -0,0 +1,37 @@
package com.loohp.limbo.events;
public enum EventPriority {
LOWEST(0),
LOW(1),
NORMAL(2),
HIGH(3),
HIGHEST(4),
MONITOR(5);
int order;
EventPriority(int order) {
this.order = order;
}
public int getOrder() {
return order;
}
public static EventPriority getByOrder(int order) {
for (EventPriority each : EventPriority.values()) {
if (each.getOrder() == order) {
return each;
}
}
return null;
}
public static EventPriority[] getPrioritiesInOrder() {
EventPriority[] array = new EventPriority[EventPriority.values().length];
for (int i = 0; i < array.length; i++) {
array[i] = EventPriority.getByOrder(i);
}
return array;
}
}

58
src/main/java/com/loohp/limbo/events/EventsManager.java Normal file
View File

@ -0,0 +1,58 @@
package com.loohp.limbo.events;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import com.loohp.limbo.plugins.LimboPlugin;
public class EventsManager {
private List<ListenerPair> listeners;
public EventsManager() {
listeners = new ArrayList<>();
}
public <T extends Event> T callEvent(T event) {
for (EventPriority priority : EventPriority.getPrioritiesInOrder()) {
for (ListenerPair entry : listeners) {
Listener listener = entry.listener;
for (Method method : listener.getClass().getMethods()) {
if (method.isAnnotationPresent(EventHandler.class)) {
if (method.getAnnotation(EventHandler.class).priority().equals(priority)) {
if (method.getParameterCount() == 1 && method.getParameterTypes()[0].equals(event.getClass())) {
try {
method.invoke(listener, event);
} catch (Exception e) {
System.err.println("Error while passing " + event.getClass().getCanonicalName() + " to the plugin \"" + entry.plugin.getName() + "\"");
e.printStackTrace();
}
}
}
}
}
}
}
return event;
}
public void registerEvents(LimboPlugin plugin, Listener listener) {
listeners.add(new ListenerPair(plugin, listener));
}
public void unregisterAllListeners(LimboPlugin plugin) {
listeners.removeIf(each -> each.plugin.equals(plugin));
}
protected static class ListenerPair {
public LimboPlugin plugin;
public Listener listener;
public ListenerPair(LimboPlugin plugin, Listener listener) {
this.plugin = plugin;
this.listener = listener;
}
}
}

5
src/main/java/com/loohp/limbo/events/Listener.java Normal file
View File

@ -0,0 +1,5 @@
package com.loohp.limbo.events;
public interface Listener {
}

45
src/main/java/com/loohp/limbo/events/player/PlayerChatEvent.java Normal file
View File

@ -0,0 +1,45 @@
package com.loohp.limbo.events.player;
import com.loohp.limbo.events.Cancellable;
import com.loohp.limbo.player.Player;
public class PlayerChatEvent extends PlayerEvent implements Cancellable {
private String prefix;
private String message;
private boolean cancelled;
public PlayerChatEvent(Player player, String prefix, String message, boolean cancelled) {
super(player);
this.prefix = prefix;
this.message = message;
this.cancelled = cancelled;
}
public String getPrefix() {
return prefix;
}
public void setPrefix(String prefix) {
this.prefix = prefix;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
@Override
public boolean isCancelled() {
return cancelled;
}
}

18
src/main/java/com/loohp/limbo/events/player/PlayerEvent.java Normal file
View File

@ -0,0 +1,18 @@
package com.loohp.limbo.events.player;
import com.loohp.limbo.events.Event;
import com.loohp.limbo.player.Player;
public class PlayerEvent extends Event {
private Player player;
public PlayerEvent(Player player) {
this.player = player;
}
public Player getPlayer() {
return player;
}
}

22
src/main/java/com/loohp/limbo/events/player/PlayerJoinEvent.java Normal file
View File

@ -0,0 +1,22 @@
package com.loohp.limbo.events.player;
import com.loohp.limbo.location.Location;
import com.loohp.limbo.player.Player;
public class PlayerJoinEvent extends PlayerEvent {
private Location spawnLocation;
public PlayerJoinEvent(Player player, Location spawnLoc) {
super(player);
spawnLocation = spawnLoc;
}
public Location getSpawnLocation() {
return spawnLocation;
}
public void setSpawnLocation(Location spawnLocation) {
this.spawnLocation = spawnLocation;
}
}

43
src/main/java/com/loohp/limbo/events/player/PlayerLoginEvent.java Normal file
View File

@ -0,0 +1,43 @@
package com.loohp.limbo.events.player;
import com.loohp.limbo.events.Cancellable;
import com.loohp.limbo.events.Event;
import com.loohp.limbo.server.ClientConnection;
import net.md_5.bungee.api.chat.BaseComponent;
public class PlayerLoginEvent extends Event implements Cancellable {
private ClientConnection connection;
private boolean cancelled;
private BaseComponent[] cancelReason;
public PlayerLoginEvent(ClientConnection connection, boolean cancelled, BaseComponent... cancelReason) {
this.connection = connection;
this.cancelled = cancelled;
this.cancelReason = cancelReason;
}
public ClientConnection getConnection() {
return connection;
}
public BaseComponent[] getCancelReason() {
return cancelReason;
}
public void setCancelReason(BaseComponent... cancelReason) {
this.cancelReason = cancelReason;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
@Override
public boolean isCancelled() {
return cancelled;
}
}

87
src/main/java/com/loohp/limbo/events/player/PlayerMoveEvent.java Normal file
View File

@ -0,0 +1,87 @@
package com.loohp.limbo.events.player;
import com.loohp.limbo.events.Cancellable;
import com.loohp.limbo.location.Location;
import com.loohp.limbo.player.Player;
/**
* Holds information for player movement events
*/
public class PlayerMoveEvent extends PlayerEvent implements Cancellable {
private boolean cancel = false;
private Location from;
private Location to;
public PlayerMoveEvent(Player player, Location from, Location to) {
super(player);
this.from = from;
this.to = to;
}
/**
* Gets the cancellation state of this event. A cancelled event will not
* be executed in the server, but will still pass to other plugins
* <p>
* If a move or teleport event is cancelled, the player will be moved or
* teleported back to the Location as defined by getFrom(). This will not
* fire an event
*
* @return true if this event is cancelled
*/
@Override
public boolean isCancelled() {
return cancel;
}
/**
* Sets the cancellation state of this event. A cancelled event will not
* be executed in the server, but will still pass to other plugins
* <p>
* If a move or teleport event is cancelled, the player will be moved or
* teleported back to the Location as defined by getFrom(). This will not
* fire an event
*
* @param cancel true if you wish to cancel this event
*/
@Override
public void setCancelled(boolean cancel) {
this.cancel = cancel;
}
/**
* Gets the location this player moved from
*
* @return Location the player moved from
*/
public Location getFrom() {
return from;
}
/**
* Sets the location to mark as where the player moved from
*
* @param from New location to mark as the players previous location
*/
public void setFrom(Location from) {
this.from = from;
}
/**
* Gets the location this player moved to
*
* @return Location the player moved to
*/
public Location getTo() {
return to;
}
/**
* Sets the location that this player will move to
*
* @param to New Location this player will move to
*/
public void setTo(Location to) {
this.to = to;
}
}

11
src/main/java/com/loohp/limbo/events/player/PlayerQuitEvent.java Normal file
View File

@ -0,0 +1,11 @@
package com.loohp.limbo.events.player;
import com.loohp.limbo.player.Player;
public class PlayerQuitEvent extends PlayerEvent {
public PlayerQuitEvent(Player player) {
super(player);
}
}

33
src/main/java/com/loohp/limbo/events/player/PlayerSelectedSlotChangeEvent.java Normal file
View File

@ -0,0 +1,33 @@
package com.loohp.limbo.events.player;
import com.loohp.limbo.events.Cancellable;
import com.loohp.limbo.player.Player;
public class PlayerSelectedSlotChangeEvent extends PlayerEvent implements Cancellable {
private boolean cancel = false;
private byte slot;
public PlayerSelectedSlotChangeEvent(Player player, byte slot) {
super(player);
this.slot = slot;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancel = cancelled;
}
@Override
public boolean isCancelled() {
return cancel;
}
public byte getSlot() {
return slot;
}
public void setSlot(byte slot) {
this.slot = slot;
}
}

12
src/main/java/com/loohp/limbo/events/player/PlayerTeleportEvent.java Normal file
View File

@ -0,0 +1,12 @@
package com.loohp.limbo.events.player;
import com.loohp.limbo.location.Location;
import com.loohp.limbo.player.Player;
public class PlayerTeleportEvent extends PlayerMoveEvent {
public PlayerTeleportEvent(Player player, Location from, Location to) {
super(player, from, to);
}
}

82
src/main/java/com/loohp/limbo/events/status/StatusPingEvent.java Normal file
View File

@ -0,0 +1,82 @@
package com.loohp.limbo.events.status;
import java.awt.image.BufferedImage;
import com.loohp.limbo.events.Event;
import com.loohp.limbo.server.ClientConnection;
import net.md_5.bungee.api.chat.BaseComponent;
public class StatusPingEvent extends Event {
private ClientConnection connection;
private String version;
private int protocol;
private BaseComponent[] motd;
private int maxPlayers;
private int playersOnline;
private BufferedImage favicon;
public StatusPingEvent(ClientConnection connection, String version, int protocol, BaseComponent[] motd, int maxPlayers, int playersOnline, BufferedImage favicon) {
this.connection = connection;
this.version = version;
this.protocol = protocol;
this.motd = motd;
this.maxPlayers = maxPlayers;
this.playersOnline = playersOnline;
this.favicon = favicon;
}
public ClientConnection getConnection() {
return connection;
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
}
public int getProtocol() {
return protocol;
}
public void setProtocol(int protocol) {
this.protocol = protocol;
}
public BaseComponent[] getMotd() {
return motd;
}
public void setMotd(BaseComponent[] motd) {
this.motd = motd;
}
public int getMaxPlayers() {
return maxPlayers;
}
public void setMaxPlayers(int maxPlayers) {
this.maxPlayers = maxPlayers;
}
public int getPlayersOnline() {
return playersOnline;
}
public void setPlayersOnline(int playersOnline) {
this.playersOnline = playersOnline;
}
public BufferedImage getFavicon() {
return favicon;
}
public void setFavicon(BufferedImage favicon) {
this.favicon = favicon;
}
}

148
src/main/java/com/loohp/limbo/file/FileConfiguration.java Normal file
View File

@ -0,0 +1,148 @@
package com.loohp.limbo.file;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;
import java.nio.charset.StandardCharsets;
import java.util.LinkedHashMap;
import java.util.Map;
import org.yaml.snakeyaml.DumperOptions;
import org.yaml.snakeyaml.Yaml;
import org.yaml.snakeyaml.representer.Representer;
import com.loohp.limbo.utils.YamlOrder;
public class FileConfiguration {
private Map<String, Object> mapping;
private String header;
public FileConfiguration(File file) throws IOException {
if (file.exists()) {
InputStreamReader reader = new InputStreamReader(new FileInputStream(file), StandardCharsets.UTF_8);
reloadConfig(reader);
reader.close();
} else {
mapping = new LinkedHashMap<>();
}
}
public FileConfiguration(InputStream input){
reloadConfig(new InputStreamReader(input, StandardCharsets.UTF_8));
}
public FileConfiguration(Reader reader){
reloadConfig(reader);
}
public FileConfiguration reloadConfig(File file) throws FileNotFoundException {
return reloadConfig(new InputStreamReader(new FileInputStream(file), StandardCharsets.UTF_8));
}
public FileConfiguration reloadConfig(InputStream input) {
return reloadConfig(new InputStreamReader(input, StandardCharsets.UTF_8));
}
public FileConfiguration reloadConfig(Reader reader) {
Yaml yml = new Yaml();
mapping = yml.load(reader);
return this;
}
public void setHeader(String header) {
this.header = header;
}
@SuppressWarnings("unchecked")
public <T> T get(String key, Class<T> returnType) {
try {
String[] tree = key.split("\\.");
Map<String, Object> map = mapping;
for (int i = 0; i < tree.length - 1; i++) {
map = (Map<String, Object>) map.get(tree[i]);
}
if (returnType.equals(String.class)) {
return (T) map.get(tree[tree.length - 1]).toString();
}
return returnType.cast(map.get(tree[tree.length - 1]));
} catch (Exception e) {
return null;
}
}
@SuppressWarnings("unchecked")
public <T> void set(String key, T value) {
String[] tree = key.split("\\.");
Map<String, Object> map = mapping;
for (int i = 0; i < tree.length - 1; i++) {
Map<String, Object> map1 = (Map<String, Object>) map.get(tree[i]);
if (map1 == null) {
map1 = new LinkedHashMap<>();
map.put(tree[i], map1);
}
map = map1;
}
if (value != null) {
map.put(tree[tree.length - 1], (T) value);
} else {
map.remove(tree[tree.length - 1]);
}
}
public String saveToString() throws IOException {
DumperOptions options = new DumperOptions();
options.setIndent(2);
options.setPrettyFlow(true);
options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
Representer customRepresenter = new Representer();
YamlOrder customProperty = new YamlOrder();
customRepresenter.setPropertyUtils(customProperty);
Yaml yaml = new Yaml(customRepresenter, options);
ByteArrayOutputStream out = new ByteArrayOutputStream();
PrintWriter pw = new PrintWriter(new OutputStreamWriter(out, StandardCharsets.UTF_8));
if (header != null) {
pw.println("#" + header.replace("\n", "\n#"));
}
yaml.dump(mapping, pw);
pw.flush();
pw.close();
String str = new String(out.toByteArray(), StandardCharsets.UTF_8);
return str;
}
public void saveConfig(File file) throws IOException {
DumperOptions options = new DumperOptions();
options.setIndent(2);
options.setPrettyFlow(true);
options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
Representer customRepresenter = new Representer();
YamlOrder customProperty = new YamlOrder();
customRepresenter.setPropertyUtils(customProperty);
Yaml yaml = new Yaml(customRepresenter, options);
if (file.getParentFile() != null) {
file.getParentFile().mkdirs();
}
PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8));
if (header != null) {
pw.println("#" + header.replace("\n", "\n#"));
}
yaml.dump(mapping, pw);
pw.flush();
pw.close();
}
}

202
src/main/java/com/loohp/limbo/file/ServerProperties.java Normal file
View File

@ -0,0 +1,202 @@
package com.loohp.limbo.file;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.nio.charset.StandardCharsets;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Properties;
import javax.imageio.ImageIO;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.location.Location;
import com.loohp.limbo.utils.GameMode;
import com.loohp.limbo.utils.NamespacedKey;
import com.loohp.limbo.world.World;
public class ServerProperties {
public static final String COMMENT = "For explaination of what each of the options does, please visit:\nhttps://github.com/LOOHP/Limbo/blob/master/src/main/resources/server.properties";
private File file;
private int maxPlayers;
private int serverPort;
private String serverIp;
private NamespacedKey levelName;
private String schemFileName;
private NamespacedKey levelDimension;
private GameMode defaultGamemode;
private Location worldSpawn;
private boolean reducedDebugInfo;
private boolean allowFlight;
private String motdJson;
private String versionString;
private int protocol;
private boolean bungeecord;
private int viewDistance;
private double ticksPerSecond;
private boolean handshakeVerbose;
Optional<BufferedImage> favicon;
public ServerProperties(File file) throws IOException {
this.file = file;
Properties def = new Properties();
InputStreamReader defStream = new InputStreamReader(getClass().getClassLoader().getResourceAsStream("server.properties"), StandardCharsets.UTF_8);
def.load(defStream);
defStream.close();
Properties prop = new Properties();
InputStreamReader stream = new InputStreamReader(new FileInputStream(file), StandardCharsets.UTF_8);
prop.load(stream);
stream.close();
for (Entry<Object, Object> entry : def.entrySet()) {
String key = entry.getKey().toString();
String value = entry.getValue().toString();
prop.putIfAbsent(key, value);
}
PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8));
prop.store(pw, COMMENT);
pw.close();
protocol = Limbo.getInstance().serverImplmentationProtocol;
maxPlayers = Integer.parseInt(prop.getProperty("max-players"));
serverPort = Integer.parseInt(prop.getProperty("server-port"));
serverIp = prop.getProperty("server-ip");
String[] level = prop.getProperty("level-name").split(";");
levelName = new NamespacedKey(level[0]);
schemFileName = level[1];
levelDimension = new NamespacedKey(prop.getProperty("level-dimension"));
defaultGamemode = GameMode.fromName(new NamespacedKey(prop.getProperty("default-gamemode")).getKey());
String[] locStr = prop.getProperty("world-spawn").split(";");
World world = Limbo.getInstance().getWorld(locStr[0]);
double x = Double.parseDouble(locStr[1]);
double y = Double.parseDouble(locStr[2]);
double z = Double.parseDouble(locStr[3]);
float yaw = Float.parseFloat(locStr[4]);
float pitch = Float.parseFloat(locStr[5]);
worldSpawn = new Location(world, x, y, z, yaw, pitch);
reducedDebugInfo = Boolean.parseBoolean(prop.getProperty("reduced-debug-info"));
allowFlight = Boolean.parseBoolean(prop.getProperty("allow-flight"));
motdJson = prop.getProperty("motd");
versionString = prop.getProperty("version");
bungeecord = Boolean.parseBoolean(prop.getProperty("bungeecord"));
viewDistance = Integer.parseInt(prop.getProperty("view-distance"));
ticksPerSecond = Double.parseDouble(prop.getProperty("ticks-per-second"));
handshakeVerbose = Boolean.parseBoolean(prop.getProperty("handshake-verbose"));
File png = new File("server-icon.png");
if (png.exists()) {
try {
BufferedImage image = ImageIO.read(png);
if (image.getHeight() == 64 && image.getWidth() == 64) {
favicon = Optional.of(image);
} else {
Limbo.getInstance().getConsole().sendMessage("Unable to load server-icon.png! The image is not 64 x 64 in size!");
}
} catch (Exception e) {
Limbo.getInstance().getConsole().sendMessage("Unable to load server-icon.png! Is it a png image?");
}
} else {
Limbo.getInstance().getConsole().sendMessage("No server-icon.png found");
favicon = Optional.empty();
}
Limbo.getInstance().getConsole().sendMessage("Loaded server.properties");
}
public String getServerImplementationVersion() {
return Limbo.getInstance().serverImplementationVersion;
}
public boolean isBungeecord() {
return bungeecord;
}
public Optional<BufferedImage> getFavicon() {
return favicon;
}
public File getFile() {
return file;
}
public int getMaxPlayers() {
return maxPlayers;
}
public int getServerPort() {
return serverPort;
}
public String getServerIp() {
return serverIp;
}
public NamespacedKey getLevelName() {
return levelName;
}
public String getSchemFileName() {
return schemFileName;
}
public NamespacedKey getLevelDimension() {
return levelDimension;
}
public GameMode getDefaultGamemode() {
return defaultGamemode;
}
public Location getWorldSpawn() {
return worldSpawn;
}
public void setWorldSpawn(Location location) {
this.worldSpawn = location;
}
public boolean isReducedDebugInfo() {
return reducedDebugInfo;
}
public boolean isAllowFlight() {
return allowFlight;
}
public String getMotdJson() {
return motdJson;
}
public String getVersionString() {
return versionString;
}
public int getProtocol() {
return protocol;
}
public int getViewDistance() {
return viewDistance;
}
public double getDefinedTicksPerSecond() {
return ticksPerSecond;
}
public boolean handshakeVerboseEnabled() {
return handshakeVerbose;
}
}

12
src/main/java/com/loohp/limbo/inventory/EquipmentSlot.java Normal file
View File

@ -0,0 +1,12 @@
package com.loohp.limbo.inventory;
public enum EquipmentSlot {
MAINHAND,
OFFHAND,
HELMENT,
CHESTPLATE,
LEGGINGS,
BOOTS;
}

468
src/main/java/com/loohp/limbo/location/Location.java Normal file
View File

@ -0,0 +1,468 @@
package com.loohp.limbo.location;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.utils.NumberConversions;
import com.loohp.limbo.world.BlockState;
import com.loohp.limbo.world.World;
public class Location implements Cloneable {
private World world;
private double x;
private double y;
private double z;
private float yaw;
private float pitch;
public Location(World world, double x, double y, double z, float yaw, float pitch) {
this.world = world;
this.x = x;
this.y = y;
this.z = z;
this.yaw = yaw;
this.pitch = pitch;
}
public Location(World world, double x, double y, double z) {
this(world, x, y, z, 0, 0);
}
@Override
public Location clone() {
try {
return (Location) super.clone();
} catch (CloneNotSupportedException e) {
throw new Error(e);
}
}
public BlockState getBlockState() {
return world.getBlock((int) x,(int) y,(int) z);
}
public void setBlockState(BlockState state) {
world.setBlock((int) x, (int) y, (int) z, state);
}
public boolean isWorldLoaded() {
return Limbo.getInstance().getWorld(world.getName()) != null;
}
public World getWorld() {
return world;
}
public void setWorld(World world) {
this.world = world;
}
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
public double getZ() {
return z;
}
public void setZ(double z) {
this.z = z;
}
public float getYaw() {
return yaw;
}
public void setYaw(float yaw) {
this.yaw = yaw;
}
public float getPitch() {
return pitch;
}
public void setPitch(float pitch) {
this.pitch = pitch;
}
/**
* Gets a unit-vector pointing in the direction that this Location is
* facing.
*
* @return a vector pointing the direction of this location's {@link
* #getPitch() pitch} and {@link #getYaw() yaw}
*/
public Vector getDirection() {
Vector vector = new Vector();
double rotX = this.getYaw();
double rotY = this.getPitch();
vector.setY(-Math.sin(Math.toRadians(rotY)));
double xz = Math.cos(Math.toRadians(rotY));
vector.setX(-xz * Math.sin(Math.toRadians(rotX)));
vector.setZ(xz * Math.cos(Math.toRadians(rotX)));
return vector;
}
/**
* Sets the {@link #getYaw() yaw} and {@link #getPitch() pitch} to point
* in the direction of the vector.
*
* @param vector the direction vector
* @return the same location
*/
public Location setDirection(Vector vector) {
/*
* Sin = Opp / Hyp
* Cos = Adj / Hyp
* Tan = Opp / Adj
*
* x = -Opp
* z = Adj
*/
final double _2PI = 2 * Math.PI;
final double x = vector.getX();
final double z = vector.getZ();
if (x == 0 && z == 0) {
pitch = vector.getY() > 0 ? -90 : 90;
return this;
}
double theta = Math.atan2(-x, z);
yaw = (float) Math.toDegrees((theta + _2PI) % _2PI);
double x2 = NumberConversions.square(x);
double z2 = NumberConversions.square(z);
double xz = Math.sqrt(x2 + z2);
pitch = (float) Math.toDegrees(Math.atan(-vector.getY() / xz));
return this;
}
/**
* Adds the location by another.
*
* @see Vector
* @param vec The other location
* @return the same location
* @throws IllegalArgumentException for differing worlds
*/
public Location add(Location vec) {
if (vec == null || vec.getWorld() != getWorld()) {
throw new IllegalArgumentException("Cannot add Locations of differing worlds");
}
x += vec.x;
y += vec.y;
z += vec.z;
return this;
}
/**
* Adds the location by a vector.
*
* @see Vector
* @param vec Vector to use
* @return the same location
*/
public Location add(Vector vec) {
this.x += vec.getX();
this.y += vec.getY();
this.z += vec.getZ();
return this;
}
/**
* Adds the location by another. Not world-aware.
*
* @see Vector
* @param x X coordinate
* @param y Y coordinate
* @param z Z coordinate
* @return the same location
*/
public Location add(double x, double y, double z) {
this.x += x;
this.y += y;
this.z += z;
return this;
}
/**
* Subtracts the location by another.
*
* @see Vector
* @param vec The other location
* @return the same location
* @throws IllegalArgumentException for differing worlds
*/
public Location subtract(Location vec) {
if (vec == null || vec.getWorld() != getWorld()) {
throw new IllegalArgumentException("Cannot add Locations of differing worlds");
}
x -= vec.x;
y -= vec.y;
z -= vec.z;
return this;
}
/**
* Subtracts the location by a vector.
*
* @see Vector
* @param vec The vector to use
* @return the same location
*/
public Location subtract(Vector vec) {
this.x -= vec.getX();
this.y -= vec.getY();
this.z -= vec.getZ();
return this;
}
/**
* Subtracts the location by another. Not world-aware and
* orientation independent.
*
* @see Vector
* @param x X coordinate
* @param y Y coordinate
* @param z Z coordinate
* @return the same location
*/
public Location subtract(double x, double y, double z) {
this.x -= x;
this.y -= y;
this.z -= z;
return this;
}
/**
* Gets the magnitude of the location, defined as sqrt(x^2+y^2+z^2). The
* value of this method is not cached and uses a costly square-root
* function, so do not repeatedly call this method to get the location's
* magnitude. NaN will be returned if the inner result of the sqrt()
* function overflows, which will be caused if the length is too long. Not
* world-aware and orientation independent.
*
* @return the magnitude
* @see Vector
*/
public double length() {
return Math.sqrt(NumberConversions.square(x) + NumberConversions.square(y) + NumberConversions.square(z));
}
/**
* Gets the magnitude of the location squared. Not world-aware and
* orientation independent.
*
* @return the magnitude
* @see Vector
*/
public double lengthSquared() {
return NumberConversions.square(x) + NumberConversions.square(y) + NumberConversions.square(z);
}
/**
* Get the distance between this location and another. The value of this
* method is not cached and uses a costly square-root function, so do not
* repeatedly call this method to get the location's magnitude. NaN will
* be returned if the inner result of the sqrt() function overflows, which
* will be caused if the distance is too long.
*
* @param o The other location
* @return the distance
* @throws IllegalArgumentException for differing worlds
* @see Vector
*/
public double distance(Location o) {
return Math.sqrt(distanceSquared(o));
}
/**
* Get the squared distance between this location and another.
*
* @param o The other location
* @return the distance
* @throws IllegalArgumentException for differing worlds
* @see Vector
*/
public double distanceSquared(Location o) {
if (o == null) {
throw new IllegalArgumentException("Cannot measure distance to a null location");
} else if (o.getWorld() == null || getWorld() == null) {
throw new IllegalArgumentException("Cannot measure distance to a null world");
} else if (o.getWorld() != getWorld()) {
throw new IllegalArgumentException("Cannot measure distance between " + getWorld().getName() + " and " + o.getWorld().getName());
}
return NumberConversions.square(x - o.x) + NumberConversions.square(y - o.y) + NumberConversions.square(z - o.z);
}
/**
* Performs scalar multiplication, multiplying all components with a
* scalar. Not world-aware.
*
* @param m The factor
* @return the same location
* @see Vector
*/
public Location multiply(double m) {
x *= m;
y *= m;
z *= m;
return this;
}
/**
* Zero this location's components. Not world-aware.
*
* @return the same location
* @see Vector
*/
public Location zero() {
x = 0;
y = 0;
z = 0;
return this;
}
/**
* Constructs a new {@link Vector} based on this Location
*
* @return New Vector containing the coordinates represented by this
* Location
*/
public Vector toVector() {
return new Vector(x, y, z);
}
/**
* Check if each component of this Location is finite.
*
* @throws IllegalArgumentException if any component is not finite
*/
public void checkFinite() throws IllegalArgumentException {
NumberConversions.checkFinite(x, "x not finite");
NumberConversions.checkFinite(y, "y not finite");
NumberConversions.checkFinite(z, "z not finite");
NumberConversions.checkFinite(pitch, "pitch not finite");
NumberConversions.checkFinite(yaw, "yaw not finite");
}
/**
* Safely converts a double (location coordinate) to an int (block
* coordinate)
*
* @param loc Precise coordinate
* @return Block coordinate
*/
public static int locToBlock(double loc) {
return NumberConversions.floor(loc);
}
/**
* Normalizes the given yaw angle to a value between <code>+/-180</code>
* degrees.
*
* @param yaw the yaw in degrees
* @return the normalized yaw in degrees
* @see Location#getYaw()
*/
public static float normalizeYaw(float yaw) {
yaw %= 360.0f;
if (yaw >= 180.0f) {
yaw -= 360.0f;
} else if (yaw < -180.0f) {
yaw += 360.0f;
}
return yaw;
}
/**
* Normalizes the given pitch angle to a value between <code>+/-90</code>
* degrees.
*
* @param pitch the pitch in degrees
* @return the normalized pitch in degrees
* @see Location#getPitch()
*/
public static float normalizePitch(float pitch) {
if (pitch > 90.0f) {
pitch = 90.0f;
} else if (pitch < -90.0f) {
pitch = -90.0f;
}
return pitch;
}
@Override
public String toString() {
return "Location{" + "world=" + world + ",x=" + x + ",y=" + y + ",z=" + z + ",pitch=" + pitch + ",yaw=" + yaw + "}";
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Location other = (Location) obj;
World world = (this.world == null) ? null : this.world;
World otherWorld = (other.world == null) ? null : other.world;
if (world != otherWorld && (world == null || !world.equals(otherWorld))) {
return false;
}
if (Double.doubleToLongBits(this.x) != Double.doubleToLongBits(other.x)) {
return false;
}
if (Double.doubleToLongBits(this.y) != Double.doubleToLongBits(other.y)) {
return false;
}
if (Double.doubleToLongBits(this.z) != Double.doubleToLongBits(other.z)) {
return false;
}
if (Float.floatToIntBits(this.pitch) != Float.floatToIntBits(other.pitch)) {
return false;
}
if (Float.floatToIntBits(this.yaw) != Float.floatToIntBits(other.yaw)) {
return false;
}
return true;
}
@Override
public int hashCode() {
int hash = 3;
World world = (this.world == null) ? null : this.world;
hash = 19 * hash + (world != null ? world.hashCode() : 0);
hash = 19 * hash + (int) (Double.doubleToLongBits(this.x) ^ (Double.doubleToLongBits(this.x) >>> 32));
hash = 19 * hash + (int) (Double.doubleToLongBits(this.y) ^ (Double.doubleToLongBits(this.y) >>> 32));
hash = 19 * hash + (int) (Double.doubleToLongBits(this.z) ^ (Double.doubleToLongBits(this.z) >>> 32));
hash = 19 * hash + Float.floatToIntBits(this.pitch);
hash = 19 * hash + Float.floatToIntBits(this.yaw);
return hash;
}
}

852
src/main/java/com/loohp/limbo/location/Vector.java Normal file
View File

@ -0,0 +1,852 @@
package com.loohp.limbo.location;
import java.util.Random;
import com.google.common.base.Preconditions;
import com.google.common.primitives.Doubles;
import com.loohp.limbo.utils.NumberConversions;
import com.loohp.limbo.world.World;
/**
* Represents a mutable vector. Because the components of Vectors are mutable,
* storing Vectors long term may be dangerous if passing code modifies the
* Vector later. If you want to keep around a Vector, it may be wise to call
* <code>clone()</code> in order to get a copy.
*/
public class Vector implements Cloneable {
private static Random random = new Random();
/**
* Threshold for fuzzy equals().
*/
private static final double epsilon = 0.000001;
protected double x;
protected double y;
protected double z;
/**
* Construct the vector with all components as 0.
*/
public Vector() {
this.x = 0;
this.y = 0;
this.z = 0;
}
/**
* Construct the vector with provided integer components.
*
* @param x X component
* @param y Y component
* @param z Z component
*/
public Vector(int x, int y, int z) {
this.x = x;
this.y = y;
this.z = z;
}
/**
* Construct the vector with provided double components.
*
* @param x X component
* @param y Y component
* @param z Z component
*/
public Vector(double x, double y, double z) {
this.x = x;
this.y = y;
this.z = z;
}
/**
* Construct the vector with provided float components.
*
* @param x X component
* @param y Y component
* @param z Z component
*/
public Vector(float x, float y, float z) {
this.x = x;
this.y = y;
this.z = z;
}
/**
* Adds a vector to this one
*
* @param vec The other vector
* @return the same vector
*/
public Vector add(Vector vec) {
x += vec.x;
y += vec.y;
z += vec.z;
return this;
}
/**
* Subtracts a vector from this one.
*
* @param vec The other vector
* @return the same vector
*/
public Vector subtract(Vector vec) {
x -= vec.x;
y -= vec.y;
z -= vec.z;
return this;
}
/**
* Multiplies the vector by another.
*
* @param vec The other vector
* @return the same vector
*/
public Vector multiply(Vector vec) {
x *= vec.x;
y *= vec.y;
z *= vec.z;
return this;
}
/**
* Divides the vector by another.
*
* @param vec The other vector
* @return the same vector
*/
public Vector divide(Vector vec) {
x /= vec.x;
y /= vec.y;
z /= vec.z;
return this;
}
/**
* Copies another vector
*
* @param vec The other vector
* @return the same vector
*/
public Vector copy(Vector vec) {
x = vec.x;
y = vec.y;
z = vec.z;
return this;
}
/**
* Gets the magnitude of the vector, defined as sqrt(x^2+y^2+z^2). The
* value of this method is not cached and uses a costly square-root
* function, so do not repeatedly call this method to get the vector's
* magnitude. NaN will be returned if the inner result of the sqrt()
* function overflows, which will be caused if the length is too long.
*
* @return the magnitude
*/
public double length() {
return Math.sqrt(NumberConversions.square(x) + NumberConversions.square(y) + NumberConversions.square(z));
}
/**
* Gets the magnitude of the vector squared.
*
* @return the magnitude
*/
public double lengthSquared() {
return NumberConversions.square(x) + NumberConversions.square(y) + NumberConversions.square(z);
}
/**
* Get the distance between this vector and another. The value of this
* method is not cached and uses a costly square-root function, so do not
* repeatedly call this method to get the vector's magnitude. NaN will be
* returned if the inner result of the sqrt() function overflows, which
* will be caused if the distance is too long.
*
* @param o The other vector
* @return the distance
*/
public double distance(Vector o) {
return Math.sqrt(NumberConversions.square(x - o.x) + NumberConversions.square(y - o.y) + NumberConversions.square(z - o.z));
}
/**
* Get the squared distance between this vector and another.
*
* @param o The other vector
* @return the distance
*/
public double distanceSquared(Vector o) {
return NumberConversions.square(x - o.x) + NumberConversions.square(y - o.y) + NumberConversions.square(z - o.z);
}
/**
* Gets the angle between this vector and another in radians.
*
* @param other The other vector
* @return angle in radians
*/
public float angle(Vector other) {
double dot = Doubles.constrainToRange(dot(other) / (length() * other.length()), -1.0, 1.0);
return (float) Math.acos(dot);
}
/**
* Sets this vector to the midpoint between this vector and another.
*
* @param other The other vector
* @return this same vector (now a midpoint)
*/
public Vector midpoint(Vector other) {
x = (x + other.x) / 2;
y = (y + other.y) / 2;
z = (z + other.z) / 2;
return this;
}
/**
* Gets a new midpoint vector between this vector and another.
*
* @param other The other vector
* @return a new midpoint vector
*/
public Vector getMidpoint(Vector other) {
double x = (this.x + other.x) / 2;
double y = (this.y + other.y) / 2;
double z = (this.z + other.z) / 2;
return new Vector(x, y, z);
}
/**
* Performs scalar multiplication, multiplying all components with a
* scalar.
*
* @param m The factor
* @return the same vector
*/
public Vector multiply(int m) {
x *= m;
y *= m;
z *= m;
return this;
}
/**
* Performs scalar multiplication, multiplying all components with a
* scalar.
*
* @param m The factor
* @return the same vector
*/
public Vector multiply(double m) {
x *= m;
y *= m;
z *= m;
return this;
}
/**
* Performs scalar multiplication, multiplying all components with a
* scalar.
*
* @param m The factor
* @return the same vector
*/
public Vector multiply(float m) {
x *= m;
y *= m;
z *= m;
return this;
}
/**
* Calculates the dot product of this vector with another. The dot product
* is defined as x1*x2+y1*y2+z1*z2. The returned value is a scalar.
*
* @param other The other vector
* @return dot product
*/
public double dot(Vector other) {
return x * other.x + y * other.y + z * other.z;
}
/**
* Calculates the cross product of this vector with another. The cross
* product is defined as:
* <ul>
* <li>x = y1 * z2 - y2 * z1
* <li>y = z1 * x2 - z2 * x1
* <li>z = x1 * y2 - x2 * y1
* </ul>
*
* @param o The other vector
* @return the same vector
*/
public Vector crossProduct(Vector o) {
double newX = y * o.z - o.y * z;
double newY = z * o.x - o.z * x;
double newZ = x * o.y - o.x * y;
x = newX;
y = newY;
z = newZ;
return this;
}
/**
* Calculates the cross product of this vector with another without mutating
* the original. The cross product is defined as:
* <ul>
* <li>x = y1 * z2 - y2 * z1
* <li>y = z1 * x2 - z2 * x1
* <li>z = x1 * y2 - x2 * y1
* </ul>
*
* @param o The other vector
* @return a new vector
*/
public Vector getCrossProduct(Vector o) {
double x = this.y * o.z - o.y * this.z;
double y = this.z * o.x - o.z * this.x;
double z = this.x * o.y - o.x * this.y;
return new Vector(x, y, z);
}
/**
* Converts this vector to a unit vector (a vector with length of 1).
*
* @return the same vector
*/
public Vector normalize() {
double length = length();
x /= length;
y /= length;
z /= length;
return this;
}
/**
* Zero this vector's components.
*
* @return the same vector
*/
public Vector zero() {
x = 0;
y = 0;
z = 0;
return this;
}
/**
* Converts each component of value <code>-0.0</code> to <code>0.0</code>.
*
* @return This vector.
*/
Vector normalizeZeros() {
if (x == -0.0D) x = 0.0D;
if (y == -0.0D) y = 0.0D;
if (z == -0.0D) z = 0.0D;
return this;
}
/**
* Returns whether this vector is in an axis-aligned bounding box.
* <p>
* The minimum and maximum vectors given must be truly the minimum and
* maximum X, Y and Z components.
*
* @param min Minimum vector
* @param max Maximum vector
* @return whether this vector is in the AABB
*/
public boolean isInAABB(Vector min, Vector max) {
return x >= min.x && x <= max.x && y >= min.y && y <= max.y && z >= min.z && z <= max.z;
}
/**
* Returns whether this vector is within a sphere.
*
* @param origin Sphere origin.
* @param radius Sphere radius
* @return whether this vector is in the sphere
*/
public boolean isInSphere(Vector origin, double radius) {
return (NumberConversions.square(origin.x - x) + NumberConversions.square(origin.y - y) + NumberConversions.square(origin.z - z)) <= NumberConversions.square(radius);
}
/**
* Returns if a vector is normalized
*
* @return whether the vector is normalised
*/
public boolean isNormalized() {
return Math.abs(this.lengthSquared() - 1) < getEpsilon();
}
/**
* Rotates the vector around the x axis.
* <p>
* This piece of math is based on the standard rotation matrix for vectors
* in three dimensional space. This matrix can be found here:
* <a href="https://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">Rotation
* Matrix</a>.
*
* @param angle the angle to rotate the vector about. This angle is passed
* in radians
* @return the same vector
*/
public Vector rotateAroundX(double angle) {
double angleCos = Math.cos(angle);
double angleSin = Math.sin(angle);
double y = angleCos * getY() - angleSin * getZ();
double z = angleSin * getY() + angleCos * getZ();
return setY(y).setZ(z);
}
/**
* Rotates the vector around the y axis.
* <p>
* This piece of math is based on the standard rotation matrix for vectors
* in three dimensional space. This matrix can be found here:
* <a href="https://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">Rotation
* Matrix</a>.
*
* @param angle the angle to rotate the vector about. This angle is passed
* in radians
* @return the same vector
*/
public Vector rotateAroundY(double angle) {
double angleCos = Math.cos(angle);
double angleSin = Math.sin(angle);
double x = angleCos * getX() + angleSin * getZ();
double z = -angleSin * getX() + angleCos * getZ();
return setX(x).setZ(z);
}
/**
* Rotates the vector around the z axis
* <p>
* This piece of math is based on the standard rotation matrix for vectors
* in three dimensional space. This matrix can be found here:
* <a href="https://en.wikipedia.org/wiki/Rotation_matrix#Basic_rotations">Rotation
* Matrix</a>.
*
* @param angle the angle to rotate the vector about. This angle is passed
* in radians
* @return the same vector
*/
public Vector rotateAroundZ(double angle) {
double angleCos = Math.cos(angle);
double angleSin = Math.sin(angle);
double x = angleCos * getX() - angleSin * getY();
double y = angleSin * getX() + angleCos * getY();
return setX(x).setY(y);
}
/**
* Rotates the vector around a given arbitrary axis in 3 dimensional space.
*
* <p>
* Rotation will follow the general Right-Hand-Rule, which means rotation
* will be counterclockwise when the axis is pointing towards the observer.
* <p>
* This method will always make sure the provided axis is a unit vector, to
* not modify the length of the vector when rotating. If you are experienced
* with the scaling of a non-unit axis vector, you can use
* {@link Vector#rotateAroundNonUnitAxis(Vector, double)}.
*
* @param axis the axis to rotate the vector around. If the passed vector is
* not of length 1, it gets copied and normalized before using it for the
* rotation. Please use {@link Vector#normalize()} on the instance before
* passing it to this method
* @param angle the angle to rotate the vector around the axis
* @return the same vector
* @throws IllegalArgumentException if the provided axis vector instance is
* null
*/
public Vector rotateAroundAxis(Vector axis, double angle) throws IllegalArgumentException {
Preconditions.checkArgument(axis != null, "The provided axis vector was null");
return rotateAroundNonUnitAxis(axis.isNormalized() ? axis : axis.clone().normalize(), angle);
}
/**
* Rotates the vector around a given arbitrary axis in 3 dimensional space.
*
* <p>
* Rotation will follow the general Right-Hand-Rule, which means rotation
* will be counterclockwise when the axis is pointing towards the observer.
* <p>
* Note that the vector length will change accordingly to the axis vector
* length. If the provided axis is not a unit vector, the rotated vector
* will not have its previous length. The scaled length of the resulting
* vector will be related to the axis vector. If you are not perfectly sure
* about the scaling of the vector, use
* {@link Vector#rotateAroundAxis(Vector, double)}
*
* @param axis the axis to rotate the vector around.
* @param angle the angle to rotate the vector around the axis
* @return the same vector
* @throws IllegalArgumentException if the provided axis vector instance is
* null
*/
public Vector rotateAroundNonUnitAxis(Vector axis, double angle) throws IllegalArgumentException {
Preconditions.checkArgument(axis != null, "The provided axis vector was null");
double x = getX(), y = getY(), z = getZ();
double x2 = axis.getX(), y2 = axis.getY(), z2 = axis.getZ();
double cosTheta = Math.cos(angle);
double sinTheta = Math.sin(angle);
double dotProduct = this.dot(axis);
double xPrime = x2 * dotProduct * (1d - cosTheta)
+ x * cosTheta
+ (-z2 * y + y2 * z) * sinTheta;
double yPrime = y2 * dotProduct * (1d - cosTheta)
+ y * cosTheta
+ (z2 * x - x2 * z) * sinTheta;
double zPrime = z2 * dotProduct * (1d - cosTheta)
+ z * cosTheta
+ (-y2 * x + x2 * y) * sinTheta;
return setX(xPrime).setY(yPrime).setZ(zPrime);
}
/**
* Gets the X component.
*
* @return The X component.
*/
public double getX() {
return x;
}
/**
* Gets the floored value of the X component, indicating the block that
* this vector is contained with.
*
* @return block X
*/
public int getBlockX() {
return NumberConversions.floor(x);
}
/**
* Gets the Y component.
*
* @return The Y component.
*/
public double getY() {
return y;
}
/**
* Gets the floored value of the Y component, indicating the block that
* this vector is contained with.
*
* @return block y
*/
public int getBlockY() {
return NumberConversions.floor(y);
}
/**
* Gets the Z component.
*
* @return The Z component.
*/
public double getZ() {
return z;
}
/**
* Gets the floored value of the Z component, indicating the block that
* this vector is contained with.
*
* @return block z
*/
public int getBlockZ() {
return NumberConversions.floor(z);
}
/**
* Set the X component.
*
* @param x The new X component.
* @return This vector.
*/
public Vector setX(int x) {
this.x = x;
return this;
}
/**
* Set the X component.
*
* @param x The new X component.
* @return This vector.
*/
public Vector setX(double x) {
this.x = x;
return this;
}
/**
* Set the X component.
*
* @param x The new X component.
* @return This vector.
*/
public Vector setX(float x) {
this.x = x;
return this;
}
/**
* Set the Y component.
*
* @param y The new Y component.
* @return This vector.
*/
public Vector setY(int y) {
this.y = y;
return this;
}
/**
* Set the Y component.
*
* @param y The new Y component.
* @return This vector.
*/
public Vector setY(double y) {
this.y = y;
return this;
}
/**
* Set the Y component.
*
* @param y The new Y component.
* @return This vector.
*/
public Vector setY(float y) {
this.y = y;
return this;
}
/**
* Set the Z component.
*
* @param z The new Z component.
* @return This vector.
*/
public Vector setZ(int z) {
this.z = z;
return this;
}
/**
* Set the Z component.
*
* @param z The new Z component.
* @return This vector.
*/
public Vector setZ(double z) {
this.z = z;
return this;
}
/**
* Set the Z component.
*
* @param z The new Z component.
* @return This vector.
*/
public Vector setZ(float z) {
this.z = z;
return this;
}
/**
* Checks to see if two objects are equal.
* <p>
* Only two Vectors can ever return true. This method uses a fuzzy match
* to account for floating point errors. The epsilon can be retrieved
* with epsilon.
*/
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Vector)) {
return false;
}
Vector other = (Vector) obj;
return Math.abs(x - other.x) < epsilon && Math.abs(y - other.y) < epsilon && Math.abs(z - other.z) < epsilon && (this.getClass().equals(obj.getClass()));
}
/**
* Returns a hash code for this vector
*
* @return hash code
*/
@Override
public int hashCode() {
int hash = 7;
hash = 79 * hash + (int) (Double.doubleToLongBits(this.x) ^ (Double.doubleToLongBits(this.x) >>> 32));
hash = 79 * hash + (int) (Double.doubleToLongBits(this.y) ^ (Double.doubleToLongBits(this.y) >>> 32));
hash = 79 * hash + (int) (Double.doubleToLongBits(this.z) ^ (Double.doubleToLongBits(this.z) >>> 32));
return hash;
}
/**
* Get a new vector.
*
* @return vector
*/
@Override
public Vector clone() {
try {
return (Vector) super.clone();
} catch (CloneNotSupportedException e) {
throw new Error(e);
}
}
/**
* Returns this vector's components as x,y,z.
*/
@Override
public String toString() {
return x + "," + y + "," + z;
}
/**
* Gets a Location version of this vector with yaw and pitch being 0.
*
* @param world The world to link the location to.
* @return the location
*/
public Location toLocation(World world) {
return new Location(world, x, y, z);
}
/**
* Gets a Location version of this vector.
*
* @param world The world to link the location to.
* @param yaw The desired yaw.
* @param pitch The desired pitch.
* @return the location
*/
public Location toLocation(World world, float yaw, float pitch) {
return new Location(world, x, y, z, yaw, pitch);
}
/**
* Get the block vector of this vector.
*
* @return A block vector.
public BlockVector toBlockVector() {
return new BlockVector(x, y, z);
}
*/
/**
* Check if each component of this Vector is finite.
*
* @throws IllegalArgumentException if any component is not finite
*/
public void checkFinite() throws IllegalArgumentException {
NumberConversions.checkFinite(x, "x not finite");
NumberConversions.checkFinite(y, "y not finite");
NumberConversions.checkFinite(z, "z not finite");
}
/**
* Get the threshold used for equals().
*
* @return The epsilon.
*/
public static double getEpsilon() {
return epsilon;
}
/**
* Gets the minimum components of two vectors.
*
* @param v1 The first vector.
* @param v2 The second vector.
* @return minimum
*/
public static Vector getMinimum(Vector v1, Vector v2) {
return new Vector(Math.min(v1.x, v2.x), Math.min(v1.y, v2.y), Math.min(v1.z, v2.z));
}
/**
* Gets the maximum components of two vectors.
*
* @param v1 The first vector.
* @param v2 The second vector.
* @return maximum
*/
public static Vector getMaximum(Vector v1, Vector v2) {
return new Vector(Math.max(v1.x, v2.x), Math.max(v1.y, v2.y), Math.max(v1.z, v2.z));
}
/**
* Gets a random vector with components having a random value between 0
* and 1.
*
* @return A random vector.
*/
public static Vector getRandom() {
return new Vector(random.nextDouble(), random.nextDouble(), random.nextDouble());
}
/*
@Override
public Map<String, Object> serialize() {
Map<String, Object> result = new LinkedHashMap<String, Object>();
result.put("x", getX());
result.put("y", getY());
result.put("z", getZ());
return result;
}
*/
/*
public static Vector deserialize(Map<String, Object> args) {
double x = 0;
double y = 0;
double z = 0;
if (args.containsKey("x")) {
x = (Double) args.get("x");
}
if (args.containsKey("y")) {
y = (Double) args.get("y");
}
if (args.containsKey("z")) {
z = (Double) args.get("z");
}
return new Vector(x, y, z);
}
*/
}

1007
src/main/java/com/loohp/limbo/metrics/Metrics.java Normal file
View File

File diff suppressed because it is too large Load Diff

69
src/main/java/com/loohp/limbo/permissions/PermissionsManager.java Normal file
View File

@ -0,0 +1,69 @@
package com.loohp.limbo.permissions;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.loohp.limbo.Console;
import com.loohp.limbo.commands.CommandSender;
import com.loohp.limbo.file.FileConfiguration;
import com.loohp.limbo.player.Player;
public class PermissionsManager {
private Map<String, List<String>> users;
private Map<String, List<String>> permissions;
public PermissionsManager() {
users = new HashMap<>();
permissions = new HashMap<>();
}
@SuppressWarnings("unchecked")
public void loadDefaultPermissionFile(File file) throws IOException {
FileConfiguration config = new FileConfiguration(file);
permissions.put("default", new ArrayList<>());
try {
for (Object obj : config.get("groups", Map.class).keySet()) {
String key = (String) obj;
List<String> nodes = new ArrayList<>();
nodes.addAll(config.get("groups." + key, List.class));
permissions.put(key, nodes);
}
} catch (Exception e) {}
try {
for (Object obj : config.get("players", Map.class).keySet()) {
String key = (String) obj;
List<String> groups = new ArrayList<>();
groups.addAll(config.get("players." + key, List.class));
users.put(key, groups);
}
} catch (Exception e) {}
}
public boolean hasPermission(CommandSender sender, String permission) {
if (sender instanceof Console) {
return true;
} else if (sender instanceof Player) {
Player player = (Player) sender;
if (users.get(player.getName()) != null && users.get(player.getName()).stream().anyMatch(each -> permissions.get(each).stream().anyMatch(node -> node.equalsIgnoreCase(permission)))) {
return true;
} else {
return permissions.get("default").stream().anyMatch(node -> node.equalsIgnoreCase(permission));
}
}
return false;
}
public Map<String, List<String>> getUsers() {
return users;
}
public Map<String, List<String>> getPermissions() {
return permissions;
}
}

261
src/main/java/com/loohp/limbo/player/Player.java Normal file
View File

@ -0,0 +1,261 @@
package com.loohp.limbo.player;
import java.io.IOException;
import java.util.UUID;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.events.player.PlayerChatEvent;
import com.loohp.limbo.events.player.PlayerTeleportEvent;
import com.loohp.limbo.server.ClientConnection;
import com.loohp.limbo.server.packets.PacketPlayOutChat;
import com.loohp.limbo.server.packets.PacketPlayOutGameState;
import com.loohp.limbo.server.packets.PacketPlayOutHeldItemChange;
import com.loohp.limbo.server.packets.PacketPlayOutPositionAndLook;
import com.loohp.limbo.server.packets.PacketPlayOutRespawn;
import com.loohp.limbo.commands.CommandSender;
import com.loohp.limbo.entity.DataWatcher;
import com.loohp.limbo.entity.EntityType;
import com.loohp.limbo.entity.LivingEntity;
import com.loohp.limbo.entity.DataWatcher.WatchableField;
import com.loohp.limbo.entity.DataWatcher.WatchableObjectType;
import com.loohp.limbo.location.Location;
import com.loohp.limbo.utils.GameMode;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
import net.md_5.bungee.chat.ComponentSerializer;
public class Player extends LivingEntity implements CommandSender {
public final ClientConnection clientConnection;
public final PlayerInteractManager playerInteractManager;
protected final String username;
protected GameMode gamemode;
protected DataWatcher watcher;
protected byte selectedSlot;
@WatchableField(MetadataIndex = 14, WatchableObjectType = WatchableObjectType.FLOAT)
protected float additionalHearts = 0.0F;
@WatchableField(MetadataIndex = 15, WatchableObjectType = WatchableObjectType.VARINT)
protected int score = 0;
@WatchableField(MetadataIndex = 16, WatchableObjectType = WatchableObjectType.BYTE)
protected byte skinLayers = 0;
@WatchableField(MetadataIndex = 17, WatchableObjectType = WatchableObjectType.BYTE)
protected byte mainHand = 1;
//@WatchableField(MetadataIndex = 18, WatchableObjectType = WatchableObjectType.NBT)
//protected Entity leftShoulder = null;
//@WatchableField(MetadataIndex = 19, WatchableObjectType = WatchableObjectType.NBT)
//protected Entity rightShoulder = null;
public Player(ClientConnection clientConnection, String username, UUID uuid, int entityId, Location location, PlayerInteractManager playerInteractManager) throws IllegalArgumentException, IllegalAccessException {
super(EntityType.PLAYER, entityId, uuid, location.getWorld(), location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
this.clientConnection = clientConnection;
this.username = username;
this.entityId = entityId;
this.playerInteractManager = playerInteractManager;
this.playerInteractManager.setPlayer(this);
this.watcher = new DataWatcher(this);
this.watcher.update();
}
public byte getSelectedSlot() {
return selectedSlot;
}
public void setSelectedSlot(byte slot) {
if(slot == selectedSlot)
return;
try {
PacketPlayOutHeldItemChange state = new PacketPlayOutHeldItemChange(slot);
clientConnection.sendPacket(state);
} catch (IOException e) {
e.printStackTrace();
}
this.selectedSlot = slot;
}
public GameMode getGamemode() {
return gamemode;
}
public void setGamemode(GameMode gamemode) {
if (!this.gamemode.equals(gamemode)) {
try {
PacketPlayOutGameState state = new PacketPlayOutGameState(3, gamemode.getId());
clientConnection.sendPacket(state);
} catch (IOException e) {
e.printStackTrace();
}
}
this.gamemode = gamemode;
}
@Deprecated
protected void setEntityId(int entityId) {
this.entityId = entityId;
}
public float getAdditionalHearts() {
return additionalHearts;
}
public void setAdditionalHearts(float additionalHearts) {
this.additionalHearts = additionalHearts;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public byte getSkinLayers() {
return skinLayers;
}
public void setSkinLayers(byte skinLayers) {
this.skinLayers = skinLayers;
}
public byte getMainHand() {
return mainHand;
}
public void setMainHand(byte mainHand) {
this.mainHand = mainHand;
}
@Override
public DataWatcher getDataWatcher() {
return watcher;
}
@Override
public boolean isValid() {
return Limbo.getInstance().getPlayers().contains(this);
}
@Override
public void remove() {
}
/*
public Entity getLeftShoulder() {
return leftShoulder;
}
public void setLeftShoulder(Entity leftShoulder) {
this.leftShoulder = leftShoulder;
}
public Entity getRightShoulder() {
return rightShoulder;
}
public void setRightShoulder(Entity rightShoulder) {
this.rightShoulder = rightShoulder;
}
*/
@Override
public String getName() {
return username;
}
@Override
public boolean hasPermission(String permission) {
return Limbo.getInstance().getPermissionsManager().hasPermission(this, permission);
}
@Override
public void teleport(Location location) {
PlayerTeleportEvent event = Limbo.getInstance().getEventsManager().callEvent(new PlayerTeleportEvent(this, getLocation(), location));
if (!event.isCancelled()) {
location = event.getTo();
super.teleport(location);
try {
if (!world.equals(location.getWorld())) {
PacketPlayOutRespawn respawn = new PacketPlayOutRespawn(location.getWorld(), Limbo.getInstance().getDimensionRegistry().getCodec(), 0, gamemode, false, false, true);
clientConnection.sendPacket(respawn);
}
PacketPlayOutPositionAndLook positionLook = new PacketPlayOutPositionAndLook(location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch(), 1);
clientConnection.sendPacket(positionLook);
} catch (IOException e) {
e.printStackTrace();
}
}
}
protected void setLocation(Location location) {
super.teleport(location);
}
public void sendMessage(String message, UUID uuid) {
sendMessage(TextComponent.fromLegacyText(message), uuid);
}
public void sendMessage(BaseComponent component, UUID uuid) {
sendMessage(new BaseComponent[] { component }, uuid);
}
@Override
public void sendMessage(BaseComponent[] component, UUID uuid) {
try {
PacketPlayOutChat chat = new PacketPlayOutChat(ComponentSerializer.toString(component), 0, uuid);
clientConnection.sendPacket(chat);
} catch (IOException e) {
e.printStackTrace();
}
}
public void sendMessage(String message) {
sendMessage(TextComponent.fromLegacyText(message));
}
public void sendMessage(BaseComponent component) {
sendMessage(new BaseComponent[] { component });
}
@Override
public void sendMessage(BaseComponent[] component) {
try {
PacketPlayOutChat chat = new PacketPlayOutChat(ComponentSerializer.toString(component), 0, new UUID(0, 0));
clientConnection.sendPacket(chat);
} catch (IOException e) {
e.printStackTrace();
}
}
public void disconnect() {
disconnect("Disconnected!");
}
public void disconnect(String reason) {
disconnect(TextComponent.fromLegacyText(reason));
}
public void disconnect(BaseComponent reason) {
disconnect(new BaseComponent[] {reason});
}
public void disconnect(BaseComponent[] reason) {
clientConnection.disconnect(reason);
}
public void chat(String message) {
String prefix = "<" + username + "> ";
PlayerChatEvent event = (PlayerChatEvent) Limbo.getInstance().getEventsManager().callEvent(new PlayerChatEvent(this, prefix, message, false));
if (!event.isCancelled()) {
String chat = event.getPrefix() + event.getMessage();
Limbo.getInstance().getConsole().sendMessage(chat);
for (Player each : Limbo.getInstance().getPlayers()) {
each.sendMessage(chat, uuid);
}
}
}
}

135
src/main/java/com/loohp/limbo/player/PlayerInteractManager.java Normal file
View File

@ -0,0 +1,135 @@
package com.loohp.limbo.player;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.stream.Collectors;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.server.packets.PacketPlayOutEntityDestroy;
import com.loohp.limbo.server.packets.PacketPlayOutEntityMetadata;
import com.loohp.limbo.server.packets.PacketPlayOutLightUpdate;
import com.loohp.limbo.server.packets.PacketPlayOutMapChunk;
import com.loohp.limbo.server.packets.PacketPlayOutSpawnEntity;
import com.loohp.limbo.server.packets.PacketPlayOutSpawnEntityLiving;
import com.loohp.limbo.server.packets.PacketPlayOutUnloadChunk;
import com.loohp.limbo.entity.Entity;
import com.loohp.limbo.location.Location;
import com.loohp.limbo.world.World;
import net.querz.mca.Chunk;
public class PlayerInteractManager {
private Player player;
private Set<Entity> entities;
private Map<Chunk, World> chunks;
public PlayerInteractManager() {
this.player = null;
this.entities = new HashSet<>();
this.chunks = new HashMap<>();
}
protected void setPlayer(Player player) {
if (this.player == null) {
this.player = player;
} else {
throw new RuntimeException("Player in PlayerInteractManager cannot be changed once created");
}
}
public Player getPlayer() {
return player;
}
public void update() throws IOException {
int viewDistanceChunks = Limbo.getInstance().getServerProperties().getViewDistance();
int viewDistanceBlocks = viewDistanceChunks << 4;
Location location = player.getLocation();
Set<Entity> entitiesInRange = player.getWorld().getEntities().stream().filter(each -> each.getLocation().distanceSquared(location) < viewDistanceBlocks * viewDistanceBlocks).collect(Collectors.toSet());
for (Entity entity : entitiesInRange) {
if (!entities.contains(entity)) {
if (entity.getType().isAlive()) {
PacketPlayOutSpawnEntityLiving packet = new PacketPlayOutSpawnEntityLiving(entity.getEntityId(), entity.getUniqueId(), entity.getType(), entity.getX(), entity.getY(), entity.getZ(), entity.getYaw(), entity.getPitch(), entity.getPitch(), (short) 0, (short) 0, (short) 0);
player.clientConnection.sendPacket(packet);
PacketPlayOutEntityMetadata meta = new PacketPlayOutEntityMetadata(entity);
player.clientConnection.sendPacket(meta);
} else {
PacketPlayOutSpawnEntity packet = new PacketPlayOutSpawnEntity(entity.getEntityId(), entity.getUniqueId(), entity.getType(), entity.getX(), entity.getY(), entity.getZ(), entity.getPitch(), entity.getYaw(), (short) 0, (short) 0, (short) 0);
player.clientConnection.sendPacket(packet);
PacketPlayOutEntityMetadata meta = new PacketPlayOutEntityMetadata(entity);
player.clientConnection.sendPacket(meta);
}
}
}
List<Integer> ids = new ArrayList<>();
for (Entity entity : entities) {
if (!entitiesInRange.contains(entity)) {
ids.add(entity.getEntityId());
}
}
PacketPlayOutEntityDestroy packet = new PacketPlayOutEntityDestroy(ids.stream().mapToInt(each -> each).toArray());
player.clientConnection.sendPacket(packet);
entities = entitiesInRange;
int playerChunkX = (int) location.getX() >> 4;
int playerChunkZ = (int) location.getZ() >> 4;
World world = location.getWorld();
Set<Chunk> chunksInRange = new HashSet<>();
for (int x = playerChunkX - viewDistanceChunks; x < playerChunkX + viewDistanceChunks; x++) {
for (int z = playerChunkZ - viewDistanceChunks; z < playerChunkZ + viewDistanceChunks; z++) {
Chunk chunk = world.getChunkAt(x, z);
if (chunk != null) {
chunksInRange.add(chunk);
}
}
}
for (Entry<Chunk, World> entry : chunks.entrySet()) {
Chunk chunk = entry.getKey();
if (location.getWorld().getChunkXZ(chunk) == null) {
World world0 = entry.getValue();
int[] chunkPos = world0.getChunkXZ(chunk);
PacketPlayOutUnloadChunk packet0 = new PacketPlayOutUnloadChunk(chunkPos[0], chunkPos[1]);
player.clientConnection.sendPacket(packet0);
}
}
for (Chunk chunk : chunksInRange) {
if (!chunks.containsKey(chunk)) {
int[] chunkPos = world.getChunkXZ(chunk);
PacketPlayOutMapChunk packet0 = new PacketPlayOutMapChunk(chunkPos[0], chunkPos[1], chunk, world.getEnvironment());
player.clientConnection.sendPacket(packet0);
List<Byte[]> blockChunk = world.getLightEngineBlock().getBlockLightBitMask(chunkPos[0], chunkPos[1]);
if (blockChunk == null) {
blockChunk = new ArrayList<>();
}
List<Byte[]> skyChunk = null;
if (world.hasSkyLight()) {
skyChunk = world.getLightEngineSky().getSkyLightBitMask(chunkPos[0], chunkPos[1]);
}
if (skyChunk == null) {
skyChunk = new ArrayList<>();
}
PacketPlayOutLightUpdate chunkdata = new PacketPlayOutLightUpdate(chunkPos[0], chunkPos[1], true, skyChunk, blockChunk);
player.clientConnection.sendPacket(chunkdata);
}
}
chunks = chunksInRange.stream().collect(Collectors.toMap(each -> each, each -> world));
}
}

31
src/main/java/com/loohp/limbo/player/Unsafe.java Normal file
View File

@ -0,0 +1,31 @@
package com.loohp.limbo.player;
import com.loohp.limbo.location.Location;
import com.loohp.limbo.utils.GameMode;
@Deprecated
public class Unsafe {
private Unsafe() {}
@Deprecated
public void a(Player a, GameMode b) {
a.gamemode = b;
}
@Deprecated
public void a(Player a, int b) {
a.setEntityId(b);
}
@Deprecated
public void a(Player a, Location b) {
a.setLocation(b);
}
@Deprecated
public void a(Player a, byte b) {
a.selectedSlot = b;
}
}

54
src/main/java/com/loohp/limbo/plugins/LimboPlugin.java Normal file
View File

@ -0,0 +1,54 @@
package com.loohp.limbo.plugins;
import java.io.File;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.file.FileConfiguration;
public class LimboPlugin {
private String name;
private File dataFolder;
private PluginInfo info;
private File pluginJar;
protected final void setInfo(FileConfiguration file, File pluginJar) {
this.info = new PluginInfo(file);
this.name = info.getName();
this.dataFolder = new File(Limbo.getInstance().getPluginFolder(), name);
this.pluginJar = pluginJar;
}
protected final File getPluginJar() {
return pluginJar;
}
public void onLoad() {
}
public void onEnable() {
}
public void onDisable() {
}
public final String getName() {
return name;
}
public final File getDataFolder() {
return new File(dataFolder.getAbsolutePath());
}
public final PluginInfo getInfo() {
return info;
}
public final Limbo getServer() {
return Limbo.getInstance();
}
}

41
src/main/java/com/loohp/limbo/plugins/PluginInfo.java Normal file
View File

@ -0,0 +1,41 @@
package com.loohp.limbo.plugins;
import com.loohp.limbo.file.FileConfiguration;
public class PluginInfo {
private String name;
private String description;
private String author;
private String version;
private String main;
public PluginInfo(FileConfiguration file) {
name = file.get("name", String.class);
description = file.get("description", String.class) == null ? "" : file.get("description", String.class);
author = file.get("author", String.class);
version = file.get("version", String.class);
main = file.get("main", String.class);
}
public String getName() {
return name;
}
public String getDescription() {
return description;
}
public String getAuthor() {
return author;
}
public String getVersion() {
return version;
}
public String getMainClass() {
return main;
}
}

139
src/main/java/com/loohp/limbo/plugins/PluginManager.java Normal file
View File

@ -0,0 +1,139 @@
package com.loohp.limbo.plugins;
import java.io.File;
import java.io.FileInputStream;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.commands.CommandExecutor;
import com.loohp.limbo.commands.CommandSender;
import com.loohp.limbo.commands.TabCompletor;
import com.loohp.limbo.file.FileConfiguration;
public class PluginManager {
private Map<String, LimboPlugin> plugins;
private List<Executor> executors;
private File pluginFolder;
public PluginManager(File pluginFolder) {
this.pluginFolder = pluginFolder;
this.executors = new ArrayList<>();
this.plugins = new LinkedHashMap<>();
}
protected void loadPlugins() {
for (File file : pluginFolder.listFiles()) {
if (file.isFile() && file.getName().endsWith(".jar")) {
boolean found = false;
try (ZipInputStream zip = new ZipInputStream(new FileInputStream(file))) {
while (true) {
ZipEntry entry = zip.getNextEntry();
if (entry == null) {
break;
}
String name = entry.getName();
if (name.endsWith("plugin.yml") || name.endsWith("limbo.yml")) {
found = true;
FileConfiguration pluginYaml = new FileConfiguration(zip);
String main = pluginYaml.get("main", String.class);
String pluginName = pluginYaml.get("name", String.class);
if (plugins.containsKey(pluginName)) {
System.err.println("Ambiguous plugin name in " + file.getName() + " with the plugin \"" + plugins.get(pluginName).getClass().getName() + "\"");
break;
}
URLClassLoader child = new URLClassLoader(new URL[] {file.toURI().toURL()}, Limbo.getInstance().getClass().getClassLoader());
Class<?> clazz = Class.forName(main, true, child);
LimboPlugin plugin = (LimboPlugin) clazz.getDeclaredConstructor().newInstance();
plugin.setInfo(pluginYaml, file);
plugins.put(plugin.getName(), plugin);
plugin.onLoad();
Limbo.getInstance().getConsole().sendMessage("Loading plugin " + file.getName() + " " + plugin.getInfo().getVersion() + " by " + plugin.getInfo().getAuthor());
break;
}
}
} catch (Exception e) {
System.err.println("Unable to load plugin \"" + file.getName() + "\"");
e.printStackTrace();
}
if (!found) {
System.err.println("Jar file " + file.getName() + " has no plugin.yml!");
}
}
}
}
public List<LimboPlugin> getPlugins() {
return new ArrayList<>(plugins.values());
}
public LimboPlugin getPlugin(String name) {
return plugins.get(name);
}
public void fireExecutors(CommandSender sender, String[] args) throws Exception {
Limbo.getInstance().getConsole().sendMessage(sender.getName() + " executed server command: /" + String.join(" ", args));
for (Executor entry : executors) {
try {
entry.executor.execute(sender, args);
} catch (Exception e) {
System.err.println("Error while passing command \"" + args[0] + "\" to the plugin \"" + entry.plugin.getName() + "\"");
e.printStackTrace();
}
}
}
public List<String> getTabOptions(CommandSender sender, String[] args) {
List<String> options = new ArrayList<>();
for (Executor entry : executors) {
if (entry.tab.isPresent()) {
try {
options.addAll(entry.tab.get().tabComplete(sender, args));
} catch (Exception e) {
System.err.println("Error while passing tab completion to the plugin \"" + entry.plugin.getName() + "\"");
e.printStackTrace();
}
}
}
return options;
}
public void registerCommands(LimboPlugin plugin, CommandExecutor executor) {
executors.add(new Executor(plugin, executor));
}
public void unregsiterAllCommands(LimboPlugin plugin) {
executors.removeIf(each -> each.plugin.equals(plugin));
}
public File getPluginFolder() {
return new File(pluginFolder.getAbsolutePath());
}
protected static class Executor {
public LimboPlugin plugin;
public CommandExecutor executor;
public Optional<TabCompletor> tab;
public Executor(LimboPlugin plugin, CommandExecutor executor) {
this.plugin = plugin;
this.executor = executor;
if (executor instanceof TabCompletor) {
this.tab = Optional.of((TabCompletor) executor);
} else {
this.tab = Optional.empty();
}
}
}
}

99
src/main/java/com/loohp/limbo/scheduler/LimboRunnable.java Normal file
View File

@ -0,0 +1,99 @@
package com.loohp.limbo.scheduler;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.plugins.LimboPlugin;
public abstract class LimboRunnable implements LimboTask {
private volatile boolean registered = false;
protected volatile int taskId = -1;
public void cancel() {
synchronized (this) {
if (registered && taskId >= 0) {
Limbo.getInstance().getScheduler().cancelTask(taskId);
}
}
}
public int getTaskId() {
if (registered && taskId >= 0) {
return taskId;
} else {
throw new IllegalStateException("LimboRunnable not yet scheduled");
}
}
public LimboRunnable runTask(LimboPlugin plugin) {
synchronized (this) {
if (!registered) {
taskId = Limbo.getInstance().getScheduler().runTask(plugin, this);
registered = true;
return this;
} else {
throw new IllegalStateException("LimboRunnable already scheduled");
}
}
}
public LimboRunnable runTaskLater(LimboPlugin plugin, long delay) {
synchronized (this) {
if (!registered) {
taskId = Limbo.getInstance().getScheduler().runTaskLater(plugin, this, delay);
registered = true;
return this;
} else {
throw new IllegalStateException("LimboRunnable already scheduled");
}
}
}
public LimboRunnable runTaskAsync(LimboPlugin plugin) {
synchronized (this) {
if (!registered) {
taskId = Limbo.getInstance().getScheduler().runTaskAsync(plugin, this);
registered = true;
return this;
} else {
throw new IllegalStateException("LimboRunnable already scheduled");
}
}
}
public LimboRunnable runTaskLaterAsync(LimboPlugin plugin, long delay) {
synchronized (this) {
if (!registered) {
taskId = Limbo.getInstance().getScheduler().runTaskLaterAsync(plugin, this, delay);
registered = true;
return this;
} else {
throw new IllegalStateException("LimboRunnable already scheduled");
}
}
}
public LimboRunnable runTaskTimer(LimboPlugin plugin, long delay, long period) {
synchronized (this) {
if (!registered) {
taskId = Limbo.getInstance().getScheduler().runTaskTimer(plugin, this, delay, period);
registered = true;
return this;
} else {
throw new IllegalStateException("LimboRunnable already scheduled");
}
}
}
public LimboRunnable runTaskTimerAsync(LimboPlugin plugin, long delay, long period) {
synchronized (this) {
if (!registered) {
taskId = Limbo.getInstance().getScheduler().runTaskTimerAsync(plugin, this, delay, period);
registered = true;
return this;
} else {
throw new IllegalStateException("LimboRunnable already scheduled");
}
}
}
}

250
src/main/java/com/loohp/limbo/scheduler/LimboScheduler.java Normal file
View File

@ -0,0 +1,250 @@
package com.loohp.limbo.scheduler;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.plugins.LimboPlugin;
public class LimboScheduler {
private AtomicInteger idProvider = new AtomicInteger(0);
private Map<Long, List<LimboSchedulerTask>> registeredTasks = new HashMap<>();
private Map<Integer, LimboSchedulerTask> tasksById = new HashMap<>();
private Set<Integer> cancelledTasks = new HashSet<>();
public LimboScheduler() {
}
protected int nextId() {
return idProvider.getAndUpdate(id -> id >= Integer.MAX_VALUE ? 0 : id + 1);
}
public void cancelTask(int taskId) {
if (tasksById.containsKey(taskId)) {
cancelledTasks.add(taskId);
}
}
public void cancelTask(LimboPlugin plugin) {
for (LimboSchedulerTask task : tasksById.values()) {
if (task.getPlugin().getName().equals(plugin.getName())) {
cancelledTasks.add(task.getTaskId());
}
}
}
protected int runTask(int taskId, LimboPlugin plugin, LimboTask task) {
return runTaskLater(taskId, plugin, task, 0);
}
public int runTask(LimboPlugin plugin, LimboTask task) {
return runTaskLater(plugin, task, 0);
}
protected int runTaskLater(int taskId, LimboPlugin plugin, LimboTask task, long delay) {
LimboSchedulerTask st = new LimboSchedulerTask(plugin, task, taskId, LimboSchedulerTaskType.SYNC, 0);
if (delay <= 0) {
delay = 1;
}
long tick = Limbo.getInstance().getHeartBeat().getCurrentTick() + delay;
tasksById.put(taskId, st);
List<LimboSchedulerTask> list = registeredTasks.get(tick);
if (list == null) {
list = new ArrayList<>();
registeredTasks.put(tick, list);
}
list.add(st);
return taskId;
}
public int runTaskLater(LimboPlugin plugin, LimboTask task, long delay) {
return runTaskLater(nextId(), plugin, task, delay);
}
protected int runTaskAsync(int taskId, LimboPlugin plugin, LimboTask task) {
return runTaskLaterAsync(taskId, plugin, task, 0);
}
public int runTaskAsync(LimboPlugin plugin, LimboTask task) {
return runTaskLaterAsync(plugin, task, 0);
}
protected int runTaskLaterAsync(int taskId, LimboPlugin plugin, LimboTask task, long delay) {
LimboSchedulerTask st = new LimboSchedulerTask(plugin, task, taskId, LimboSchedulerTaskType.ASYNC, 0);
if (delay <= 0) {
delay = 1;
}
long tick = Limbo.getInstance().getHeartBeat().getCurrentTick() + delay;
tasksById.put(taskId, st);
List<LimboSchedulerTask> list = registeredTasks.get(tick);
if (list == null) {
list = new ArrayList<>();
registeredTasks.put(tick, list);
}
list.add(st);
return taskId;
}
public int runTaskLaterAsync(LimboPlugin plugin, LimboTask task, long delay) {
return runTaskLaterAsync(nextId(), plugin, task, delay);
}
protected int runTaskTimer(int taskId, LimboPlugin plugin, LimboTask task, long delay, long period) {
LimboSchedulerTask st = new LimboSchedulerTask(plugin, task, taskId, LimboSchedulerTaskType.TIMER_SYNC, period);
if (delay <= 0) {
delay = 1;
}
if (period <= 0) {
period = 1;
}
long tick = Limbo.getInstance().getHeartBeat().getCurrentTick() + delay;
tasksById.put(taskId, st);
List<LimboSchedulerTask> list = registeredTasks.get(tick);
if (list == null) {
list = new ArrayList<>();
registeredTasks.put(tick, list);
}
list.add(st);
return taskId;
}
public int runTaskTimer(LimboPlugin plugin, LimboTask task, long delay, long period) {
return runTaskTimer(nextId(), plugin, task, delay, period);
}
protected int runTaskTimerAsync(int taskId, LimboPlugin plugin, LimboTask task, long delay, long period) {
LimboSchedulerTask st = new LimboSchedulerTask(plugin, task, taskId, LimboSchedulerTaskType.TIMER_ASYNC, period);
if (delay <= 0) {
delay = 1;
}
if (period <= 0) {
period = 1;
}
long tick = Limbo.getInstance().getHeartBeat().getCurrentTick() + delay;
tasksById.put(taskId, st);
List<LimboSchedulerTask> list = registeredTasks.get(tick);
if (list == null) {
list = new ArrayList<>();
registeredTasks.put(tick, list);
}
list.add(st);
return taskId;
}
public int runTaskTimerAsync(LimboPlugin plugin, LimboTask task, long delay, long period) {
return runTaskTimerAsync(nextId(), plugin, task, delay, period);
}
protected CurrentSchedulerTask collectTasks(long currentTick) {
List<LimboSchedulerTask> tasks = registeredTasks.remove(currentTick);
if (tasks == null) {
return null;
}
List<LimboSchedulerTask> asyncTasks = new LinkedList<>();
List<LimboSchedulerTask> syncedTasks = new LinkedList<>();
for (LimboSchedulerTask task : tasks) {
int taskId = task.getTaskId();
if (cancelledTasks.contains(taskId)) {
cancelledTasks.remove(taskId);
continue;
}
switch (task.getType()) {
case ASYNC:
asyncTasks.add(task);
break;
case SYNC:
syncedTasks.add(task);
break;
case TIMER_ASYNC:
asyncTasks.add(task);
runTaskTimerAsync(task.getTaskId(), task.getPlugin(), task.getTask(), task.getPeriod(), task.getPeriod());
break;
case TIMER_SYNC:
syncedTasks.add(task);
runTaskTimer(task.getTaskId(), task.getPlugin(), task.getTask(), task.getPeriod(), task.getPeriod());
break;
}
}
return new CurrentSchedulerTask(syncedTasks, asyncTasks);
}
public static class CurrentSchedulerTask {
private List<LimboSchedulerTask> asyncTasks;
private List<LimboSchedulerTask> syncedTasks;
public CurrentSchedulerTask(List<LimboSchedulerTask> syncedTasks, List<LimboSchedulerTask> asyncTasks) {
this.asyncTasks = asyncTasks;
this.syncedTasks = syncedTasks;
}
public List<LimboSchedulerTask> getAsyncTasks() {
return asyncTasks;
}
public List<LimboSchedulerTask> getSyncedTasks() {
return syncedTasks;
}
}
public static class LimboSchedulerTask {
private int taskId;
private LimboPlugin plugin;
private LimboTask task;
private LimboSchedulerTaskType type;
private long period;
private LimboSchedulerTask(LimboPlugin plugin, LimboTask task, int taskId, LimboSchedulerTaskType type, long period) {
this.plugin = plugin;
this.task = task;
this.taskId = taskId;
this.type = type;
this.period = period;
}
public LimboPlugin getPlugin() {
return plugin;
}
public LimboTask getTask() {
return task;
}
public int getTaskId() {
return taskId;
}
public LimboSchedulerTaskType getType() {
return type;
}
public long getPeriod() {
return period;
}
}
public static enum LimboSchedulerTaskType {
SYNC,
ASYNC,
TIMER_SYNC,
TIMER_ASYNC;
}
}

5
src/main/java/com/loohp/limbo/scheduler/LimboTask.java Normal file
View File

@ -0,0 +1,5 @@
package com.loohp.limbo.scheduler;
public interface LimboTask extends Runnable {
}

129
src/main/java/com/loohp/limbo/scheduler/Tick.java Normal file
View File

@ -0,0 +1,129 @@
package com.loohp.limbo.scheduler;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.scheduler.LimboScheduler.CurrentSchedulerTask;
import com.loohp.limbo.scheduler.LimboScheduler.LimboSchedulerTask;
public class Tick {
private int tickingInterval;
private AtomicLong tick = new AtomicLong(0);
private List<Thread> threads = new ArrayList<>();
private Queue<LimboSchedulerTask> asyncTasksQueue = new ConcurrentLinkedQueue<>();
public Tick(Limbo instance) {
new Thread(new Runnable() {
@Override
public void run() {
tickingInterval = (int) Math.round(1000.0 / Limbo.getInstance().getServerProperties().getDefinedTicksPerSecond());
for (int i = 0; i < 4; i++) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
while (instance.isRunning()) {
LimboSchedulerTask task = asyncTasksQueue.poll();
if (task == null) {
try {
TimeUnit.NANOSECONDS.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
LimboTask limboTask = task.getTask();
try {
limboTask.run();
} catch (Throwable e) {
System.err.println("Task " + task.getTaskId() + " threw an exception: " + e.getLocalizedMessage());
e.printStackTrace();
}
}
}
}
});
thread.start();
threads.add(thread);
}
while (instance.isRunning()) {
long start = System.currentTimeMillis();
tick.incrementAndGet();
instance.getPlayers().forEach(each -> {
if (each.clientConnection.isReady()) {
try {
each.playerInteractManager.update();
} catch (IOException e) {
e.printStackTrace();
}
/*
try {
each.getDataWatcher().update();
} catch (IllegalArgumentException | IllegalAccessException e) {
e.printStackTrace();
}
*/
}
});
instance.getWorlds().forEach(each -> {
try {
each.update();
} catch (IllegalArgumentException | IllegalAccessException e) {
e.printStackTrace();
}
});
CurrentSchedulerTask tasks = instance.getScheduler().collectTasks(getCurrentTick());
if (tasks != null) {
asyncTasksQueue.addAll(tasks.getAsyncTasks());
tasks.getSyncedTasks().forEach(task -> {
LimboTask limboTask = task.getTask();
try {
limboTask.run();
} catch (Throwable e) {
System.err.println("Task " + task.getTaskId() + " threw an exception: " + e.getLocalizedMessage());
e.printStackTrace();
}
});
}
long end = System.currentTimeMillis();
try {
TimeUnit.MILLISECONDS.sleep(tickingInterval - (end - start));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}).start();
}
public long getCurrentTick() {
return tick.get();
}
@SuppressWarnings("deprecation")
public void waitAndKillThreads(long waitTime) {
long end = System.currentTimeMillis() + waitTime;
for (Thread thread : threads) {
try {
thread.join(Math.max(end - System.currentTimeMillis(), 1));
} catch (InterruptedException e) {
e.printStackTrace();
}
if (thread.isAlive()) {
thread.stop();
}
}
}
}

472
src/main/java/com/loohp/limbo/server/ClientConnection.java Normal file
View File

@ -0,0 +1,472 @@
package com.loohp.limbo.server;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.stream.Collectors;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.events.player.PlayerJoinEvent;
import com.loohp.limbo.events.player.PlayerLoginEvent;
import com.loohp.limbo.events.player.PlayerMoveEvent;
import com.loohp.limbo.events.player.PlayerQuitEvent;
import com.loohp.limbo.events.player.PlayerSelectedSlotChangeEvent;
import com.loohp.limbo.events.status.StatusPingEvent;
import com.loohp.limbo.server.packets.Packet;
import com.loohp.limbo.server.packets.PacketHandshakingIn;
import com.loohp.limbo.server.packets.PacketLoginInLoginStart;
import com.loohp.limbo.server.packets.PacketLoginOutDisconnect;
import com.loohp.limbo.server.packets.PacketLoginOutLoginSuccess;
import com.loohp.limbo.server.packets.PacketOut;
import com.loohp.limbo.server.packets.PacketPlayInChat;
import com.loohp.limbo.server.packets.PacketPlayInHeldItemChange;
import com.loohp.limbo.server.packets.PacketPlayInKeepAlive;
import com.loohp.limbo.server.packets.PacketPlayInPosition;
import com.loohp.limbo.server.packets.PacketPlayInPositionAndLook;
import com.loohp.limbo.server.packets.PacketPlayInRotation;
import com.loohp.limbo.server.packets.PacketPlayInTabComplete;
import com.loohp.limbo.server.packets.PacketPlayOutDeclareCommands;
import com.loohp.limbo.server.packets.PacketPlayOutDisconnect;
import com.loohp.limbo.server.packets.PacketPlayOutEntityMetadata;
import com.loohp.limbo.server.packets.PacketPlayOutHeldItemChange;
import com.loohp.limbo.server.packets.PacketPlayOutLogin;
import com.loohp.limbo.server.packets.PacketPlayOutPlayerAbilities;
import com.loohp.limbo.server.packets.PacketPlayOutPlayerInfo;
import com.loohp.limbo.server.packets.PacketPlayOutPositionAndLook;
import com.loohp.limbo.server.packets.PacketPlayOutSpawnPosition;
import com.loohp.limbo.server.packets.PacketPlayOutTabComplete;
import com.loohp.limbo.server.packets.PacketPlayOutUpdateViewPosition;
import com.loohp.limbo.server.packets.PacketStatusInPing;
import com.loohp.limbo.server.packets.PacketStatusInRequest;
import com.loohp.limbo.server.packets.PacketStatusOutPong;
import com.loohp.limbo.server.packets.PacketStatusOutResponse;
import com.loohp.limbo.server.packets.PacketPlayOutPlayerAbilities.PlayerAbilityFlags;
import com.loohp.limbo.server.packets.PacketPlayOutPlayerInfo.PlayerInfoAction;
import com.loohp.limbo.server.packets.PacketPlayOutPlayerInfo.PlayerInfoData;
import com.loohp.limbo.server.packets.PacketPlayOutPlayerInfo.PlayerInfoData.PlayerInfoDataAddPlayer.PlayerSkinProperty;
import com.loohp.limbo.server.packets.PacketPlayOutTabComplete.TabCompleteMatches;
import com.loohp.limbo.file.ServerProperties;
import com.loohp.limbo.location.Location;
import com.loohp.limbo.player.Player;
import com.loohp.limbo.player.PlayerInteractManager;
import com.loohp.limbo.utils.CustomStringUtils;
import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.utils.DeclareCommands;
import com.loohp.limbo.utils.GameMode;
import com.loohp.limbo.utils.MojangAPIUtils;
import com.loohp.limbo.utils.NamespacedKey;
import com.loohp.limbo.utils.MojangAPIUtils.SkinResponse;
import com.loohp.limbo.world.BlockPosition;
import com.loohp.limbo.world.World;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
import net.md_5.bungee.chat.ComponentSerializer;
public class ClientConnection extends Thread {
public static enum ClientState {
LEGACY,
HANDSHAKE,
STATUS,
LOGIN,
PLAY,
DISCONNECTED;
}
private final Socket client_socket;
private boolean running;
private ClientState state;
private Player player;
private AtomicLong lastKeepAlivePayLoad;
private DataOutputStream output;
private DataInputStream input;
private InetAddress inetAddress;
private boolean ready;
public ClientConnection(Socket client_socket) {
this.client_socket = client_socket;
this.inetAddress = client_socket.getInetAddress();
this.lastKeepAlivePayLoad = new AtomicLong();
this.running = false;
this.ready = false;
}
public InetAddress getInetAddress() {
return inetAddress;
}
public long getLastKeepAlivePayLoad() {
return lastKeepAlivePayLoad.get();
}
public void setLastKeepAlivePayLoad(long payLoad) {
this.lastKeepAlivePayLoad.set(payLoad);
}
public Player getPlayer() {
return player;
}
public ClientState getClientState() {
return state;
}
public Socket getSocket() {
return client_socket;
}
public boolean isRunning() {
return running;
}
public boolean isReady() {
return ready;
}
public synchronized void sendPacket(PacketOut packet) throws IOException {
byte[] packetByte = packet.serializePacket();
DataTypeIO.writeVarInt(output, packetByte.length);
output.write(packetByte);
output.flush();
}
public void disconnect(BaseComponent[] reason) {
try {
PacketPlayOutDisconnect packet = new PacketPlayOutDisconnect(ComponentSerializer.toString(reason));
sendPacket(packet);
} catch (IOException e) {}
try {
client_socket.close();
} catch (IOException e) {}
}
private void disconnectDuringLogin(BaseComponent[] reason) {
try {
PacketLoginOutDisconnect packet = new PacketLoginOutDisconnect(ComponentSerializer.toString(reason));
sendPacket(packet);
} catch (IOException e) {}
try {
client_socket.close();
} catch (IOException e) {}
}
@SuppressWarnings("deprecation")
@Override
public void run() {
running = true;
state = ClientState.HANDSHAKE;
try {
client_socket.setKeepAlive(true);
input = new DataInputStream(client_socket.getInputStream());
output = new DataOutputStream(client_socket.getOutputStream());
int handShakeSize = DataTypeIO.readVarInt(input);
//legacy ping
if (handShakeSize == 0xFE) {
state = ClientState.LEGACY;
output.writeByte(255);
String str = client_socket.getInetAddress().getHostName() + ":" + client_socket.getPort();
Limbo.getInstance().getConsole().sendMessage("[/" + str + "] <-> Legacy Status has pinged");
ServerProperties p = Limbo.getInstance().getServerProperties();
StatusPingEvent event = Limbo.getInstance().getEventsManager().callEvent(new StatusPingEvent(this, p.getVersionString(), p.getProtocol(), ComponentSerializer.parse(p.getMotdJson()), p.getMaxPlayers(), Limbo.getInstance().getPlayers().size(), p.getFavicon().orElse(null)));
String response = Limbo.getInstance().buildLegacyPingResponse(event.getVersion(), event.getMotd(), event.getMaxPlayers(), event.getPlayersOnline());
byte[] bytes = response.getBytes(StandardCharsets.UTF_16BE);
output.writeShort(response.length());
output.write(bytes);
client_socket.close();
state = ClientState.DISCONNECTED;
}
@SuppressWarnings("unused")
int handShakeId = DataTypeIO.readVarInt(input);
PacketHandshakingIn handshake = new PacketHandshakingIn(input);
boolean isBungeecord = Limbo.getInstance().getServerProperties().isBungeecord();
String bungeeForwarding = handshake.getServerAddress();
UUID bungeeUUID = null;
SkinResponse bungeeSkin = null;
try {
switch (handshake.getHandshakeType()) {
case STATUS:
state = ClientState.STATUS;
while (client_socket.isConnected()) {
DataTypeIO.readVarInt(input);
int packetId = DataTypeIO.readVarInt(input);
Class<? extends Packet> packetType = Packet.getStatusIn().get(packetId);
if (packetType == null) {
//do nothing
} else if (packetType.equals(PacketStatusInRequest.class)) {
String str = client_socket.getInetAddress().getHostName() + ":" + client_socket.getPort();
if (Limbo.getInstance().getServerProperties().handshakeVerboseEnabled()) {
Limbo.getInstance().getConsole().sendMessage("[/" + str + "] <-> Handshake Status has pinged");
}
ServerProperties p = Limbo.getInstance().getServerProperties();
StatusPingEvent event = Limbo.getInstance().getEventsManager().callEvent(new StatusPingEvent(this, p.getVersionString(), p.getProtocol(), ComponentSerializer.parse(p.getMotdJson()), p.getMaxPlayers(), Limbo.getInstance().getPlayers().size(), p.getFavicon().orElse(null)));
PacketStatusOutResponse packet = new PacketStatusOutResponse(Limbo.getInstance().buildServerListResponseJson(event.getVersion(), event.getProtocol(), event.getMotd(), event.getMaxPlayers(), event.getPlayersOnline(), event.getFavicon()));
sendPacket(packet);
} else if (packetType.equals(PacketStatusInPing.class)) {
PacketStatusInPing ping = new PacketStatusInPing(input);
PacketStatusOutPong packet = new PacketStatusOutPong(ping.getPayload());
sendPacket(packet);
break;
}
}
break;
case LOGIN:
state = ClientState.LOGIN;
if (isBungeecord) {
try {
String[] data = bungeeForwarding.split("\\x00");
//String host = data[0];
String ip = data[1];
bungeeUUID = UUID.fromString(data[2].replaceFirst("([0-9a-fA-F]{8})([0-9a-fA-F]{4})([0-9a-fA-F]{4})([0-9a-fA-F]{4})([0-9a-fA-F]+)", "$1-$2-$3-$4-$5"));
inetAddress = InetAddress.getByName(ip);
if (data.length > 3) {
String skinJson = data[3];
String skin = skinJson.split("\"value\":\"")[1].split("\"")[0];
String signature = skinJson.split("\"signature\":\"")[1].split("\"")[0];
bungeeSkin = new SkinResponse(skin, signature);
}
} catch (Exception e) {
Limbo.getInstance().getConsole().sendMessage("If you wish to use bungeecord's IP forwarding, please enable that in your bungeecord config.yml as well!");
disconnectDuringLogin(new BaseComponent[] {new TextComponent(ChatColor.RED + "Please connect from the proxy!")});
}
}
while (client_socket.isConnected()) {
int size = DataTypeIO.readVarInt(input);
int packetId = DataTypeIO.readVarInt(input);
Class<? extends Packet> packetType = Packet.getLoginIn().get(packetId);
if (packetType == null) {
input.skipBytes(size - DataTypeIO.getVarIntLength(packetId));
} else if (packetType.equals(PacketLoginInLoginStart.class)) {
PacketLoginInLoginStart start = new PacketLoginInLoginStart(input);
String username = start.getUsername();
UUID uuid = isBungeecord ? bungeeUUID : UUID.nameUUIDFromBytes(("OfflinePlayer:" + username).getBytes(StandardCharsets.UTF_8));
PacketLoginOutLoginSuccess success = new PacketLoginOutLoginSuccess(uuid, username);
sendPacket(success);
state = ClientState.PLAY;
player = new Player(this, username, uuid, Limbo.getInstance().getNextEntityId(), Limbo.getInstance().getServerProperties().getWorldSpawn(), new PlayerInteractManager());
player.setSkinLayers((byte) (0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40));
Limbo.getInstance().addPlayer(player);
break;
} else {
input.skipBytes(size - DataTypeIO.getVarIntLength(packetId));
}
}
PlayerLoginEvent event = Limbo.getInstance().getEventsManager().callEvent(new PlayerLoginEvent(this, false));
if (event.isCancelled()) {
disconnectDuringLogin(event.getCancelReason());
}
break;
}
} catch (Exception e) {
client_socket.close();
state = ClientState.DISCONNECTED;
}
if (state == ClientState.PLAY) {
TimeUnit.MILLISECONDS.sleep(500);
ServerProperties properties = Limbo.getInstance().getServerProperties();
Location worldSpawn = properties.getWorldSpawn();
PlayerJoinEvent joinEvent = Limbo.getInstance().getEventsManager().callEvent(new PlayerJoinEvent(player, worldSpawn));
worldSpawn = joinEvent.getSpawnLocation();
World world = worldSpawn.getWorld();
PacketPlayOutLogin join = new PacketPlayOutLogin(player.getEntityId(), false, properties.getDefaultGamemode(), Limbo.getInstance().getWorlds().stream().map(each -> new NamespacedKey(each.getName()).toString()).collect(Collectors.toList()).toArray(new String[Limbo.getInstance().getWorlds().size()]), Limbo.getInstance().getDimensionRegistry().getCodec(), world, 0, (byte) properties.getMaxPlayers(), 8, properties.isReducedDebugInfo(), true, false, true);
sendPacket(join);
Limbo.getInstance().getUnsafe().setPlayerGameModeSilently(player, properties.getDefaultGamemode());
player.playerInteractManager.update();
SkinResponse skinresponce = isBungeecord && bungeeSkin != null ? bungeeSkin : MojangAPIUtils.getSkinFromMojangServer(player.getName());
PlayerSkinProperty skin = skinresponce != null ? new PlayerSkinProperty(skinresponce.getSkin(), skinresponce.getSignature()) : null;
PacketPlayOutPlayerInfo info = new PacketPlayOutPlayerInfo(PlayerInfoAction.ADD_PLAYER, player.getUniqueId(), new PlayerInfoData.PlayerInfoDataAddPlayer(player.getName(), Optional.ofNullable(skin), properties.getDefaultGamemode(), 0, false, Optional.empty()));
sendPacket(info);
Set<PlayerAbilityFlags> flags = new HashSet<>();
if (properties.isAllowFlight()) {
flags.add(PlayerAbilityFlags.FLY);
}
if (player.getGamemode().equals(GameMode.CREATIVE)) {
flags.add(PlayerAbilityFlags.CREATIVE);
}
PacketPlayOutPlayerAbilities abilities = new PacketPlayOutPlayerAbilities(0.05F, 0.1F, flags.toArray(new PlayerAbilityFlags[flags.size()]));
sendPacket(abilities);
String str = client_socket.getInetAddress().getHostName() + ":" + client_socket.getPort() + "|" + player.getName();
Limbo.getInstance().getConsole().sendMessage("[/" + str + "] <-> Player had connected to the Limbo server!");
PacketPlayOutDeclareCommands declare = DeclareCommands.getDeclareCommandsPacket(player);
if (declare != null) {
sendPacket(declare);
}
PacketPlayOutSpawnPosition spawnPos = new PacketPlayOutSpawnPosition(BlockPosition.from(worldSpawn));
sendPacket(spawnPos);
PacketPlayOutPositionAndLook positionLook = new PacketPlayOutPositionAndLook(worldSpawn.getX(), worldSpawn.getY(), worldSpawn.getZ(), worldSpawn.getYaw(), worldSpawn.getPitch(), 1);
Limbo.getInstance().getUnsafe().setPlayerLocationSilently(player, new Location(world, worldSpawn.getX(), worldSpawn.getY(), worldSpawn.getZ(), worldSpawn.getYaw(), worldSpawn.getPitch()));
sendPacket(positionLook);
player.getDataWatcher().update();
PacketPlayOutEntityMetadata show = new PacketPlayOutEntityMetadata(player, false, Player.class.getDeclaredField("skinLayers"));
sendPacket(show);
ready = true;
while (client_socket.isConnected()) {
try {
int size = DataTypeIO.readVarInt(input);
int packetId = DataTypeIO.readVarInt(input);
Class<? extends Packet> packetType = Packet.getPlayIn().get(packetId);
//Limbo.getInstance().getConsole().sendMessage(packetId + " -> " + packetType);
CheckedConsumer<PlayerMoveEvent, IOException> processMoveEvent = event -> {
Location originalTo = event.getTo().clone();
if (event.isCancelled()) {
Location returnTo = event.getFrom();
PacketPlayOutPositionAndLook cancel = new PacketPlayOutPositionAndLook(returnTo.getX(), returnTo.getY(), returnTo.getZ(), returnTo.getYaw(), returnTo.getPitch(), 1);
sendPacket(cancel);
} else {
Location to = event.getTo();
Limbo.getInstance().getUnsafe().setPlayerLocationSilently(player, to);
// If an event handler used setTo, let's make sure we tell the player about it.
if (!originalTo.equals(to)) {
PacketPlayOutPositionAndLook pos = new PacketPlayOutPositionAndLook(to.getX(), to.getY(), to.getZ(), to.getYaw(), to.getPitch(), 1);
sendPacket(pos);
}
PacketPlayOutUpdateViewPosition response = new PacketPlayOutUpdateViewPosition((int) player.getLocation().getX() >> 4, (int) player.getLocation().getZ() >> 4);
sendPacket(response);
}
};
if (packetType == null) {
input.skipBytes(size - DataTypeIO.getVarIntLength(packetId));
} else if (packetType.equals(PacketPlayInPositionAndLook.class)) {
PacketPlayInPositionAndLook pos = new PacketPlayInPositionAndLook(input);
Location from = player.getLocation();
Location to = new Location(player.getWorld(), pos.getX(), pos.getY(), pos.getZ(), pos.getYaw(), pos.getPitch());
PlayerMoveEvent event = Limbo.getInstance().getEventsManager().callEvent(new PlayerMoveEvent(player, from, to));
processMoveEvent.consume(event);
} else if (packetType.equals(PacketPlayInPosition.class)) {
PacketPlayInPosition pos = new PacketPlayInPosition(input);
Location from = player.getLocation();
Location to = new Location(player.getWorld(), pos.getX(), pos.getY(), pos.getZ(), player.getLocation().getYaw(), player.getLocation().getPitch());
PlayerMoveEvent event = Limbo.getInstance().getEventsManager().callEvent(new PlayerMoveEvent(player, from, to));
processMoveEvent.consume(event);
} else if (packetType.equals(PacketPlayInRotation.class)) {
PacketPlayInRotation pos = new PacketPlayInRotation(input);
Location from = player.getLocation();
Location to = new Location(player.getWorld(), player.getLocation().getX(), player.getLocation().getY(), player.getLocation().getZ(), pos.getYaw(), pos.getPitch());
PlayerMoveEvent event = Limbo.getInstance().getEventsManager().callEvent(new PlayerMoveEvent(player, from, to));
processMoveEvent.consume(event);
} else if (packetType.equals(PacketPlayInKeepAlive.class)) {
PacketPlayInKeepAlive alive = new PacketPlayInKeepAlive(input);
if (alive.getPayload() != getLastKeepAlivePayLoad()) {
Limbo.getInstance().getConsole().sendMessage("Incorrect Payload recieved in KeepAlive packet for player " + player.getName());
break;
}
} else if (packetType.equals(PacketPlayInTabComplete.class)) {
PacketPlayInTabComplete request = new PacketPlayInTabComplete(input);
String[] command = CustomStringUtils.splitStringToArgs(request.getText().substring(1));
List<TabCompleteMatches> matches = new ArrayList<TabCompleteMatches>();
matches.addAll(Limbo.getInstance().getPluginManager().getTabOptions(player, command).stream().map(each -> new TabCompleteMatches(each)).collect(Collectors.toList()));
int start = CustomStringUtils.getIndexOfArg(request.getText(), command.length - 1) + 1;
int length = command[command.length - 1].length();
PacketPlayOutTabComplete response = new PacketPlayOutTabComplete(request.getId(), start, length, matches.toArray(new TabCompleteMatches[matches.size()]));
sendPacket(response);
} else if (packetType.equals(PacketPlayInChat.class)) {
PacketPlayInChat chat = new PacketPlayInChat(input);
if (chat.getMessage().startsWith("/")) {
Limbo.getInstance().dispatchCommand(player, chat.getMessage());
} else {
player.chat(chat.getMessage());
}
} else if (packetType.equals(PacketPlayInHeldItemChange.class)) {
PacketPlayInHeldItemChange change = new PacketPlayInHeldItemChange(input);
PlayerSelectedSlotChangeEvent event = Limbo.getInstance().getEventsManager().callEvent(new PlayerSelectedSlotChangeEvent(player, (byte) change.getSlot()));
if (event.isCancelled()) {
PacketPlayOutHeldItemChange cancelPacket = new PacketPlayOutHeldItemChange(player.getSelectedSlot());
sendPacket(cancelPacket);
} else if (change.getSlot() != event.getSlot()) {
PacketPlayOutHeldItemChange changePacket = new PacketPlayOutHeldItemChange(event.getSlot());
sendPacket(changePacket);
Limbo.getInstance().getUnsafe().setSelectedSlotSilently(player, event.getSlot());
} else {
Limbo.getInstance().getUnsafe().setSelectedSlotSilently(player, event.getSlot());
}
} else {
input.skipBytes(size - DataTypeIO.getVarIntLength(packetId));
}
} catch (Exception e) {
break;
}
}
Limbo.getInstance().getEventsManager().callEvent(new PlayerQuitEvent(player));
str = client_socket.getInetAddress().getHostName() + ":" + client_socket.getPort() + "|" + player.getName();
Limbo.getInstance().getConsole().sendMessage("[/" + str + "] <-> Player had disconnected!");
}
} catch (Exception e) {e.printStackTrace();}
try {
client_socket.close();
} catch (IOException e) {}
state = ClientState.DISCONNECTED;
if (player != null) {
Limbo.getInstance().removePlayer(player);
}
Limbo.getInstance().getServerConnection().getClients().remove(this);
running = false;
}
@FunctionalInterface
public interface CheckedConsumer<T, TException extends Throwable> {
void consume(T t) throws TException;
}
}

40
src/main/java/com/loohp/limbo/server/KeepAliveSender.java Normal file
View File

@ -0,0 +1,40 @@
package com.loohp.limbo.server;
import java.io.IOException;
import java.util.Random;
import java.util.concurrent.TimeUnit;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.server.ClientConnection.ClientState;
import com.loohp.limbo.server.packets.PacketPlayOutKeepAlive;
public class KeepAliveSender extends Thread {
private Random random;
public KeepAliveSender() {
random = new Random();
start();
}
@Override
public void run() {
while (true) {
try {
for (ClientConnection client : Limbo.getInstance().getServerConnection().getClients()) {
if (client.getClientState() != null && client.getClientState().equals(ClientState.PLAY)) {
try {
PacketPlayOutKeepAlive packet = new PacketPlayOutKeepAlive(random.nextLong());
client.setLastKeepAlivePayLoad(packet.getPayload());
client.sendPacket(packet);
} catch (IOException ignore) {}
}
}
TimeUnit.SECONDS.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

58
src/main/java/com/loohp/limbo/server/ServerConnection.java Normal file
View File

@ -0,0 +1,58 @@
package com.loohp.limbo.server;
import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import com.loohp.limbo.Limbo;
public class ServerConnection extends Thread {
private ServerSocket serverSocket;
private List<ClientConnection> clients;
private String ip;
private int port;
private KeepAliveSender keepAliveSender;
public ServerConnection(String ip, int port) {
clients = new ArrayList<ClientConnection>();
this.ip = ip;
this.port = port;
start();
keepAliveSender = new KeepAliveSender();
}
@Override
public void run() {
try {
serverSocket = new ServerSocket(port, 50, InetAddress.getByName(ip));
Limbo.getInstance().getConsole().sendMessage("Limbo server listening on /" + serverSocket.getInetAddress().getHostName() + ":" + serverSocket.getLocalPort());
while (true) {
Socket connection = serverSocket.accept();
//String str = connection.getInetAddress().getHostName() + ":" + connection.getPort();
//Limbo.getInstance().getConsole().sendMessage("[/127.0.0.1:57310] <-> InitialHandler has pinged);
ClientConnection sc = new ClientConnection(connection);
clients.add(sc);
sc.start();
}
} catch(IOException e) {
e.printStackTrace();
}
}
public KeepAliveSender getKeepAliveSender() {
return keepAliveSender;
}
public ServerSocket getServerSocket() {
return serverSocket;
}
public List<ClientConnection> getClients() {
return clients;
}
}

74
src/main/java/com/loohp/limbo/server/packets/Packet.java Normal file
View File

@ -0,0 +1,74 @@
package com.loohp.limbo.server.packets;
import java.util.Map;
public class Packet {
private static Map<Integer, Class<? extends PacketIn>> HandshakeIn;
private static Map<Integer, Class<? extends PacketIn>> StatusIn;
private static Map<Class<? extends PacketOut>, Integer> StatusOut;
private static Map<Integer, Class<? extends PacketIn>> LoginIn;
private static Map<Class<? extends PacketOut>, Integer> LoginOut;
private static Map<Integer, Class<? extends PacketIn>> PlayIn;
private static Map<Class<? extends PacketOut>, Integer> PlayOut;
public static Map<Integer, Class<? extends PacketIn>> getHandshakeIn() {
return HandshakeIn;
}
public static void setHandshakeIn(Map<Integer, Class<? extends PacketIn>> handshakeIn) {
HandshakeIn = handshakeIn;
}
public static Map<Integer, Class<? extends PacketIn>> getStatusIn() {
return StatusIn;
}
public static void setStatusIn(Map<Integer, Class<? extends PacketIn>> statusIn) {
StatusIn = statusIn;
}
public static Map<Class<? extends PacketOut>, Integer> getStatusOut() {
return StatusOut;
}
public static void setStatusOut(Map<Class<? extends PacketOut>, Integer> statusOut) {
StatusOut = statusOut;
}
public static Map<Integer, Class<? extends PacketIn>> getLoginIn() {
return LoginIn;
}
public static void setLoginIn(Map<Integer, Class<? extends PacketIn>> loginIn) {
LoginIn = loginIn;
}
public static Map<Class<? extends PacketOut>, Integer> getLoginOut() {
return LoginOut;
}
public static void setLoginOut(Map<Class<? extends PacketOut>, Integer> loginOut) {
LoginOut = loginOut;
}
public static Map<Integer, Class<? extends PacketIn>> getPlayIn() {
return PlayIn;
}
public static void setPlayIn(Map<Integer, Class<? extends PacketIn>> playIn) {
PlayIn = playIn;
}
public static Map<Class<? extends PacketOut>, Integer> getPlayOut() {
return PlayOut;
}
public static void setPlayOut(Map<Class<? extends PacketOut>, Integer> playOut) {
PlayOut = playOut;
}
}

69
src/main/java/com/loohp/limbo/server/packets/PacketHandshakingIn.java Normal file
View File

@ -0,0 +1,69 @@
package com.loohp.limbo.server.packets;
import java.io.DataInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketHandshakingIn extends PacketIn {
public static enum HandshakeType {
STATUS(1),
LOGIN(2);
int networkId;
HandshakeType(int networkId) {
this.networkId = networkId;
}
public int getNetworkId() {
return networkId;
}
public static HandshakeType fromNetworkId(int networkId) {
for (HandshakeType type : HandshakeType.values()) {
if (type.getNetworkId() == networkId) {
return type;
}
}
return null;
}
}
//==============================
private int protocolVersion;
private String serverAddress;
private int serverPort;
private HandshakeType handshakeType;
public PacketHandshakingIn(int protocolVersion, String serverAddress, int serverPort, HandshakeType handshakeType) {
this.protocolVersion = protocolVersion;
this.serverAddress = serverAddress;
this.serverPort = serverPort;
this.handshakeType = handshakeType;
}
public PacketHandshakingIn(DataInputStream in) throws IOException {
this(DataTypeIO.readVarInt(in), DataTypeIO.readString(in, StandardCharsets.UTF_8), in.readShort() & 0xFFFF, HandshakeType.fromNetworkId(DataTypeIO.readVarInt(in)));
}
public int getProtocolVersion() {
return protocolVersion;
}
public String getServerAddress() {
return serverAddress;
}
public int getServerPort() {
return serverPort;
}
public HandshakeType getHandshakeType() {
return handshakeType;
}
}

5
src/main/java/com/loohp/limbo/server/packets/PacketIn.java Normal file
View File

@ -0,0 +1,5 @@
package com.loohp.limbo.server.packets;
public abstract class PacketIn extends Packet {
}

25
src/main/java/com/loohp/limbo/server/packets/PacketLoginInLoginStart.java Normal file
View File

@ -0,0 +1,25 @@
package com.loohp.limbo.server.packets;
import java.io.DataInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketLoginInLoginStart extends PacketIn {
private String username;
public PacketLoginInLoginStart(String username) {
this.username = username;
}
public PacketLoginInLoginStart(DataInputStream in) throws IOException {
this(DataTypeIO.readString(in, StandardCharsets.UTF_8));
}
public String getUsername() {
return username;
}
}

43
src/main/java/com/loohp/limbo/server/packets/PacketLoginInPluginMessaging.java Normal file
View File

@ -0,0 +1,43 @@
package com.loohp.limbo.server.packets;
import java.io.DataInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.utils.NamespacedKey;
public class PacketLoginInPluginMessaging extends PacketIn {
private int messageId;
private NamespacedKey channel;
private byte[] data;
public PacketLoginInPluginMessaging(int messageId, NamespacedKey channel, byte[] data) {
this.messageId = messageId;
this.channel = channel;
this.data = data;
}
public PacketLoginInPluginMessaging(DataInputStream in, int packetLength, int packetId) throws IOException {
messageId = DataTypeIO.readVarInt(in);
String rawChannel = DataTypeIO.readString(in, StandardCharsets.UTF_8);
channel = new NamespacedKey(rawChannel);
int dataLength = packetLength - DataTypeIO.getVarIntLength(packetId) - DataTypeIO.getVarIntLength(messageId) - DataTypeIO.getStringLength(rawChannel, StandardCharsets.UTF_8);
data = new byte[dataLength];
in.read(data);
}
public int getMessageId() {
return messageId;
}
public NamespacedKey getChannel() {
return channel;
}
public byte[] getData() {
return data;
}
}

33
src/main/java/com/loohp/limbo/server/packets/PacketLoginOutDisconnect.java Normal file
View File

@ -0,0 +1,33 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketLoginOutDisconnect extends PacketOut {
private String jsonReason;
public PacketLoginOutDisconnect(String jsonReason) {
this.jsonReason = jsonReason;
}
public String getJsonReason() {
return jsonReason;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getLoginOut().get(getClass()));
DataTypeIO.writeString(output, jsonReason, StandardCharsets.UTF_8);
return buffer.toByteArray();
}
}

41
src/main/java/com/loohp/limbo/server/packets/PacketLoginOutLoginSuccess.java Normal file
View File

@ -0,0 +1,41 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.UUID;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketLoginOutLoginSuccess extends PacketOut {
private UUID uuid;
private String username;
public PacketLoginOutLoginSuccess(UUID uuid, String username) {
this.uuid = uuid;
this.username = username;
}
public UUID getUuid() {
return uuid;
}
public String getUsername() {
return username;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getLoginOut().get(getClass()));
DataTypeIO.writeUUID(output, uuid);
DataTypeIO.writeString(output, username, StandardCharsets.UTF_8);
return buffer.toByteArray();
}
}

48
src/main/java/com/loohp/limbo/server/packets/PacketLoginOutPluginMessaging.java Normal file
View File

@ -0,0 +1,48 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.utils.NamespacedKey;
public class PacketLoginOutPluginMessaging extends PacketOut {
private int messageId;
private NamespacedKey channel;
private byte[] data;
public PacketLoginOutPluginMessaging(int messageId, NamespacedKey channel, byte[] data) {
this.messageId = messageId;
this.channel = channel;
this.data = data;
}
public int getMessageId() {
return messageId;
}
public NamespacedKey getChannel() {
return channel;
}
public byte[] getData() {
return data;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getLoginOut().get(getClass()));
DataTypeIO.writeVarInt(output, messageId);
DataTypeIO.writeString(output, channel.toString(), StandardCharsets.UTF_8);
output.write(data);
return buffer.toByteArray();
}
}

9
src/main/java/com/loohp/limbo/server/packets/PacketOut.java Normal file
View File

@ -0,0 +1,9 @@
package com.loohp.limbo.server.packets;
import java.io.IOException;
public abstract class PacketOut extends Packet {
public abstract byte[] serializePacket() throws IOException;
}

25
src/main/java/com/loohp/limbo/server/packets/PacketPlayInChat.java Normal file
View File

@ -0,0 +1,25 @@
package com.loohp.limbo.server.packets;
import java.io.DataInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketPlayInChat extends PacketIn {
private String message;
public PacketPlayInChat(String message) {
this.message = message;
}
public PacketPlayInChat(DataInputStream in) throws IOException {
this(DataTypeIO.readString(in, StandardCharsets.UTF_8));
}
public String getMessage() {
return message;
}
}

21
src/main/java/com/loohp/limbo/server/packets/PacketPlayInHeldItemChange.java Normal file
View File

@ -0,0 +1,21 @@
package com.loohp.limbo.server.packets;
import java.io.DataInputStream;
import java.io.IOException;
public class PacketPlayInHeldItemChange extends PacketIn {
private short slot;
public PacketPlayInHeldItemChange(short slot) {
this.slot = slot;
}
public PacketPlayInHeldItemChange(DataInputStream in) throws IOException {
this(in.readShort());
}
public short getSlot() {
return slot;
}
}

22
src/main/java/com/loohp/limbo/server/packets/PacketPlayInKeepAlive.java Normal file
View File

@ -0,0 +1,22 @@
package com.loohp.limbo.server.packets;
import java.io.DataInputStream;
import java.io.IOException;
public class PacketPlayInKeepAlive extends PacketIn {
private long payload;
public PacketPlayInKeepAlive(long payload) {
this.payload = payload;
}
public PacketPlayInKeepAlive(DataInputStream in) throws IOException {
this(in.readLong());
}
public long getPayload() {
return payload;
}
}

36
src/main/java/com/loohp/limbo/server/packets/PacketPlayInPluginMessaging.java Normal file
View File

@ -0,0 +1,36 @@
package com.loohp.limbo.server.packets;
import java.io.DataInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.utils.NamespacedKey;
public class PacketPlayInPluginMessaging extends PacketIn {
private NamespacedKey channel;
private byte[] data;
public PacketPlayInPluginMessaging(NamespacedKey channel, byte[] data) {
this.channel = channel;
this.data = data;
}
public PacketPlayInPluginMessaging(DataInputStream in, int packetLength, int packetId) throws IOException {
String rawChannel = DataTypeIO.readString(in, StandardCharsets.UTF_8);
channel = new NamespacedKey(rawChannel);
int dataLength = packetLength - DataTypeIO.getVarIntLength(packetId) - DataTypeIO.getStringLength(rawChannel, StandardCharsets.UTF_8);
data = new byte[dataLength];
in.read(data);
}
public NamespacedKey getChannel() {
return channel;
}
public byte[] getData() {
return data;
}
}

40
src/main/java/com/loohp/limbo/server/packets/PacketPlayInPosition.java Normal file
View File

@ -0,0 +1,40 @@
package com.loohp.limbo.server.packets;
import java.io.DataInputStream;
import java.io.IOException;
public class PacketPlayInPosition extends PacketIn {
private double x;
private double y;
private double z;
private boolean onGround;
public PacketPlayInPosition(double x, double y, double z, boolean onGround) {
this.x = x;
this.y = y;
this.z = z;
this.onGround = onGround;
}
public PacketPlayInPosition(DataInputStream in) throws IOException {
this(in.readDouble(), in.readDouble(), in.readDouble(), in.readBoolean());
}
public double getX() {
return x;
}
public double getY() {
return y;
}
public double getZ() {
return z;
}
public boolean onGround() {
return onGround;
}
}

52
src/main/java/com/loohp/limbo/server/packets/PacketPlayInPositionAndLook.java Normal file
View File

@ -0,0 +1,52 @@
package com.loohp.limbo.server.packets;
import java.io.DataInputStream;
import java.io.IOException;
public class PacketPlayInPositionAndLook extends PacketIn {
private double x;
private double y;
private double z;
private float yaw;
private float pitch;
private boolean onGround;
public PacketPlayInPositionAndLook(double x, double y, double z, float yaw, float pitch, boolean onGround) {
this.x = x;
this.y = y;
this.z = z;
this.yaw = yaw;
this.pitch = pitch;
this.onGround = onGround;
}
public PacketPlayInPositionAndLook(DataInputStream in) throws IOException {
this(in.readDouble(), in.readDouble(), in.readDouble(), in.readFloat(), in.readFloat(), in.readBoolean());
}
public double getX() {
return x;
}
public double getY() {
return y;
}
public double getZ() {
return z;
}
public float getYaw() {
return yaw;
}
public float getPitch() {
return pitch;
}
public boolean onGround() {
return onGround;
}
}

34
src/main/java/com/loohp/limbo/server/packets/PacketPlayInRotation.java Normal file
View File

@ -0,0 +1,34 @@
package com.loohp.limbo.server.packets;
import java.io.DataInputStream;
import java.io.IOException;
public class PacketPlayInRotation extends PacketIn {
private float yaw;
private float pitch;
private boolean onGround;
public PacketPlayInRotation(float yaw, float pitch, boolean onGround) {
this.yaw = yaw;
this.pitch = pitch;
this.onGround = onGround;
}
public PacketPlayInRotation(DataInputStream in) throws IOException {
this(in.readFloat(), in.readFloat(), in.readBoolean());
}
public float getYaw() {
return yaw;
}
public float getPitch() {
return pitch;
}
public boolean onGround() {
return onGround;
}
}

31
src/main/java/com/loohp/limbo/server/packets/PacketPlayInTabComplete.java Normal file
View File

@ -0,0 +1,31 @@
package com.loohp.limbo.server.packets;
import java.io.DataInputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketPlayInTabComplete extends PacketIn {
private int id;
private String text;
public PacketPlayInTabComplete(int id, String text) {
this.id = id;
this.text = text;
}
public PacketPlayInTabComplete(DataInputStream in) throws IOException {
this(DataTypeIO.readVarInt(in), DataTypeIO.readString(in, StandardCharsets.UTF_8));
}
public int getId() {
return id;
}
public String getText() {
return text;
}
}

48
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutChat.java Normal file
View File

@ -0,0 +1,48 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.UUID;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketPlayOutChat extends PacketOut {
private String json;
private int position;
private UUID sender;
public PacketPlayOutChat(String json, int position, UUID sender) {
this.json = json;
this.position = position;
this.sender = sender;
}
public String getJson() {
return json;
}
public int getPosition() {
return position;
}
public UUID getSender() {
return sender;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
DataTypeIO.writeString(output, json, StandardCharsets.UTF_8);
output.writeByte(position);
DataTypeIO.writeUUID(output, sender);
return buffer.toByteArray();
}
}

30
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutDeclareCommands.java Normal file
View File

@ -0,0 +1,30 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
public class PacketPlayOutDeclareCommands extends PacketOut {
private byte[] data;
public PacketPlayOutDeclareCommands(byte[] data) {
this.data = data;
}
public byte[] getData() {
return data;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
output.write(data);
return buffer.toByteArray();
}
}

33
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutDisconnect.java Normal file
View File

@ -0,0 +1,33 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketPlayOutDisconnect extends PacketOut {
private String jsonReason;
public PacketPlayOutDisconnect(String jsonReason) {
this.jsonReason = jsonReason;
}
public String getJsonReason() {
return jsonReason;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
DataTypeIO.writeString(output, jsonReason, StandardCharsets.UTF_8);
return buffer.toByteArray();
}
}

35
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutEntityDestroy.java Normal file
View File

@ -0,0 +1,35 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketPlayOutEntityDestroy extends PacketOut {
private int[] entityIds;
public PacketPlayOutEntityDestroy(int... entityIds) {
this.entityIds = entityIds;
}
public int[] getEntityIds() {
return entityIds;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
DataTypeIO.writeVarInt(output, entityIds.length);
for (int id : entityIds) {
DataTypeIO.writeVarInt(output, id);
}
return buffer.toByteArray();
}
}

156
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutEntityMetadata.java Normal file
View File

@ -0,0 +1,156 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.lang.reflect.Field;
import java.nio.charset.StandardCharsets;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.UUID;
import com.loohp.limbo.entity.Entity;
import com.loohp.limbo.entity.Pose;
import com.loohp.limbo.entity.DataWatcher.WatchableObject;
import com.loohp.limbo.entity.DataWatcher.WatchableObjectType;
import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.utils.Rotation3f;
import com.loohp.limbo.world.BlockPosition;
import net.md_5.bungee.chat.ComponentSerializer;
public class PacketPlayOutEntityMetadata extends PacketOut {
public static final int END_OFF_METADATA = 0xff;
private Entity entity;
public boolean allFields;
public Field[] fields;
public PacketPlayOutEntityMetadata(Entity entity, boolean allFields, Field... fields) {
this.entity = entity;
this.allFields = allFields;
this.fields = fields;
}
public PacketPlayOutEntityMetadata(Entity entity) {
this(entity, true);
}
public Entity getEntity() {
return entity;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
DataTypeIO.writeVarInt(output, entity.getEntityId());
Collection<WatchableObject> watches;
if (allFields) {
watches = new HashSet<>(entity.getDataWatcher().getWatchableObjects().values());
} else {
watches = new HashSet<>();
Map<Field, WatchableObject> entries = entity.getDataWatcher().getWatchableObjects();
for (Field field : fields) {
WatchableObject watch = entries.get(field);
if (watch != null) {
watches.add(watch);
}
}
}
Map<Integer, Integer> bitmasks = new HashMap<>();
Iterator<WatchableObject> itr = watches.iterator();
while (itr.hasNext()) {
WatchableObject watch = itr.next();
if (watch.isBitmask()) {
itr.remove();
Integer bitmask = bitmasks.get(watch.getIndex());
if (bitmask == null) {
bitmask = 0;
}
if ((boolean) watch.getValue()) {
bitmask |= watch.getBitmask();
} else {
bitmask &= ~watch.getBitmask();
}
bitmasks.put(watch.getIndex(), bitmask);
}
}
for (Entry<Integer, Integer> entry : bitmasks.entrySet()) {
watches.add(new WatchableObject(entry.getValue().byteValue(), entry.getKey(), WatchableObjectType.BYTE));
}
for (WatchableObject watch : watches) {
output.writeByte(watch.getIndex());
if (watch.isOptional()) {
DataTypeIO.writeVarInt(output, watch.getType().getOptionalTypeId());
output.writeBoolean(watch.getValue() != null);
} else {
DataTypeIO.writeVarInt(output, watch.getType().getTypeId());
}
if (!watch.isOptional() || watch.getValue() != null) {
switch (watch.getType()) {
//case BLOCKID:
// break;
case POSITION:
DataTypeIO.writeBlockPosition(output, (BlockPosition) watch.getValue());
break;
case BOOLEAN:
output.writeBoolean((boolean) watch.getValue());
break;
case BYTE:
output.writeByte((byte) watch.getValue());
break;
case CHAT:
DataTypeIO.writeString(output, ComponentSerializer.toString(watch.getValue()), StandardCharsets.UTF_8);
break;
//case DIRECTION:
// break;
case FLOAT:
output.writeFloat((float) watch.getValue());
break;
//case NBT:
// break;
//case PARTICLE:
// break;
case POSE:
DataTypeIO.writeVarInt(output, ((Pose) watch.getValue()).getId());
break;
case ROTATION:
Rotation3f rotation = (Rotation3f) watch.getValue();
output.writeFloat((float) rotation.getX());
output.writeFloat((float) rotation.getY());
output.writeFloat((float) rotation.getZ());
break;
//case SLOT:
// break;
case STRING:
DataTypeIO.writeString(output, watch.getValue().toString(), StandardCharsets.UTF_8);
break;
case UUID:
DataTypeIO.writeUUID(output, (UUID) watch.getValue());
break;
case VARINT:
DataTypeIO.writeVarInt(output, (int) watch.getValue());
break;
//case VILLAGER_DATA:
// break;
default:
break;
}
}
}
output.writeByte(END_OFF_METADATA);
return buffer.toByteArray();
}
}

37
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutGameState.java Normal file
View File

@ -0,0 +1,37 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
public class PacketPlayOutGameState extends PacketOut {
private int reason;
private float value;
public PacketPlayOutGameState(int reason, float value) {
this.reason = reason;
this.value = value;
}
public int getReason() {
return reason;
}
public float getValue() {
return value;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
output.writeByte(reason);
output.writeFloat(value);
return buffer.toByteArray();
}
}

29
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutHeldItemChange.java Normal file
View File

@ -0,0 +1,29 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
public class PacketPlayOutHeldItemChange extends PacketOut {
private final byte slot;
public PacketPlayOutHeldItemChange(byte slot) {
this.slot = slot;
}
public byte getSlot() {
return slot;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
output.writeByte(slot);
return buffer.toByteArray();
}
}

30
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutKeepAlive.java Normal file
View File

@ -0,0 +1,30 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
public class PacketPlayOutKeepAlive extends PacketOut {
long payload;
public PacketPlayOutKeepAlive(long payload) {
this.payload = payload;
}
public long getPayload() {
return payload;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
output.writeLong(payload);
return buffer.toByteArray();
}
}

111
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutLightUpdate.java Normal file
View File

@ -0,0 +1,111 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.List;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketPlayOutLightUpdate extends PacketOut {
private int chunkX;
private int chunkZ;
private boolean trustEdges;
private int skyLightBitMask;
private int blockLightBitMask;
private List<Byte[]> skylightArrays;
private List<Byte[]> blocklightArrays;
public PacketPlayOutLightUpdate(int chunkX, int chunkZ, boolean trustEdges, List<Byte[]> skylightArrays, List<Byte[]> blocklightArrays) {
this.chunkX = chunkX;
this.chunkZ = chunkZ;
this.trustEdges = trustEdges;
this.skylightArrays = skylightArrays;
this.blocklightArrays = blocklightArrays;
skyLightBitMask = 0;
for (int i = Math.min(17, skylightArrays.size() - 1); i >= 0; i--) {
skyLightBitMask = skyLightBitMask >> 1;
if (skylightArrays.get(i) != null) {
skyLightBitMask |= 131072;
}
}
blockLightBitMask = 0;
for (int i = Math.min(17, blocklightArrays.size() - 1); i >= 0; i--) {
blockLightBitMask = blockLightBitMask >> 1;
if (blocklightArrays.get(i) != null) {
blockLightBitMask |= 131072;
}
}
}
public int getChunkX() {
return chunkX;
}
public int getChunkZ() {
return chunkZ;
}
public boolean isTrustEdges() {
return trustEdges;
}
public int getSkyLightBitMask() {
return skyLightBitMask;
}
public int getBlockLightBitMask() {
return blockLightBitMask;
}
public List<Byte[]> getSkylightArrays() {
return skylightArrays;
}
public List<Byte[]> getBlocklightArrays() {
return blocklightArrays;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
DataTypeIO.writeVarInt(output, chunkX);
DataTypeIO.writeVarInt(output, chunkZ);
output.writeBoolean(trustEdges);
DataTypeIO.writeVarInt(output, skyLightBitMask);
DataTypeIO.writeVarInt(output, blockLightBitMask);
DataTypeIO.writeVarInt(output, ~skyLightBitMask & 262143);
DataTypeIO.writeVarInt(output, ~blockLightBitMask & 262143);
for (int i = skylightArrays.size() - 1; i >= 0; i--) {
Byte[] array = skylightArrays.get(i);
if (array != null) {
DataTypeIO.writeVarInt(output, 2048);
//System.out.println(Arrays.toString(ArrayUtils.toPrimitive(array)));
for (int u = 0; u < array.length; u++) {
output.writeByte(array[u]);
}
}
}
for (int i = blocklightArrays.size() - 1; i >= 0; i--) {
Byte[] array = blocklightArrays.get(i);
if (array != null) {
DataTypeIO.writeVarInt(output, 2048);
//System.out.println(Arrays.toString(ArrayUtils.toPrimitive(array)));
for (int u = 0; u < array.length; u++) {
output.writeByte(array[u]);
}
}
}
return buffer.toByteArray();
}
}

146
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutLogin.java Normal file
View File

@ -0,0 +1,146 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.utils.GameMode;
import com.loohp.limbo.utils.NamespacedKey;
import com.loohp.limbo.world.Environment;
import com.loohp.limbo.world.World;
import net.querz.nbt.tag.CompoundTag;
import net.querz.nbt.tag.ListTag;
public class PacketPlayOutLogin extends PacketOut {
private int entityId;
private boolean isHardcore;
private GameMode gamemode;
private String[] worldsNames;
private CompoundTag dimensionCodec;
private Environment dimension;
private String worldName;
private long hashedSeed;
private byte maxPlayers;
private int viewDistance;
private boolean reducedDebugInfo;
private boolean enableRespawnScreen;
private boolean isDebug;
private boolean isFlat;
public PacketPlayOutLogin(int entityId, boolean isHardcore, GameMode gamemode,
String[] worldsNames, CompoundTag dimensionCodec, World world, long hashedSeed,
byte maxPlayers, int viewDistance, boolean reducedDebugInfo, boolean enableRespawnScreen, boolean isDebug,
boolean isFlat) {
this.entityId = entityId;
this.isHardcore = isHardcore;
this.gamemode = gamemode;
this.worldsNames = worldsNames;
this.dimensionCodec = dimensionCodec;
this.dimension = world.getEnvironment();
this.worldName = new NamespacedKey(world.getName()).toString();
this.hashedSeed = hashedSeed;
this.maxPlayers = maxPlayers;
this.viewDistance = viewDistance;
this.reducedDebugInfo = reducedDebugInfo;
this.enableRespawnScreen = enableRespawnScreen;
this.isDebug = isDebug;
this.isFlat = isFlat;
}
public int getEntityId() {
return entityId;
}
public boolean isHardcore() {
return isHardcore;
}
public GameMode getGamemode() {
return gamemode;
}
public String[] getWorldsNames() {
return worldsNames;
}
public CompoundTag getDimensionCodec() {
return dimensionCodec;
}
public Environment getDimension() {
return dimension;
}
public String getWorldName() {
return worldName;
}
public long getHashedSeed() {
return hashedSeed;
}
public byte getMaxPlayers() {
return maxPlayers;
}
public int getViewDistance() {
return viewDistance;
}
public boolean isReducedDebugInfo() {
return reducedDebugInfo;
}
public boolean isEnableRespawnScreen() {
return enableRespawnScreen;
}
public boolean isDebug() {
return isDebug;
}
public boolean isFlat() {
return isFlat;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
output.writeInt(entityId);
output.writeBoolean(isHardcore);
output.writeByte((byte) gamemode.getId());
output.writeByte((byte) gamemode.getId());
DataTypeIO.writeVarInt(output, worldsNames.length);
for (int u = 0; u < worldsNames.length; u++) {
DataTypeIO.writeString(output, worldsNames[u], StandardCharsets.UTF_8);
}
DataTypeIO.writeCompoundTag(output, dimensionCodec);
CompoundTag tag = null;
ListTag<CompoundTag> list = dimensionCodec.getCompoundTag("minecraft:dimension_type").getListTag("value").asCompoundTagList();
for (CompoundTag each : list) {
if (each.getString("name").equals(dimension.getNamespacedKey().toString())) {
tag = each.getCompoundTag("element");
break;
}
}
DataTypeIO.writeCompoundTag(output, tag != null ? tag : list.get(0));
DataTypeIO.writeString(output, worldName, StandardCharsets.UTF_8);
output.writeLong(hashedSeed);
DataTypeIO.writeVarInt(output, maxPlayers);
DataTypeIO.writeVarInt(output, viewDistance);
output.writeBoolean(reducedDebugInfo);
output.writeBoolean(enableRespawnScreen);
output.writeBoolean(isDebug);
output.writeBoolean(isFlat);
return buffer.toByteArray();
}
}

211
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutMapChunk.java Normal file
View File

@ -0,0 +1,211 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import com.loohp.limbo.utils.BitsUtils;
import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.world.Environment;
import com.loohp.limbo.world.GeneratedBlockDataMappings;
import net.querz.mca.Chunk;
import net.querz.mca.Section;
import net.querz.nbt.tag.CompoundTag;
import net.querz.nbt.tag.ListTag;
public class PacketPlayOutMapChunk extends PacketOut {
private int chunkX;
private int chunkZ;
private Chunk chunk;
private Environment environment;
public PacketPlayOutMapChunk(int chunkX, int chunkZ, Chunk chunk, Environment environment) {
this.chunkX = chunkX;
this.chunkZ = chunkZ;
this.chunk = chunk;
this.environment = environment;
}
@Deprecated
public PacketPlayOutMapChunk(int chunkX, int chunkZ, Chunk chunk) {
this(chunkZ, chunkZ, chunk, Environment.NORMAL);
}
public Chunk getChunk() {
return chunk;
}
public int getChunkX() {
return chunkX;
}
public int getChunkZ() {
return chunkZ;
}
public Environment getEnvironment() {
return environment;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
output.writeInt(chunkX);
output.writeInt(chunkZ);
output.writeBoolean(true);
int bitmask = 0;
for (int i = 0; i < 16; i++) {
Section section = chunk.getSection(i);
if (section != null) {
bitmask = bitmask | (int) Math.pow(2, i);
}
}
DataTypeIO.writeVarInt(output, bitmask);
DataTypeIO.writeCompoundTag(output, chunk.getHeightMaps());
DataTypeIO.writeVarInt(output, 1024);
int biome;
if (environment.equals(Environment.END)) {
biome = 9; //the_end
} else if (environment.equals(Environment.NETHER)) {
biome = 8; //nether_waste
} else if (environment.equals(Environment.NORMAL)) {
biome = 1; //plains
} else {
biome = 1; //plains
}
for (int i = 0; i < 1024; i++) {
DataTypeIO.writeVarInt(output, biome);
}
ByteArrayOutputStream dataBuffer = new ByteArrayOutputStream();
DataOutputStream dataOut = new DataOutputStream(dataBuffer);
for (int i = 0; i < 16; i++) {
Section section = chunk.getSection(i);
if (section != null) {
int counter = 0;
for (int x = 0; x < 16; x++) {
for (int z = 0; z < 16; z++) {
for (int y = 0; y < 16; y++) {
CompoundTag tag = section.getBlockStateAt(x, y, z);
if (tag != null && !tag.getString("Name").equals("minecraft:air")) {
counter++;
}
}
}
}
dataOut.writeShort(counter);
int newBits = 32 - Integer.numberOfLeadingZeros(section.getPalette().size() - 1);
newBits = Math.max(newBits, 4);
//Limbo.getInstance().getConsole().sendMessage(i + " " + newBits);
if (newBits <= 8) {
/*
if (newBits == 4) {
dataOut.writeByte(4);
} else {
newBits = 8;
ChunkDataUtils.adjustBlockStateBits(newBits, section, chunk.getDataVersion());
dataOut.writeByte(8);
}
*/
dataOut.writeByte(newBits);
DataTypeIO.writeVarInt(dataOut, section.getPalette().size());
//Limbo.getInstance().getConsole().sendMessage(section.getPalette().size());
Iterator<CompoundTag> itr1 = section.getPalette().iterator();
//Limbo.getInstance().getConsole().sendMessage("Nonnull -> " + i + " " + newBits);
while (itr1.hasNext()) {
CompoundTag tag = itr1.next();
DataTypeIO.writeVarInt(dataOut, GeneratedBlockDataMappings.getGlobalPaletteIDFromState(tag));
//Limbo.getInstance().getConsole().sendMessage(tag + " -> " + GeneratedDataUtils.getGlobalPaletteIDFromState(tag));
}
BitSet bits = BitSet.valueOf(section.getBlockStates());
int shift = 64 % newBits;
int longsNeeded = (int) Math.ceil(4096 / (double) (64 / newBits));
for (int u = 64; u <= bits.length(); u += 64) {
bits = BitsUtils.shiftAfter(bits, u - shift, shift);
}
long[] formattedLongs = bits.toLongArray();
//Limbo.getInstance().getConsole().sendMessage(longsNeeded + "");
DataTypeIO.writeVarInt(dataOut, longsNeeded);
for (int u = 0; u < longsNeeded; u++) {
if (u < formattedLongs.length) {
dataOut.writeLong(formattedLongs[u]);
} else {
dataOut.writeLong(0);
}
//Limbo.getInstance().getConsole().sendMessage(Arrays.toString(section.getBlockStates()));
}
} else {
try {
dataOut.writeByte(15);
section.getBlockStates();
int longsNeeded = 1024;
List<Integer> list = new LinkedList<>();
for (int y = 0; y < 16; y++) {
for (int z = 0; z < 16; z++) {
for (int x = 0; x < 16; x++) {
list.add(GeneratedBlockDataMappings.getGlobalPaletteIDFromState(section.getBlockStateAt(x, y, z)));
}
}
}
List<Long> globalLongs = new ArrayList<>();
long currentLong = 0;
int pos = 0;
int u = 0;
while (pos < longsNeeded) {
if (u == 3) {
globalLongs.add(currentLong);
currentLong = 0;
u = 0;
pos++;
} else {
u++;
}
int id = list.isEmpty() ? 0 : list.remove(0);
currentLong = currentLong << 15;
currentLong |= (long) id;
}
DataTypeIO.writeVarInt(dataOut, longsNeeded);
for (int j = 0; j < longsNeeded; j++) {
if (j < globalLongs.size()) {
dataOut.writeLong(globalLongs.get(j));
} else {
dataOut.writeLong(0);
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
byte[] data = dataBuffer.toByteArray();
DataTypeIO.writeVarInt(output, data.length);
output.write(data);
ListTag<CompoundTag> tileEntities = chunk.getTileEntities();
DataTypeIO.writeVarInt(output, tileEntities.size());
for (CompoundTag each : tileEntities) {
DataTypeIO.writeCompoundTag(output, each);
}
return buffer.toByteArray();
}
}

66
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutPlayerAbilities.java Normal file
View File

@ -0,0 +1,66 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
public class PacketPlayOutPlayerAbilities extends PacketOut {
public enum PlayerAbilityFlags {
INVULNERABLE(0x01),
FLY(0x02),
ALLOW_FLYING(0x04),
CREATIVE(0x08);
int bitvalue;
PlayerAbilityFlags(int bitvalue) {
this.bitvalue = bitvalue;
}
public int getValue() {
return bitvalue;
}
}
private PlayerAbilityFlags[] flags;
private float flySpeed;
private float fieldOfField;
public PacketPlayOutPlayerAbilities(float flySpeed, float fieldOfField, PlayerAbilityFlags... flags) {
this.flags = flags;
this.flySpeed = flySpeed;
this.fieldOfField = fieldOfField;
}
public PlayerAbilityFlags[] getFlags() {
return flags;
}
public float getFlySpeed() {
return flySpeed;
}
public float getFieldOfField() {
return fieldOfField;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
int value = 0;
for (PlayerAbilityFlags flag : flags) {
value = value | flag.getValue();
}
output.writeByte(value);
output.writeFloat(flySpeed);
output.writeFloat(fieldOfField);
return buffer.toByteArray();
}
}

168
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutPlayerInfo.java Normal file
View File

@ -0,0 +1,168 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Optional;
import java.util.UUID;
import com.loohp.limbo.server.packets.PacketPlayOutPlayerInfo.PlayerInfoData.PlayerInfoDataAddPlayer;
import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.utils.GameMode;
public class PacketPlayOutPlayerInfo extends PacketOut {
public enum PlayerInfoAction {
ADD_PLAYER(0), UPDATE_GAMEMODE(1), UPDATE_LATENCY(2), UPDATE_DISPLAY_NAME(3), REMOVE_PLAYER(4);
int id;
PlayerInfoAction(int id) {
this.id = id;
}
public int getId() {
return id;
}
}
private PlayerInfoAction action;
private UUID uuid;
private PlayerInfoData data;
public PacketPlayOutPlayerInfo(PlayerInfoAction action, UUID uuid, PlayerInfoData data) {
this.action = action;
this.uuid = uuid;
this.data = data;
}
public PlayerInfoAction getAction() {
return action;
}
public UUID getUuid() {
return uuid;
}
public PlayerInfoData getData() {
return data;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
DataTypeIO.writeVarInt(output, action.getId());
DataTypeIO.writeVarInt(output, 1);
DataTypeIO.writeUUID(output, uuid);
switch (action) {
case ADD_PLAYER:
PlayerInfoDataAddPlayer data = (PlayerInfoDataAddPlayer) this.data;
DataTypeIO.writeString(output, data.getName(), StandardCharsets.UTF_8);
if (data.getProperty().isPresent()) {
DataTypeIO.writeVarInt(output, 1);
DataTypeIO.writeString(output, "textures", StandardCharsets.UTF_8);
DataTypeIO.writeString(output, data.getProperty().get().getSkin(), StandardCharsets.UTF_8);
output.writeBoolean(true);
DataTypeIO.writeString(output, data.getProperty().get().getSignature(), StandardCharsets.UTF_8);
} else {
DataTypeIO.writeVarInt(output, 0);
}
DataTypeIO.writeVarInt(output, data.getGamemode().getId());
DataTypeIO.writeVarInt(output, data.getPing());
if (data.getDisplayNameJson().isPresent()) {
output.writeBoolean(true);
DataTypeIO.writeString(output, data.getDisplayNameJson().get(), StandardCharsets.UTF_8);
} else {
output.writeBoolean(false);
}
break;
case REMOVE_PLAYER:
break;
case UPDATE_DISPLAY_NAME:
break;
case UPDATE_GAMEMODE:
break;
case UPDATE_LATENCY:
break;
}
return buffer.toByteArray();
}
// =========
public static class PlayerInfoData {
public static class PlayerInfoDataAddPlayer extends PlayerInfoData {
private String name;
private Optional<PlayerSkinProperty> skin;
private GameMode gamemode;
private int ping;
private boolean hasDisplayName;
private Optional<String> displayNameJson;
public PlayerInfoDataAddPlayer(String name, Optional<PlayerSkinProperty> skin, GameMode gamemode, int ping,
boolean hasDisplayName, Optional<String> displayNameJson) {
this.name = name;
this.skin = skin;
this.gamemode = gamemode;
this.ping = ping;
this.hasDisplayName = hasDisplayName;
this.displayNameJson = displayNameJson;
}
public String getName() {
return name;
}
public Optional<PlayerSkinProperty> getProperty() {
return skin;
}
public GameMode getGamemode() {
return gamemode;
}
public int getPing() {
return ping;
}
public boolean isHasDisplayName() {
return hasDisplayName;
}
public Optional<String> getDisplayNameJson() {
return displayNameJson;
}
public static class PlayerSkinProperty {
private String skin;
private String signature;
public PlayerSkinProperty(String skin, String signature) {
this.skin = skin;
this.signature = signature;
}
public String getSkin() {
return skin;
}
public String getSignature() {
return signature;
}
}
}
}
}

41
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutPluginMessaging.java Normal file
View File

@ -0,0 +1,41 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.utils.NamespacedKey;
public class PacketPlayOutPluginMessaging extends PacketOut {
private NamespacedKey channel;
private byte[] data;
public PacketPlayOutPluginMessaging(NamespacedKey channel, byte[] data) {
this.channel = channel;
this.data = data;
}
public NamespacedKey getChannel() {
return channel;
}
public byte[] getData() {
return data;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
DataTypeIO.writeString(output, channel.toString(), StandardCharsets.UTF_8);
output.write(data);
return buffer.toByteArray();
}
}

101
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutPositionAndLook.java Normal file
View File

@ -0,0 +1,101 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.Set;
import java.util.stream.Collectors;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketPlayOutPositionAndLook extends PacketOut {
public enum PlayerTeleportFlags {
X((byte) 0x01),
Y((byte) 0x02),
Z((byte) 0x04),
Y_ROT((byte) 0x08),
X_ROT((byte) 0x10);
byte bit;
PlayerTeleportFlags(byte bit) {
this.bit = bit;
}
public byte getBit() {
return bit;
}
}
private double x;
private double y;
private double z;
private float yaw;
private float pitch;
private Set<PlayerTeleportFlags> flags;
private int teleportId;
public PacketPlayOutPositionAndLook(double x, double y, double z, float yaw, float pitch, int teleportId, PlayerTeleportFlags... flags) {
this.x = x;
this.y = y;
this.z = z;
this.yaw = yaw;
this.pitch = pitch;
this.teleportId = teleportId;
this.flags = Arrays.asList(flags).stream().collect(Collectors.toSet());
}
public double getX() {
return x;
}
public double getY() {
return y;
}
public double getZ() {
return z;
}
public float getYaw() {
return yaw;
}
public float getPitch() {
return pitch;
}
public Set<PlayerTeleportFlags> getFlags() {
return flags;
}
public int getTeleportId() {
return teleportId;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
output.writeDouble(x);
output.writeDouble(y);
output.writeDouble(z);
output.writeFloat(yaw);
output.writeFloat(pitch);
byte flag = 0;
for (PlayerTeleportFlags each : flags) {
flag = (byte) (flag | each.getBit());
}
output.writeByte(flag);
DataTypeIO.writeVarInt(output, teleportId);
return buffer.toByteArray();
}
}

97
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutRespawn.java Normal file
View File

@ -0,0 +1,97 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.utils.GameMode;
import com.loohp.limbo.utils.NamespacedKey;
import com.loohp.limbo.world.Environment;
import com.loohp.limbo.world.World;
import net.querz.nbt.tag.CompoundTag;
import net.querz.nbt.tag.ListTag;
public class PacketPlayOutRespawn extends PacketOut {
private Environment dimension;
private String worldName;
private CompoundTag dimensionCodec;
private long hashedSeed;
private GameMode gamemode;
private boolean isDebug;
private boolean isFlat;
private boolean copyMetaData;
public PacketPlayOutRespawn(World world, CompoundTag dimensionCodec, long hashedSeed, GameMode gamemode, boolean isDebug, boolean isFlat, boolean copyMetaData) {
this.dimension = world.getEnvironment();
this.dimensionCodec = dimensionCodec;
this.worldName = new NamespacedKey(world.getName()).toString();
this.hashedSeed = hashedSeed;
this.gamemode = gamemode;
this.isDebug = isDebug;
this.isFlat = isFlat;
this.copyMetaData = copyMetaData;
}
public CompoundTag getDimensionCodec() {
return dimensionCodec;
}
public Environment getDimension() {
return dimension;
}
public String getWorldName() {
return worldName;
}
public long getHashedSeed() {
return hashedSeed;
}
public GameMode getGamemode() {
return gamemode;
}
public boolean isDebug() {
return isDebug;
}
public boolean isFlat() {
return isFlat;
}
public boolean isCopyMetaData() {
return copyMetaData;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
CompoundTag tag = null;
ListTag<CompoundTag> list = dimensionCodec.getCompoundTag("minecraft:dimension_type").getListTag("value").asCompoundTagList();
for (CompoundTag each : list) {
if (each.getString("name").equals(dimension.getNamespacedKey().toString())) {
tag = each.getCompoundTag("element");
break;
}
}
DataTypeIO.writeCompoundTag(output, tag != null ? tag : list.get(0));
DataTypeIO.writeString(output, worldName, StandardCharsets.UTF_8);
output.writeLong(hashedSeed);
output.writeByte((byte) gamemode.getId());
output.writeByte((byte) gamemode.getId());
output.writeBoolean(isDebug);
output.writeBoolean(isFlat);
output.writeBoolean(copyMetaData);
return buffer.toByteArray();
}
}

111
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutSpawnEntity.java Normal file
View File

@ -0,0 +1,111 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.UUID;
import com.loohp.limbo.entity.EntityType;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketPlayOutSpawnEntity extends PacketOut {
private int entityId;
private UUID uuid;
private EntityType type;
private double x;
private double y;
private double z;
private float pitch;
private float yaw;
private int data;
private short velocityX;
private short velocityY;
private short velocityZ;
public PacketPlayOutSpawnEntity(int entityId, UUID uuid, EntityType type, double x, double y, double z, float pitch, float yaw, short velocityX, short velocityY, short velocityZ) {
this.entityId = entityId;
this.uuid = uuid;
this.type = type;
this.x = x;
this.y = y;
this.z = z;
this.pitch = pitch;
this.yaw = yaw;
this.data = 0; //TO-DO
this.velocityX = velocityX;
this.velocityY = velocityY;
this.velocityZ = velocityZ;
}
public int getEntityId() {
return entityId;
}
public UUID getUuid() {
return uuid;
}
public EntityType getType() {
return type;
}
public double getX() {
return x;
}
public double getY() {
return y;
}
public double getZ() {
return z;
}
public float getPitch() {
return pitch;
}
public float getYaw() {
return yaw;
}
public int getData() {
return data;
}
public short getVelocityX() {
return velocityX;
}
public short getVelocityY() {
return velocityY;
}
public short getVelocityZ() {
return velocityZ;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
DataTypeIO.writeVarInt(output, entityId);
DataTypeIO.writeUUID(output, uuid);
DataTypeIO.writeVarInt(output, type.getTypeId());
output.writeDouble(x);
output.writeDouble(y);
output.writeDouble(z);
output.writeByte((byte) (int) (pitch * 256.0F / 360.0F));
output.writeByte((byte) (int) (yaw * 256.0F / 360.0F));
output.writeInt(data);
output.writeShort((int) (velocityX * 8000));
output.writeShort((int) (velocityY * 8000));
output.writeShort((int) (velocityZ * 8000));
return buffer.toByteArray();
}
}

111
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutSpawnEntityLiving.java Normal file
View File

@ -0,0 +1,111 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.UUID;
import com.loohp.limbo.entity.EntityType;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketPlayOutSpawnEntityLiving extends PacketOut {
private int entityId;
private UUID uuid;
private EntityType type;
private double x;
private double y;
private double z;
private float yaw;
private float pitch;
private float headPitch;
private short velocityX;
private short velocityY;
private short velocityZ;
public PacketPlayOutSpawnEntityLiving(int entityId, UUID uuid, EntityType type, double x, double y, double z, float yaw, float pitch, float headPitch, short velocityX, short velocityY, short velocityZ) {
this.entityId = entityId;
this.uuid = uuid;
this.type = type;
this.x = x;
this.y = y;
this.z = z;
this.yaw = yaw;
this.pitch = pitch;
this.headPitch = headPitch;
this.velocityX = velocityX;
this.velocityY = velocityY;
this.velocityZ = velocityZ;
}
public int getEntityId() {
return entityId;
}
public UUID getUuid() {
return uuid;
}
public EntityType getType() {
return type;
}
public double getX() {
return x;
}
public double getY() {
return y;
}
public double getZ() {
return z;
}
public float getYaw() {
return yaw;
}
public float getPitch() {
return pitch;
}
public float getHeadPitch() {
return headPitch;
}
public short getVelocityX() {
return velocityX;
}
public short getVelocityY() {
return velocityY;
}
public short getVelocityZ() {
return velocityZ;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
DataTypeIO.writeVarInt(output, entityId);
DataTypeIO.writeUUID(output, uuid);
DataTypeIO.writeVarInt(output, type.getTypeId());
output.writeDouble(x);
output.writeDouble(y);
output.writeDouble(z);
output.writeByte((byte) (int) (yaw * 256.0F / 360.0F));
output.writeByte((byte) (int) (pitch * 256.0F / 360.0F));
output.writeByte((byte) (int) (headPitch * 256.0F / 360.0F));
output.writeShort((int) (velocityX * 8000));
output.writeShort((int) (velocityY * 8000));
output.writeShort((int) (velocityZ * 8000));
return buffer.toByteArray();
}
}

32
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutSpawnPosition.java Normal file
View File

@ -0,0 +1,32 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.world.BlockPosition;
public class PacketPlayOutSpawnPosition extends PacketOut {
private BlockPosition position;
public PacketPlayOutSpawnPosition(BlockPosition position) {
this.position = position;
}
public BlockPosition getPosition() {
return position;
}
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
DataTypeIO.writeBlockPosition(output, position);
return buffer.toByteArray();
}
}

88
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutTabComplete.java Normal file
View File

@ -0,0 +1,88 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Optional;
import com.loohp.limbo.utils.DataTypeIO;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.chat.ComponentSerializer;
public class PacketPlayOutTabComplete extends PacketOut {
private int id;
private int start;
private int length;
private TabCompleteMatches[] matches;
public PacketPlayOutTabComplete(int id, int start, int length, TabCompleteMatches... matches) {
this.id = id;
this.start = start;
this.length = length;
this.matches = matches;
}
public int getId() {
return id;
}
public int getStart() {
return start;
}
public int getLength() {
return length;
}
public TabCompleteMatches[] getMatches() {
return matches;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
DataTypeIO.writeVarInt(output, id);
DataTypeIO.writeVarInt(output, start);
DataTypeIO.writeVarInt(output, length);
DataTypeIO.writeVarInt(output, matches.length);
for (TabCompleteMatches match : matches) {
DataTypeIO.writeString(output, match.getMatch(), StandardCharsets.UTF_8);
if (match.getTooltip().isPresent()) {
output.writeBoolean(true);
DataTypeIO.writeString(output, ComponentSerializer.toString(match.getTooltip().get()), StandardCharsets.UTF_8);
} else {
output.writeBoolean(false);
}
}
return buffer.toByteArray();
}
public static class TabCompleteMatches {
private String match;
private Optional<BaseComponent[]> tooltip;
public TabCompleteMatches(String match, BaseComponent... tooltip) {
this.match = match;
this.tooltip = tooltip.length > 0 ? Optional.of(tooltip) : Optional.empty();
}
public String getMatch() {
return match;
}
public Optional<BaseComponent[]> getTooltip() {
return tooltip;
}
}
}

37
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutUnloadChunk.java Normal file
View File

@ -0,0 +1,37 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
public class PacketPlayOutUnloadChunk extends PacketOut {
private int chunkX;
private int chunkZ;
public PacketPlayOutUnloadChunk(int chunkX, int chunkZ) {
this.chunkX = chunkX;
this.chunkZ = chunkZ;
}
public int getChunkX() {
return chunkX;
}
public int getChunkZ() {
return chunkZ;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
output.writeInt(chunkX);
output.writeInt(chunkZ);
return buffer.toByteArray();
}
}

39
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutUpdateViewPosition.java Normal file
View File

@ -0,0 +1,39 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketPlayOutUpdateViewPosition extends PacketOut {
private int chunkX;
private int chunkZ;
public PacketPlayOutUpdateViewPosition(int chunkX, int chunkZ) {
this.chunkX = chunkX;
this.chunkZ = chunkZ;
}
public int getChunkX() {
return chunkX;
}
public int getChunkZ() {
return chunkZ;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass()));
DataTypeIO.writeVarInt(output, chunkX);
DataTypeIO.writeVarInt(output, chunkZ);
return buffer.toByteArray();
}
}

22
src/main/java/com/loohp/limbo/server/packets/PacketStatusInPing.java Normal file
View File

@ -0,0 +1,22 @@
package com.loohp.limbo.server.packets;
import java.io.DataInputStream;
import java.io.IOException;
public class PacketStatusInPing extends PacketIn {
private long payload;
public PacketStatusInPing(long payload) {
this.payload = payload;
}
public PacketStatusInPing(DataInputStream in) throws IOException {
this(in.readLong());
}
public long getPayload() {
return payload;
}
}

15
src/main/java/com/loohp/limbo/server/packets/PacketStatusInRequest.java Normal file
View File

@ -0,0 +1,15 @@
package com.loohp.limbo.server.packets;
import java.io.DataInputStream;
public class PacketStatusInRequest extends PacketIn {
public PacketStatusInRequest() {
}
public PacketStatusInRequest(DataInputStream in) {
this();
}
}

30
src/main/java/com/loohp/limbo/server/packets/PacketStatusOutPong.java Normal file
View File

@ -0,0 +1,30 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
public class PacketStatusOutPong extends PacketOut {
private long payload;
public PacketStatusOutPong(long payload) {
this.payload = payload;
}
public long getPayload() {
return payload;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getStatusOut().get(getClass()));
output.writeLong(payload);
return buffer.toByteArray();
}
}

33
src/main/java/com/loohp/limbo/server/packets/PacketStatusOutResponse.java Normal file
View File

@ -0,0 +1,33 @@
package com.loohp.limbo.server.packets;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketStatusOutResponse extends PacketOut {
private String json;
public PacketStatusOutResponse(String json) {
this.json = json;
}
public String getJson() {
return json;
}
@Override
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getStatusOut().get(getClass()));
DataTypeIO.writeString(output, json, StandardCharsets.UTF_8);
return buffer.toByteArray();
}
}

31
src/main/java/com/loohp/limbo/utils/BitsUtils.java Normal file
View File

@ -0,0 +1,31 @@
package com.loohp.limbo.utils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.List;
public class BitsUtils {
public static BitSet shiftAfter(BitSet bitset, int from, int shift) {
BitSet subset = bitset.get(from, bitset.length());
for (int i = 0; i < subset.length(); i++) {
bitset.set(from + shift + i, subset.get(i));
}
if (shift > 0) {
for (int i = 0; i < shift; i++) {
bitset.set(from + i, false);
}
}
return bitset;
}
public static String toLongString(BitSet bitset) {
List<String> list = new ArrayList<>();
for (long l : bitset.toLongArray()) {
list.add(Long.toBinaryString(l));
}
return Arrays.toString(list.toArray());
}
}

58
src/main/java/com/loohp/limbo/utils/BungeeLoginMessageUtils.java Normal file
View File

@ -0,0 +1,58 @@
package com.loohp.limbo.utils;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.UUID;
import com.google.common.io.ByteArrayDataInput;
import com.google.common.io.ByteArrayDataOutput;
import com.google.common.io.ByteStreams;
import com.loohp.limbo.server.packets.PacketPlayOutPluginMessaging;
public class BungeeLoginMessageUtils {
public static void sendUUIDRequest(DataOutputStream output) throws IOException {
ByteArrayDataOutput out = ByteStreams.newDataOutput();
out.writeUTF("UUID");
PacketPlayOutPluginMessaging packet = new PacketPlayOutPluginMessaging(new NamespacedKey("bungeecord", "main"), out.toByteArray());
byte[] packetByte = packet.serializePacket();
DataTypeIO.writeVarInt(output, packetByte.length);
output.write(packetByte);
}
public static UUID readUUIDResponse(byte[] data) {
ByteArrayDataInput in = ByteStreams.newDataInput(data);
String subchannel = in.readUTF();
if (subchannel.equals("UUID")) {
return UUID.fromString(in.readUTF());
} else {
throw new RuntimeException("Bungeecord Message receieved is not an IP");
}
}
public static void sendIPRequest(DataOutputStream output) throws IOException {
ByteArrayDataOutput out = ByteStreams.newDataOutput();
out.writeUTF("IP");
PacketPlayOutPluginMessaging packet = new PacketPlayOutPluginMessaging(new NamespacedKey("bungeecord", "main"), out.toByteArray());
byte[] packetByte = packet.serializePacket();
DataTypeIO.writeVarInt(output, packetByte.length);
output.write(packetByte);
}
public static InetAddress readIPResponse(byte[] data) throws UnknownHostException {
ByteArrayDataInput in = ByteStreams.newDataInput(data);
String subchannel = in.readUTF();
if (subchannel.equals("IP")) {
String ip = in.readUTF();
in.readInt();
return InetAddress.getByName(ip);
} else {
throw new RuntimeException("Bungeecord Message receieved is not an IP");
}
}
}

26
src/main/java/com/loohp/limbo/utils/ChunkDataUtils.java Normal file
View File

@ -0,0 +1,26 @@
package com.loohp.limbo.utils;
import net.querz.mca.Section;
public class ChunkDataUtils {
public static void adjustBlockStateBits(int newBits, Section section, int dataVersion) {
//increases or decreases the amount of bits used per BlockState
//based on the size of the palette.
long[] blockStates = section.getBlockStates();
long[] newBlockStates;
if (dataVersion < 2527) {
newBlockStates = newBits == blockStates.length / 64 ? blockStates : new long[newBits * 64];
} else {
int newLength = (int) Math.ceil(4096D / (64D / newBits));
newBlockStates = newBits == blockStates.length / 64 ? blockStates : new long[newLength];
}
for (int i = 0; i < 4096; i++) {
section.setPaletteIndex(i, section.getPaletteIndex(i), newBlockStates);
}
section.setBlockStates(newBlockStates);
}
}

21
src/main/java/com/loohp/limbo/utils/CustomArrayUtils.java Normal file
View File

@ -0,0 +1,21 @@
package com.loohp.limbo.utils;
public class CustomArrayUtils {
public static int[] longArrayToIntArray(long[] numbers) {
int[] intNumbers = new int[numbers.length];
for(int i = 0; i < numbers.length; i++) {
intNumbers[i] = (int) numbers[i];
}
return intNumbers;
}
public static byte[] longArrayToByteArray(long[] numbers) {
byte[] intNumbers = new byte[numbers.length];
for(int i = 0; i < numbers.length; i++) {
intNumbers[i] = (byte) numbers[i];
}
return intNumbers;
}
}

180
src/main/java/com/loohp/limbo/utils/CustomNBTUtils.java Normal file
View File

@ -0,0 +1,180 @@
package com.loohp.limbo.utils;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import net.querz.nbt.tag.ByteArrayTag;
import net.querz.nbt.tag.ByteTag;
import net.querz.nbt.tag.CompoundTag;
import net.querz.nbt.tag.DoubleTag;
import net.querz.nbt.tag.FloatTag;
import net.querz.nbt.tag.IntArrayTag;
import net.querz.nbt.tag.IntTag;
import net.querz.nbt.tag.ListTag;
import net.querz.nbt.tag.LongArrayTag;
import net.querz.nbt.tag.LongTag;
import net.querz.nbt.tag.ShortTag;
import net.querz.nbt.tag.StringTag;
import net.querz.nbt.tag.Tag;
@SuppressWarnings("rawtypes")
public class CustomNBTUtils {
public enum TagClass {
CompoundTagClass(CompoundTag.class),
ByteTagClass(ByteTag.class),
ShortTagClass(ShortTag.class),
IntTagClass(IntTag.class),
LongTagClass(LongTag.class),
FloatTagClass(FloatTag.class),
DoubleTagClass(DoubleTag.class),
ByteArrayTagClass(ByteArrayTag.class),
IntArrayTagClass(IntArrayTag.class),
LongArrayTagClass(LongArrayTag.class),
StringTagClass(StringTag.class),
ListTagClass(ListTag.class);
Class<? extends Tag> clazz;
TagClass(Class<? extends Tag> clazz) {
this.clazz = clazz;
}
public Class<? extends Tag> getTagClass() {
return clazz;
}
}
public static Class<? extends Tag> getClassFromName(String name) {
for (TagClass clazz : TagClass.values()) {
if (clazz.getTagClass().getSimpleName().equals(name)) {
return clazz.getTagClass();
}
}
return null;
}
public static CompoundTag getCompoundTagFromJson(JSONObject json) {
CompoundTag tag = new CompoundTag();
for (Object obj : json.keySet()) {
String key = (String) obj;
JSONObject inside = (JSONObject) json.get(key);
String type = (String) inside.get("type");
switch (type) {
case "ByteTag":
tag.putByte(key, (byte) (long) inside.get("value"));
break;
case "ShortTag":
tag.putShort(key, (short) (long) inside.get("value"));
break;
case "IntTag":
tag.putInt(key, (int) (long) inside.get("value"));
break;
case "LongTag":
tag.putLong(key, (long) inside.get("value"));
break;
case "FloatTag":
tag.putFloat(key, inside.get("value") instanceof Long ? (float) (long) inside.get("value") : (float) (double) inside.get("value"));
break;
case "DoubleTag":
tag.putDouble(key, inside.get("value") instanceof Long ? (double) (long) inside.get("value") : (double) inside.get("value"));
break;
case "ByteArrayTag":
tag.putByteArray(key, CustomArrayUtils.longArrayToByteArray((long[]) inside.get("value")));
break;
case "IntArrayTag":
tag.putIntArray(key, CustomArrayUtils.longArrayToIntArray((long[]) inside.get("value")));
break;
case "LongArrayTag":
tag.putLongArray(key, (long[]) inside.get("value"));
break;
case "StringTag":
tag.putString(key, (String) inside.get("value"));
break;
case "CompoundTag":
tag.put(key, getCompoundTagFromJson((JSONObject) inside.get("value")));
break;
case "ListTag":
tag.put(key, getListTagFromJson((JSONObject) inside.get("value")));
break;
}
}
return tag;
}
public static ListTag<?> getListTagFromJson(JSONObject json) {
String type = (String) json.get("type");
JSONArray array = (JSONArray) json.get("list");
ListTag<?> listTag = ListTag.createUnchecked(getClassFromName(type));
switch (type) {
case "ByteTag":
for (Object obj : array) {
listTag.addByte((byte) (long) obj);
}
break;
case "ShortTag":
for (Object obj : array) {
listTag.addShort((short) (long) obj);
}
break;
case "IntTag":
for (Object obj : array) {
listTag.addInt((int) (long) obj);
}
break;
case "LongTag":
for (Object obj : array) {
listTag.addLong((long) obj);
}
break;
case "FloatTag":
for (Object obj : array) {
listTag.addFloat(obj instanceof Long ? (float) (long) obj : (float) (double) obj);
}
break;
case "DoubleTag":
for (Object obj : array) {
listTag.addDouble(obj instanceof Long ? (double) (long) obj : (double) obj);
}
break;
case "ByteArrayTag":
for (Object obj : array) {
listTag.addByteArray(CustomArrayUtils.longArrayToByteArray((long[]) obj));
}
break;
case "IntArrayTag":
for (Object obj : array) {
listTag.addIntArray(CustomArrayUtils.longArrayToIntArray((long[]) obj));
}
break;
case "LongArrayTag":
for (Object obj : array) {
listTag.addLongArray((long[]) obj);
}
break;
case "StringTag":
for (Object obj : array) {
listTag.addString((String) obj);
}
break;
case "CompoundTag":
for (Object obj : array) {
listTag.asCompoundTagList().add(getCompoundTagFromJson((JSONObject) obj));
}
break;
case "ListTag":
for (Object obj : array) {
listTag.asListTagList().add(getListTagFromJson((JSONObject) obj));
}
break;
}
return listTag;
}
}

67
src/main/java/com/loohp/limbo/utils/CustomStringUtils.java Normal file
View File

@ -0,0 +1,67 @@
package com.loohp.limbo.utils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class CustomStringUtils {
public static boolean arrayContains(String compare, String[] args, boolean IgnoreCase) {
return IgnoreCase ? Arrays.asList(args).stream().anyMatch(each -> each.equalsIgnoreCase(compare)) : Arrays.asList(args).stream().anyMatch(each -> each.equals(compare));
}
public static boolean arrayContains(String compare, String[] args) {
return arrayContains(compare, args, true);
}
public static String[] splitStringToArgs(String str) {
List<String> tokens = new ArrayList<String>();
StringBuilder sb = new StringBuilder();
boolean insideQuote = false;
for (char c : str.toCharArray()) {
if (c == '"') {
insideQuote = !insideQuote;
} else if (c == ' ' && !insideQuote) {
if (sb.length() > 0) {
tokens.add(sb.toString());
}
sb.delete(0, sb.length());
} else {
sb.append(c);
}
}
tokens.add(sb.toString());
return tokens.toArray(new String[tokens.size()]);
}
public static int getIndexOfArg(String str, int ordinal) {
StringBuilder sb = new StringBuilder();
boolean insideQuote = false;
int pos = 0;
int found = 0;
for (char c : str.toCharArray()) {
if (c == '"') {
insideQuote = !insideQuote;
} else if (c == ' ' && !insideQuote) {
if (sb.length() > 0) {
found++;
}
sb.delete(0, sb.length());
} else {
sb.append(c);
}
if (found == ordinal) {
return pos;
}
pos++;
}
return -1;
}
}

135
src/main/java/com/loohp/limbo/utils/DataTypeIO.java Normal file
View File

@ -0,0 +1,135 @@
package com.loohp.limbo.utils;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.UUID;
import com.loohp.limbo.world.BlockPosition;
import net.querz.nbt.io.NBTOutputStream;
import net.querz.nbt.tag.CompoundTag;
import net.querz.nbt.tag.Tag;
public class DataTypeIO {
public static void writeBlockPosition(DataOutputStream out, BlockPosition position) throws IOException {
out.writeLong(((position.getX() & 0x3FFFFFF) << 38) | ((position.getZ() & 0x3FFFFFF) << 12) | (position.getY() & 0xFFF));
}
public static void writeUUID(DataOutputStream out, UUID uuid) throws IOException {
out.writeLong(uuid.getMostSignificantBits());
out.writeLong(uuid.getLeastSignificantBits());
}
public static void writeCompoundTag(DataOutputStream out, CompoundTag tag) throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
new NBTOutputStream(output).writeTag(tag, Tag.DEFAULT_MAX_DEPTH);
byte[] b = buffer.toByteArray();
out.write(b);
}
public static String readString(DataInputStream in, Charset charset) throws IOException {
int length = readVarInt(in);
if (length == -1) {
throw new IOException("Premature end of stream.");
}
byte[] b = new byte[length];
in.readFully(b);
return new String(b, charset);
}
public static int getStringLength(String string, Charset charset) throws IOException {
byte[] bytes = string.getBytes(charset);
return bytes.length;
}
public static void writeString(DataOutputStream out, String string, Charset charset) throws IOException {
byte[] bytes = string.getBytes(charset);
writeVarInt(out, bytes.length);
out.write(bytes);
}
public static int readVarInt(DataInputStream in) throws IOException {
int numRead = 0;
int result = 0;
byte read;
do {
read = in.readByte();
int value = (read & 0b01111111);
result |= (value << (7 * numRead));
numRead++;
if (numRead > 5) {
throw new RuntimeException("VarInt is too big");
}
} while ((read & 0b10000000) != 0);
return result;
}
public static void writeVarInt(DataOutputStream out, int value) throws IOException {
do {
byte temp = (byte)(value & 0b01111111);
// Note: >>> means that the sign bit is shifted with the rest of the number rather than being left alone
value >>>= 7;
if (value != 0) {
temp |= 0b10000000;
}
out.writeByte(temp);
} while (value != 0);
}
public static int getVarIntLength(int value) throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream out = new DataOutputStream(buffer);
do {
byte temp = (byte)(value & 0b01111111);
// Note: >>> means that the sign bit is shifted with the rest of the number rather than being left alone
value >>>= 7;
if (value != 0) {
temp |= 0b10000000;
}
out.writeByte(temp);
} while (value != 0);
return buffer.toByteArray().length;
}
public static long readVarLong(DataInputStream in) throws IOException {
int numRead = 0;
long result = 0;
byte read;
do {
read = in.readByte();
long value = (read & 0b01111111);
result |= (value << (7 * numRead));
numRead++;
if (numRead > 10) {
throw new RuntimeException("VarLong is too big");
}
} while ((read & 0b10000000) != 0);
return result;
}
public static void writeVarLong(DataOutputStream out, long value) throws IOException {
do {
byte temp = (byte)(value & 0b01111111);
// Note: >>> means that the sign bit is shifted with the rest of the number rather than being left alone
value >>>= 7;
if (value != 0) {
temp |= 0b10000000;
}
out.writeByte(temp);
} while (value != 0);
}
}

Some files were not shown because too many files have changed in this diff Show More