Add versionDependantCall, See #144 BauSystem #80
@ -47,8 +47,8 @@ public class BungeeReceiver implements PluginMessageListener {
|
||||
UUID uuid = SteamwarUser.get(byteArrayDataInput.readInt()).getUUID();
|
||||
if(Bukkit.getPlayer(uuid).isOnline()) {
|
||||
Player player = Bukkit.getPlayer(uuid);
|
||||
Core.versionDependantCall(new VersionedRunnable(() -> BungeeReceiver_8.playPling(player), 8),
|
||||
new VersionedRunnable(() -> BungeeReceiver_9.playpling(player)));
|
||||
VersionedRunnable.versionDependantCall(new VersionedRunnable(() -> BungeeReceiver_8.playPling(player), 8),
|
||||
|
|
||||
new VersionedRunnable(() -> BungeeReceiver_9.playpling(player), 9));
|
||||
}
|
||||
|
||||
});
|
||||
|
||||
@ -83,83 +83,4 @@ public class Core extends JavaPlugin{
|
||||
Core.instance = instance;
|
||||
}
|
||||
|
||||
Lixfel
hat
Echt tolle nötige Newline! Echt tolle nötige Newline!
|
||||
public static void versionDependantCall(Runnable v12, Runnable v15) {
|
||||
switch (getVersion()) {
|
||||
case 12:
|
||||
v12.run();
|
||||
break;
|
||||
case 15:
|
||||
default:
|
||||
v15.run();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
public static <T> T versionDependantCall(ExceptionlessCallable<T> v12, ExceptionlessCallable<T> v15) {
|
||||
switch (getVersion()) {
|
||||
case 12:
|
||||
return v12.call();
|
||||
case 15:
|
||||
default:
|
||||
return v15.call();
|
||||
}
|
||||
}
|
||||
|
||||
public static void versionDependantCall(Runnable v8, Runnable v9, Runnable v10, Runnable v12, Runnable v14, Runnable v15) {
|
||||
switch (Core.getVersion()) {
|
||||
case 8:
|
||||
v8.run();
|
||||
break;
|
||||
case 9:
|
||||
v9.run();
|
||||
break;
|
||||
case 10:
|
||||
v10.run();
|
||||
break;
|
||||
case 12:
|
||||
v12.run();
|
||||
break;
|
||||
case 14:
|
||||
v14.run();
|
||||
break;
|
||||
case 15:
|
||||
default:
|
||||
v15.run();
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
public static <T> T versionDependantCall(ExceptionlessCallable<T> v8, ExceptionlessCallable<T> v9, ExceptionlessCallable<T> v10, ExceptionlessCallable<T> v12, ExceptionlessCallable<T> v14, ExceptionlessCallable<T> v15) {
|
||||
switch (Core.getVersion()) {
|
||||
case 8:
|
||||
return v8.call();
|
||||
case 9:
|
||||
return v9.call();
|
||||
case 10:
|
||||
return v10.call();
|
||||
case 12:
|
||||
return v12.call();
|
||||
case 14:
|
||||
return v14.call();
|
||||
case 15:
|
||||
default:
|
||||
return v15.call();
|
||||
}
|
||||
}
|
||||
|
||||
public static void versionDependantCall(VersionedRunnable versionedRunnable1, VersionedRunnable versionedRunnable2) {
|
||||
if (versionedRunnable1.isVersion()) {
|
||||
versionedRunnable1.run();
|
||||
return;
|
||||
}
|
||||
versionedRunnable2.run();
|
||||
}
|
||||
|
||||
public static <T> T versionDependantCall(VersionedCallable<T> versionedCallable1, VersionedCallable<T> versionedCallable2) {
|
||||
if (versionedCallable1.isVersion()) {
|
||||
return versionedCallable1.call();
|
||||
}
|
||||
return versionedCallable2.call();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -71,7 +71,12 @@ public class TPSWatcher {
|
||||
}
|
||||
|
||||
private static double[] getSpigotTPS() {
|
||||
return Core.versionDependantCall(SpigotTPS_8::getTps, SpigotTPS_9::getTps, SpigotTPS_10::getTps, SpigotTPS_12::getTps, SpigotTPS_14::getTps, SpigotTPS_15::getTps);
|
||||
return VersionedCallable.versionDependantCall(new VersionedCallable<>(SpigotTPS_8::getTps, 8),
|
||||
new VersionedCallable<>(SpigotTPS_9::getTps, 9),
|
||||
new VersionedCallable<>(SpigotTPS_10::getTps, 10),
|
||||
new VersionedCallable<>(SpigotTPS_12::getTps, 12),
|
||||
new VersionedCallable<>(SpigotTPS_14::getTps, 14),
|
||||
new VersionedCallable<>(SpigotTPS_15::getTps, 15));
|
||||
}
|
||||
|
||||
private static double round(double d) {
|
||||
|
||||
@ -21,25 +21,29 @@
|
||||
|
||||
package de.steamwar.core;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
public class VersionedCallable<T> {
|
||||
|
||||
private ExceptionlessCallable<T> exceptionlessCallable;
|
||||
private Set<Integer> versions = new HashSet<>();
|
||||
private int minVersion;
|
||||
|
||||
public VersionedCallable(ExceptionlessCallable<T> exceptionlessCallable, int... versions) {
|
||||
public VersionedCallable(ExceptionlessCallable<T> exceptionlessCallable, int minVersion) {
|
||||
this.exceptionlessCallable = exceptionlessCallable;
|
||||
for (int version : versions) this.versions.add(version);
|
||||
}
|
||||
|
||||
boolean isVersion() {
|
||||
return versions.contains(Core.getVersion());
|
||||
this.minVersion = minVersion;
|
||||
}
|
||||
|
||||
public T call() {
|
||||
|
Lixfel
hat
Besser wäre es, einfach die minimale (kleinste) Version, für die dieser Versionsabhängige Code zuständig ist, zu speichern. Dann müssen die Versionsabhängigen Schnipsel zwar immer in absteigender Reihenfolge kommen, aber meistens ist ja die höchste Version die meistbenötigste. Besser wäre es, einfach die minimale (kleinste) Version, für die dieser Versionsabhängige Code zuständig ist, zu speichern. Dann müssen die Versionsabhängigen Schnipsel zwar immer in absteigender Reihenfolge kommen, aber meistens ist ja die höchste Version die meistbenötigste.
Lixfel
hat
Dann ist auch bei X Werten immer klar, was aufgerufen werden muss. Dann ist auch bei X Werten immer klar, was aufgerufen werden muss.
|
||||
return exceptionlessCallable.call();
|
||||
}
|
||||
|
||||
public static <T> T versionDependantCall(VersionedCallable<T>... versionedCallables) {
|
||||
|
Lixfel
hat
Könnte man auch einfach in call umbenennen, weil es ist ja schon durch den Klassennamen klar, dass es versionsabhängig ist. Könnte man auch einfach in call umbenennen, weil es ist ja schon durch den Klassennamen klar, dass es versionsabhängig ist.
|
||||
int version = Core.getVersion();
|
||||
|
Lixfel
hat
Du musst die version nicht zwischenspeichern, Core.getVersion() ist kostenlos. Du musst die version nicht zwischenspeichern, Core.getVersion() ist kostenlos.
|
||||
for (int i = versionedCallables.length - 1; i >= 0; i--) {
|
||||
|
Lixfel
hat
Kann man nicht einfach einen reverse-iterator verwenden? Wäre wesentlich sauberer Kann man nicht einfach einen reverse-iterator verwenden? Wäre wesentlich sauberer
YoyoNow
hat
Ich glaube nicht so ganz Ich glaube nicht so ganz
YoyoNow
hat
Außerdem wäre ein Reverse-Iterator wieder ein Objekt mehr. Ich glaube die einfache Schleife reicht da. Außerdem wäre ein Reverse-Iterator wieder ein Objekt mehr. Ich glaube die einfache Schleife reicht da.
|
||||
VersionedCallable<T> versionedCallable = versionedCallables[i];
|
||||
if (version >= versionedCallable.minVersion || i == 0) {
|
||||
|
Lixfel
hat
Kein überprüfen auf i == 0 hier! Kein überprüfen auf i == 0 hier!
YoyoNow
hat
Wenn ich dies nicht mache, können NullPointerExceptions fliegen! Wenn ich dies nicht mache, können NullPointerExceptions fliegen!
Lixfel
hat
Bitte erstmal weiterlesen! Ja! Wenn hier nichts zutrifft, ist das ein Fehler! Bitte erstmal weiterlesen! Ja! Wenn hier nichts zutrifft, ist das ein Fehler!
YoyoNow
hat
Habe ich ja jetzt schon behoben! Habe ich ja jetzt schon behoben!
|
||||
return versionedCallable.call();
|
||||
}
|
||||
}
|
||||
return null;
|
||||
|
Lixfel
hat
Wird nie aufgerufen & gefällt mir nicht. Wenn diese Zeile erreicht wird, ist das ein Fehler und sollte auch entsprechend geworfen werden (als Programmierer, also Silent fehler, z.B. SecurityException) Wird nie aufgerufen & gefällt mir nicht. Wenn diese Zeile erreicht wird, ist das ein Fehler und sollte auch entsprechend geworfen werden (als Programmierer, also Silent fehler, z.B. SecurityException)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -21,25 +21,29 @@
|
||||
|
||||
package de.steamwar.core;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
public class VersionedRunnable {
|
||||
|
||||
private Runnable runnable;
|
||||
private Set<Integer> versions = new HashSet<>();
|
||||
private int minVersion;
|
||||
|
||||
public VersionedRunnable(Runnable runnable, int... versions) {
|
||||
public VersionedRunnable(Runnable runnable, int minVersion) {
|
||||
this.runnable = runnable;
|
||||
for (int version : versions) this.versions.add(version);
|
||||
}
|
||||
|
||||
boolean isVersion() {
|
||||
return versions.contains(Core.getVersion());
|
||||
this.minVersion = minVersion;
|
||||
}
|
||||
|
||||
public void run() {
|
||||
runnable.run();
|
||||
}
|
||||
|
||||
public static void versionDependantCall(VersionedRunnable... versionedRunnables) {
|
||||
int version = Core.getVersion();
|
||||
for (int i = versionedRunnables.length - 1; i >= 0; i--) {
|
||||
|
Lixfel
hat
Siehe VersionedCallable. Siehe VersionedCallable.
|
||||
VersionedRunnable versionedRunnable = versionedRunnables[i];
|
||||
if (version >= versionedRunnable.minVersion) {
|
||||
versionedRunnable.run();
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -28,6 +28,7 @@ import com.comphenix.protocol.injector.server.TemporaryPlayer;
|
||||
import com.comphenix.protocol.reflect.StructureModifier;
|
||||
import de.steamwar.chunk.*;
|
||||
import de.steamwar.core.Core;
|
||||
import de.steamwar.core.VersionedRunnable;
|
||||
import de.steamwar.sql.SteamwarUser;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.entity.Player;
|
||||
@ -71,11 +72,11 @@ public class ChunkListener {
|
||||
}
|
||||
|
||||
public static void sendChunk(Player p, int chunkX, int chunkZ){
|
||||
Core.versionDependantCall(() -> Chunk_8.sendChunk(p, chunkX, chunkZ),
|
||||
() -> Chunk_9.sendChunk(p, chunkX, chunkZ),
|
||||
() -> Chunk_10.sendChunk(p, chunkX, chunkZ),
|
||||
() -> Chunk_12.sendChunk(p, chunkX, chunkZ),
|
||||
() -> Chunk_14.sendChunk(p, chunkX, chunkZ),
|
||||
() -> Chunk_15.sendChunk(p, chunkX, chunkZ));
|
||||
VersionedRunnable.versionDependantCall(new VersionedRunnable(() -> Chunk_8.sendChunk(p, chunkX, chunkZ), 8),
|
||||
new VersionedRunnable(() -> Chunk_9.sendChunk(p, chunkX, chunkZ), 9),
|
||||
new VersionedRunnable(() -> Chunk_10.sendChunk(p, chunkX, chunkZ), 10),
|
||||
new VersionedRunnable(() -> Chunk_12.sendChunk(p, chunkX, chunkZ), 12),
|
||||
new VersionedRunnable(() -> Chunk_14.sendChunk(p, chunkX, chunkZ), 14),
|
||||
new VersionedRunnable(() -> Chunk_15.sendChunk(p, chunkX, chunkZ), 15));
|
||||
}
|
||||
}
|
||||
|
||||
@ -45,24 +45,24 @@ public class SWItem {
|
||||
|
||||
public static SWItem getPlayerSkull(String playerName){
|
||||
SWItem p = new SWItem();
|
||||
ItemStack head = Core.versionDependantCall(new VersionedCallable<>(() -> SWItem_8.setSkullOwner(playerName), 8, 9, 10, 12),
|
||||
new VersionedCallable<>(() -> SWItem_14.setSkullOwner(playerName)));
|
||||
ItemStack head = VersionedCallable.versionDependantCall(new VersionedCallable<>(() -> SWItem_8.setSkullOwner(playerName), 8),
|
||||
new VersionedCallable<>(() -> SWItem_14.setSkullOwner(playerName), 14));
|
||||
p.setItemStack(head);
|
||||
return p;
|
||||
}
|
||||
|
||||
public static Material getMaterial(String material){
|
||||
try{
|
||||
return Core.versionDependantCall(new VersionedCallable<>(() -> SWItem_8.getMaterial(material), 8, 9, 10, 12),
|
||||
new VersionedCallable<>(() -> SWItem_14.getMaterial(material)));
|
||||
return VersionedCallable.versionDependantCall(new VersionedCallable<>(() -> SWItem_8.getMaterial(material), 8),
|
||||
new VersionedCallable<>(() -> SWItem_14.getMaterial(material), 14));
|
||||
}catch(IllegalArgumentException e){
|
||||
return Material.STONE;
|
||||
}
|
||||
}
|
||||
|
||||
public static Material getDye(int colorCode){
|
||||
return Core.versionDependantCall(new VersionedCallable<>(SWItem_8::getDye, 8, 9, 10, 12),
|
||||
new VersionedCallable<>(() -> SWItem_14.getDye(colorCode)));
|
||||
return VersionedCallable.versionDependantCall(new VersionedCallable<>(SWItem_8::getDye, 8),
|
||||
new VersionedCallable<>(() -> SWItem_14.getDye(colorCode), 14));
|
||||
}
|
||||
|
||||
public SWItem() {
|
||||
|
||||
@ -74,8 +74,8 @@ public class Message {
|
||||
}
|
||||
|
||||
private Locale getLocale(Player player){
|
||||
return Core.versionDependantCall(new VersionedCallable<>(() -> Message_8.getLocale(player), 8, 9, 10),
|
||||
new VersionedCallable<>(() -> Message_12.getLocale(player)));
|
||||
return VersionedCallable.versionDependantCall(new VersionedCallable<>(() -> Message_8.getLocale(player), 8),
|
||||
new VersionedCallable<>(() -> Message_12.getLocale(player), 12));
|
||||
}
|
||||
|
||||
/* Send a message to one player */
|
||||
|
||||
@ -95,8 +95,8 @@ public class SWScoreboard {
|
||||
PacketContainer packet = manager.createPacket(PacketType.Play.Server.SCOREBOARD_OBJECTIVE);
|
||||
packet.getStrings().write(0, SIDEBAR + toggle);
|
||||
packet.getIntegers().write(0, 0); //0 to create
|
||||
Core.versionDependantCall(new VersionedRunnable(() -> packet.getStrings().write(1, name), 8, 9, 10, 12),
|
||||
new VersionedRunnable(() -> packet.getChatComponents().write(0, WrappedChatComponent.fromText(name))));
|
||||
VersionedRunnable.versionDependantCall(new VersionedRunnable(() -> packet.getStrings().write(1, name), 8),
|
||||
new VersionedRunnable(() -> packet.getChatComponents().write(0, WrappedChatComponent.fromText(name)), 14));
|
||||
packet.getEnumModifier(RenderType.class, 2).write(0, RenderType.INTEGER);
|
||||
return packet;
|
||||
}
|
||||
|
||||
@ -21,7 +21,6 @@ package de.steamwar.sql;
|
||||
|
||||
import com.sk89q.worldedit.extent.clipboard.Clipboard;
|
||||
import de.steamwar.core.Core;
|
||||
import de.steamwar.core.VersionedCallable;
|
||||
import org.bukkit.entity.Player;
|
||||
|
Lixfel
hat
Bitte aktiviere mal in deine IDE, dass Unused Imports automatisch aufgeräumt werden. Bitte aktiviere mal in deine IDE, dass Unused Imports automatisch aufgeräumt werden.
YoyoNow
hat
Habe ich kriegt er aber manchmal selber nicht hin Habe ich kriegt er aber manchmal selber nicht hin
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
In neuem Issue referenzieren
Einen Benutzer sperren
Das finde ich nicht so gut, dass du hier immer 2 (bzw. 4) Wegwerfobjekte erstellst. Der GC freut sich...