SteamWar/LobbySystem2.0
Archiviert
13
0
Fork 0
Code Issues 5 Pull-Requests Projekte Releases Wiki Aktivität

Add GhostJumpAndRun
Alle Prüfungen waren erfolgreich
SteamWarCI Build successful
Details

Quellcode durchsuchen
Dieser Commit ist enthalten in:
yoyosource 2023-04-08 15:11:06 +02:00
Ursprung 9d5ff317ea
Commit b466d7fbff
2 geänderte Dateien mit 189 neuen und 5 gelöschten Zeilen
Statistiken anzeigen Patch-Datei herunterladen Vergleichs-Datei herunterladen Alle Dateien ausklappen Alle Dateien einklappen

148
src/de/steamwar/lobby/jumpandrun/GhostJumpAndRun.java Normale Datei
Datei anzeigen

@ -0,0 +1,148 @@
package de.steamwar.lobby.jumpandrun;
import de.steamwar.entity.REntityServer;
import de.steamwar.entity.RPlayer;
import de.steamwar.lobby.LobbySystem;
import de.steamwar.sql.UserConfig;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.util.Vector;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.*;
import static de.steamwar.lobby.jumpandrun.JumpAndRun.JUMP_AND_RUN_REPLAY_CONFIG;
public class GhostJumpAndRun implements Listener {
private Player player;
private BukkitRunnable recordingRunnable;
private List<Vector> recordingList = new ArrayList<>();
private BukkitRunnable replayRunnable;
private List<Vector> replayList = new ArrayList<>();
private REntityServer entityServer;
private RPlayer entityPlayer;
public GhostJumpAndRun(Player player) {
this.player = player;
String s = UserConfig.getConfig(player.getUniqueId(), JUMP_AND_RUN_REPLAY_CONFIG);
if (s == null) return;
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(Base64.getDecoder().decode(s));
while (byteArrayInputStream.available() > 0) {
int x = byteArrayInputStream.read() << 24;
x |= byteArrayInputStream.read() << 16;
x |= byteArrayInputStream.read() << 8;
x |= byteArrayInputStream.read();
int y = byteArrayInputStream.read() << 24;
y |= byteArrayInputStream.read() << 16;
y |= byteArrayInputStream.read() << 8;
y |= byteArrayInputStream.read();
int z = byteArrayInputStream.read() << 24;
z |= byteArrayInputStream.read() << 16;
z |= byteArrayInputStream.read() << 8;
z |= byteArrayInputStream.read();
replayList.add(new Vector(Float.intBitsToFloat(x), Float.intBitsToFloat(y), Float.intBitsToFloat(z)));
}
}
public void record() {
if (recordingRunnable != null) return;
recordingList.clear();
recordingRunnable = new BukkitRunnable() {
@Override
public void run() {
recordingList.add(player.getLocation().toVector());
}
};
recordingRunnable.runTaskTimer(LobbySystem.getPlugin(), 1, 2);
}
public void stop() {
if (recordingRunnable == null) return;
recordingRunnable.cancel();
recordingRunnable = null;
if (recordingRunnable != null) {
replayRunnable.cancel();
replayRunnable = null;
}
if (entityServer != null) {
entityServer.close();
entityServer = null;
entityPlayer = null;
}
}
public void saveBestTime() {
replayList = recordingList;
recordingList = new ArrayList<>();
}
public void saveToDB() {
if (replayList.size() > 4000) {
return;
}
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
for (Vector vector : replayList) {
int x = Float.floatToIntBits((float) vector.getX());
int y = Float.floatToIntBits((float) vector.getY());
int z = Float.floatToIntBits((float) vector.getZ());
outputStream.write(x >> 24);
outputStream.write(x >> 16);
outputStream.write(x >> 8);
outputStream.write(x);
outputStream.write(y >> 24);
outputStream.write(y >> 16);
outputStream.write(y >> 8);
outputStream.write(y);
outputStream.write(z >> 24);
outputStream.write(z >> 16);
outputStream.write(z >> 8);
outputStream.write(z);
}
String replay = Base64.getEncoder().encodeToString(outputStream.toByteArray());
UserConfig.updatePlayerConfig(player.getUniqueId(), JUMP_AND_RUN_REPLAY_CONFIG, replay);
}
public void replay() {
if (replayRunnable != null) return;
if (replayList.isEmpty()) return;
entityServer = new REntityServer();
entityServer.addPlayer(player);
entityPlayer = new RPlayer(entityServer, UUID.randomUUID(), "Ghost", player.getLocation());
entityPlayer.setGlowing(true);
entityPlayer.setInvisible(true);
Iterator<Vector> iterator = replayList.iterator();
replayRunnable = new BukkitRunnable() {
@Override
public void run() {
if (!iterator.hasNext()) {
replayRunnable.cancel();
replayRunnable = null;
entityServer.close();
entityServer = null;
entityPlayer = null;
return;
}
entityPlayer.move(iterator.next().toLocation(player.getWorld()));
}
};
replayRunnable.runTaskTimer(LobbySystem.getPlugin(), 1, 2);
}
@EventHandler
public void onPlayerQuit(PlayerQuitEvent event) {
if (event.getPlayer() != player) return;
if (entityServer != null) entityServer.close();
if (recordingRunnable != null) recordingRunnable.cancel();
if (replayRunnable != null) replayRunnable.cancel();
}
}

46
src/de/steamwar/lobby/jumpandrun/JumpAndRun.java
Datei anzeigen

@ -3,6 +3,7 @@ package de.steamwar.lobby.jumpandrun;
import de.steamwar.lobby.LobbySystem;
import de.steamwar.lobby.listener.BasicListener;
import de.steamwar.lobby.listener.PlayerSpawn;
import de.steamwar.lobby.util.Leaderboard;
import de.steamwar.sql.UserConfig;
import net.md_5.bungee.api.ChatMessageType;
import org.bukkit.Bukkit;
@ -13,6 +14,7 @@ import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.inventory.ItemStack;
@ -23,6 +25,9 @@ import java.util.*;
public class JumpAndRun extends BasicListener {
public static final String JUMP_AND_RUN_CONFIG = "jump_and_run";
public static final String JUMP_AND_RUN_REPLAY_CONFIG = "jump_and_run_replay";
private static final String BAR_EMPTY = "||||||||||||||||||||||||||||||";
public static List<Vector> points = new ArrayList<>();
@ -33,6 +38,10 @@ public class JumpAndRun extends BasicListener {
private static final Map<Player, Long> CLICKED = new HashMap<>();
private static final Map<Player, Integer> CLICKED_COUNT = new HashMap<>();
private static final Map<Player, GhostJumpAndRun> GHOSTS = new HashMap<>();
private static final Leaderboard LEADERBOARD = new Leaderboard(LobbySystem.getEntityServer(false), JUMP_AND_RUN_CONFIG, new Location(Bukkit.getWorlds().get(0), 2338.5, 42.5, 1231.5), 5);
{
Bukkit.getScheduler().runTaskTimer(LobbySystem.getPlugin(), () -> {
Set<Player> toReset = new HashSet<>();
@ -75,6 +84,7 @@ public class JumpAndRun extends BasicListener {
}
});
toReset.forEach(player -> {
GHOSTS.get(player).stop();
reset(player);
player.teleport(Bukkit.getWorlds().get(0).getSpawnLocation().clone().add(0.5, 0, 0.5));
});
@ -116,40 +126,66 @@ public class JumpAndRun extends BasicListener {
event.getPlayer().getInventory().setItem(4, new ItemStack(Material.COMPASS, 1));
FAILS.put(event.getPlayer(), 0);
START.put(event.getPlayer(), System.currentTimeMillis());
GHOSTS.get(event.getPlayer()).record();
GHOSTS.get(event.getPlayer()).replay();
}
if (index == points.size() - 1) {
long time = System.currentTimeMillis() - START.get(event.getPlayer());
SimpleDateFormat format = new SimpleDateFormat(LobbySystem.getMessage().parse("JUMP_AND_RUN_TIME", event.getPlayer()), Locale.ROOT);
String parsed = format.format(new Date(time));
LobbySystem.getMessage().sendPrefixless("JUMP_AND_RUN_FINISHED", event.getPlayer(), parsed.substring(0, parsed.length() - 2), FAILS.get(event.getPlayer()));
GHOSTS.get(event.getPlayer()).stop();
updateJumpAndRunTime(event.getPlayer(), time);
reset(event.getPlayer());
}
}
private void updateJumpAndRunTime(Player player, long time) {
String jumpAndRunTimeConfig = UserConfig.getConfig(player.getUniqueId(), "jump_and_run");
boolean needsSave = true;
if (UserConfig.getConfig(player.getUniqueId(), JUMP_AND_RUN_REPLAY_CONFIG) == null) {
GHOSTS.get(player).saveBestTime();
GHOSTS.get(player).saveToDB();
needsSave = false;
}
String jumpAndRunTimeConfig = UserConfig.getConfig(player.getUniqueId(), JUMP_AND_RUN_CONFIG);
if (jumpAndRunTimeConfig == null) {
UserConfig.updatePlayerConfig(player.getUniqueId(), "jump_and_run", time + "");
UserConfig.updatePlayerConfig(player.getUniqueId(), JUMP_AND_RUN_CONFIG, time + "");
if (needsSave) {
GHOSTS.get(player).saveBestTime();
GHOSTS.get(player).saveToDB();
}
} else {
long jumpAndRunTime = Long.parseLong(jumpAndRunTimeConfig);
if (time < jumpAndRunTime) {
SimpleDateFormat format = new SimpleDateFormat(LobbySystem.getMessage().parse("JUMP_AND_RUN_TIME", player), Locale.ROOT);
String parsed = format.format(new Date(jumpAndRunTime - time));
LobbySystem.getMessage().sendPrefixless("JUMP_AND_RUN_PERSONAL_BEST", player, parsed);
UserConfig.updatePlayerConfig(player.getUniqueId(), "jump_and_run", time + "");
UserConfig.updatePlayerConfig(player.getUniqueId(), JUMP_AND_RUN_CONFIG, time + "");
if (needsSave) {
GHOSTS.get(player).saveBestTime();
GHOSTS.get(player).saveToDB();
}
LEADERBOARD.update();
}
}
}
@EventHandler
public void onPlayerJoin(PlayerJoinEvent event) {
Player player = event.getPlayer();
GHOSTS.put(player, new GhostJumpAndRun(player));
}
@EventHandler
public void onPlayerQuit(PlayerQuitEvent event) {
Player player = event.getPlayer();
CURRENT_POS.remove(player);
START.remove(player);
FAILS.remove(player);
CLICKED.remove(event.getPlayer());
CLICKED_COUNT.remove(event.getPlayer());
CLICKED.remove(player);
CLICKED_COUNT.remove(player);
GHOSTS.remove(player);
}
@EventHandler