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

Let intellij reformat the code

This commit is contained in:
Alex 2021-04-16 10:29:54 +02:00
parent 3ccfca9ecf
commit 87aaf7f7b3
115 changed files with 8024 additions and 8227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

853
src/main/java/com/loohp/limbo/Console.java
View File

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

963
src/main/java/com/loohp/limbo/Limbo.java
View File

File diff suppressed because it is too large Load Diff

94
src/main/java/com/loohp/limbo/Unsafe.java
View File

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

4
src/main/java/com/loohp/limbo/commands/CommandExecutor.java
View File

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

36
src/main/java/com/loohp/limbo/commands/CommandSender.java
View File

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

4
src/main/java/com/loohp/limbo/commands/TabCompletor.java
View File

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

30
src/main/java/com/loohp/limbo/consolegui/ConsoleTextOutput.java
View File

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

401
src/main/java/com/loohp/limbo/consolegui/GUI.java
View File

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

76
src/main/java/com/loohp/limbo/consolegui/SystemInfo.java
View File

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

206
src/main/java/com/loohp/limbo/entity/ArmorStand.java
View File

@ -1,7 +1,5 @@
package com.loohp.limbo.entity; package com.loohp.limbo.entity;
import java.util.UUID;
import com.loohp.limbo.Limbo; import com.loohp.limbo.Limbo;
import com.loohp.limbo.entity.DataWatcher.WatchableField; import com.loohp.limbo.entity.DataWatcher.WatchableField;
import com.loohp.limbo.entity.DataWatcher.WatchableObjectType; import com.loohp.limbo.entity.DataWatcher.WatchableObjectType;
@ -9,127 +7,129 @@ import com.loohp.limbo.location.Location;
import com.loohp.limbo.utils.Rotation3f; import com.loohp.limbo.utils.Rotation3f;
import com.loohp.limbo.world.World; import com.loohp.limbo.world.World;
import java.util.UUID;
public class ArmorStand extends LivingEntity { 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() { @WatchableField(MetadataIndex = 14, WatchableObjectType = WatchableObjectType.BYTE, IsBitmask = true, Bitmask = 0x01)
return small; 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 void setSmall(boolean small) { public ArmorStand(int entityId, UUID uuid, World world, double x, double y, double z, float yaw, float pitch) {
this.small = small; super(EntityType.ARMOR_STAND, entityId, uuid, world, x, y, z, yaw, pitch);
} }
public boolean showArms() { public ArmorStand(UUID uuid, World world, double x, double y, double z, float yaw, float pitch) {
return arms; this(Limbo.getInstance().getNextEntityId(), uuid, world, x, y, z, yaw, pitch);
} }
public void setArms(boolean arms) { public ArmorStand(World world, double x, double y, double z, float yaw, float pitch) {
this.arms = arms; this(Limbo.getInstance().getNextEntityId(), UUID.randomUUID(), world, x, y, z, yaw, pitch);
} }
public boolean hasNoBasePlate() { public ArmorStand(UUID uuid, Location location) {
return noBasePlate; this(Limbo.getInstance().getNextEntityId(), uuid, location.getWorld(), location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
} }
public void setNoBasePlate(boolean noBasePlate) { public ArmorStand(Location location) {
this.noBasePlate = noBasePlate; this(Limbo.getInstance().getNextEntityId(), UUID.randomUUID(), location.getWorld(), location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
} }
public boolean isMarker() { public boolean isSmall() {
return marker; return small;
} }
public void setMarker(boolean marker) { public void setSmall(boolean small) {
this.marker = marker; this.small = small;
} }
public Rotation3f getHeadRotation() { public boolean showArms() {
return headRotation; return arms;
} }
public void setHeadRotation(Rotation3f headRotation) { public void setArms(boolean arms) {
this.headRotation = headRotation; this.arms = arms;
} }
public Rotation3f getBodyRotation() { public boolean hasNoBasePlate() {
return bodyRotation; return noBasePlate;
} }
public void setBodyRotation(Rotation3f bodyRotation) { public void setNoBasePlate(boolean noBasePlate) {
this.bodyRotation = bodyRotation; this.noBasePlate = noBasePlate;
} }
public Rotation3f getLeftArmRotation() { public boolean isMarker() {
return leftArmRotation; return marker;
} }
public void setLeftArmRotation(Rotation3f leftArmRotation) { public void setMarker(boolean marker) {
this.leftArmRotation = leftArmRotation; this.marker = marker;
} }
public Rotation3f getRightArmRotation() { public Rotation3f getHeadRotation() {
return rightArmRotation; return headRotation;
} }
public void setRightArmRotation(Rotation3f rightArmRotation) { public void setHeadRotation(Rotation3f headRotation) {
this.rightArmRotation = rightArmRotation; this.headRotation = headRotation;
} }
public Rotation3f getLeftLegRotation() { public Rotation3f getBodyRotation() {
return leftLegRotation; return bodyRotation;
} }
public void setLeftLegRotation(Rotation3f leftLegRotation) { public void setBodyRotation(Rotation3f bodyRotation) {
this.leftLegRotation = leftLegRotation; this.bodyRotation = bodyRotation;
} }
public Rotation3f getRightLegRotation() { public Rotation3f getLeftArmRotation() {
return rightLegRotation; return leftArmRotation;
} }
public void setRightLegRotation(Rotation3f rightLegRotation) { public void setLeftArmRotation(Rotation3f leftArmRotation) {
this.rightLegRotation = rightLegRotation; 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;
}
} }

322
src/main/java/com/loohp/limbo/entity/DataWatcher.java
View File

@ -11,168 +11,172 @@ import java.util.Map;
import java.util.Map.Entry; import java.util.Map.Entry;
public class DataWatcher { 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() { private final Entity entity;
return index; private final Map<Field, WatchableObject> values;
}
public WatchableObjectType getType() { public DataWatcher(Entity entity) {
return type; this.entity = entity;
} this.values = new HashMap<>();
public boolean isOptional() { Class<?> clazz = entity.getClass();
return optional; 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 boolean isBitmask() { public Entity getEntity() {
return isBitmask; 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 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;
}
}
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface WatchableField {
int MetadataIndex();
WatchableObjectType WatchableObjectType();
boolean IsOptional() default false;
boolean IsBitmask() default false;
int Bitmask() default 0x00;
}
public static class WatchableObject {
private final int index;
private final WatchableObjectType type;
private final boolean optional;
private final boolean isBitmask;
private final 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;
}
}
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;
}
}
} }

461
src/main/java/com/loohp/limbo/entity/Entity.java
View File

@ -1,283 +1,280 @@
package com.loohp.limbo.entity; package com.loohp.limbo.entity;
import java.util.UUID;
import com.loohp.limbo.Limbo; import com.loohp.limbo.Limbo;
import com.loohp.limbo.entity.DataWatcher.WatchableField; import com.loohp.limbo.entity.DataWatcher.WatchableField;
import com.loohp.limbo.entity.DataWatcher.WatchableObjectType; import com.loohp.limbo.entity.DataWatcher.WatchableObjectType;
import com.loohp.limbo.location.Location; import com.loohp.limbo.location.Location;
import com.loohp.limbo.world.World; import com.loohp.limbo.world.World;
import net.md_5.bungee.api.chat.BaseComponent; import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent; import net.md_5.bungee.api.chat.TextComponent;
import java.util.UUID;
public abstract class Entity { 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() { protected final EntityType type;
return onFire; @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 int entityId;
protected UUID uuid;
protected World world;
protected double x;
protected double y;
protected double z;
protected float yaw;
protected float pitch;
public void setOnFire(boolean onFire) { public Entity(EntityType type, int entityId, UUID uuid, World world, double x, double y, double z, float yaw, float pitch) {
this.onFire = onFire; 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 boolean isCrouching() { public Entity(EntityType type, UUID uuid, World world, double x, double y, double z, float yaw, float pitch) {
return crouching; this(type, Limbo.getInstance().getNextEntityId(), uuid, world, x, y, z, yaw, pitch);
} }
public void setCrouching(boolean crouching) { public Entity(EntityType type, World world, double x, double y, double z, float yaw, float pitch) {
this.crouching = crouching; this(type, Limbo.getInstance().getNextEntityId(), UUID.randomUUID(), world, x, y, z, yaw, pitch);
} }
public boolean isSprinting() { public Entity(EntityType type, UUID uuid, Location location) {
return sprinting; this(type, Limbo.getInstance().getNextEntityId(), uuid, location.getWorld(), location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
} }
public void setSprinting(boolean sprinting) { public Entity(EntityType type, Location location) {
this.sprinting = sprinting; this(type, Limbo.getInstance().getNextEntityId(), UUID.randomUUID(), location.getWorld(), location.getX(), location.getY(), location.getZ(), location.getYaw(), location.getPitch());
} }
public boolean isSwimming() { public EntityType getType() {
return swimming; return type;
} }
public void setSwimming(boolean swimming) { public Location getLocation() {
this.swimming = swimming; return new Location(world, x, y, z, yaw, pitch);
} }
public boolean isInvisible() { public void teleport(Location location) {
return invisible; 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 void setInvisible(boolean invisible) { public BaseComponent[] getCustomName() {
this.invisible = invisible; return customName;
} }
public boolean isGlowing() { public void setCustomName(String name) {
return glowing; this.customName = name == null ? null : new BaseComponent[]{new TextComponent(name)};
} }
public void setGlowing(boolean glowing) { public void setCustomName(BaseComponent component) {
this.glowing = glowing; this.customName = component == null ? null : new BaseComponent[]{component};
} }
public boolean isElytraFlying() { public void setCustomName(BaseComponent[] components) {
return elytraFlying; this.customName = components;
} }
public void setElytraFlying(boolean elytraFlying) { public boolean isOnFire() {
this.elytraFlying = elytraFlying; return onFire;
} }
public int getAir() { public void setOnFire(boolean onFire) {
return air; this.onFire = onFire;
} }
public void setAir(int air) { public boolean isCrouching() {
this.air = air; return crouching;
} }
public boolean isCustomNameVisible() { public void setCrouching(boolean crouching) {
return customNameVisible; this.crouching = crouching;
} }
public void setCustomNameVisible(boolean customNameVisible) { public boolean isSprinting() {
this.customNameVisible = customNameVisible; return sprinting;
} }
public boolean isSilent() { public void setSprinting(boolean sprinting) {
return silent; this.sprinting = sprinting;
} }
public void setSilent(boolean silent) { public boolean isSwimming() {
this.silent = silent; return swimming;
} }
public boolean hasGravity() { public void setSwimming(boolean swimming) {
return !noGravity; this.swimming = swimming;
} }
public void setGravity(boolean gravity) { public boolean isInvisible() {
this.noGravity = !gravity; return invisible;
} }
public Pose getPose() { public void setInvisible(boolean invisible) {
return pose; this.invisible = invisible;
} }
public void setPose(Pose pose) { public boolean isGlowing() {
this.pose = pose; return glowing;
} }
public World getWorld() { public void setGlowing(boolean glowing) {
return world; this.glowing = glowing;
} }
public void setWorld(World world) { public boolean isElytraFlying() {
this.world = world; return elytraFlying;
} }
public double getX() { public void setElytraFlying(boolean elytraFlying) {
return x; this.elytraFlying = elytraFlying;
} }
public void setX(double x) { public int getAir() {
this.x = x; return air;
} }
public double getY() { public void setAir(int air) {
return y; this.air = air;
} }
public void setY(double y) { public boolean isCustomNameVisible() {
this.y = y; return customNameVisible;
} }
public double getZ() { public void setCustomNameVisible(boolean customNameVisible) {
return z; this.customNameVisible = customNameVisible;
} }
public void setZ(double z) { public boolean isSilent() {
this.z = z; return silent;
} }
public float getYaw() { public void setSilent(boolean silent) {
return yaw; this.silent = silent;
} }
public void setYaw(float yaw) { public boolean hasGravity() {
this.yaw = yaw; return !noGravity;
} }
public float getPitch() { public void setGravity(boolean gravity) {
return pitch; this.noGravity = !gravity;
} }
public void setPitch(float pitch) { public Pose getPose() {
this.pitch = pitch; return pose;
} }
public int getEntityId() { public void setPose(Pose pose) {
return entityId; this.pose = pose;
} }
public UUID getUniqueId() { public World getWorld() {
return uuid; return world;
} }
public boolean isValid() { public void setWorld(World world) {
return world.getEntities().contains(this); this.world = world;
} }
@SuppressWarnings("deprecation") public double getX() {
public void remove() { return x;
Limbo.getInstance().getUnsafe().removeEntity(world, this); }
}
public void setX(double x) {
@SuppressWarnings("deprecation") this.x = x;
public DataWatcher getDataWatcher() { }
return Limbo.getInstance().getUnsafe().getDataWatcher(world, this);
} 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);
}
} }

80
src/main/java/com/loohp/limbo/entity/EntityType.java
View File

@ -1,13 +1,13 @@
package com.loohp.limbo.entity; package com.loohp.limbo.entity;
import java.util.HashMap;
import java.util.Map;
import com.loohp.limbo.location.Location; import com.loohp.limbo.location.Location;
import com.loohp.limbo.player.Player; import com.loohp.limbo.player.Player;
import com.loohp.limbo.utils.NamespacedKey; import com.loohp.limbo.utils.NamespacedKey;
import com.loohp.limbo.world.World; import com.loohp.limbo.world.World;
import java.util.HashMap;
import java.util.Map;
public enum EntityType { public enum EntityType {
// These strings MUST match the strings in nms.EntityTypes and are case sensitive. // These strings MUST match the strings in nms.EntityTypes and are case sensitive.
@ -270,13 +270,6 @@ public enum EntityType {
*/ */
UNKNOWN(null, null, -1, false); 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<String, EntityType> NAME_MAP = new HashMap<>();
private static final Map<Short, EntityType> ID_MAP = new HashMap<>(); private static final Map<Short, EntityType> ID_MAP = new HashMap<>();
@ -308,11 +301,18 @@ public enum EntityType {
*/ */
} }
private EntityType(String name, Class<? extends Entity> clazz, int typeId) { 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;
EntityType(String name, Class<? extends Entity> clazz, int typeId) {
this(name, clazz, typeId, true); this(name, clazz, typeId, true);
} }
private EntityType(String name, Class<? extends Entity> clazz, int typeId, boolean independent) { EntityType(String name, Class<? extends Entity> clazz, int typeId, boolean independent) {
this.name = name; this.name = name;
this.clazz = clazz; this.clazz = clazz;
this.typeId = (short) typeId; this.typeId = (short) typeId;
@ -321,34 +321,6 @@ public enum EntityType {
this.key = (name == null) ? null : NamespacedKey.minecraft(name); 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. * Gets an entity type from its name.
* *
@ -379,6 +351,34 @@ public enum EntityType {
return ID_MAP.get((short) id); return ID_MAP.get((short) id);
} }
/**
* 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;
}
/** /**
* Some entities cannot be spawned using {@link * Some entities cannot be spawned using {@link
* World#spawnEntity(Location, EntityType)} or {@link * World#spawnEntity(Location, EntityType)} or {@link

200
src/main/java/com/loohp/limbo/entity/LivingEntity.java
View File

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

58
src/main/java/com/loohp/limbo/entity/Pose.java
View File

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

8
src/main/java/com/loohp/limbo/events/Cancellable.java
View File

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

12
src/main/java/com/loohp/limbo/events/EventHandler.java
View File

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

66
src/main/java/com/loohp/limbo/events/EventPriority.java
View File

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

98
src/main/java/com/loohp/limbo/events/EventsManager.java
View File

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

58
src/main/java/com/loohp/limbo/events/player/PlayerChatEvent.java
View File

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

20
src/main/java/com/loohp/limbo/events/player/PlayerEvent.java
View File

@ -4,15 +4,15 @@ import com.loohp.limbo.events.Event;
import com.loohp.limbo.player.Player; import com.loohp.limbo.player.Player;
public class PlayerEvent extends Event { public class PlayerEvent extends Event {
private Player player; private final Player player;
public PlayerEvent(Player player) { public PlayerEvent(Player player) {
this.player = player; this.player = player;
} }
public Player getPlayer() { public Player getPlayer() {
return player; return player;
} }
} }

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

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

55
src/main/java/com/loohp/limbo/events/player/PlayerLoginEvent.java
View File

@ -3,41 +3,40 @@ package com.loohp.limbo.events.player;
import com.loohp.limbo.events.Cancellable; import com.loohp.limbo.events.Cancellable;
import com.loohp.limbo.events.Event; import com.loohp.limbo.events.Event;
import com.loohp.limbo.server.ClientConnection; import com.loohp.limbo.server.ClientConnection;
import net.md_5.bungee.api.chat.BaseComponent; import net.md_5.bungee.api.chat.BaseComponent;
public class PlayerLoginEvent extends Event implements Cancellable { 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() { private final ClientConnection connection;
return connection; private boolean cancelled;
} private BaseComponent[] cancelReason;
public BaseComponent[] getCancelReason() { public PlayerLoginEvent(ClientConnection connection, boolean cancelled, BaseComponent... cancelReason) {
return cancelReason; this.connection = connection;
} this.cancelled = cancelled;
this.cancelReason = cancelReason;
}
public void setCancelReason(BaseComponent... cancelReason) { public ClientConnection getConnection() {
this.cancelReason = cancelReason; return connection;
} }
@Override public BaseComponent[] getCancelReason() {
public void setCancelled(boolean cancelled) { return cancelReason;
this.cancelled = cancelled; }
}
@Override public void setCancelReason(BaseComponent... cancelReason) {
public boolean isCancelled() { this.cancelReason = cancelReason;
return cancelled; }
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancelled) {
this.cancelled = cancelled;
}
} }

8
src/main/java/com/loohp/limbo/events/player/PlayerQuitEvent.java
View File

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

8
src/main/java/com/loohp/limbo/events/player/PlayerSelectedSlotChangeEvent.java
View File

@ -14,13 +14,13 @@ public class PlayerSelectedSlotChangeEvent extends PlayerEvent implements Cancel
} }
@Override @Override
public void setCancelled(boolean cancelled) { public boolean isCancelled() {
this.cancel = cancelled; return cancel;
} }
@Override @Override
public boolean isCancelled() { public void setCancelled(boolean cancelled) {
return cancel; this.cancel = cancelled;
} }
public byte getSlot() { public byte getSlot() {

6
src/main/java/com/loohp/limbo/events/player/PlayerTeleportEvent.java
View File

@ -5,8 +5,8 @@ import com.loohp.limbo.player.Player;
public class PlayerTeleportEvent extends PlayerMoveEvent { public class PlayerTeleportEvent extends PlayerMoveEvent {
public PlayerTeleportEvent(Player player, Location from, Location to) { public PlayerTeleportEvent(Player player, Location from, Location to) {
super(player, from, to); super(player, from, to);
} }
} }

117
src/main/java/com/loohp/limbo/events/status/StatusPingEvent.java
View File

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

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

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

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

@ -1,202 +1,193 @@
package com.loohp.limbo.file; 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.Limbo;
import com.loohp.limbo.location.Location; import com.loohp.limbo.location.Location;
import com.loohp.limbo.utils.GameMode; import com.loohp.limbo.utils.GameMode;
import com.loohp.limbo.utils.NamespacedKey; import com.loohp.limbo.utils.NamespacedKey;
import com.loohp.limbo.world.World; import com.loohp.limbo.world.World;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Properties;
public class ServerProperties { 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; 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 int maxPlayers; Optional<BufferedImage> favicon;
private int serverPort; private final File file;
private String serverIp; private final int maxPlayers;
private NamespacedKey levelName; private final int serverPort;
private String schemFileName; private final String serverIp;
private NamespacedKey levelDimension; private final NamespacedKey levelName;
private GameMode defaultGamemode; private final String schemFileName;
private Location worldSpawn; private final NamespacedKey levelDimension;
private boolean reducedDebugInfo; private final GameMode defaultGamemode;
private boolean allowFlight; private Location worldSpawn;
private String motdJson; private final boolean reducedDebugInfo;
private String versionString; private final boolean allowFlight;
private int protocol; private final String motdJson;
private boolean bungeecord; private final String versionString;
private int viewDistance; private final int protocol;
private double ticksPerSecond; private final boolean bungeecord;
private boolean handshakeVerbose; private final int viewDistance;
private final double ticksPerSecond;
Optional<BufferedImage> favicon; private final boolean handshakeVerbose;
public ServerProperties(File file) throws IOException { public ServerProperties(File file) throws IOException {
this.file = file; 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; Properties def = new Properties();
InputStreamReader defStream = new InputStreamReader(getClass().getClassLoader().getResourceAsStream("server.properties"), StandardCharsets.UTF_8);
def.load(defStream);
defStream.close();
maxPlayers = Integer.parseInt(prop.getProperty("max-players")); Properties prop = new Properties();
serverPort = Integer.parseInt(prop.getProperty("server-port")); InputStreamReader stream = new InputStreamReader(new FileInputStream(file), StandardCharsets.UTF_8);
serverIp = prop.getProperty("server-ip"); prop.load(stream);
String[] level = prop.getProperty("level-name").split(";"); stream.close();
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"); for (Entry<Object, Object> entry : def.entrySet()) {
} String key = entry.getKey().toString();
String value = entry.getValue().toString();
public String getServerImplementationVersion() { prop.putIfAbsent(key, value);
return Limbo.getInstance().serverImplementationVersion; }
} PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8));
prop.store(pw, COMMENT);
pw.close();
public boolean isBungeecord() { protocol = Limbo.getInstance().serverImplmentationProtocol;
return bungeecord;
}
public Optional<BufferedImage> getFavicon() { maxPlayers = Integer.parseInt(prop.getProperty("max-players"));
return favicon; 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"));
public File getFile() { File png = new File("server-icon.png");
return file; 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();
}
public int getMaxPlayers() { Limbo.getInstance().getConsole().sendMessage("Loaded server.properties");
return maxPlayers; }
}
public int getServerPort() { public String getServerImplementationVersion() {
return serverPort; return Limbo.getInstance().serverImplementationVersion;
} }
public String getServerIp() { public boolean isBungeecord() {
return serverIp; return bungeecord;
} }
public NamespacedKey getLevelName() { public Optional<BufferedImage> getFavicon() {
return levelName; return favicon;
} }
public String getSchemFileName() { public File getFile() {
return schemFileName; return file;
} }
public NamespacedKey getLevelDimension() { public int getMaxPlayers() {
return levelDimension; return maxPlayers;
} }
public GameMode getDefaultGamemode() { public int getServerPort() {
return defaultGamemode; return serverPort;
} }
public Location getWorldSpawn() { public String getServerIp() {
return worldSpawn; return serverIp;
} }
public void setWorldSpawn(Location location) { public NamespacedKey getLevelName() {
this.worldSpawn = location; return levelName;
} }
public boolean isReducedDebugInfo() { public String getSchemFileName() {
return reducedDebugInfo; return schemFileName;
} }
public boolean isAllowFlight() { public NamespacedKey getLevelDimension() {
return allowFlight; return levelDimension;
} }
public String getMotdJson() { public GameMode getDefaultGamemode() {
return motdJson; return defaultGamemode;
} }
public String getVersionString() { public Location getWorldSpawn() {
return versionString; return worldSpawn;
} }
public int getProtocol() { public void setWorldSpawn(Location location) {
return protocol; this.worldSpawn = location;
} }
public int getViewDistance() {
return viewDistance;
}
public double getDefinedTicksPerSecond() {
return ticksPerSecond;
}
public boolean handshakeVerboseEnabled() { public boolean isReducedDebugInfo() {
return handshakeVerbose; 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;
}
} }

14
src/main/java/com/loohp/limbo/inventory/EquipmentSlot.java
View File

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

271
src/main/java/com/loohp/limbo/location/Location.java
View File

@ -6,102 +6,148 @@ import com.loohp.limbo.world.BlockState;
import com.loohp.limbo.world.World; import com.loohp.limbo.world.World;
public class Location implements Cloneable { public class Location implements Cloneable {
private World world; private World world;
private double x; private double x;
private double y; private double y;
private double z; private double z;
private float yaw; private float yaw;
private float pitch; private float pitch;
public Location(World world, double x, double y, double z, float yaw, float pitch) { public Location(World world, double x, double y, double z, float yaw, float pitch) {
this.world = world; this.world = world;
this.x = x; this.x = x;
this.y = y; this.y = y;
this.z = z; this.z = z;
this.yaw = yaw; this.yaw = yaw;
this.pitch = pitch; this.pitch = pitch;
} }
public Location(World world, double x, double y, double z) { public Location(World world, double x, double y, double z) {
this(world, x, y, z, 0, 0); this(world, x, y, z, 0, 0);
} }
@Override /**
public Location clone() { * Safely converts a double (location coordinate) to an int (block
try { * 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 Location clone() {
try {
return (Location) super.clone(); return (Location) super.clone();
} catch (CloneNotSupportedException e) { } catch (CloneNotSupportedException e) {
throw new Error(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() { public BlockState getBlockState() {
return world; return world.getBlock((int) x, (int) y, (int) z);
} }
public void setWorld(World world) { public void setBlockState(BlockState state) {
this.world = world; world.setBlock((int) x, (int) y, (int) z, state);
} }
public double getX() { public boolean isWorldLoaded() {
return x; return Limbo.getInstance().getWorld(world.getName()) != null;
} }
public void setX(double x) { public World getWorld() {
this.x = x; return world;
} }
public double getY() { public void setWorld(World world) {
return y; this.world = world;
} }
public void setY(double y) { public double getX() {
this.y = y; return x;
} }
public double getZ() { public void setX(double x) {
return z; this.x = x;
} }
public void setZ(double z) { public double getY() {
this.z = z; return y;
} }
public float getYaw() { public void setY(double y) {
return yaw; this.y = y;
} }
public void setYaw(float yaw) { public double getZ() {
this.yaw = yaw; return z;
} }
public float getPitch() { public void setZ(double z) {
return pitch; this.z = z;
} }
public void setPitch(float pitch) { public float getYaw() {
this.pitch = pitch; 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 * Gets a unit-vector pointing in the direction that this Location is
* facing. * facing.
* *
* @return a vector pointing the direction of this location's {@link * @return a vector pointing the direction of this location's {@link
* #getPitch() pitch} and {@link #getYaw() yaw} * #getPitch() pitch} and {@link #getYaw() yaw}
*/ */
public Vector getDirection() { public Vector getDirection() {
Vector vector = new Vector(); Vector vector = new Vector();
@ -158,10 +204,10 @@ public class Location implements Cloneable {
/** /**
* Adds the location by another. * Adds the location by another.
* *
* @see Vector
* @param vec The other location * @param vec The other location
* @return the same location * @return the same location
* @throws IllegalArgumentException for differing worlds * @throws IllegalArgumentException for differing worlds
* @see Vector
*/ */
public Location add(Location vec) { public Location add(Location vec) {
if (vec == null || vec.getWorld() != getWorld()) { if (vec == null || vec.getWorld() != getWorld()) {
@ -177,9 +223,9 @@ public class Location implements Cloneable {
/** /**
* Adds the location by a vector. * Adds the location by a vector.
* *
* @see Vector
* @param vec Vector to use * @param vec Vector to use
* @return the same location * @return the same location
* @see Vector
*/ */
public Location add(Vector vec) { public Location add(Vector vec) {
this.x += vec.getX(); this.x += vec.getX();
@ -191,11 +237,11 @@ public class Location implements Cloneable {
/** /**
* Adds the location by another. Not world-aware. * Adds the location by another. Not world-aware.
* *
* @see Vector
* @param x X coordinate * @param x X coordinate
* @param y Y coordinate * @param y Y coordinate
* @param z Z coordinate * @param z Z coordinate
* @return the same location * @return the same location
* @see Vector
*/ */
public Location add(double x, double y, double z) { public Location add(double x, double y, double z) {
this.x += x; this.x += x;
@ -207,10 +253,10 @@ public class Location implements Cloneable {
/** /**
* Subtracts the location by another. * Subtracts the location by another.
* *
* @see Vector
* @param vec The other location * @param vec The other location
* @return the same location * @return the same location
* @throws IllegalArgumentException for differing worlds * @throws IllegalArgumentException for differing worlds
* @see Vector
*/ */
public Location subtract(Location vec) { public Location subtract(Location vec) {
if (vec == null || vec.getWorld() != getWorld()) { if (vec == null || vec.getWorld() != getWorld()) {
@ -226,9 +272,9 @@ public class Location implements Cloneable {
/** /**
* Subtracts the location by a vector. * Subtracts the location by a vector.
* *
* @see Vector
* @param vec The vector to use * @param vec The vector to use
* @return the same location * @return the same location
* @see Vector
*/ */
public Location subtract(Vector vec) { public Location subtract(Vector vec) {
this.x -= vec.getX(); this.x -= vec.getX();
@ -241,11 +287,11 @@ public class Location implements Cloneable {
* Subtracts the location by another. Not world-aware and * Subtracts the location by another. Not world-aware and
* orientation independent. * orientation independent.
* *
* @see Vector
* @param x X coordinate * @param x X coordinate
* @param y Y coordinate * @param y Y coordinate
* @param z Z coordinate * @param z Z coordinate
* @return the same location * @return the same location
* @see Vector
*/ */
public Location subtract(double x, double y, double z) { public Location subtract(double x, double y, double z) {
this.x -= x; this.x -= x;
@ -348,7 +394,7 @@ public class Location implements Cloneable {
* Constructs a new {@link Vector} based on this Location * Constructs a new {@link Vector} based on this Location
* *
* @return New Vector containing the coordinates represented by this * @return New Vector containing the coordinates represented by this
* Location * Location
*/ */
public Vector toVector() { public Vector toVector() {
return new Vector(x, y, z); return new Vector(x, y, z);
@ -367,58 +413,12 @@ public class Location implements Cloneable {
NumberConversions.checkFinite(yaw, "yaw not finite"); NumberConversions.checkFinite(yaw, "yaw not finite");
} }
/** @Override
* Safely converts a double (location coordinate) to an int (block public String toString() {
* coordinate) return "Location{" + "world=" + world + ",x=" + x + ",y=" + y + ",z=" + z + ",pitch=" + pitch + ",yaw=" + yaw + "}";
*
* @param loc Precise coordinate
* @return Block coordinate
*/
public static int locToBlock(double loc) {
return NumberConversions.floor(loc);
} }
/** @Override
* 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) { public boolean equals(Object obj) {
if (obj == null) { if (obj == null) {
return false; return false;
@ -445,10 +445,7 @@ public class Location implements Cloneable {
if (Float.floatToIntBits(this.pitch) != Float.floatToIntBits(other.pitch)) { if (Float.floatToIntBits(this.pitch) != Float.floatToIntBits(other.pitch)) {
return false; return false;
} }
if (Float.floatToIntBits(this.yaw) != Float.floatToIntBits(other.yaw)) { return Float.floatToIntBits(this.yaw) == Float.floatToIntBits(other.yaw);
return false;
}
return true;
} }
@Override @Override

226
src/main/java/com/loohp/limbo/location/Vector.java
View File

@ -1,12 +1,12 @@
package com.loohp.limbo.location; package com.loohp.limbo.location;
import java.util.Random;
import com.google.common.base.Preconditions; import com.google.common.base.Preconditions;
import com.google.common.primitives.Doubles; import com.google.common.primitives.Doubles;
import com.loohp.limbo.utils.NumberConversions; import com.loohp.limbo.utils.NumberConversions;
import com.loohp.limbo.world.World; import com.loohp.limbo.world.World;
import java.util.Random;
/** /**
* Represents a mutable vector. Because the components of Vectors are mutable, * Represents a mutable vector. Because the components of Vectors are mutable,
* storing Vectors long term may be dangerous if passing code modifies the * storing Vectors long term may be dangerous if passing code modifies the
@ -15,13 +15,11 @@ import com.loohp.limbo.world.World;
*/ */
public class Vector implements Cloneable { public class Vector implements Cloneable {
private static Random random = new Random();
/** /**
* Threshold for fuzzy equals(). * Threshold for fuzzy equals().
*/ */
private static final double epsilon = 0.000001; private static final double epsilon = 0.000001;
private static final Random random = new Random();
protected double x; protected double x;
protected double y; protected double y;
protected double z; protected double z;
@ -74,6 +72,47 @@ public class Vector implements Cloneable {
this.z = z; this.z = z;
} }
/**
* 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());
}
/** /**
* Adds a vector to this one * Adds a vector to this one
* *
@ -400,7 +439,7 @@ public class Vector implements Cloneable {
* Matrix</a>. * Matrix</a>.
* *
* @param angle the angle to rotate the vector about. This angle is passed * @param angle the angle to rotate the vector about. This angle is passed
* in radians * in radians
* @return the same vector * @return the same vector
*/ */
public Vector rotateAroundX(double angle) { public Vector rotateAroundX(double angle) {
@ -421,7 +460,7 @@ public class Vector implements Cloneable {
* Matrix</a>. * Matrix</a>.
* *
* @param angle the angle to rotate the vector about. This angle is passed * @param angle the angle to rotate the vector about. This angle is passed
* in radians * in radians
* @return the same vector * @return the same vector
*/ */
public Vector rotateAroundY(double angle) { public Vector rotateAroundY(double angle) {
@ -442,7 +481,7 @@ public class Vector implements Cloneable {
* Matrix</a>. * Matrix</a>.
* *
* @param angle the angle to rotate the vector about. This angle is passed * @param angle the angle to rotate the vector about. This angle is passed
* in radians * in radians
* @return the same vector * @return the same vector
*/ */
public Vector rotateAroundZ(double angle) { public Vector rotateAroundZ(double angle) {
@ -466,14 +505,14 @@ public class Vector implements Cloneable {
* with the scaling of a non-unit axis vector, you can use * with the scaling of a non-unit axis vector, you can use
* {@link Vector#rotateAroundNonUnitAxis(Vector, double)}. * {@link Vector#rotateAroundNonUnitAxis(Vector, double)}.
* *
* @param axis the axis to rotate the vector around. If the passed vector is * @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 * not of length 1, it gets copied and normalized before using it for the
* rotation. Please use {@link Vector#normalize()} on the instance before * rotation. Please use {@link Vector#normalize()} on the instance before
* passing it to this method * passing it to this method
* @param angle the angle to rotate the vector around the axis * @param angle the angle to rotate the vector around the axis
* @return the same vector * @return the same vector
* @throws IllegalArgumentException if the provided axis vector instance is * @throws IllegalArgumentException if the provided axis vector instance is
* null * null
*/ */
public Vector rotateAroundAxis(Vector axis, double angle) throws IllegalArgumentException { public Vector rotateAroundAxis(Vector axis, double angle) throws IllegalArgumentException {
Preconditions.checkArgument(axis != null, "The provided axis vector was null"); Preconditions.checkArgument(axis != null, "The provided axis vector was null");
@ -495,11 +534,11 @@ public class Vector implements Cloneable {
* about the scaling of the vector, use * about the scaling of the vector, use
* {@link Vector#rotateAroundAxis(Vector, double)} * {@link Vector#rotateAroundAxis(Vector, double)}
* *
* @param axis the axis to rotate the vector around. * @param axis the axis to rotate the vector around.
* @param angle the angle to rotate the vector around the axis * @param angle the angle to rotate the vector around the axis
* @return the same vector * @return the same vector
* @throws IllegalArgumentException if the provided axis vector instance is * @throws IllegalArgumentException if the provided axis vector instance is
* null * null
*/ */
public Vector rotateAroundNonUnitAxis(Vector axis, double angle) throws IllegalArgumentException { public Vector rotateAroundNonUnitAxis(Vector axis, double angle) throws IllegalArgumentException {
Preconditions.checkArgument(axis != null, "The provided axis vector was null"); Preconditions.checkArgument(axis != null, "The provided axis vector was null");
@ -533,54 +572,6 @@ public class Vector implements Cloneable {
return x; 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. * Set the X component.
* *
@ -614,6 +605,25 @@ public class Vector implements Cloneable {
return this; return this;
} }
/**
* 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;
}
/** /**
* Set the Y component. * Set the Y component.
* *
@ -647,6 +657,25 @@ public class Vector implements Cloneable {
return this; return this;
} }
/**
* 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;
}
/** /**
* Set the Z component. * Set the Z component.
* *
@ -680,6 +709,16 @@ public class Vector implements Cloneable {
return this; return this;
} }
/**
* 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);
}
/** /**
* Checks to see if two objects are equal. * Checks to see if two objects are equal.
* <p> * <p>
@ -713,6 +752,15 @@ public class Vector implements Cloneable {
return hash; return hash;
} }
/**
* Get the block vector of this vector.
*
* @return A block vector.
public BlockVector toBlockVector() {
return new BlockVector(x, y, z);
}
*/
/** /**
* Get a new vector. * Get a new vector.
* *
@ -749,7 +797,7 @@ public class Vector implements Cloneable {
* Gets a Location version of this vector. * Gets a Location version of this vector.
* *
* @param world The world to link the location to. * @param world The world to link the location to.
* @param yaw The desired yaw. * @param yaw The desired yaw.
* @param pitch The desired pitch. * @param pitch The desired pitch.
* @return the location * @return the location
*/ */
@ -757,15 +805,6 @@ public class Vector implements Cloneable {
return new Location(world, x, y, z, yaw, 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. * Check if each component of this Vector is finite.
* *
@ -777,47 +816,6 @@ public class Vector implements Cloneable {
NumberConversions.checkFinite(z, "z 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 @Override
public Map<String, Object> serialize() { public Map<String, Object> serialize() {

1088
src/main/java/com/loohp/limbo/metrics/Metrics.java
View File

File diff suppressed because it is too large Load Diff

112
src/main/java/com/loohp/limbo/permissions/PermissionsManager.java
View File

@ -1,5 +1,10 @@
package com.loohp.limbo.permissions; package com.loohp.limbo.permissions;
import com.loohp.limbo.Console;
import com.loohp.limbo.commands.CommandSender;
import com.loohp.limbo.file.FileConfiguration;
import com.loohp.limbo.player.Player;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;
import java.util.ArrayList; import java.util.ArrayList;
@ -7,63 +12,60 @@ import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Map; 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 { 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() { private final Map<String, List<String>> users;
return users; private final Map<String, List<String>> permissions;
}
public Map<String, List<String>> getPermissions() { public PermissionsManager() {
return permissions; 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;
}
} }

409
src/main/java/com/loohp/limbo/player/Player.java
View File

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

236
src/main/java/com/loohp/limbo/player/PlayerInteractManager.java
View File

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

43
src/main/java/com/loohp/limbo/player/Unsafe.java
View File

@ -5,27 +5,28 @@ import com.loohp.limbo.utils.GameMode;
@Deprecated @Deprecated
public class Unsafe { 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 private Unsafe() {
public void a(Player a, byte b) { }
a.selectedSlot = b;
} @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;
}
} }

74
src/main/java/com/loohp/limbo/plugins/LimboPlugin.java
View File

@ -1,54 +1,54 @@
package com.loohp.limbo.plugins; package com.loohp.limbo.plugins;
import java.io.File;
import com.loohp.limbo.Limbo; import com.loohp.limbo.Limbo;
import com.loohp.limbo.file.FileConfiguration; import com.loohp.limbo.file.FileConfiguration;
import java.io.File;
public class LimboPlugin { public class LimboPlugin {
private String name; private String name;
private File dataFolder; private File dataFolder;
private PluginInfo info; private PluginInfo info;
private File pluginJar; 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() { 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 onEnable() { public void onLoad() {
} }
public void onDisable() { public void onEnable() {
} }
public final String getName() { public void onDisable() {
return name;
}
public final File getDataFolder() { }
return new File(dataFolder.getAbsolutePath());
} public final String getName() {
return name;
public final PluginInfo getInfo() { }
return info;
} public final File getDataFolder() {
return new File(dataFolder.getAbsolutePath());
public final Limbo getServer() { }
return Limbo.getInstance();
} public final PluginInfo getInfo() {
return info;
}
public final Limbo getServer() {
return Limbo.getInstance();
}
} }

60
src/main/java/com/loohp/limbo/plugins/PluginInfo.java
View File

@ -3,39 +3,39 @@ package com.loohp.limbo.plugins;
import com.loohp.limbo.file.FileConfiguration; import com.loohp.limbo.file.FileConfiguration;
public class PluginInfo { 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() { private final String name;
return name; private final String description;
} private final String author;
private final String version;
private final String main;
public String getDescription() { public PluginInfo(FileConfiguration file) {
return description; name = file.get("name", String.class);
} description = file.get("description", String.class) == null ? "" : file.get("description", String.class);
author = file.get("author", String.class);
public String getAuthor() { version = file.get("version", String.class);
return author; main = file.get("main", String.class);
} }
public String getVersion() { public String getName() {
return version; return name;
} }
public String getMainClass() { public String getDescription() {
return main; return description;
} }
public String getAuthor() {
return author;
}
public String getVersion() {
return version;
}
public String getMainClass() {
return main;
}
} }

236
src/main/java/com/loohp/limbo/plugins/PluginManager.java
View File

@ -1,139 +1,135 @@
package com.loohp.limbo.plugins; 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.Limbo;
import com.loohp.limbo.commands.CommandExecutor; import com.loohp.limbo.commands.CommandExecutor;
import com.loohp.limbo.commands.CommandSender; import com.loohp.limbo.commands.CommandSender;
import com.loohp.limbo.commands.TabCompletor; import com.loohp.limbo.commands.TabCompletor;
import com.loohp.limbo.file.FileConfiguration; import com.loohp.limbo.file.FileConfiguration;
import java.io.File;
import java.io.FileInputStream;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
public class PluginManager { public class PluginManager {
private Map<String, LimboPlugin> plugins; private final Map<String, LimboPlugin> plugins;
private List<Executor> executors; private final List<Executor> executors;
private File pluginFolder; private final File pluginFolder;
public PluginManager(File pluginFolder) { public PluginManager(File pluginFolder) {
this.pluginFolder = pluginFolder; this.pluginFolder = pluginFolder;
this.executors = new ArrayList<>(); this.executors = new ArrayList<>();
this.plugins = new LinkedHashMap<>(); 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 { protected void loadPlugins() {
Limbo.getInstance().getConsole().sendMessage(sender.getName() + " executed server command: /" + String.join(" ", args)); for (File file : pluginFolder.listFiles()) {
for (Executor entry : executors) { if (file.isFile() && file.getName().endsWith(".jar")) {
try { boolean found = false;
entry.executor.execute(sender, args); try (ZipInputStream zip = new ZipInputStream(new FileInputStream(file))) {
} catch (Exception e) { while (true) {
System.err.println("Error while passing command \"" + args[0] + "\" to the plugin \"" + entry.plugin.getName() + "\""); ZipEntry entry = zip.getNextEntry();
e.printStackTrace(); if (entry == null) {
} break;
} }
} String name = entry.getName();
if (name.endsWith("plugin.yml") || name.endsWith("limbo.yml")) {
found = true;
public List<String> getTabOptions(CommandSender sender, String[] args) { FileConfiguration pluginYaml = new FileConfiguration(zip);
List<String> options = new ArrayList<>(); String main = pluginYaml.get("main", String.class);
for (Executor entry : executors) { String pluginName = pluginYaml.get("name", String.class);
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) { if (plugins.containsKey(pluginName)) {
executors.add(new Executor(plugin, executor)); 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 void unregsiterAllCommands(LimboPlugin plugin) { public List<LimboPlugin> getPlugins() {
executors.removeIf(each -> each.plugin.equals(plugin)); return new ArrayList<>(plugins.values());
} }
public File getPluginFolder() {
return new File(pluginFolder.getAbsolutePath());
}
protected static class Executor { public LimboPlugin getPlugin(String name) {
public LimboPlugin plugin; return plugins.get(name);
public CommandExecutor executor; }
public Optional<TabCompletor> tab;
public Executor(LimboPlugin plugin, CommandExecutor executor) { public void fireExecutors(CommandSender sender, String[] args) throws Exception {
this.plugin = plugin; Limbo.getInstance().getConsole().sendMessage(sender.getName() + " executed server command: /" + String.join(" ", args));
this.executor = executor; for (Executor entry : executors) {
if (executor instanceof TabCompletor) { try {
this.tab = Optional.of((TabCompletor) executor); entry.executor.execute(sender, args);
} else { } catch (Exception e) {
this.tab = Optional.empty(); 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();
}
}
}
} }

182
src/main/java/com/loohp/limbo/scheduler/LimboRunnable.java
View File

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

474
src/main/java/com/loohp/limbo/scheduler/LimboScheduler.java
View File

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

220
src/main/java/com/loohp/limbo/scheduler/Tick.java
View File

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

795
src/main/java/com/loohp/limbo/server/ClientConnection.java
View File

@ -1,105 +1,50 @@
package com.loohp.limbo.server; package com.loohp.limbo.server;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.events.player.*;
import com.loohp.limbo.events.status.StatusPingEvent;
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.server.packets.*;
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.utils.*;
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;
import java.io.DataInputStream; import java.io.DataInputStream;
import java.io.DataOutputStream; import java.io.DataOutputStream;
import java.io.IOException; import java.io.IOException;
import java.net.InetAddress; import java.net.InetAddress;
import java.net.Socket; import java.net.Socket;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import java.util.ArrayList; import java.util.*;
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.TimeUnit;
import java.util.concurrent.atomic.AtomicLong; import java.util.concurrent.atomic.AtomicLong;
import java.util.stream.Collectors; 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 class ClientConnection extends Thread {
public static enum ClientState {
LEGACY,
HANDSHAKE,
STATUS,
LOGIN,
PLAY,
DISCONNECTED;
}
private final Socket client_socket; private final Socket client_socket;
private boolean running; private boolean running;
private ClientState state; private ClientState state;
private Player player;
private Player player; private final AtomicLong lastKeepAlivePayLoad;
private AtomicLong lastKeepAlivePayLoad; private DataOutputStream output;
private DataInputStream input;
private DataOutputStream output; private InetAddress inetAddress;
private DataInputStream input; private boolean ready;
private InetAddress inetAddress;
private boolean ready;
public ClientConnection(Socket client_socket) { public ClientConnection(Socket client_socket) {
this.client_socket = client_socket; this.client_socket = client_socket;
this.inetAddress = client_socket.getInetAddress(); this.inetAddress = client_socket.getInetAddress();
@ -107,366 +52,382 @@ public class ClientConnection extends Thread {
this.running = false; this.running = false;
this.ready = false; this.ready = false;
} }
public InetAddress getInetAddress() {
return inetAddress;
}
public long getLastKeepAlivePayLoad() { public InetAddress getInetAddress() {
return lastKeepAlivePayLoad.get(); return inetAddress;
} }
public void setLastKeepAlivePayLoad(long payLoad) { public long getLastKeepAlivePayLoad() {
this.lastKeepAlivePayLoad.set(payLoad); return lastKeepAlivePayLoad.get();
} }
public void setLastKeepAlivePayLoad(long payLoad) {
this.lastKeepAlivePayLoad.set(payLoad);
}
public Player getPlayer() {
return player;
}
public Player getPlayer() {
return player;
}
public ClientState getClientState() { public ClientState getClientState() {
return state; 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") public Socket getSocket() {
@Override 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() { public void run() {
running = true; running = true;
state = ClientState.HANDSHAKE; state = ClientState.HANDSHAKE;
try { try {
client_socket.setKeepAlive(true); client_socket.setKeepAlive(true);
input = new DataInputStream(client_socket.getInputStream()); input = new DataInputStream(client_socket.getInputStream());
output = new DataOutputStream(client_socket.getOutputStream()); output = new DataOutputStream(client_socket.getOutputStream());
int handShakeSize = DataTypeIO.readVarInt(input); int handShakeSize = DataTypeIO.readVarInt(input);
//legacy ping //legacy ping
if (handShakeSize == 0xFE) { if (handShakeSize == 0xFE) {
state = ClientState.LEGACY; state = ClientState.LEGACY;
output.writeByte(255); output.writeByte(255);
String str = inetAddress.getHostName() + ":" + client_socket.getPort(); String str = inetAddress.getHostName() + ":" + client_socket.getPort();
Limbo.getInstance().getConsole().sendMessage("[/" + str + "] <-> Legacy Status has pinged"); Limbo.getInstance().getConsole().sendMessage("[/" + str + "] <-> Legacy Status has pinged");
ServerProperties p = Limbo.getInstance().getServerProperties(); 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))); 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()); String response = Limbo.getInstance().buildLegacyPingResponse(event.getVersion(), event.getMotd(), event.getMaxPlayers(), event.getPlayersOnline());
byte[] bytes = response.getBytes(StandardCharsets.UTF_16BE); byte[] bytes = response.getBytes(StandardCharsets.UTF_16BE);
output.writeShort(response.length()); output.writeShort(response.length());
output.write(bytes); 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 = inetAddress.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(); client_socket.close();
Location worldSpawn = properties.getWorldSpawn(); state = ClientState.DISCONNECTED;
}
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); @SuppressWarnings("unused")
sendPacket(join); int handShakeId = DataTypeIO.readVarInt(input);
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 = inetAddress.getHostName() + ":" + client_socket.getPort() + "|" + player.getName(); PacketHandshakingIn handshake = new PacketHandshakingIn(input);
Limbo.getInstance().getConsole().sendMessage("[/" + str + "] <-> Player had connected to the Limbo server!");
PacketPlayOutDeclareCommands declare = DeclareCommands.getDeclareCommandsPacket(player); boolean isBungeecord = Limbo.getInstance().getServerProperties().isBungeecord();
if (declare != null) { String bungeeForwarding = handshake.getServerAddress();
sendPacket(declare); UUID bungeeUUID = null;
} SkinResponse bungeeSkin = null;
PacketPlayOutSpawnPosition spawnPos = new PacketPlayOutSpawnPosition(BlockPosition.from(worldSpawn)); try {
sendPacket(spawnPos); 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 = inetAddress.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;
PacketPlayOutPositionAndLook positionLook = new PacketPlayOutPositionAndLook(worldSpawn.getX(), worldSpawn.getY(), worldSpawn.getZ(), worldSpawn.getYaw(), worldSpawn.getPitch(), 1); if (isBungeecord) {
Limbo.getInstance().getUnsafe().setPlayerLocationSilently(player, new Location(world, worldSpawn.getX(), worldSpawn.getY(), worldSpawn.getZ(), worldSpawn.getYaw(), worldSpawn.getPitch())); try {
sendPacket(positionLook); String[] data = bungeeForwarding.split("\\x00");
//String host = data[0];
String ip = data[1];
player.getDataWatcher().update(); 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"));
PacketPlayOutEntityMetadata show = new PacketPlayOutEntityMetadata(player, false, Player.class.getDeclaredField("skinLayers")); inetAddress = InetAddress.getByName(ip);
sendPacket(show);
ready = true; if (data.length > 3) {
String skinJson = data[3];
while (client_socket.isConnected()) { String skin = skinJson.split("\"value\":\"")[1].split("\"")[0];
try { String signature = skinJson.split("\"signature\":\"")[1].split("\"")[0];
int size = DataTypeIO.readVarInt(input); bungeeSkin = new SkinResponse(skin, signature);
int packetId = DataTypeIO.readVarInt(input); }
Class<? extends Packet> packetType = Packet.getPlayIn().get(packetId); } catch (Exception e) {
//Limbo.getInstance().getConsole().sendMessage(packetId + " -> " + packetType); Limbo.getInstance().getConsole().sendMessage("If you wish to use bungeecord's IP forwarding, please enable that in your bungeecord config.yml as well!");
CheckedConsumer<PlayerMoveEvent, IOException> processMoveEvent = event -> { disconnectDuringLogin(new BaseComponent[]{new TextComponent(ChatColor.RED + "Please connect from the proxy!")});
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)); while (client_socket.isConnected()) {
processMoveEvent.consume(event); int size = DataTypeIO.readVarInt(input);
} else if (packetType.equals(PacketPlayInPosition.class)) { int packetId = DataTypeIO.readVarInt(input);
PacketPlayInPosition pos = new PacketPlayInPosition(input); Class<? extends Packet> packetType = Packet.getLoginIn().get(packetId);
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)); if (packetType == null) {
processMoveEvent.consume(event); input.skipBytes(size - DataTypeIO.getVarIntLength(packetId));
} else if (packetType.equals(PacketPlayInRotation.class)) { } else if (packetType.equals(PacketLoginInLoginStart.class)) {
PacketPlayInRotation pos = new PacketPlayInRotation(input); PacketLoginInLoginStart start = new PacketLoginInLoginStart(input);
Location from = player.getLocation(); String username = start.getUsername();
Location to = new Location(player.getWorld(), player.getLocation().getX(), player.getLocation().getY(), player.getLocation().getZ(), pos.getYaw(), pos.getPitch()); UUID uuid = isBungeecord ? bungeeUUID : UUID.nameUUIDFromBytes(("OfflinePlayer:" + username).getBytes(StandardCharsets.UTF_8));
PlayerMoveEvent event = Limbo.getInstance().getEventsManager().callEvent(new PlayerMoveEvent(player, from, to)); PacketLoginOutLoginSuccess success = new PacketLoginOutLoginSuccess(uuid, username);
processMoveEvent.consume(event); sendPacket(success);
} 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>(); state = ClientState.PLAY;
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) { player = new Player(this, username, uuid, Limbo.getInstance().getNextEntityId(), Limbo.getInstance().getServerProperties().getWorldSpawn(), new PlayerInteractManager());
break; player.setSkinLayers((byte) (0x01 | 0x02 | 0x04 | 0x08 | 0x10 | 0x20 | 0x40));
} Limbo.getInstance().addPlayer(player);
}
Limbo.getInstance().getEventsManager().callEvent(new PlayerQuitEvent(player)); break;
} else {
input.skipBytes(size - DataTypeIO.getVarIntLength(packetId));
}
}
str = inetAddress.getHostName() + ":" + client_socket.getPort() + "|" + player.getName(); PlayerLoginEvent event = Limbo.getInstance().getEventsManager().callEvent(new PlayerLoginEvent(this, false));
Limbo.getInstance().getConsole().sendMessage("[/" + str + "] <-> Player had disconnected!"); if (event.isCancelled()) {
disconnectDuringLogin(event.getCancelReason());
}
} break;
}
} catch (Exception e) {
client_socket.close();
state = ClientState.DISCONNECTED;
}
} catch (Exception e) {e.printStackTrace();} if (state == ClientState.PLAY) {
try { TimeUnit.MILLISECONDS.sleep(500);
client_socket.close();
} catch (IOException e) {}
state = ClientState.DISCONNECTED;
if (player != null) { ServerProperties properties = Limbo.getInstance().getServerProperties();
Limbo.getInstance().removePlayer(player); Location worldSpawn = properties.getWorldSpawn();
}
Limbo.getInstance().getServerConnection().getClients().remove(this);
running = false;
}
@FunctionalInterface PlayerJoinEvent joinEvent = Limbo.getInstance().getEventsManager().callEvent(new PlayerJoinEvent(player, worldSpawn));
public interface CheckedConsumer<T, TException extends Throwable> { worldSpawn = joinEvent.getSpawnLocation();
void consume(T t) throws TException; 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 = inetAddress.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 = inetAddress.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;
}
public enum ClientState {
LEGACY,
HANDSHAKE,
STATUS,
LOGIN,
PLAY,
DISCONNECTED
}
@FunctionalInterface
public interface CheckedConsumer<T, TException extends Throwable> {
void consume(T t) throws TException;
}
} }

63
src/main/java/com/loohp/limbo/server/KeepAliveSender.java
View File

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

86
src/main/java/com/loohp/limbo/server/ServerConnection.java
View File

@ -1,5 +1,7 @@
package com.loohp.limbo.server; package com.loohp.limbo.server;
import com.loohp.limbo.Limbo;
import java.io.IOException; import java.io.IOException;
import java.net.InetAddress; import java.net.InetAddress;
import java.net.ServerSocket; import java.net.ServerSocket;
@ -7,52 +9,50 @@ import java.net.Socket;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
import com.loohp.limbo.Limbo;
public class ServerConnection extends Thread { 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) { private ServerSocket serverSocket;
clients = new ArrayList<ClientConnection>(); private final List<ClientConnection> clients;
this.ip = ip; private final String ip;
this.port = port; private final int port;
start(); private final KeepAliveSender keepAliveSender;
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() { public ServerConnection(String ip, int port) {
return serverSocket; clients = new ArrayList<ClientConnection>();
} this.ip = ip;
this.port = port;
start();
keepAliveSender = new KeepAliveSender();
}
public List<ClientConnection> getClients() { @Override
return clients; 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;
}
} }

98
src/main/java/com/loohp/limbo/server/packets/Packet.java
View File

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

109
src/main/java/com/loohp/limbo/server/packets/PacketHandshakingIn.java
View File

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

30
src/main/java/com/loohp/limbo/server/packets/PacketLoginInLoginStart.java
View File

@ -1,25 +1,25 @@
package com.loohp.limbo.server.packets; package com.loohp.limbo.server.packets;
import com.loohp.limbo.utils.DataTypeIO;
import java.io.DataInputStream; import java.io.DataInputStream;
import java.io.IOException; import java.io.IOException;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketLoginInLoginStart extends PacketIn { 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() { private final String username;
return 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;
}
} }

60
src/main/java/com/loohp/limbo/server/packets/PacketLoginInPluginMessaging.java
View File

@ -1,43 +1,43 @@
package com.loohp.limbo.server.packets; package com.loohp.limbo.server.packets;
import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.utils.NamespacedKey;
import java.io.DataInputStream; import java.io.DataInputStream;
import java.io.IOException; import java.io.IOException;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.utils.NamespacedKey;
public class PacketLoginInPluginMessaging extends PacketIn { public class PacketLoginInPluginMessaging extends PacketIn {
private int messageId; private final int messageId;
private NamespacedKey channel; private final NamespacedKey channel;
private byte[] data; private final byte[] data;
public PacketLoginInPluginMessaging(int messageId, NamespacedKey channel, byte[] data) { public PacketLoginInPluginMessaging(int messageId, NamespacedKey channel, byte[] data) {
this.messageId = messageId; this.messageId = messageId;
this.channel = channel; this.channel = channel;
this.data = data; 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() { public PacketLoginInPluginMessaging(DataInputStream in, int packetLength, int packetId) throws IOException {
return channel; 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 byte[] getData() { public int getMessageId() {
return data; return messageId;
} }
public NamespacedKey getChannel() {
return channel;
}
public byte[] getData() {
return data;
}
} }

40
src/main/java/com/loohp/limbo/server/packets/PacketLoginOutDisconnect.java
View File

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

58
src/main/java/com/loohp/limbo/server/packets/PacketLoginOutLoginSuccess.java
View File

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

66
src/main/java/com/loohp/limbo/server/packets/PacketLoginOutPluginMessaging.java
View File

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

4
src/main/java/com/loohp/limbo/server/packets/PacketOut.java
View File

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

30
src/main/java/com/loohp/limbo/server/packets/PacketPlayInChat.java
View File

@ -1,25 +1,25 @@
package com.loohp.limbo.server.packets; package com.loohp.limbo.server.packets;
import com.loohp.limbo.utils.DataTypeIO;
import java.io.DataInputStream; import java.io.DataInputStream;
import java.io.IOException; import java.io.IOException;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketPlayInChat extends PacketIn { 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() { private final String message;
return 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;
}
} }

2
src/main/java/com/loohp/limbo/server/packets/PacketPlayInHeldItemChange.java
View File

@ -5,7 +5,7 @@ import java.io.IOException;
public class PacketPlayInHeldItemChange extends PacketIn { public class PacketPlayInHeldItemChange extends PacketIn {
private short slot; private final short slot;
public PacketPlayInHeldItemChange(short slot) { public PacketPlayInHeldItemChange(short slot) {
this.slot = slot; this.slot = slot;

28
src/main/java/com/loohp/limbo/server/packets/PacketPlayInKeepAlive.java
View File

@ -4,19 +4,19 @@ import java.io.DataInputStream;
import java.io.IOException; import java.io.IOException;
public class PacketPlayInKeepAlive extends PacketIn { public class PacketPlayInKeepAlive extends PacketIn {
private long payload; private final long payload;
public PacketPlayInKeepAlive(long payload) { public PacketPlayInKeepAlive(long payload) {
this.payload = payload; this.payload = payload;
} }
public PacketPlayInKeepAlive(DataInputStream in) throws IOException { public PacketPlayInKeepAlive(DataInputStream in) throws IOException {
this(in.readLong()); this(in.readLong());
} }
public long getPayload() { public long getPayload() {
return payload; return payload;
} }
} }

46
src/main/java/com/loohp/limbo/server/packets/PacketPlayInPluginMessaging.java
View File

@ -1,36 +1,36 @@
package com.loohp.limbo.server.packets; package com.loohp.limbo.server.packets;
import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.utils.NamespacedKey;
import java.io.DataInputStream; import java.io.DataInputStream;
import java.io.IOException; import java.io.IOException;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.utils.NamespacedKey;
public class PacketPlayInPluginMessaging extends PacketIn { public class PacketPlayInPluginMessaging extends PacketIn {
private NamespacedKey channel; private final NamespacedKey channel;
private byte[] data; private final byte[] data;
public PacketPlayInPluginMessaging(NamespacedKey channel, byte[] data) { public PacketPlayInPluginMessaging(NamespacedKey channel, byte[] data) {
this.channel = channel; this.channel = channel;
this.data = data; 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() { public PacketPlayInPluginMessaging(DataInputStream in, int packetLength, int packetId) throws IOException {
return channel; 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 byte[] getData() { public NamespacedKey getChannel() {
return data; return channel;
} }
public byte[] getData() {
return data;
}
} }

56
src/main/java/com/loohp/limbo/server/packets/PacketPlayInPosition.java
View File

@ -4,37 +4,37 @@ import java.io.DataInputStream;
import java.io.IOException; import java.io.IOException;
public class PacketPlayInPosition extends PacketIn { 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() { private final double x;
return x; private final double y;
} private final double z;
private final boolean onGround;
public double getY() { public PacketPlayInPosition(double x, double y, double z, boolean onGround) {
return y; this.x = x;
} this.y = y;
this.z = z;
this.onGround = onGround;
}
public double getZ() { public PacketPlayInPosition(DataInputStream in) throws IOException {
return z; this(in.readDouble(), in.readDouble(), in.readDouble(), in.readBoolean());
} }
public boolean onGround() { public double getX() {
return onGround; return x;
} }
public double getY() {
return y;
}
public double getZ() {
return z;
}
public boolean onGround() {
return onGround;
}
} }

76
src/main/java/com/loohp/limbo/server/packets/PacketPlayInPositionAndLook.java
View File

@ -4,49 +4,49 @@ import java.io.DataInputStream;
import java.io.IOException; import java.io.IOException;
public class PacketPlayInPositionAndLook extends PacketIn { 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() { private final double x;
return x; private final double y;
} private final double z;
private final float yaw;
private final float pitch;
private final boolean onGround;
public double getY() { public PacketPlayInPositionAndLook(double x, double y, double z, float yaw, float pitch, boolean onGround) {
return y; this.x = x;
} this.y = y;
this.z = z;
this.yaw = yaw;
this.pitch = pitch;
this.onGround = onGround;
}
public double getZ() { public PacketPlayInPositionAndLook(DataInputStream in) throws IOException {
return z; this(in.readDouble(), in.readDouble(), in.readDouble(), in.readFloat(), in.readFloat(), in.readBoolean());
} }
public float getYaw() { public double getX() {
return yaw; return x;
} }
public float getPitch() { public double getY() {
return pitch; return y;
} }
public boolean onGround() { public double getZ() {
return onGround; return z;
} }
public float getYaw() {
return yaw;
}
public float getPitch() {
return pitch;
}
public boolean onGround() {
return onGround;
}
} }

46
src/main/java/com/loohp/limbo/server/packets/PacketPlayInRotation.java
View File

@ -4,31 +4,31 @@ import java.io.DataInputStream;
import java.io.IOException; import java.io.IOException;
public class PacketPlayInRotation extends PacketIn { 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() { private final float yaw;
return yaw; private final float pitch;
} private final boolean onGround;
public float getPitch() { public PacketPlayInRotation(float yaw, float pitch, boolean onGround) {
return pitch; this.yaw = yaw;
} this.pitch = pitch;
this.onGround = onGround;
}
public boolean onGround() { public PacketPlayInRotation(DataInputStream in) throws IOException {
return onGround; this(in.readFloat(), in.readFloat(), in.readBoolean());
} }
public float getYaw() {
return yaw;
}
public float getPitch() {
return pitch;
}
public boolean onGround() {
return onGround;
}
} }

34
src/main/java/com/loohp/limbo/server/packets/PacketPlayInTabComplete.java
View File

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

68
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutChat.java
View File

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

40
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutDeclareCommands.java
View File

@ -5,26 +5,26 @@ import java.io.DataOutputStream;
import java.io.IOException; import java.io.IOException;
public class PacketPlayOutDeclareCommands extends PacketOut { public class PacketPlayOutDeclareCommands extends PacketOut {
private byte[] data;
public PacketPlayOutDeclareCommands(byte[] data) {
this.data = data;
}
public byte[] getData() {
return data;
}
@Override private final byte[] data;
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream(); public PacketPlayOutDeclareCommands(byte[] data) {
this.data = data;
DataOutputStream output = new DataOutputStream(buffer); }
output.writeByte(Packet.getPlayOut().get(getClass()));
output.write(data); public byte[] getData() {
return data;
return buffer.toByteArray(); }
}
@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();
}
} }

40
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutDisconnect.java
View File

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

50
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutEntityDestroy.java
View File

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

277
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutEntityMetadata.java
View File

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

46
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutGameState.java
View File

@ -6,32 +6,32 @@ import java.io.IOException;
public class PacketPlayOutGameState extends PacketOut { public class PacketPlayOutGameState extends PacketOut {
private int reason; private final int reason;
private float value; private final float value;
public PacketPlayOutGameState(int reason, float value) { public PacketPlayOutGameState(int reason, float value) {
this.reason = reason; this.reason = reason;
this.value = value; this.value = value;
} }
public int getReason() { public int getReason() {
return reason; return reason;
} }
public float getValue() { public float getValue() {
return value; return value;
} }
@Override @Override
public byte[] serializePacket() throws IOException { public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream(); ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer); DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass())); output.writeByte(Packet.getPlayOut().get(getClass()));
output.writeByte(reason); output.writeByte(reason);
output.writeFloat(value); output.writeFloat(value);
return buffer.toByteArray(); return buffer.toByteArray();
} }
} }

42
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutKeepAlive.java
View File

@ -5,26 +5,26 @@ import java.io.DataOutputStream;
import java.io.IOException; import java.io.IOException;
public class PacketPlayOutKeepAlive extends PacketOut { public class PacketPlayOutKeepAlive extends PacketOut {
long payload; long payload;
public PacketPlayOutKeepAlive(long payload) { public PacketPlayOutKeepAlive(long payload) {
this.payload = payload; this.payload = payload;
} }
public long getPayload() { public long getPayload() {
return payload; return payload;
} }
@Override @Override
public byte[] serializePacket() throws IOException { public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream(); ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer); DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass())); output.writeByte(Packet.getPlayOut().get(getClass()));
output.writeLong(payload); output.writeLong(payload);
return buffer.toByteArray(); return buffer.toByteArray();
} }
} }

182
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutLightUpdate.java
View File

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

233
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutLogin.java
View File

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

361
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutMapChunk.java
View File

@ -1,116 +1,111 @@
package com.loohp.limbo.server.packets; 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.BitsUtils;
import com.loohp.limbo.utils.DataTypeIO; import com.loohp.limbo.utils.DataTypeIO;
import com.loohp.limbo.world.Environment; import com.loohp.limbo.world.Environment;
import com.loohp.limbo.world.GeneratedBlockDataMappings; import com.loohp.limbo.world.GeneratedBlockDataMappings;
import net.querz.mca.Chunk; import net.querz.mca.Chunk;
import net.querz.mca.Section; import net.querz.mca.Section;
import net.querz.nbt.tag.CompoundTag; import net.querz.nbt.tag.CompoundTag;
import net.querz.nbt.tag.ListTag; import net.querz.nbt.tag.ListTag;
import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.*;
public class PacketPlayOutMapChunk extends PacketOut { public class PacketPlayOutMapChunk extends PacketOut {
private int chunkX; private final int chunkX;
private int chunkZ; private final int chunkZ;
private Chunk chunk; private final Chunk chunk;
private Environment environment; private final 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() { public PacketPlayOutMapChunk(int chunkX, int chunkZ, Chunk chunk, Environment environment) {
return chunk; this.chunkX = chunkX;
} this.chunkZ = chunkZ;
this.chunk = chunk;
public int getChunkX() { this.environment = environment;
return chunkX; }
}
public int getChunkZ() { @Deprecated
return chunkZ; public PacketPlayOutMapChunk(int chunkX, int chunkZ, Chunk chunk) {
} this(chunkZ, chunkZ, chunk, Environment.NORMAL);
}
public Environment getEnvironment() {
return environment;
}
@Override public Chunk getChunk() {
public byte[] serializePacket() throws IOException { return chunk;
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); public int getChunkX() {
newBits = Math.max(newBits, 4); return chunkX;
//Limbo.getInstance().getConsole().sendMessage(i + " " + newBits); }
if (newBits <= 8) {
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) { if (newBits == 4) {
dataOut.writeByte(4); dataOut.writeByte(4);
@ -120,92 +115,92 @@ public class PacketPlayOutMapChunk extends PacketOut {
dataOut.writeByte(8); dataOut.writeByte(8);
} }
*/ */
dataOut.writeByte(newBits); dataOut.writeByte(newBits);
DataTypeIO.writeVarInt(dataOut, section.getPalette().size()); DataTypeIO.writeVarInt(dataOut, section.getPalette().size());
//Limbo.getInstance().getConsole().sendMessage(section.getPalette().size()); //Limbo.getInstance().getConsole().sendMessage(section.getPalette().size());
Iterator<CompoundTag> itr1 = section.getPalette().iterator(); Iterator<CompoundTag> itr1 = section.getPalette().iterator();
//Limbo.getInstance().getConsole().sendMessage("Nonnull -> " + i + " " + newBits); //Limbo.getInstance().getConsole().sendMessage("Nonnull -> " + i + " " + newBits);
while (itr1.hasNext()) { while (itr1.hasNext()) {
CompoundTag tag = itr1.next(); CompoundTag tag = itr1.next();
DataTypeIO.writeVarInt(dataOut, GeneratedBlockDataMappings.getGlobalPaletteIDFromState(tag)); DataTypeIO.writeVarInt(dataOut, GeneratedBlockDataMappings.getGlobalPaletteIDFromState(tag));
//Limbo.getInstance().getConsole().sendMessage(tag + " -> " + GeneratedDataUtils.getGlobalPaletteIDFromState(tag)); //Limbo.getInstance().getConsole().sendMessage(tag + " -> " + GeneratedDataUtils.getGlobalPaletteIDFromState(tag));
} }
BitSet bits = BitSet.valueOf(section.getBlockStates()); BitSet bits = BitSet.valueOf(section.getBlockStates());
int shift = 64 % newBits; int shift = 64 % newBits;
int longsNeeded = (int) Math.ceil(4096 / (double) (64 / newBits)); int longsNeeded = (int) Math.ceil(4096 / (double) (64 / newBits));
for (int u = 64; u <= bits.length(); u += 64) { for (int u = 64; u <= bits.length(); u += 64) {
bits = BitsUtils.shiftAfter(bits, u - shift, shift); bits = BitsUtils.shiftAfter(bits, u - shift, shift);
} }
long[] formattedLongs = bits.toLongArray(); long[] formattedLongs = bits.toLongArray();
//Limbo.getInstance().getConsole().sendMessage(longsNeeded + ""); //Limbo.getInstance().getConsole().sendMessage(longsNeeded + "");
DataTypeIO.writeVarInt(dataOut, longsNeeded); DataTypeIO.writeVarInt(dataOut, longsNeeded);
for (int u = 0; u < longsNeeded; u++) { for (int u = 0; u < longsNeeded; u++) {
if (u < formattedLongs.length) { if (u < formattedLongs.length) {
dataOut.writeLong(formattedLongs[u]); dataOut.writeLong(formattedLongs[u]);
} else { } else {
dataOut.writeLong(0); dataOut.writeLong(0);
} }
//Limbo.getInstance().getConsole().sendMessage(Arrays.toString(section.getBlockStates())); //Limbo.getInstance().getConsole().sendMessage(Arrays.toString(section.getBlockStates()));
} }
} else { } else {
try { try {
dataOut.writeByte(15); dataOut.writeByte(15);
section.getBlockStates(); section.getBlockStates();
int longsNeeded = 1024; int longsNeeded = 1024;
List<Integer> list = new LinkedList<>(); List<Integer> list = new LinkedList<>();
for (int y = 0; y < 16; y++) { for (int y = 0; y < 16; y++) {
for (int z = 0; z < 16; z++) { for (int z = 0; z < 16; z++) {
for (int x = 0; x < 16; x++) { for (int x = 0; x < 16; x++) {
list.add(GeneratedBlockDataMappings.getGlobalPaletteIDFromState(section.getBlockStateAt(x, y, z))); list.add(GeneratedBlockDataMappings.getGlobalPaletteIDFromState(section.getBlockStateAt(x, y, z)));
} }
} }
} }
List<Long> globalLongs = new ArrayList<>(); List<Long> globalLongs = new ArrayList<>();
long currentLong = 0; long currentLong = 0;
int pos = 0; int pos = 0;
int u = 0; int u = 0;
while (pos < longsNeeded) { while (pos < longsNeeded) {
if (u == 3) { if (u == 3) {
globalLongs.add(currentLong); globalLongs.add(currentLong);
currentLong = 0; currentLong = 0;
u = 0; u = 0;
pos++; pos++;
} else { } else {
u++; u++;
} }
int id = list.isEmpty() ? 0 : list.remove(0); int id = list.isEmpty() ? 0 : list.remove(0);
currentLong = currentLong << 15; currentLong = currentLong << 15;
currentLong |= (long) id; currentLong |= id;
} }
DataTypeIO.writeVarInt(dataOut, longsNeeded); DataTypeIO.writeVarInt(dataOut, longsNeeded);
for (int j = 0; j < longsNeeded; j++) { for (int j = 0; j < longsNeeded; j++) {
if (j < globalLongs.size()) { if (j < globalLongs.size()) {
dataOut.writeLong(globalLongs.get(j)); dataOut.writeLong(globalLongs.get(j));
} else { } else {
dataOut.writeLong(0); dataOut.writeLong(0);
} }
} }
} catch (Exception e) { } catch (Exception e) {
e.printStackTrace(); e.printStackTrace();
} }
} }
} }
} }
byte[] data = dataBuffer.toByteArray(); byte[] data = dataBuffer.toByteArray();
DataTypeIO.writeVarInt(output, data.length); DataTypeIO.writeVarInt(output, data.length);
output.write(data); output.write(data);
ListTag<CompoundTag> tileEntities = chunk.getTileEntities(); ListTag<CompoundTag> tileEntities = chunk.getTileEntities();
DataTypeIO.writeVarInt(output, tileEntities.size()); DataTypeIO.writeVarInt(output, tileEntities.size());
for (CompoundTag each : tileEntities) { for (CompoundTag each : tileEntities) {
DataTypeIO.writeCompoundTag(output, each); DataTypeIO.writeCompoundTag(output, each);
} }
return buffer.toByteArray(); return buffer.toByteArray();
} }
} }

103
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutPlayerAbilities.java
View File

@ -5,62 +5,61 @@ import java.io.DataOutputStream;
import java.io.IOException; import java.io.IOException;
public class PacketPlayOutPlayerAbilities extends PacketOut { 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 final PlayerAbilityFlags[] flags;
private float flySpeed; private final float flySpeed;
private float fieldOfField; private final float fieldOfField;
public PacketPlayOutPlayerAbilities(float flySpeed, float fieldOfField, PlayerAbilityFlags... flags) {
this.flags = flags;
this.flySpeed = flySpeed;
this.fieldOfField = fieldOfField;
}
public PacketPlayOutPlayerAbilities(float flySpeed, float fieldOfField, PlayerAbilityFlags... flags) { public PlayerAbilityFlags[] getFlags() {
this.flags = flags; return flags;
this.flySpeed = flySpeed; }
this.fieldOfField = fieldOfField;
}
public PlayerAbilityFlags[] getFlags() { public float getFlySpeed() {
return flags; return flySpeed;
} }
public float getFlySpeed() { public float getFieldOfField() {
return flySpeed; return fieldOfField;
} }
public float getFieldOfField() { @Override
return fieldOfField; public byte[] serializePacket() throws IOException {
} ByteArrayOutputStream buffer = new ByteArrayOutputStream();
@Override DataOutputStream output = new DataOutputStream(buffer);
public byte[] serializePacket() throws IOException { output.writeByte(Packet.getPlayOut().get(getClass()));
ByteArrayOutputStream buffer = new ByteArrayOutputStream(); int value = 0;
for (PlayerAbilityFlags flag : flags) {
DataOutputStream output = new DataOutputStream(buffer); value = value | flag.getValue();
output.writeByte(Packet.getPlayOut().get(getClass())); }
int value = 0;
for (PlayerAbilityFlags flag : flags) { output.writeByte(value);
value = value | flag.getValue(); output.writeFloat(flySpeed);
} output.writeFloat(fieldOfField);
output.writeByte(value); return buffer.toByteArray();
output.writeFloat(flySpeed); }
output.writeFloat(fieldOfField);
public enum PlayerAbilityFlags {
return buffer.toByteArray(); INVULNERABLE(0x01),
} FLY(0x02),
ALLOW_FLYING(0x04),
CREATIVE(0x08);
int bitvalue;
PlayerAbilityFlags(int bitvalue) {
this.bitvalue = bitvalue;
}
public int getValue() {
return bitvalue;
}
}
} }

261
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutPlayerInfo.java
View File

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

52
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutPluginMessaging.java
View File

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

163
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutPositionAndLook.java
View File

@ -1,5 +1,7 @@
package com.loohp.limbo.server.packets; package com.loohp.limbo.server.packets;
import com.loohp.limbo.utils.DataTypeIO;
import java.io.ByteArrayOutputStream; import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream; import java.io.DataOutputStream;
import java.io.IOException; import java.io.IOException;
@ -7,95 +9,92 @@ import java.util.Arrays;
import java.util.Set; import java.util.Set;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import com.loohp.limbo.utils.DataTypeIO;
public class PacketPlayOutPositionAndLook extends PacketOut { 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() { private final double x;
return x; private final double y;
} private final double z;
private final float yaw;
private final float pitch;
private final Set<PlayerTeleportFlags> flags;
private final 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 getY() { public double getX() {
return y; return x;
} }
public double getZ() { public double getY() {
return z; return y;
} }
public float getYaw() { public double getZ() {
return yaw; return z;
} }
public float getPitch() { public float getYaw() {
return pitch; return yaw;
} }
public Set<PlayerTeleportFlags> getFlags() { public float getPitch() {
return flags; return pitch;
} }
public int getTeleportId() { public Set<PlayerTeleportFlags> getFlags() {
return teleportId; return flags;
} }
@Override public int getTeleportId() {
public byte[] serializePacket() throws IOException { return teleportId;
ByteArrayOutputStream buffer = new ByteArrayOutputStream(); }
DataOutputStream output = new DataOutputStream(buffer); @Override
output.writeByte(Packet.getPlayOut().get(getClass())); public byte[] serializePacket() throws IOException {
output.writeDouble(x); ByteArrayOutputStream buffer = new ByteArrayOutputStream();
output.writeDouble(y);
output.writeDouble(z); DataOutputStream output = new DataOutputStream(buffer);
output.writeFloat(yaw); output.writeByte(Packet.getPlayOut().get(getClass()));
output.writeFloat(pitch); output.writeDouble(x);
output.writeDouble(y);
byte flag = 0; output.writeDouble(z);
for (PlayerTeleportFlags each : flags) { output.writeFloat(yaw);
flag = (byte) (flag | each.getBit()); output.writeFloat(pitch);
}
byte flag = 0;
output.writeByte(flag); for (PlayerTeleportFlags each : flags) {
DataTypeIO.writeVarInt(output, teleportId); flag = (byte) (flag | each.getBit());
}
return buffer.toByteArray();
} output.writeByte(flag);
DataTypeIO.writeVarInt(output, teleportId);
return buffer.toByteArray();
}
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;
}
}
} }

143
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutRespawn.java
View File

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

176
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutSpawnEntity.java
View File

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

178
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutSpawnEntityLiving.java
View File

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

44
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutSpawnPosition.java
View File

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

127
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutTabComplete.java
View File

@ -1,88 +1,87 @@
package com.loohp.limbo.server.packets; package com.loohp.limbo.server.packets;
import com.loohp.limbo.utils.DataTypeIO;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.chat.ComponentSerializer;
import java.io.ByteArrayOutputStream; import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream; import java.io.DataOutputStream;
import java.io.IOException; import java.io.IOException;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import java.util.Optional; 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 { public class PacketPlayOutTabComplete extends PacketOut {
private int id; private final int id;
private int start; private final int start;
private int length; private final int length;
private TabCompleteMatches[] matches; private final TabCompleteMatches[] matches;
public PacketPlayOutTabComplete(int id, int start, int length, TabCompleteMatches... matches) { public PacketPlayOutTabComplete(int id, int start, int length, TabCompleteMatches... matches) {
this.id = id; this.id = id;
this.start = start; this.start = start;
this.length = length; this.length = length;
this.matches = matches; this.matches = matches;
} }
public int getId() { public int getId() {
return id; return id;
} }
public int getStart() { public int getStart() {
return start; return start;
} }
public int getLength() { public int getLength() {
return length; return length;
} }
public TabCompleteMatches[] getMatches() { public TabCompleteMatches[] getMatches() {
return matches; return matches;
} }
@Override @Override
public byte[] serializePacket() throws IOException { public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream(); 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 { 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);
private String match; for (TabCompleteMatches match : matches) {
private Optional<BaseComponent[]> tooltip; 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);
}
}
public TabCompleteMatches(String match, BaseComponent... tooltip) { return buffer.toByteArray();
this.match = match; }
this.tooltip = tooltip.length > 0 ? Optional.of(tooltip) : Optional.empty();
}
public String getMatch() { public static class TabCompleteMatches {
return match;
}
public Optional<BaseComponent[]> getTooltip() { private final String match;
return tooltip; private final 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;
}
}
} }

52
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutUnloadChunk.java
View File

@ -5,33 +5,33 @@ import java.io.DataOutputStream;
import java.io.IOException; import java.io.IOException;
public class PacketPlayOutUnloadChunk extends PacketOut { 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() { private final int chunkX;
return chunkX; private final int chunkZ;
}
public int getChunkZ() { public PacketPlayOutUnloadChunk(int chunkX, int chunkZ) {
return chunkZ; this.chunkX = chunkX;
} this.chunkZ = chunkZ;
}
@Override
public byte[] serializePacket() throws IOException { public int getChunkX() {
ByteArrayOutputStream buffer = new ByteArrayOutputStream(); return chunkX;
}
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getPlayOut().get(getClass())); public int getChunkZ() {
output.writeInt(chunkX); return chunkZ;
output.writeInt(chunkZ); }
return buffer.toByteArray(); @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();
}
} }

56
src/main/java/com/loohp/limbo/server/packets/PacketPlayOutUpdateViewPosition.java
View File

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

28
src/main/java/com/loohp/limbo/server/packets/PacketStatusInPing.java
View File

@ -4,19 +4,19 @@ import java.io.DataInputStream;
import java.io.IOException; import java.io.IOException;
public class PacketStatusInPing extends PacketIn { 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() { private final long payload;
return payload;
} public PacketStatusInPing(long payload) {
this.payload = payload;
}
public PacketStatusInPing(DataInputStream in) throws IOException {
this(in.readLong());
}
public long getPayload() {
return payload;
}
} }

16
src/main/java/com/loohp/limbo/server/packets/PacketStatusInRequest.java
View File

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

42
src/main/java/com/loohp/limbo/server/packets/PacketStatusOutPong.java
View File

@ -5,26 +5,26 @@ import java.io.DataOutputStream;
import java.io.IOException; import java.io.IOException;
public class PacketStatusOutPong extends PacketOut { public class PacketStatusOutPong extends PacketOut {
private long payload;
public PacketStatusOutPong(long payload) {
this.payload = payload;
}
public long getPayload() { private final long payload;
return payload;
} public PacketStatusOutPong(long payload) {
this.payload = payload;
@Override }
public byte[] serializePacket() throws IOException {
ByteArrayOutputStream buffer = new ByteArrayOutputStream(); public long getPayload() {
return payload;
DataOutputStream output = new DataOutputStream(buffer); }
output.writeByte(Packet.getStatusOut().get(getClass()));
output.writeLong(payload); @Override
public byte[] serializePacket() throws IOException {
return buffer.toByteArray(); ByteArrayOutputStream buffer = new ByteArrayOutputStream();
}
DataOutputStream output = new DataOutputStream(buffer);
output.writeByte(Packet.getStatusOut().get(getClass()));
output.writeLong(payload);
return buffer.toByteArray();
}
} }

46
src/main/java/com/loohp/limbo/server/packets/PacketStatusOutResponse.java
View File

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

30
src/main/java/com/loohp/limbo/utils/BitsUtils.java
View File

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

92
src/main/java/com/loohp/limbo/utils/BungeeLoginMessageUtils.java
View File

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

34
src/main/java/com/loohp/limbo/utils/ChunkDataUtils.java
View File

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

32
src/main/java/com/loohp/limbo/utils/CustomArrayUtils.java
View File

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

329
src/main/java/com/loohp/limbo/utils/CustomNBTUtils.java
View File

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

112
src/main/java/com/loohp/limbo/utils/CustomStringUtils.java
View File

@ -5,63 +5,63 @@ import java.util.Arrays;
import java.util.List; import java.util.List;
public class CustomStringUtils { 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; 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));
}
for (char c : str.toCharArray()) { public static boolean arrayContains(String compare, String[] args) {
if (c == '"') { return arrayContains(compare, args, true);
insideQuote = !insideQuote; }
} else if (c == ' ' && !insideQuote) {
if (sb.length() > 0) { public static String[] splitStringToArgs(String str) {
tokens.add(sb.toString()); List<String> tokens = new ArrayList<String>();
} StringBuilder sb = new StringBuilder();
sb.delete(0, sb.length());
} else { boolean insideQuote = false;
sb.append(c);
} for (char c : str.toCharArray()) {
} if (c == '"') {
tokens.add(sb.toString()); insideQuote = !insideQuote;
} else if (c == ' ' && !insideQuote) {
return tokens.toArray(new String[tokens.size()]); if (sb.length() > 0) {
} tokens.add(sb.toString());
}
public static int getIndexOfArg(String str, int ordinal) { sb.delete(0, sb.length());
StringBuilder sb = new StringBuilder(); } 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;
}
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;
}
} }

231
src/main/java/com/loohp/limbo/utils/DataTypeIO.java
View File

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

88
src/main/java/com/loohp/limbo/utils/DeclareCommands.java
View File

@ -1,56 +1,56 @@
package com.loohp.limbo.utils; package com.loohp.limbo.utils;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.commands.CommandSender;
import com.loohp.limbo.server.packets.PacketPlayOutDeclareCommands;
import java.io.ByteArrayOutputStream; import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream; import java.io.DataOutputStream;
import java.io.IOException; import java.io.IOException;
import java.nio.charset.StandardCharsets; import java.nio.charset.StandardCharsets;
import java.util.List; import java.util.List;
import com.loohp.limbo.Limbo;
import com.loohp.limbo.server.packets.PacketPlayOutDeclareCommands;
import com.loohp.limbo.commands.CommandSender;
public class DeclareCommands { public class DeclareCommands {
public static PacketPlayOutDeclareCommands getDeclareCommandsPacket(CommandSender sender) throws IOException {
List<String> commands = Limbo.getInstance().getPluginManager().getTabOptions(sender, new String[0]);
if (commands.isEmpty()) {
return null;
}
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
DataOutputStream output = new DataOutputStream(buffer);
DataTypeIO.writeVarInt(output, commands.size() * 2 + 1); public static PacketPlayOutDeclareCommands getDeclareCommandsPacket(CommandSender sender) throws IOException {
List<String> commands = Limbo.getInstance().getPluginManager().getTabOptions(sender, new String[0]);
output.writeByte(0);
DataTypeIO.writeVarInt(output, commands.size()); if (commands.isEmpty()) {
for (int i = 1; i <= commands.size() * 2; i++) { return null;
DataTypeIO.writeVarInt(output, i++); }
}
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
int i = 1; DataOutputStream output = new DataOutputStream(buffer);
for (String label : commands) {
output.writeByte(1 | 0x04); DataTypeIO.writeVarInt(output, commands.size() * 2 + 1);
DataTypeIO.writeVarInt(output, 1);
DataTypeIO.writeVarInt(output, i + 1); output.writeByte(0);
DataTypeIO.writeString(output, label, StandardCharsets.UTF_8); DataTypeIO.writeVarInt(output, commands.size());
i++; for (int i = 1; i <= commands.size() * 2; i++) {
DataTypeIO.writeVarInt(output, i++);
output.writeByte(2 | 0x04 | 0x10); }
DataTypeIO.writeVarInt(output, 1);
DataTypeIO.writeVarInt(output, i); int i = 1;
DataTypeIO.writeString(output, "arg", StandardCharsets.UTF_8); for (String label : commands) {
DataTypeIO.writeString(output, "brigadier:string", StandardCharsets.UTF_8); output.writeByte(1 | 0x04);
DataTypeIO.writeVarInt(output, 0); DataTypeIO.writeVarInt(output, 1);
DataTypeIO.writeString(output, "minecraft:ask_server", StandardCharsets.UTF_8); DataTypeIO.writeVarInt(output, i + 1);
i++; DataTypeIO.writeString(output, label, StandardCharsets.UTF_8);
} i++;
DataTypeIO.writeVarInt(output, 0); output.writeByte(2 | 0x04 | 0x10);
DataTypeIO.writeVarInt(output, 1);
return new PacketPlayOutDeclareCommands(buffer.toByteArray()); DataTypeIO.writeVarInt(output, i);
} DataTypeIO.writeString(output, "arg", StandardCharsets.UTF_8);
DataTypeIO.writeString(output, "brigadier:string", StandardCharsets.UTF_8);
DataTypeIO.writeVarInt(output, 0);
DataTypeIO.writeString(output, "minecraft:ask_server", StandardCharsets.UTF_8);
i++;
}
DataTypeIO.writeVarInt(output, 0);
return new PacketPlayOutDeclareCommands(buffer.toByteArray());
}
} }

78
src/main/java/com/loohp/limbo/utils/GameMode.java
View File

@ -1,44 +1,44 @@
package com.loohp.limbo.utils; package com.loohp.limbo.utils;
public enum GameMode { public enum GameMode {
SURVIVAL(0, "survival"), SURVIVAL(0, "survival"),
CREATIVE(1, "creative"), CREATIVE(1, "creative"),
ADVENTURE(2, "adventure"), ADVENTURE(2, "adventure"),
SPECTATOR(3, "spectator"); SPECTATOR(3, "spectator");
int id; int id;
String name; String name;
GameMode(int id, String name) { GameMode(int id, String name) {
this.id = id; this.id = id;
this.name = name; this.name = name;
} }
public int getId() { public static GameMode fromId(int id) {
return id; for (GameMode mode : GameMode.values()) {
} if (mode.getId() == id) {
return mode;
public String getName() { }
return name; }
} return null;
}
public static GameMode fromId(int id) {
for (GameMode mode : GameMode.values()) { public static GameMode fromName(String name) {
if (mode.getId() == id) { for (GameMode mode : GameMode.values()) {
return mode; if (mode.getName().equalsIgnoreCase(name)) {
} return mode;
} }
return null; }
} return null;
}
public static GameMode fromName(String name) {
for (GameMode mode : GameMode.values()) { public int getId() {
if (mode.getName().equalsIgnoreCase(name)) { return id;
return mode; }
}
} public String getName() {
return null; return name;
} }
} }

13
src/main/java/com/loohp/limbo/utils/ImageUtils.java
View File

@ -1,18 +1,17 @@
package com.loohp.limbo.utils; package com.loohp.limbo.utils;
import javax.imageio.ImageIO;
import java.awt.image.RenderedImage; import java.awt.image.RenderedImage;
import java.io.ByteArrayOutputStream; import java.io.ByteArrayOutputStream;
import java.io.IOException; import java.io.IOException;
import java.util.Base64; import java.util.Base64;
import javax.imageio.ImageIO;
public class ImageUtils { public class ImageUtils {
public static String imgToBase64String(final RenderedImage img, String formatName) throws IOException { public static String imgToBase64String(final RenderedImage img, String formatName) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream(); ByteArrayOutputStream out = new ByteArrayOutputStream();
ImageIO.write(img, formatName, out); ImageIO.write(img, formatName, out);
return Base64.getEncoder().encodeToString(out.toByteArray()); return Base64.getEncoder().encodeToString(out.toByteArray());
} }
} }

139
src/main/java/com/loohp/limbo/utils/MojangAPIUtils.java
View File

@ -1,5 +1,6 @@
package com.loohp.limbo.utils; package com.loohp.limbo.utils;
import javax.net.ssl.HttpsURLConnection;
import java.io.BufferedReader; import java.io.BufferedReader;
import java.io.IOException; import java.io.IOException;
import java.io.InputStreamReader; import java.io.InputStreamReader;
@ -7,87 +8,85 @@ import java.net.URL;
import java.util.UUID; import java.util.UUID;
import java.util.stream.Collectors; import java.util.stream.Collectors;
import javax.net.ssl.HttpsURLConnection;
public class MojangAPIUtils { public class MojangAPIUtils {
public static class SkinResponse {
String skin; public static UUID getOnlineUUIDOfPlayerFromMojang(String username) {
String signature; try {
URL url = new URL("https://api.mojang.com/users/profiles/minecraft/" + username);
public SkinResponse(String skin, String signature) { HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
this.skin = skin;
this.signature = signature;
}
public String getSkin() {
return skin;
}
public String getSignature() {
return signature;
}
}
public static UUID getOnlineUUIDOfPlayerFromMojang(String username) {
try {
URL url = new URL("https://api.mojang.com/users/profiles/minecraft/" + username);
HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
connection.setUseCaches(false); connection.setUseCaches(false);
connection.setDefaultUseCaches(false); connection.setDefaultUseCaches(false);
connection.addRequestProperty("User-Agent", "Mozilla/5.0"); connection.addRequestProperty("User-Agent", "Mozilla/5.0");
connection.addRequestProperty("Cache-Control", "no-cache, no-store, must-revalidate"); connection.addRequestProperty("Cache-Control", "no-cache, no-store, must-revalidate");
connection.addRequestProperty("Pragma", "no-cache"); connection.addRequestProperty("Pragma", "no-cache");
if (connection.getResponseCode() == HttpsURLConnection.HTTP_OK) { if (connection.getResponseCode() == HttpsURLConnection.HTTP_OK) {
String reply = new BufferedReader(new InputStreamReader(connection.getInputStream())).readLine(); String reply = new BufferedReader(new InputStreamReader(connection.getInputStream())).readLine();
if (!reply.contains("\"error\":\"BadRequestException\"")) { if (!reply.contains("\"error\":\"BadRequestException\"")) {
String uuid = reply.split("\"id\":\"")[1].split("\"")[0]; String uuid = reply.split("\"id\":\"")[1].split("\"")[0];
return UUID.fromString(uuid.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")); return UUID.fromString(uuid.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"));
} else { } else {
return null; return null;
} }
} else { } else {
System.err.println("Connection could not be opened (Response code " + connection.getResponseCode() + ", " + connection.getResponseMessage() + ")"); System.err.println("Connection could not be opened (Response code " + connection.getResponseCode() + ", " + connection.getResponseMessage() + ")");
return null; return null;
} }
} catch (IOException e) { } catch (IOException e) {
e.printStackTrace(); e.printStackTrace();
return null; return null;
} }
} }
public static SkinResponse getSkinFromMojangServer(String username) { public static SkinResponse getSkinFromMojangServer(String username) {
UUID uuid = getOnlineUUIDOfPlayerFromMojang(username); UUID uuid = getOnlineUUIDOfPlayerFromMojang(username);
if (uuid == null) { if (uuid == null) {
return null; return null;
} }
return getSkinFromMojangServer(uuid); return getSkinFromMojangServer(uuid);
} }
public static SkinResponse getSkinFromMojangServer(UUID uuid) { public static SkinResponse getSkinFromMojangServer(UUID uuid) {
try { try {
URL url = new URL("https://sessionserver.mojang.com/session/minecraft/profile/" + uuid.toString() + "?unsigned=false"); URL url = new URL("https://sessionserver.mojang.com/session/minecraft/profile/" + uuid.toString() + "?unsigned=false");
HttpsURLConnection connection = (HttpsURLConnection) url.openConnection(); HttpsURLConnection connection = (HttpsURLConnection) url.openConnection();
connection.setUseCaches(false); connection.setUseCaches(false);
connection.setDefaultUseCaches(false); connection.setDefaultUseCaches(false);
connection.addRequestProperty("User-Agent", "Mozilla/5.0"); connection.addRequestProperty("User-Agent", "Mozilla/5.0");
connection.addRequestProperty("Cache-Control", "no-cache, no-store, must-revalidate"); connection.addRequestProperty("Cache-Control", "no-cache, no-store, must-revalidate");
connection.addRequestProperty("Pragma", "no-cache"); connection.addRequestProperty("Pragma", "no-cache");
if (connection.getResponseCode() == HttpsURLConnection.HTTP_OK) { if (connection.getResponseCode() == HttpsURLConnection.HTTP_OK) {
String reply = String.join("", new BufferedReader(new InputStreamReader(connection.getInputStream())).lines().collect(Collectors.toList())).replace(" ", ""); String reply = String.join("", new BufferedReader(new InputStreamReader(connection.getInputStream())).lines().collect(Collectors.toList())).replace(" ", "");
String skin = reply.split("\"value\":\"")[1].split("\"")[0]; String skin = reply.split("\"value\":\"")[1].split("\"")[0];
String signature = reply.split("\"signature\":\"")[1].split("\"")[0]; String signature = reply.split("\"signature\":\"")[1].split("\"")[0];
return new SkinResponse(skin, signature); return new SkinResponse(skin, signature);
} else { } else {
System.err.println("Connection could not be opened (Response code " + connection.getResponseCode() + ", " + connection.getResponseMessage() + ")"); System.err.println("Connection could not be opened (Response code " + connection.getResponseCode() + ", " + connection.getResponseMessage() + ")");
return null; return null;
} }
} catch (IOException e) { } catch (IOException e) {
e.printStackTrace(); e.printStackTrace();
return null; return null;
} }
} }
public static class SkinResponse {
String skin;
String signature;
public SkinResponse(String skin, String signature) {
this.skin = skin;
this.signature = signature;
}
public String getSkin() {
return skin;
}
public String getSignature() {
return signature;
}
}
} }

119
src/main/java/com/loohp/limbo/utils/NamespacedKey.java
View File

@ -1,74 +1,71 @@
package com.loohp.limbo.utils; package com.loohp.limbo.utils;
public class NamespacedKey { public class NamespacedKey {
public static final String MINECRAFT_KEY = "minecraft";
private String namespace; public static final String MINECRAFT_KEY = "minecraft";
private String key;
public NamespacedKey(String namespacedKey) { private final String namespace;
int index = namespacedKey.indexOf(":"); private final String key;
if (index >= 0) {
this.namespace = namespacedKey.substring(0, index);
this.key = namespacedKey.substring(index + 1);
} else {
this.namespace = "minecraft";
this.key = namespacedKey;
}
}
public NamespacedKey(String namespace, String key) { public NamespacedKey(String namespacedKey) {
this.namespace = namespace; int index = namespacedKey.indexOf(":");
this.key = key; if (index >= 0) {
} this.namespace = namespacedKey.substring(0, index);
this.key = namespacedKey.substring(index + 1);
public static NamespacedKey minecraft(String key) { } else {
return new NamespacedKey(MINECRAFT_KEY, key); this.namespace = "minecraft";
} this.key = namespacedKey;
}
}
public String getNamespace() { public NamespacedKey(String namespace, String key) {
return namespace; this.namespace = namespace;
} this.key = key;
}
public String getKey() { public static NamespacedKey minecraft(String key) {
return key; return new NamespacedKey(MINECRAFT_KEY, key);
} }
@Override public String getNamespace() {
public String toString() { return namespace;
return namespace + ":" + key; }
}
@Override public String getKey() {
public int hashCode() { return key;
final int prime = 31; }
int result = 1;
result = prime * result + ((key == null) ? 0 : key.hashCode());
result = prime * result + ((namespace == null) ? 0 : namespace.hashCode());
return result;
}
@Override @Override
public boolean equals(Object obj) { public String toString() {
if (this == obj) return namespace + ":" + key;
return true; }
if (obj == null)
return false; @Override
if (getClass() != obj.getClass()) public int hashCode() {
return false; final int prime = 31;
NamespacedKey other = (NamespacedKey) obj; int result = 1;
if (key == null) { result = prime * result + ((key == null) ? 0 : key.hashCode());
if (other.key != null) result = prime * result + ((namespace == null) ? 0 : namespace.hashCode());
return false; return result;
} else if (!key.equals(other.key)) }
return false;
if (namespace == null) { @Override
if (other.namespace != null) public boolean equals(Object obj) {
return false; if (this == obj)
} else if (!namespace.equals(other.namespace)) return true;
return false; if (obj == null)
return true; return false;
} if (getClass() != obj.getClass())
return false;
NamespacedKey other = (NamespacedKey) obj;
if (key == null) {
if (other.key != null)
return false;
} else if (!key.equals(other.key))
return false;
if (namespace == null) {
return other.namespace == null;
} else return namespace.equals(other.namespace);
}
} }

52
src/main/java/com/loohp/limbo/utils/NetworkUtils.java
View File

@ -5,32 +5,32 @@ import java.net.DatagramSocket;
import java.net.ServerSocket; import java.net.ServerSocket;
public class NetworkUtils { public class NetworkUtils {
public static boolean available(int port) {
ServerSocket ss = null;
DatagramSocket ds = null;
try {
ss = new ServerSocket(port);
ss.setReuseAddress(true);
ds = new DatagramSocket(port);
ds.setReuseAddress(true);
return true;
} catch (IOException e) {
e.printStackTrace();
} finally {
if (ds != null) {
ds.close();
}
if (ss != null) { public static boolean available(int port) {
try { ServerSocket ss = null;
ss.close(); DatagramSocket ds = null;
} catch (IOException e) { try {
e.printStackTrace(); ss = new ServerSocket(port);
} ss.setReuseAddress(true);
} ds = new DatagramSocket(port);
} ds.setReuseAddress(true);
return false; return true;
} } catch (IOException e) {
e.printStackTrace();
} finally {
if (ds != null) {
ds.close();
}
if (ss != null) {
try {
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return false;
}
} }

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