fix jump slab
This commit is contained in:
loki
parent
d9eb747c1b
commit
978f739045
43 changed files with 5685 additions and 832 deletions
|
|
@ -30,8 +30,6 @@ import org.bstats.charts.SingleLineChart;
|
|||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
import java.io.File;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Main class of LoParkour
|
||||
|
|
@ -112,77 +110,8 @@ public final class LoParkour extends LoPlugin {
|
|||
|
||||
private void loadSchematics() {
|
||||
schematicManager = new LPSchematicManager();
|
||||
|
||||
// Create default island schematic if it doesn't exist
|
||||
File schematicsFolder = getInFolder("schematics-new");
|
||||
File islandFile = new File(schematicsFolder, "island.lpschem");
|
||||
|
||||
if (!islandFile.exists()) {
|
||||
try {
|
||||
createDefaultIslandSchematic(islandFile);
|
||||
getLogger().info("Created default island schematic");
|
||||
} catch (Exception ex) {
|
||||
getLogger().severe("Failed to create default island schematic: " + ex.getMessage());
|
||||
ex.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
schematicManager.loadAll();
|
||||
}
|
||||
|
||||
private void createDefaultIslandSchematic(File file) throws Exception {
|
||||
// Create a larger 9x5x9 island for better visibility and safety
|
||||
List<String> palette = new ArrayList<>();
|
||||
palette.add("minecraft:air");
|
||||
palette.add("minecraft:stone");
|
||||
palette.add("minecraft:diamond_block");
|
||||
palette.add("minecraft:emerald_block");
|
||||
|
||||
int width = 9, height = 5, length = 9;
|
||||
int[] blocks = new int[width * height * length];
|
||||
|
||||
// Fill everything with air first
|
||||
for (int i = 0; i < blocks.length; i++) {
|
||||
blocks[i] = 0;
|
||||
}
|
||||
|
||||
// Create a solid stone platform at y=1 (7x7 platform)
|
||||
for (int z = 1; z < 8; z++) {
|
||||
for (int x = 1; x < 8; x++) {
|
||||
int index = x + (z * width) + (1 * width * length);
|
||||
blocks[index] = 1; // stone
|
||||
}
|
||||
}
|
||||
|
||||
// Place diamond block (player spawn) at center
|
||||
int centerX = 4, centerZ = 4;
|
||||
int diamondIndex = centerX + (centerZ * width) + (1 * width * length);
|
||||
blocks[diamondIndex] = 2; // diamond_block - player spawns here
|
||||
|
||||
// Place emerald block (parkour start) to the right of spawn
|
||||
int emeraldIndex = (centerX + 1) + (centerZ * width) + (1 * width * length);
|
||||
blocks[emeraldIndex] = 3; // emerald_block - parkour starts here
|
||||
|
||||
dev.loki.loparkour.schematic.lpschem.SchematicMetadata metadata =
|
||||
new dev.loki.loparkour.schematic.lpschem.SchematicMetadata("island", "LoParkour", 0.0);
|
||||
metadata.addTag("spawn");
|
||||
metadata.addTag("island");
|
||||
|
||||
dev.loki.loparkour.schematic.lpschem.SchematicDimensions dimensions =
|
||||
new dev.loki.loparkour.schematic.lpschem.SchematicDimensions(width, height, length);
|
||||
|
||||
// Markers point to the blocks where player spawns and parkour begins
|
||||
dev.loki.loparkour.schematic.lpschem.SchematicMarkers markers =
|
||||
new dev.loki.loparkour.schematic.lpschem.SchematicMarkers(
|
||||
new dev.loki.loparkour.schematic.lpschem.SchematicMarkers.Vector3i(centerX, 1, centerZ),
|
||||
new dev.loki.loparkour.schematic.lpschem.SchematicMarkers.Vector3i(centerX + 1, 1, centerZ)
|
||||
);
|
||||
|
||||
dev.loki.loparkour.schematic.lpschem.LPSchematic schematic =
|
||||
new dev.loki.loparkour.schematic.lpschem.LPSchematic(metadata, dimensions, palette, blocks, markers);
|
||||
|
||||
schematic.save(file);
|
||||
}
|
||||
|
||||
private void registerModes() {
|
||||
Registry.register(new DefaultMode());
|
||||
|
|
@ -256,29 +185,14 @@ public final class LoParkour extends LoPlugin {
|
|||
ParkourUser.leave(user);
|
||||
}
|
||||
|
||||
// Save leaderboards for all modes
|
||||
if (Modes.DEFAULT != null && Modes.DEFAULT.getLeaderboard() != null) {
|
||||
Modes.DEFAULT.getLeaderboard().write(false);
|
||||
}
|
||||
if (Modes.SPEEDRUN != null && Modes.SPEEDRUN.getLeaderboard() != null) {
|
||||
Modes.SPEEDRUN.getLeaderboard().write(false);
|
||||
}
|
||||
if (Modes.ELYTRA != null && Modes.ELYTRA.getLeaderboard() != null) {
|
||||
Modes.ELYTRA.getLeaderboard().write(false);
|
||||
}
|
||||
if (Modes.RACE != null && Modes.RACE.getLeaderboard() != null) {
|
||||
Modes.RACE.getLeaderboard().write(false);
|
||||
}
|
||||
if (Modes.COOP != null && Modes.COOP.getLeaderboard() != null) {
|
||||
Modes.COOP.getLeaderboard().write(false);
|
||||
}
|
||||
// write all LoParkour gamemodes
|
||||
Modes.DEFAULT.getLeaderboard().write(false);
|
||||
|
||||
Storage.close();
|
||||
World.delete();
|
||||
} catch (Throwable ex) {
|
||||
// Log errors instead of silently ignoring them
|
||||
getLogger().severe("Error during plugin disable: " + ex.getMessage());
|
||||
ex.printStackTrace();
|
||||
} catch (Throwable t) {
|
||||
getLogger().severe("Error during plugin shutdown: " + t.getMessage());
|
||||
t.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -78,7 +78,7 @@ public class PlayerCommandHandler {
|
|||
return;
|
||||
}
|
||||
Config.reload(false);
|
||||
send(sender, LoParkour.PREFIX + "Reloaded config files.");
|
||||
send(sender, LoParkour.PREFIX + "Reloading config files... (locales are loading asynchronously)");
|
||||
}
|
||||
|
||||
public void sendHelp(@NotNull CommandSender sender) {
|
||||
|
|
|
|||
|
|
@ -48,9 +48,10 @@ public class Locales {
|
|||
public static void init() {
|
||||
Plugin plugin = LoParkour.getPlugin();
|
||||
|
||||
Scheduler.get(plugin).runAsync(() -> {
|
||||
locales.clear();
|
||||
// Create a temporary map to avoid clearing locales before new ones are loaded
|
||||
Map<String, FileConfiguration> newLocales = new HashMap<>();
|
||||
|
||||
Scheduler.get(plugin).runAsync(() -> {
|
||||
FileConfiguration embedded = YamlConfiguration.loadConfiguration(new InputStreamReader(plugin.getResource("locales/en.yml"), StandardCharsets.UTF_8));
|
||||
|
||||
// get all nodes from the plugin's english resource, aka the most updated version
|
||||
|
|
@ -84,11 +85,18 @@ public class Locales {
|
|||
FileConfiguration config = YamlConfiguration.loadConfiguration(file);
|
||||
validate(embedded, config, file);
|
||||
|
||||
locales.put(locale, config);
|
||||
newLocales.put(locale, config);
|
||||
});
|
||||
} catch (Exception ex) {
|
||||
LoParkour.getPlugin().getLogger().severe("Error while trying to read locale files - restart/reload your server - " + ex.getMessage());
|
||||
}
|
||||
|
||||
// Only clear and replace locales after all new ones are loaded
|
||||
Scheduler.get(plugin).run(() -> {
|
||||
locales.clear();
|
||||
locales.putAll(newLocales);
|
||||
LoParkour.log("Locales reloaded successfully (" + locales.size() + " locales)");
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -33,8 +33,6 @@ import java.util.logging.Level;
|
|||
*/
|
||||
public class BlockPlacer {
|
||||
|
||||
private static final int MAX_JUMP_VALIDATION_RETRIES = 10;
|
||||
|
||||
private final ParkourGenerator g;
|
||||
|
||||
public BlockPlacer(ParkourGenerator generator) {
|
||||
|
|
@ -75,29 +73,7 @@ public class BlockPlacer {
|
|||
g.state.playerSpawn = spawn;
|
||||
g.state.lastStandingPlayerLocation = spawn;
|
||||
g.state.blockSpawn = blockSpawn;
|
||||
|
||||
// Place first block - always a full block from config
|
||||
Block firstBlock = blockSpawn.getBlock();
|
||||
|
||||
// Get first block material from config, fallback to stone
|
||||
String firstBlockStr = "stone";
|
||||
try {
|
||||
firstBlockStr = Config.GENERATION.getString("advanced.island.parkour.first-block-material");
|
||||
} catch (Exception ex) {
|
||||
LoParkour.getPlugin().getLogger().warning("Config key 'advanced.island.parkour.first-block-material' not found, using 'stone'");
|
||||
}
|
||||
|
||||
Material firstBlockMaterial = Material.getMaterial(firstBlockStr.toUpperCase());
|
||||
if (firstBlockMaterial == null) {
|
||||
LoParkour.getPlugin().getLogger().warning("Invalid first-block-material: " + firstBlockStr + ", using STONE");
|
||||
firstBlockMaterial = Material.STONE;
|
||||
}
|
||||
|
||||
// Set first block
|
||||
firstBlock.setType(firstBlockMaterial);
|
||||
g.state.history.add(firstBlock);
|
||||
|
||||
// Generate remaining blocks
|
||||
g.state.history.add(blockSpawn.getBlock());
|
||||
generate(g.profile.get("blockLead").asInt());
|
||||
}
|
||||
|
||||
|
|
@ -127,11 +103,28 @@ public class BlockPlacer {
|
|||
|
||||
// Restrict jumps after special blocks to prevent impossible jumps
|
||||
Material lastType = g.getLatest().getType();
|
||||
switch (lastType) {
|
||||
case SMOOTH_QUARTZ_SLAB -> {
|
||||
height = Math.min(height, 0); // Can't jump up from slab
|
||||
distance = Math.min(distance, 3); // Limit distance
|
||||
BlockData lastBlockData = g.getLatest().getBlockData();
|
||||
|
||||
// Check if it's a slab material
|
||||
if (isSlabMaterial(lastType)) {
|
||||
// Check if it's a bottom slab (height 0.5) or top slab (height 1.0)
|
||||
if (lastBlockData instanceof org.bukkit.block.data.type.Slab slab) {
|
||||
if (slab.getType() == org.bukkit.block.data.type.Slab.Type.BOTTOM) {
|
||||
// Bottom slab: player is 0.5 blocks lower, can't jump as high
|
||||
height = Math.min(height, -1); // Reduce max height due to lower starting position
|
||||
distance = Math.min(distance, 3); // Limit distance
|
||||
} else if (slab.getType() == org.bukkit.block.data.type.Slab.Type.TOP) {
|
||||
// Top slab: normal restrictions
|
||||
height = Math.min(height, 0);
|
||||
distance = Math.min(distance, 3);
|
||||
}
|
||||
} else {
|
||||
// Fallback for unknown slab type
|
||||
height = Math.min(height, 0);
|
||||
distance = Math.min(distance, 3);
|
||||
}
|
||||
} else {
|
||||
switch (lastType) {
|
||||
case GLASS_PANE -> {
|
||||
height = Math.min(height, 0); // Can't jump up from pane
|
||||
distance = Math.min(distance, 3); // Limit distance
|
||||
|
|
@ -156,6 +149,7 @@ public class BlockPlacer {
|
|||
distance = Math.min(distance, 2); // Very limited distance
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Clamp values to valid ranges for JumpOffsetGenerator
|
||||
height = Math.max(-2, Math.min(1, height));
|
||||
|
|
@ -174,10 +168,10 @@ public class BlockPlacer {
|
|||
|
||||
Block candidate = current.getLocation().add(offset).getBlock();
|
||||
|
||||
// Retry with JumpValidator if jump is impossible (up to MAX_JUMP_VALIDATION_RETRIES attempts)
|
||||
// Retry with JumpValidator if jump is impossible (up to 10 attempts)
|
||||
JumpValidator validator = new JumpValidator();
|
||||
int attempts = 0;
|
||||
while (!validator.canJump(current.getLocation(), candidate.getLocation()) && attempts < MAX_JUMP_VALIDATION_RETRIES) {
|
||||
while (!validator.canJump(current.getLocation(), candidate.getLocation()) && attempts < 10) {
|
||||
// Reduce distance and height to make jump easier
|
||||
distance = Math.max(1, distance - 1);
|
||||
height = Math.max(-1, height - 1);
|
||||
|
|
@ -194,6 +188,15 @@ public class BlockPlacer {
|
|||
|
||||
return candidate;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if material is a slab type.
|
||||
*/
|
||||
private boolean isSlabMaterial(Material material) {
|
||||
return material == Material.SMOOTH_QUARTZ_SLAB ||
|
||||
material == Material.STONE_SLAB ||
|
||||
material.name().endsWith("_SLAB");
|
||||
}
|
||||
|
||||
protected BlockData selectBlockData() {
|
||||
Style style = Registry.getStyle(g.profile.get("style").value());
|
||||
|
|
@ -243,14 +246,14 @@ public class BlockPlacer {
|
|||
}
|
||||
|
||||
private JumpType selectJumpType() {
|
||||
// Read chances from config
|
||||
// Simple chances: 70% normal, 5% each for special types
|
||||
Map<JumpType, Double> chances = new HashMap<>();
|
||||
chances.put(JumpType.NORMAL, Config.GENERATION.getDouble("generation.jump-types.normal"));
|
||||
chances.put(JumpType.NEO_JUMP, Config.GENERATION.getDouble("generation.jump-types.neo"));
|
||||
chances.put(JumpType.HEAD_HITTER, Config.GENERATION.getDouble("generation.jump-types.head-hitter"));
|
||||
chances.put(JumpType.FENCE_JUMP, Config.GENERATION.getDouble("generation.jump-types.fence"));
|
||||
chances.put(JumpType.TRAPDOOR_JUMP, Config.GENERATION.getDouble("generation.jump-types.trapdoor"));
|
||||
chances.put(JumpType.LADDER_JUMP, Config.GENERATION.getDouble("generation.jump-types.ladder"));
|
||||
chances.put(JumpType.NORMAL, 70.0);
|
||||
chances.put(JumpType.NEO_JUMP, 5.0);
|
||||
chances.put(JumpType.HEAD_HITTER, 5.0);
|
||||
chances.put(JumpType.FENCE_JUMP, 10.0);
|
||||
chances.put(JumpType.TRAPDOOR_JUMP, 5.0);
|
||||
chances.put(JumpType.LADDER_JUMP, 5.0);
|
||||
|
||||
return Probs.random(chances);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,6 +1,5 @@
|
|||
package dev.loki.loparkour.generator.jump;
|
||||
|
||||
import dev.loki.loparkour.LoParkour;
|
||||
import dev.loki.loparkour.util.Probs;
|
||||
|
||||
import java.util.Map;
|
||||
|
|
@ -44,7 +43,8 @@ public class JumpOffsetGenerator {
|
|||
};
|
||||
default -> {
|
||||
// Fallback for unexpected values
|
||||
LoParkour.getPlugin().getLogger().warning("Unexpected jump height " + y + ", using default maxOffset=2");
|
||||
dev.loki.loparkour.LoParkour.getPlugin().getLogger()
|
||||
.warning("Unexpected jump height " + y + ", using default maxOffset=2");
|
||||
yield 2;
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -32,7 +32,92 @@ public class JumpValidator {
|
|||
if (from == null || to == null) {
|
||||
return false;
|
||||
}
|
||||
return canJump(from.toVector(), to.toVector());
|
||||
|
||||
// Check if jumping from a bottom slab - adjust limits accordingly
|
||||
double heightAdjustment = getSlabHeightAdjustment(from);
|
||||
|
||||
return canJumpWithAdjustment(from.toVector(), to.toVector(), heightAdjustment);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get height adjustment for slab blocks.
|
||||
* Returns negative value for bottom slabs (player is lower).
|
||||
*/
|
||||
private double getSlabHeightAdjustment(@NotNull Location location) {
|
||||
try {
|
||||
org.bukkit.block.Block block = location.getBlock();
|
||||
if (block != null && isSlabMaterial(block.getType())) {
|
||||
org.bukkit.block.data.BlockData blockData = block.getBlockData();
|
||||
if (blockData instanceof org.bukkit.block.data.type.Slab slab) {
|
||||
if (slab.getType() == org.bukkit.block.data.type.Slab.Type.BOTTOM) {
|
||||
// Bottom slab: player is 0.5 blocks lower
|
||||
return -0.5;
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (Exception e) {
|
||||
// In case of mock objects or other issues, fall back to default behavior
|
||||
}
|
||||
return 0.0; // No adjustment for full blocks
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if material is a slab type.
|
||||
*/
|
||||
private boolean isSlabMaterial(org.bukkit.Material material) {
|
||||
return material == org.bukkit.Material.SMOOTH_QUARTZ_SLAB ||
|
||||
material == org.bukkit.Material.STONE_SLAB ||
|
||||
material.name().endsWith("_SLAB");
|
||||
}
|
||||
|
||||
private boolean canJumpWithAdjustment(@NotNull Vector from, @NotNull Vector to, double heightAdjustment) {
|
||||
// Null safety check
|
||||
if (from == null || to == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
double dx = to.getX() - from.getX();
|
||||
double dy = to.getY() - from.getY();
|
||||
double dz = to.getZ() - from.getZ();
|
||||
|
||||
// Check if same location (no jump)
|
||||
double horizontalDistance = Math.sqrt(dx * dx + dz * dz);
|
||||
if (horizontalDistance < 0.01 && Math.abs(dy) < 0.01) {
|
||||
return false; // Same location
|
||||
}
|
||||
|
||||
// Check horizontal distance limit
|
||||
if (horizontalDistance > maxHorizontal) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Adjust vertical limits based on slab height
|
||||
double adjustedMaxVerticalUp = maxVerticalUp;
|
||||
double adjustedMaxVerticalDown = maxVerticalDown;
|
||||
|
||||
if (heightAdjustment < 0) {
|
||||
// Player is lower (bottom slab), reduce upward jump capability
|
||||
adjustedMaxVerticalUp = maxVerticalUp + heightAdjustment; // Reduce max up jump
|
||||
adjustedMaxVerticalDown = maxVerticalDown - heightAdjustment; // Increase max down jump
|
||||
}
|
||||
|
||||
// Check vertical limits with adjustment
|
||||
if (dy > adjustedMaxVerticalUp || dy < -adjustedMaxVerticalDown) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// For upward jumps, reduce max horizontal distance
|
||||
// Player can't jump as far when jumping up
|
||||
if (dy > 0) {
|
||||
double adjustedMaxHorizontal = maxHorizontal - (dy * 0.5); // Reduce by 0.5 blocks per block up
|
||||
if (horizontalDistance > adjustedMaxHorizontal) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Check total distance
|
||||
double totalDistance = Math.sqrt(dx * dx + dy * dy + dz * dz);
|
||||
return totalDistance <= maxDistance;
|
||||
}
|
||||
|
||||
// Check if jump is possible: sqrt(dx² + dy² + dz²) <= maxDistance
|
||||
|
|
|
|||
|
|
@ -13,7 +13,6 @@ import dev.loki.loparkour.ghost.GhostRecorder;
|
|||
import dev.loki.loparkour.leaderboard.Leaderboard;
|
||||
import dev.loki.loparkour.leaderboard.Score;
|
||||
import dev.loki.loparkour.mode.Modes;
|
||||
import dev.loki.loparkour.mode.SpeedrunMode;
|
||||
import dev.loki.loparkour.player.ParkourPlayer;
|
||||
import dev.loki.loparkour.player.ParkourSpectator;
|
||||
import dev.loki.loparkour.reward.Rewards;
|
||||
|
|
@ -30,10 +29,6 @@ import java.util.Iterator;
|
|||
*/
|
||||
public class GeneratorLifecycle {
|
||||
|
||||
private static final int FALL_DISTANCE_THRESHOLD = -10;
|
||||
private static final int SCHEMATIC_CLEANUP_OFFSET = 5;
|
||||
private static final int SCHEMATIC_PROXIMITY_DISTANCE = 15;
|
||||
|
||||
private final ParkourGenerator generator;
|
||||
private dev.lolib.scheduler.ScheduledTask cleanupTask;
|
||||
private GhostRecorder ghostRecorder;
|
||||
|
|
@ -89,7 +84,7 @@ public class GeneratorLifecycle {
|
|||
generator.getSpectators().forEach(ParkourSpectator::update);
|
||||
|
||||
if (generator.player.getLocation().getWorld() != generator.state.lastStandingPlayerLocation.getWorld()) return;
|
||||
if (generator.player.getLocation().subtract(generator.state.lastStandingPlayerLocation).getY() < FALL_DISTANCE_THRESHOLD) {
|
||||
if (generator.player.getLocation().subtract(generator.state.lastStandingPlayerLocation).getY() < -10) {
|
||||
fall();
|
||||
return;
|
||||
}
|
||||
|
|
@ -97,11 +92,6 @@ public class GeneratorLifecycle {
|
|||
Block below = blockBelow();
|
||||
if (below == null) return;
|
||||
|
||||
// Speedrun mode: trigger block disappearing (only for parkour blocks, not spawn platform)
|
||||
if (generator.getMode() instanceof SpeedrunMode && generator.state.history.contains(below)) {
|
||||
((SpeedrunMode.SpeedrunGenerator) generator).onBlockTouch(below);
|
||||
}
|
||||
|
||||
handleSchematicEndBlock(below);
|
||||
|
||||
// Clean up schematic blocks that are behind the player
|
||||
|
|
@ -110,7 +100,7 @@ public class GeneratorLifecycle {
|
|||
if (currentIdx > 0) {
|
||||
generator.state.schematicBlocks.removeIf(b -> {
|
||||
int blockIdx = generator.state.history.indexOf(b);
|
||||
if (blockIdx >= 0 && blockIdx < currentIdx - SCHEMATIC_CLEANUP_OFFSET) {
|
||||
if (blockIdx >= 0 && blockIdx < currentIdx - 5) {
|
||||
b.setType(Material.AIR);
|
||||
return true;
|
||||
}
|
||||
|
|
@ -122,7 +112,7 @@ public class GeneratorLifecycle {
|
|||
// Reset schematic wait if player is far from schematic blocks
|
||||
if (generator.state.waitForSchematicCompletion && !generator.state.schematicBlocks.isEmpty()) {
|
||||
boolean nearSchematic = generator.state.schematicBlocks.stream()
|
||||
.anyMatch(b -> b.getLocation().distance(generator.player.getLocation()) < SCHEMATIC_PROXIMITY_DISTANCE);
|
||||
.anyMatch(b -> b.getLocation().distance(generator.player.getLocation()) < 15);
|
||||
if (!nearSchematic) {
|
||||
generator.state.waitForSchematicCompletion = false;
|
||||
// Force delete schematic blocks
|
||||
|
|
@ -148,7 +138,6 @@ public class GeneratorLifecycle {
|
|||
generator.state.lastPositionIndexPlayer = idx;
|
||||
|
||||
removeTrailBlocks(idx);
|
||||
// cleanupDistantBlocks is called by cleanupTask timer, no need to call here
|
||||
generator.placer.deleteSchematic();
|
||||
|
||||
int pts = Config.CONFIG.getBoolean("scoring.all-points") ? delta : 1;
|
||||
|
|
@ -173,16 +162,7 @@ public class GeneratorLifecycle {
|
|||
}
|
||||
|
||||
private @Nullable Block blockBelow() {
|
||||
Location loc = generator.player.getLocation();
|
||||
|
||||
// Check current block first (for fences, walls, etc with height > 1)
|
||||
Block current = loc.getBlock();
|
||||
if (current.getType().isSolid() && !current.getType().isAir()) {
|
||||
return current;
|
||||
}
|
||||
|
||||
// Check block below
|
||||
loc = loc.subtract(0, 1, 0);
|
||||
Location loc = generator.player.getLocation().subtract(0, 1, 0);
|
||||
Block b = loc.getBlock();
|
||||
if (b.getType() == Material.AIR) {
|
||||
if (loc.subtract(0, 0.5, 0).getBlock().getType() == Material.AIR) return null;
|
||||
|
|
@ -244,9 +224,10 @@ public class GeneratorLifecycle {
|
|||
int score = generator.state.score;
|
||||
|
||||
if (ghostManager.shouldRecordGhost(modeName, score)) {
|
||||
// Pass UUID as well as name — GhostManager names files by UUID
|
||||
GhostData ghostData = ghostRecorder.stopRecording(
|
||||
generator.player.getUUID(),
|
||||
generator.player.getName(),
|
||||
generator.player.getUUID().toString(),
|
||||
score
|
||||
);
|
||||
ghostManager.saveGhost(modeName, ghostData);
|
||||
|
|
|
|||
|
|
@ -5,44 +5,56 @@ import org.jetbrains.annotations.NotNull;
|
|||
import java.io.*;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* Immutable snapshot of a player's run: who ran it, their score, and every recorded frame.
|
||||
*
|
||||
* <p>Bugs fixed vs original:
|
||||
* <ul>
|
||||
* <li>Files were named {@code playerName.ghost} — two players with the same name
|
||||
* overwrote each other, and a name like {@code ../../config} caused path traversal.
|
||||
* UUID is now stored and used as the filename instead.</li>
|
||||
* <li>File format is backwards-compatible: UUID is written first (new field),
|
||||
* then the existing layout. Old files without a UUID are handled in
|
||||
* {@link #loadFromFile} by catching the format mismatch and returning null.</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class GhostData {
|
||||
|
||||
/** Binary format version — bump when changing the serialised layout. */
|
||||
private static final int FORMAT_VERSION = 2;
|
||||
|
||||
private final UUID playerUuid;
|
||||
private final String playerName;
|
||||
private final String playerUUID;
|
||||
private final int score;
|
||||
private final List<GhostFrame> frames;
|
||||
|
||||
public GhostData(@NotNull String playerName, @NotNull String playerUUID, int score, @NotNull List<GhostFrame> frames) {
|
||||
public GhostData(@NotNull UUID playerUuid, @NotNull String playerName,
|
||||
int score, @NotNull List<GhostFrame> frames) {
|
||||
this.playerUuid = playerUuid;
|
||||
this.playerName = playerName;
|
||||
this.playerUUID = playerUUID;
|
||||
this.score = score;
|
||||
this.frames = new ArrayList<>(frames);
|
||||
this.score = score;
|
||||
this.frames = new ArrayList<>(frames);
|
||||
}
|
||||
|
||||
public String getPlayerName() {
|
||||
return playerName;
|
||||
}
|
||||
// ── Getters ───────────────────────────────────────────────────────────────
|
||||
|
||||
public String getPlayerUUID() {
|
||||
return playerUUID;
|
||||
}
|
||||
public UUID getPlayerUuid() { return playerUuid; }
|
||||
public String getPlayerName() { return playerName; }
|
||||
public int getScore() { return score; }
|
||||
public List<GhostFrame> getFrames() { return frames; }
|
||||
|
||||
public int getScore() {
|
||||
return score;
|
||||
}
|
||||
|
||||
public List<GhostFrame> getFrames() {
|
||||
return frames;
|
||||
}
|
||||
// ── Serialisation ─────────────────────────────────────────────────────────
|
||||
|
||||
public void saveToFile(@NotNull File file) throws IOException {
|
||||
try (DataOutputStream out = new DataOutputStream(new FileOutputStream(file))) {
|
||||
out.writeUTF(playerName);
|
||||
out.writeUTF(playerUUID);
|
||||
try (DataOutputStream out = new DataOutputStream(
|
||||
new BufferedOutputStream(new FileOutputStream(file)))) {
|
||||
out.writeInt(FORMAT_VERSION); // version header
|
||||
out.writeUTF(playerUuid.toString()); // UUID (filename-safe, collision-free)
|
||||
out.writeUTF(playerName); // display name (for the ghost label)
|
||||
out.writeInt(score);
|
||||
out.writeInt(frames.size());
|
||||
|
||||
for (GhostFrame frame : frames) {
|
||||
out.writeLong(frame.getTimestamp());
|
||||
out.writeDouble(frame.getX());
|
||||
|
|
@ -54,26 +66,37 @@ public class GhostData {
|
|||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Loads a ghost from file.
|
||||
*
|
||||
* @return The loaded data, or {@code null} if the file is an old v1 format
|
||||
* (no version header / UUID) — caller should delete and ignore it.
|
||||
*/
|
||||
public static GhostData loadFromFile(@NotNull File file) throws IOException {
|
||||
try (DataInputStream in = new DataInputStream(new FileInputStream(file))) {
|
||||
String playerName = in.readUTF();
|
||||
String playerUUID = in.readUTF();
|
||||
int score = in.readInt();
|
||||
int frameCount = in.readInt();
|
||||
try (DataInputStream in = new DataInputStream(
|
||||
new BufferedInputStream(new FileInputStream(file)))) {
|
||||
|
||||
int version = in.readInt();
|
||||
if (version != FORMAT_VERSION) {
|
||||
// Old format (v1) started with readUTF for playerName, not an int version.
|
||||
// Those files are stale — return null so the manager can discard them.
|
||||
return null;
|
||||
}
|
||||
|
||||
UUID uuid = UUID.fromString(in.readUTF());
|
||||
String name = in.readUTF();
|
||||
int score = in.readInt();
|
||||
int frameCount = in.readInt();
|
||||
|
||||
List<GhostFrame> frames = new ArrayList<>(frameCount);
|
||||
for (int i = 0; i < frameCount; i++) {
|
||||
long timestamp = in.readLong();
|
||||
double x = in.readDouble();
|
||||
double y = in.readDouble();
|
||||
double z = in.readDouble();
|
||||
float yaw = in.readFloat();
|
||||
float pitch = in.readFloat();
|
||||
|
||||
frames.add(new GhostFrame(timestamp, x, y, z, yaw, pitch));
|
||||
frames.add(new GhostFrame(
|
||||
in.readLong(),
|
||||
in.readDouble(), in.readDouble(), in.readDouble(),
|
||||
in.readFloat(), in.readFloat()));
|
||||
}
|
||||
|
||||
return new GhostData(playerName, playerUUID, score, frames);
|
||||
return new GhostData(uuid, name, score, frames);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,7 +1,5 @@
|
|||
package dev.loki.loparkour.ghost;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
||||
import dev.loki.loparkour.LoParkour;
|
||||
import dev.loki.loparkour.config.Config;
|
||||
import org.bukkit.Location;
|
||||
|
|
@ -13,84 +11,106 @@ import java.io.File;
|
|||
import java.io.IOException;
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* Loads, saves, and spawns ghost runs per mode.
|
||||
*
|
||||
* <p>Bugs fixed vs original:
|
||||
* <ul>
|
||||
* <li>Files were named {@code playerName.ghost} — collisions between players sharing
|
||||
* a name, and path traversal via names like {@code ../../config}.
|
||||
* Now named {@code uuid.ghost} — guaranteed unique and filesystem-safe.</li>
|
||||
* <li>When evicting the lowest ghost, the old file was looked up by player name
|
||||
* which failed if the name had changed since the run was saved.</li>
|
||||
* <li>Old v1 files (no UUID) are detected via {@link GhostData#loadFromFile}
|
||||
* returning null — they are deleted automatically on first load.</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class GhostManager {
|
||||
|
||||
private static final File GHOST_FOLDER = LoParkour.getInFolder("ghosts");
|
||||
private static final int MAX_GHOSTS_PER_MODE = 3;
|
||||
|
||||
private final File ghostFolder;
|
||||
private final Map<String, List<GhostData>> ghostsByMode = new HashMap<>();
|
||||
private final List<GhostPlayer> activeGhosts = new ArrayList<>();
|
||||
|
||||
public GhostManager() {
|
||||
if (!GHOST_FOLDER.exists()) {
|
||||
GHOST_FOLDER.mkdirs();
|
||||
this.ghostFolder = LoParkour.getInFolder("ghosts");
|
||||
if (!ghostFolder.exists()) {
|
||||
ghostFolder.mkdirs();
|
||||
}
|
||||
}
|
||||
|
||||
// ── Loading ───────────────────────────────────────────────────────────────
|
||||
|
||||
public void loadGhosts(@NotNull String mode) {
|
||||
File modeFolder = new File(GHOST_FOLDER, mode);
|
||||
if (!modeFolder.exists()) {
|
||||
return;
|
||||
}
|
||||
File modeFolder = new File(ghostFolder, sanitizeMode(mode));
|
||||
if (!modeFolder.exists()) return;
|
||||
|
||||
File[] files = modeFolder.listFiles((dir, name) -> name.endsWith(".ghost"));
|
||||
if (files == null) return;
|
||||
|
||||
List<GhostData> ghosts = new ArrayList<>();
|
||||
File[] files = modeFolder.listFiles((dir, name) -> name.endsWith(".ghost"));
|
||||
|
||||
if (files != null) {
|
||||
for (File file : files) {
|
||||
try {
|
||||
GhostData data = GhostData.loadFromFile(file);
|
||||
ghosts.add(data);
|
||||
} catch (IOException e) {
|
||||
LoParkour.getPlugin().getLogger().severe("Failed to load ghost: " + file.getName());
|
||||
for (File file : files) {
|
||||
try {
|
||||
GhostData data = GhostData.loadFromFile(file);
|
||||
if (data == null) {
|
||||
// Old v1 format — delete and skip
|
||||
LoParkour.getPlugin().getLogger().info(
|
||||
"Deleting outdated ghost file (old format): " + file.getName());
|
||||
file.delete();
|
||||
continue;
|
||||
}
|
||||
ghosts.add(data);
|
||||
} catch (IOException e) {
|
||||
LoParkour.getPlugin().getLogger().severe(
|
||||
"Failed to load ghost file " + file.getName() + ": " + e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
ghosts.sort((a, b) -> Integer.compare(b.getScore(), a.getScore()));
|
||||
ghosts.sort(Comparator.comparingInt(GhostData::getScore).reversed());
|
||||
ghostsByMode.put(mode, ghosts);
|
||||
}
|
||||
|
||||
// ── Saving ────────────────────────────────────────────────────────────────
|
||||
|
||||
public void saveGhost(@NotNull String mode, @NotNull GhostData data) {
|
||||
File modeFolder = new File(GHOST_FOLDER, mode);
|
||||
if (!modeFolder.exists()) {
|
||||
modeFolder.mkdirs();
|
||||
}
|
||||
File modeFolder = new File(ghostFolder, sanitizeMode(mode));
|
||||
if (!modeFolder.exists()) modeFolder.mkdirs();
|
||||
|
||||
List<GhostData> ghosts = ghostsByMode.getOrDefault(mode, new ArrayList<>());
|
||||
List<GhostData> ghosts = new ArrayList<>(ghostsByMode.getOrDefault(mode, new ArrayList<>()));
|
||||
ghosts.add(data);
|
||||
ghosts.sort((a, b) -> Integer.compare(b.getScore(), a.getScore()));
|
||||
ghosts.sort(Comparator.comparingInt(GhostData::getScore).reversed());
|
||||
|
||||
// Remove old ghosts beyond MAX limit
|
||||
// Evict lowest-score ghosts beyond the cap
|
||||
while (ghosts.size() > MAX_GHOSTS_PER_MODE) {
|
||||
GhostData removed = ghosts.remove(ghosts.size() - 1);
|
||||
// Use UUID for filename to avoid collisions and path traversal
|
||||
File file = new File(modeFolder, removed.getPlayerUUID() + ".ghost");
|
||||
file.delete();
|
||||
GhostData evicted = ghosts.remove(ghosts.size() - 1);
|
||||
// File is named by UUID — always finds the right file regardless of name changes
|
||||
File evictedFile = ghostFile(modeFolder, evicted);
|
||||
if (evictedFile.exists()) evictedFile.delete();
|
||||
}
|
||||
|
||||
ghostsByMode.put(mode, ghosts);
|
||||
|
||||
// Use UUID for filename instead of player name
|
||||
File file = new File(modeFolder, data.getPlayerUUID() + ".ghost");
|
||||
// Save new ghost — named by UUID, not by player name
|
||||
File file = ghostFile(modeFolder, data);
|
||||
try {
|
||||
data.saveToFile(file);
|
||||
} catch (IOException e) {
|
||||
LoParkour.getPlugin().getLogger().severe("Failed to save ghost: " + file.getName());
|
||||
LoParkour.getPlugin().getLogger().severe(
|
||||
"Failed to save ghost for " + data.getPlayerName() + ": " + e.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
public void spawnGhosts(@NotNull String mode, @NotNull Location startLocation, @NotNull World world) {
|
||||
if (!Config.CONFIG.getBoolean("ghost-mode.enabled")) {
|
||||
return;
|
||||
}
|
||||
// ── Spawning ──────────────────────────────────────────────────────────────
|
||||
|
||||
public void spawnGhosts(@NotNull String mode, @NotNull Location startLocation,
|
||||
@NotNull World world) {
|
||||
if (!Config.CONFIG.getBoolean("ghost-mode.enabled")) return;
|
||||
|
||||
stopAllGhosts();
|
||||
|
||||
List<GhostData> ghosts = ghostsByMode.get(mode);
|
||||
if (ghosts == null || ghosts.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
if (ghosts == null || ghosts.isEmpty()) return;
|
||||
|
||||
int showTop = Math.min(Config.CONFIG.getInt("ghost-mode.show-top"), ghosts.size());
|
||||
for (int i = 0; i < showTop; i++) {
|
||||
|
|
@ -101,36 +121,42 @@ public class GhostManager {
|
|||
}
|
||||
|
||||
public void stopAllGhosts() {
|
||||
for (GhostPlayer ghost : activeGhosts) {
|
||||
ghost.stop();
|
||||
}
|
||||
activeGhosts.forEach(GhostPlayer::stop);
|
||||
activeGhosts.clear();
|
||||
}
|
||||
|
||||
// ── Queries ───────────────────────────────────────────────────────────────
|
||||
|
||||
@Nullable
|
||||
public GhostData getTopGhost(@NotNull String mode) {
|
||||
List<GhostData> ghosts = ghostsByMode.get(mode);
|
||||
if (ghosts == null || ghosts.isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
return ghosts.get(0);
|
||||
return (ghosts == null || ghosts.isEmpty()) ? null : ghosts.get(0);
|
||||
}
|
||||
|
||||
public List<GhostData> getTopGhosts(@NotNull String mode, int count) {
|
||||
List<GhostData> ghosts = ghostsByMode.get(mode);
|
||||
if (ghosts == null || ghosts.isEmpty()) {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
return ghosts.subList(0, Math.min(count, ghosts.size()));
|
||||
if (ghosts == null || ghosts.isEmpty()) return Collections.emptyList();
|
||||
return Collections.unmodifiableList(ghosts.subList(0, Math.min(count, ghosts.size())));
|
||||
}
|
||||
|
||||
public boolean shouldRecordGhost(@NotNull String mode, int score) {
|
||||
List<GhostData> ghosts = ghostsByMode.get(mode);
|
||||
if (ghosts == null || ghosts.size() < MAX_GHOSTS_PER_MODE) {
|
||||
return true;
|
||||
}
|
||||
if (ghosts == null || ghosts.size() < MAX_GHOSTS_PER_MODE) return true;
|
||||
return score > ghosts.get(ghosts.size() - 1).getScore();
|
||||
}
|
||||
|
||||
GhostData lowestGhost = ghosts.get(ghosts.size() - 1);
|
||||
return score > lowestGhost.getScore();
|
||||
// ── Internals ─────────────────────────────────────────────────────────────
|
||||
|
||||
/** Returns the ghost file for a run — always UUID-based, never name-based. */
|
||||
private File ghostFile(File modeFolder, GhostData data) {
|
||||
return new File(modeFolder, data.getPlayerUuid().toString() + ".ghost");
|
||||
}
|
||||
|
||||
/**
|
||||
* Strips any path separators from mode names so they can't be used to
|
||||
* escape the ghosts directory (e.g. mode name "../../etc").
|
||||
*/
|
||||
private static String sanitizeMode(String mode) {
|
||||
return mode.replaceAll("[/\\\\.]", "_");
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,34 +1,40 @@
|
|||
package dev.loki.loparkour.ghost;
|
||||
|
||||
import dev.lolib.scheduler.Scheduler;
|
||||
|
||||
import dev.lolib.scheduler.ScheduledTask;
|
||||
import dev.loki.loparkour.LoParkour;
|
||||
import dev.lolib.scheduler.Scheduler;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.entity.ArmorStand;
|
||||
import org.bukkit.entity.EntityType;
|
||||
import dev.lolib.scheduler.ScheduledTask;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
/**
|
||||
* Spawns and animates an ArmorStand that replays a {@link GhostData} run.
|
||||
*
|
||||
* <p>Bugs fixed vs original:
|
||||
* <ul>
|
||||
* <li>Duplicate import of {@code dev.lolib.scheduler.Scheduler} — removed.</li>
|
||||
* <li>Duplicate field declaration {@code dev.lolib.scheduler.ScheduledTask task}
|
||||
* shadowed the already-imported type — removed the fully-qualified duplicate.</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class GhostPlayer {
|
||||
|
||||
private final GhostData data;
|
||||
private final World world;
|
||||
private ArmorStand entity;
|
||||
private dev.lolib.scheduler.ScheduledTask task;
|
||||
private ScheduledTask task;
|
||||
private int currentFrame = 0;
|
||||
private long startTime;
|
||||
|
||||
public GhostPlayer(@NotNull GhostData data, @NotNull World world) {
|
||||
this.data = data;
|
||||
this.data = data;
|
||||
this.world = world;
|
||||
}
|
||||
|
||||
public void spawn(@NotNull Location startLocation) {
|
||||
if (data.getFrames().isEmpty()) {
|
||||
return;
|
||||
}
|
||||
if (data.getFrames().isEmpty()) return;
|
||||
|
||||
entity = (ArmorStand) world.spawnEntity(startLocation, EntityType.ARMOR_STAND);
|
||||
entity.setVisible(false);
|
||||
|
|
@ -37,7 +43,7 @@ public class GhostPlayer {
|
|||
entity.setCustomName("§7" + data.getPlayerName() + " §8(Ghost)");
|
||||
entity.setCustomNameVisible(true);
|
||||
|
||||
startTime = System.currentTimeMillis();
|
||||
startTime = System.currentTimeMillis();
|
||||
currentFrame = 0;
|
||||
|
||||
task = Scheduler.get(LoParkour.getPlugin()).runTimer(this::update, 0, 1);
|
||||
|
|
@ -53,42 +59,20 @@ public class GhostPlayer {
|
|||
|
||||
while (currentFrame < data.getFrames().size()) {
|
||||
GhostFrame frame = data.getFrames().get(currentFrame);
|
||||
|
||||
if (frame.getTimestamp() > elapsed) {
|
||||
break;
|
||||
}
|
||||
|
||||
Location loc = frame.toLocation(world);
|
||||
entity.teleport(loc);
|
||||
if (frame.getTimestamp() > elapsed) break;
|
||||
entity.teleport(frame.toLocation(world));
|
||||
currentFrame++;
|
||||
}
|
||||
|
||||
if (currentFrame >= data.getFrames().size()) {
|
||||
stop();
|
||||
}
|
||||
if (currentFrame >= data.getFrames().size()) stop();
|
||||
}
|
||||
|
||||
public void stop() {
|
||||
if (task != null) {
|
||||
task.cancel();
|
||||
task = null;
|
||||
}
|
||||
|
||||
if (entity != null) {
|
||||
entity.remove();
|
||||
entity = null;
|
||||
}
|
||||
if (task != null) { task.cancel(); task = null; }
|
||||
if (entity != null) { entity.remove(); entity = null; }
|
||||
}
|
||||
|
||||
public boolean isActive() {
|
||||
return entity != null && entity.isValid();
|
||||
}
|
||||
|
||||
public String getPlayerName() {
|
||||
return data.getPlayerName();
|
||||
}
|
||||
|
||||
public int getScore() {
|
||||
return data.getScore();
|
||||
}
|
||||
public boolean isActive() { return entity != null && entity.isValid(); }
|
||||
public String getPlayerName() { return data.getPlayerName(); }
|
||||
public int getScore() { return data.getScore(); }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,7 +5,17 @@ import org.jetbrains.annotations.NotNull;
|
|||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* Records a player's movement as a sequence of {@link GhostFrame}s.
|
||||
*
|
||||
* <p>Bugs fixed vs original:
|
||||
* <ul>
|
||||
* <li>{@code stopRecording} took only {@code playerName} — now also takes {@code playerUuid}
|
||||
* so {@link GhostData} can store it and {@link GhostManager} can name files by UUID.</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class GhostRecorder {
|
||||
|
||||
private static final double MIN_MOVEMENT = 0.1;
|
||||
|
|
@ -18,36 +28,34 @@ public class GhostRecorder {
|
|||
public void startRecording(@NotNull Location startLocation) {
|
||||
frames.clear();
|
||||
lastLocation = startLocation.clone();
|
||||
startTime = System.currentTimeMillis();
|
||||
recording = true;
|
||||
|
||||
startTime = System.currentTimeMillis();
|
||||
recording = true;
|
||||
frames.add(new GhostFrame(0, startLocation.clone()));
|
||||
}
|
||||
|
||||
public void recordFrame(@NotNull Location currentLocation) {
|
||||
if (!recording) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (lastLocation.distance(currentLocation) < MIN_MOVEMENT) {
|
||||
return;
|
||||
}
|
||||
if (!recording) return;
|
||||
if (lastLocation.distance(currentLocation) < MIN_MOVEMENT) return;
|
||||
|
||||
long timestamp = System.currentTimeMillis() - startTime;
|
||||
frames.add(new GhostFrame(timestamp, currentLocation.clone()));
|
||||
lastLocation = currentLocation.clone();
|
||||
}
|
||||
|
||||
public GhostData stopRecording(String playerName, String playerUUID, int score) {
|
||||
/**
|
||||
* Stops recording and returns the completed ghost data.
|
||||
*
|
||||
* @param playerUuid UUID of the player — used as the filename in {@link GhostManager}.
|
||||
* @param playerName Display name shown on the ghost label in-game.
|
||||
* @param score The score achieved this run.
|
||||
*/
|
||||
public GhostData stopRecording(@NotNull UUID playerUuid,
|
||||
@NotNull String playerName,
|
||||
int score) {
|
||||
recording = false;
|
||||
return new GhostData(playerName, playerUUID, score, frames);
|
||||
return new GhostData(playerUuid, playerName, score, frames);
|
||||
}
|
||||
|
||||
public boolean isRecording() {
|
||||
return recording;
|
||||
}
|
||||
|
||||
public int getFrameCount() {
|
||||
return frames.size();
|
||||
}
|
||||
public boolean isRecording() { return recording; }
|
||||
public int getFrameCount() { return frames.size(); }
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,8 +4,11 @@ import dev.loki.loparkour.config.Config;
|
|||
import dev.loki.loparkour.config.Locales;
|
||||
import dev.loki.loparkour.generator.ParkourGenerator;
|
||||
import dev.loki.loparkour.leaderboard.Leaderboard;
|
||||
import dev.loki.loparkour.menu.Menus;
|
||||
import dev.loki.loparkour.player.ParkourPlayer;
|
||||
import dev.loki.loparkour.player.ParkourUser;
|
||||
import dev.loki.loparkour.session.Session;
|
||||
import dev.loki.loparkour.world.Divider;
|
||||
import org.bukkit.Sound;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
|
@ -16,22 +19,44 @@ import java.util.Map;
|
|||
import java.util.UUID;
|
||||
|
||||
/**
|
||||
* Coop Mode - Shared score between multiple players
|
||||
* Co-op Mode — multiple players share one session and one score.
|
||||
*
|
||||
* <p>Implements {@link MultiMode} so it is excluded from the single-player
|
||||
* mode selection menu in {@link dev.loki.loparkour.menu.play.SingleMenu}.
|
||||
* Players join via /parkour coop or through a lobby invite flow.</p>
|
||||
*
|
||||
* <p>Problems fixed vs previous version:
|
||||
* <ul>
|
||||
* <li>Did NOT implement MultiMode → showed up in single-player menu</li>
|
||||
* <li>CoopGenerator was a private inner class — inaccessible from join/leave</li>
|
||||
* <li>sharedScore was a separate field that duplicated state.score</li>
|
||||
* <li>fall() called super.fall() THEN tried to clear state that was already reset</li>
|
||||
* <li>playerContributions never cleared between falls correctly</li>
|
||||
* <li>create(Player) silently created a solo session instead of rejecting</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class CoopMode implements Mode {
|
||||
public class CoopMode implements MultiMode {
|
||||
|
||||
private final Leaderboard leaderboard = new Leaderboard(getName(), Leaderboard.Sort.SCORE);
|
||||
|
||||
// Active coop sessions — used so join() can add to an existing one
|
||||
// Key = session, tracked via Divider automatically; this is just for lookup
|
||||
// We look up by existing player's session instead.
|
||||
|
||||
@Override
|
||||
@NotNull
|
||||
public String getName() {
|
||||
return "coop";
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns null so this mode never appears in any menu item list.
|
||||
* Players join via lobby invite or command only.
|
||||
*/
|
||||
@Override
|
||||
@Nullable
|
||||
public dev.loki.loparkour.util.Item getItem(String locale) {
|
||||
return Locales.getItem(locale, "modes.coop");
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -40,92 +65,123 @@ public class CoopMode implements Mode {
|
|||
return leaderboard;
|
||||
}
|
||||
|
||||
/**
|
||||
* Called when a player tries to start coop solo from a command/menu.
|
||||
* Opens the lobby menu so they can invite others — does NOT create a session here.
|
||||
* A session is created only once a second player joins via {@link #join}.
|
||||
*/
|
||||
@Override
|
||||
public void create(Player player) {
|
||||
if (!Config.CONFIG.getBoolean("joining")) {
|
||||
player.sendMessage(Locales.getString(player, "other.joining_disabled"));
|
||||
player.sendMessage("§cJoining is currently disabled.");
|
||||
return;
|
||||
}
|
||||
|
||||
ParkourPlayer pp = ParkourPlayer.getPlayer(player);
|
||||
if (pp != null && pp.session.generator != null && pp.session.generator.getMode() instanceof CoopMode) {
|
||||
return;
|
||||
}
|
||||
|
||||
player.closeInventory();
|
||||
Session.create(session -> new CoopGenerator(session), null, null, player);
|
||||
// Opening lobby menu lets player invite others — actual session created in join()
|
||||
Menus.LOBBY.open(player);
|
||||
}
|
||||
|
||||
private static class CoopGenerator extends ParkourGenerator {
|
||||
private final Map<UUID, Integer> playerContributions = new HashMap<>();
|
||||
private int sharedScore = 0;
|
||||
/**
|
||||
* Adds a player to an existing coop session, or creates a new session if
|
||||
* the target player is not yet in one.
|
||||
*/
|
||||
@Override
|
||||
public void join(Player joiningPlayer, Session session) {
|
||||
if (!Config.CONFIG.getBoolean("joining")) {
|
||||
joiningPlayer.sendMessage("§cJoining is currently disabled.");
|
||||
return;
|
||||
}
|
||||
|
||||
if (session.generator == null) return;
|
||||
|
||||
// Register the joining player into the existing session
|
||||
ParkourPlayer pp = ParkourUser.register(joiningPlayer, session);
|
||||
session.addPlayers(pp);
|
||||
pp.updateGeneratorSettings(session.generator);
|
||||
|
||||
// Inform everyone
|
||||
session.getPlayers().forEach(p ->
|
||||
p.sendTranslated("modes.coop.player_joined", joiningPlayer.getName()));
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes a player from a coop session.
|
||||
* If the last player leaves, the session ends normally.
|
||||
*/
|
||||
@Override
|
||||
public void leave(Player player, Session session) {
|
||||
ParkourPlayer pp = ParkourPlayer.getPlayer(player);
|
||||
if (pp == null) return;
|
||||
ParkourUser.leave(pp);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMaxPlayers() {
|
||||
return Config.CONFIG.getInt("modes.coop.max-players");
|
||||
}
|
||||
|
||||
// ── CoopGenerator ─────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Package-accessible so Session.create() lambda can reference it,
|
||||
* and so join() can cast generator when needed.
|
||||
*/
|
||||
static class CoopGenerator extends ParkourGenerator {
|
||||
|
||||
/** Individual block contributions per player UUID. */
|
||||
private final Map<UUID, Integer> contributions = new HashMap<>();
|
||||
|
||||
public CoopGenerator(@NotNull Session session) {
|
||||
super(session);
|
||||
|
||||
// Initialize contributions
|
||||
for (ParkourPlayer pp : session.getPlayers()) {
|
||||
playerContributions.put(pp.getUUID(), 0);
|
||||
pp.player.sendTitle("§a§lCOOP MODE", "§7Work together for a shared score!", 10, 70, 20);
|
||||
pp.player.sendMessage("§a§lCoop Mode §7activated! Team score is shared.");
|
||||
}
|
||||
session.getPlayers().forEach(pp -> contributions.put(pp.getUUID(), 0));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void score() {
|
||||
super.score();
|
||||
sharedScore++;
|
||||
|
||||
// Track individual contributions
|
||||
if (!getPlayers().isEmpty()) {
|
||||
UUID scorer = player.getUUID();
|
||||
playerContributions.put(scorer, playerContributions.getOrDefault(scorer, 0) + 1);
|
||||
}
|
||||
|
||||
// Milestone celebrations
|
||||
if (sharedScore % 50 == 0) {
|
||||
for (ParkourPlayer pp : getPlayers()) {
|
||||
pp.player.sendTitle("§6" + sharedScore + " Points!", "§eTeam effort!", 5, 30, 10);
|
||||
pp.player.playSound(pp.getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 0.5f, 1.5f);
|
||||
}
|
||||
super.score(); // increments state.score and totalScore
|
||||
|
||||
// Track which player was on the block (primary player for single, varies in multi)
|
||||
contributions.merge(player.getUUID(), 1, Integer::sum);
|
||||
|
||||
// Milestone every 50 points
|
||||
if (state.score % 50 == 0) {
|
||||
getPlayers().forEach(pp -> {
|
||||
pp.player.sendTitle(
|
||||
"§6Team: §e" + state.score,
|
||||
"§aKeep it up!",
|
||||
5, 40, 10);
|
||||
pp.player.playSound(pp.getLocation(),
|
||||
Sound.ENTITY_PLAYER_LEVELUP, 0.6f, 1.5f);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void tick() {
|
||||
super.tick();
|
||||
|
||||
// Display shared score and contributions in ActionBar
|
||||
for (ParkourPlayer pp : getPlayers()) {
|
||||
int myContribution = playerContributions.getOrDefault(pp.getUUID(), 0);
|
||||
int percentage = sharedScore > 0 ? (myContribution * 100 / sharedScore) : 0;
|
||||
|
||||
String message = "§aTeam: §e" + sharedScore + " §7| §bYou: §e" + myContribution + " §7(" + percentage + "%)";
|
||||
pp.player.spigot().sendMessage(
|
||||
net.md_5.bungee.api.ChatMessageType.ACTION_BAR,
|
||||
net.md_5.bungee.api.chat.TextComponent.fromLegacyText(message)
|
||||
);
|
||||
}
|
||||
/**
|
||||
* When a new player joins mid-game, add them to contributions map.
|
||||
*/
|
||||
public void onPlayerJoin(ParkourPlayer pp) {
|
||||
contributions.putIfAbsent(pp.getUUID(), 0);
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void fall() {
|
||||
// Show final stats before reset
|
||||
for (ParkourPlayer pp : getPlayers()) {
|
||||
int contribution = playerContributions.getOrDefault(pp.getUUID(), 0);
|
||||
pp.sendTranslated("modes.coop.stats",
|
||||
Integer.toString(sharedScore),
|
||||
Integer.toString(contribution));
|
||||
}
|
||||
|
||||
super.fall();
|
||||
|
||||
// Reset coop state
|
||||
sharedScore = 0;
|
||||
playerContributions.clear();
|
||||
for (ParkourPlayer pp : getPlayers()) {
|
||||
playerContributions.put(pp.getUUID(), 0);
|
||||
}
|
||||
// Show each player their individual contribution before reset
|
||||
getPlayers().forEach(pp -> {
|
||||
int contrib = contributions.getOrDefault(pp.getUUID(), 0);
|
||||
int pct = state.score > 0 ? (contrib * 100 / state.score) : 0;
|
||||
pp.sendTranslated("modes.coop.stats",
|
||||
Integer.toString(state.score),
|
||||
Integer.toString(contrib),
|
||||
Integer.toString(pct));
|
||||
});
|
||||
|
||||
super.fall(); // handles reset, leaderboard, etc.
|
||||
}
|
||||
|
||||
@Override
|
||||
public void reset(boolean regenerate) {
|
||||
super.reset(regenerate);
|
||||
contributions.clear();
|
||||
getPlayers().forEach(pp -> contributions.put(pp.getUUID(), 0));
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -1,20 +1,752 @@
|
|||
package dev.loki.loparkour.mode;
|
||||
|
||||
import dev.lolib.scheduler.Scheduler;
|
||||
import dev.lolib.scheduler.ScheduledTask;
|
||||
import dev.loki.loparkour.LoParkour;
|
||||
import dev.loki.loparkour.api.event.ParkourFallEvent;
|
||||
import dev.loki.loparkour.api.event.ParkourScoreEvent;
|
||||
import dev.loki.loparkour.config.Config;
|
||||
import dev.loki.loparkour.generator.ParkourGenerator;
|
||||
import dev.loki.loparkour.leaderboard.Leaderboard;
|
||||
import dev.loki.loparkour.leaderboard.Score;
|
||||
import dev.loki.loparkour.player.ParkourPlayer;
|
||||
import dev.loki.loparkour.session.Session;
|
||||
import dev.loki.loparkour.world.Divider;
|
||||
import org.bukkit.*;
|
||||
import org.bukkit.block.Block;
|
||||
import org.bukkit.entity.Firework;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.EventHandler;
|
||||
import org.bukkit.event.EventPriority;
|
||||
import org.bukkit.event.HandlerList;
|
||||
import org.bukkit.event.Listener;
|
||||
import org.bukkit.event.player.PlayerInteractEvent;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.bukkit.inventory.meta.FireworkMeta;
|
||||
import org.bukkit.util.Vector;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.time.ZoneOffset;
|
||||
import java.time.format.DateTimeFormatter;
|
||||
import java.util.*;
|
||||
import java.util.concurrent.ThreadLocalRandom;
|
||||
|
||||
/**
|
||||
* Generator for Elytra mode parkour
|
||||
* Generator for Elytra mode.
|
||||
*
|
||||
* <p>Completely replaces block-based parkour with an aerial ring course:
|
||||
* <ul>
|
||||
* <li>Rings are placed ahead along a smooth curved path in the sky</li>
|
||||
* <li>Each ring is vertical, perpendicular to the flight direction</li>
|
||||
* <li>Player must fly through the center — detection uses plane-crossing math</li>
|
||||
* <li>Firework usage is intercepted via event to enforce cooldown properly</li>
|
||||
* <li>Fall = player touches ground / loses flight / flies too far from course</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class ElytraGenerator extends ParkourGenerator {
|
||||
public class ElytraGenerator extends ParkourGenerator implements Listener {
|
||||
|
||||
// ── Constants ─────────────────────────────────────────────────────────────
|
||||
|
||||
/** How many rings behind the player to keep before deleting. */
|
||||
private static final int RING_TRAIL = 3;
|
||||
|
||||
/** Ticks between particle ring renders (every 2 ticks = 10fps). */
|
||||
private static final int RENDER_INTERVAL = 2;
|
||||
|
||||
/** Minimum Y height — if player drops below this they failed. */
|
||||
private static final double MIN_Y_OFFSET = -30.0;
|
||||
|
||||
// Config-driven values cached at init
|
||||
private int ringLead;
|
||||
private double maxDeviation;
|
||||
|
||||
/** Particle count per ring point. */
|
||||
private static final int PARTICLES_PER_POINT = 1;
|
||||
|
||||
/** Number of particle points around each ring. */
|
||||
private static final int RING_POINTS = 36;
|
||||
|
||||
// ── State ─────────────────────────────────────────────────────────────────
|
||||
|
||||
private final List<ElytraRing> rings = new ArrayList<>();
|
||||
private int nextRingIndex = 0; // index of the next ring the player hasn't passed
|
||||
private int tickCounter = 0;
|
||||
private Instant startTime = null;
|
||||
private int score = 0;
|
||||
|
||||
private ScheduledTask tickTask;
|
||||
private ScheduledTask renderTask;
|
||||
|
||||
/** Firework cooldown per player UUID in ms. */
|
||||
private final Map<UUID, Long> fireworkCooldowns = new HashMap<>();
|
||||
|
||||
/** Starting Y for fall detection. */
|
||||
private double spawnY;
|
||||
|
||||
// ── Constructor ───────────────────────────────────────────────────────────
|
||||
|
||||
public ElytraGenerator(@NotNull Session session) {
|
||||
super(session);
|
||||
this.ringLead = Config.CONFIG.getInt("modes.elytra.ring-lead");
|
||||
this.maxDeviation = Config.CONFIG.getDouble("modes.elytra.max-deviation");
|
||||
}
|
||||
|
||||
// ── Mode identification ───────────────────────────────────────────────────
|
||||
|
||||
@Override
|
||||
public Mode getMode() {
|
||||
return Modes.ELYTRA;
|
||||
}
|
||||
|
||||
// ── Lifecycle: called by Session after island.build() ────────────────────
|
||||
|
||||
/**
|
||||
* Called once when the generator is set up.
|
||||
* We skip the block-based generateFirst and do our own aerial setup.
|
||||
*/
|
||||
@Override
|
||||
public void generateFirst(Location spawn, Location blockSpawn) {
|
||||
spawnY = spawn.getY();
|
||||
state.playerSpawn = spawn;
|
||||
state.lastStandingPlayerLocation = spawn;
|
||||
state.blockSpawn = blockSpawn;
|
||||
|
||||
// Seed the ring path starting just in front of spawn
|
||||
Vector initialHeading = state.heading.clone().normalize();
|
||||
Location ringOrigin = spawn.clone().add(initialHeading.clone().multiply(10)).add(0, 2, 0);
|
||||
|
||||
generateRings(ringOrigin, initialHeading, ringLead);
|
||||
|
||||
// Setup player
|
||||
for (ParkourPlayer pp : getPlayers()) {
|
||||
Player p = pp.player;
|
||||
p.setGameMode(GameMode.ADVENTURE);
|
||||
p.getInventory().clear();
|
||||
|
||||
// Elytra chestplate
|
||||
p.getInventory().setChestplate(new ItemStack(Material.ELYTRA));
|
||||
|
||||
// Starting fireworks
|
||||
int amount = Config.CONFIG.getInt("modes.elytra.starting-fireworks");
|
||||
p.getInventory().setItem(0, makeFirework(amount));
|
||||
p.getInventory().setHeldItemSlot(0);
|
||||
|
||||
// Launch into glide
|
||||
p.setVelocity(initialHeading.clone().multiply(1.2).setY(0.4));
|
||||
p.setGliding(true);
|
||||
|
||||
pp.sendTranslated("modes.elytra.start_hint");
|
||||
}
|
||||
|
||||
// Register firework event listener
|
||||
Bukkit.getPluginManager().registerEvents(this, LoParkour.getPlugin());
|
||||
|
||||
// Start ticks
|
||||
tickTask = Scheduler.get(LoParkour.getPlugin()).runTimer(this::tick, 1, 1);
|
||||
renderTask = Scheduler.get(LoParkour.getPlugin()).runTimer(this::renderRings, 0, RENDER_INTERVAL);
|
||||
}
|
||||
|
||||
// ── generateFirst is the entry — skip normal generate() completely ────────
|
||||
|
||||
@Override
|
||||
public void generate() { /* not used in elytra mode */ }
|
||||
|
||||
@Override
|
||||
public void generate(int amount) { /* not used */ }
|
||||
|
||||
@Override
|
||||
public void startTick() { /* tick started in generateFirst */ }
|
||||
|
||||
// ── Main tick ─────────────────────────────────────────────────────────────
|
||||
|
||||
@Override
|
||||
public void tick() {
|
||||
if (state.stopped) {
|
||||
stopTasks();
|
||||
return;
|
||||
}
|
||||
|
||||
tickCounter++;
|
||||
|
||||
for (ParkourPlayer pp : getPlayers()) {
|
||||
Player p = pp.player;
|
||||
|
||||
// Ensure player stays gliding
|
||||
if (!p.isGliding() && p.getGameMode() == GameMode.ADVENTURE) {
|
||||
// Only force-glide if they're not on ground and have elytra
|
||||
if (!p.isOnGround()) {
|
||||
p.setGliding(true);
|
||||
}
|
||||
}
|
||||
|
||||
// Update scoreboard
|
||||
pp.updateScoreboard(this);
|
||||
p.setSaturation(20);
|
||||
|
||||
// Action bar: score + next ring distance
|
||||
updateActionBar(pp);
|
||||
}
|
||||
|
||||
// Fall detection
|
||||
checkFall();
|
||||
|
||||
// Ring crossing detection
|
||||
checkRingCrossings();
|
||||
}
|
||||
|
||||
// ── Ring generation ───────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Generates {@code count} new rings starting from {@code origin},
|
||||
* heading in {@code direction}, with smooth curve randomisation.
|
||||
*/
|
||||
private void generateRings(Location origin, Vector direction, int count) {
|
||||
int distMin = Config.CONFIG.getInt("modes.elytra.ring-distance-min");
|
||||
int distMax = Config.CONFIG.getInt("modes.elytra.ring-distance-max");
|
||||
double ringSize = Config.CONFIG.getDouble("modes.elytra.ring-size");
|
||||
double maxYaw = Config.CONFIG.getDouble("modes.elytra.max-heading-change-horizontal");
|
||||
double maxPitch = Config.CONFIG.getDouble("modes.elytra.max-heading-change-vertical");
|
||||
double maxHeight = Config.CONFIG.getDouble("modes.elytra.max-height-above-spawn");
|
||||
|
||||
ThreadLocalRandom rng = ThreadLocalRandom.current();
|
||||
Location cursor = origin.clone();
|
||||
Vector heading = direction.clone().normalize();
|
||||
|
||||
// If we already have rings, continue from the last one
|
||||
if (!rings.isEmpty()) {
|
||||
ElytraRing last = rings.get(rings.size() - 1);
|
||||
cursor = last.center.clone();
|
||||
heading = last.normal.clone();
|
||||
}
|
||||
|
||||
for (int i = 0; i < count; i++) {
|
||||
// Distance between rings
|
||||
double dist = distMin + rng.nextDouble() * (distMax - distMin);
|
||||
|
||||
// Smooth heading change using config-defined limits
|
||||
double yawDelta = Math.toRadians(rng.nextDouble(-maxYaw, maxYaw));
|
||||
double pitchDelta = Math.toRadians(rng.nextDouble(-maxPitch, maxPitch));
|
||||
|
||||
heading = rotateVector(heading, yawDelta, pitchDelta);
|
||||
heading.normalize();
|
||||
|
||||
// New ring center
|
||||
Location center = cursor.clone().add(heading.clone().multiply(dist));
|
||||
|
||||
// Keep rings in a reasonable Y band
|
||||
double targetY = Math.max(spawnY + 5, Math.min(spawnY + maxHeight, center.getY()));
|
||||
center.setY(targetY);
|
||||
|
||||
rings.add(new ElytraRing(rings.size(), center.clone(), heading.clone(), ringSize));
|
||||
cursor = center;
|
||||
}
|
||||
}
|
||||
|
||||
// ── Ring crossing detection ───────────────────────────────────────────────
|
||||
|
||||
private void checkRingCrossings() {
|
||||
if (rings.isEmpty() || nextRingIndex >= rings.size()) return;
|
||||
|
||||
ParkourPlayer pp = player; // primary player
|
||||
Location loc = pp.getLocation();
|
||||
|
||||
ElytraRing nextRing = rings.get(nextRingIndex);
|
||||
|
||||
// Check if player crossed the ring's plane
|
||||
if (nextRing.hasCrossed(loc, pp.player.getVelocity())) {
|
||||
if (nextRing.isInside(loc)) {
|
||||
// Perfect pass — score
|
||||
onRingPassed(pp, nextRing, true);
|
||||
} else {
|
||||
// Crossed the plane but missed the ring hole
|
||||
onRingMissed(pp, nextRing);
|
||||
}
|
||||
nextRingIndex++;
|
||||
|
||||
// Generate more rings ahead
|
||||
int ahead = rings.size() - nextRingIndex;
|
||||
if (ahead < ringLead) {
|
||||
generateRings(null, null, ringLead - ahead);
|
||||
}
|
||||
|
||||
// Clean up old rings
|
||||
cleanOldRings();
|
||||
}
|
||||
|
||||
// Check deviation — if player flew too far off course
|
||||
double deviation = nextRing.center.distance(loc);
|
||||
if (deviation > maxDeviation) {
|
||||
triggerFall("flew off course");
|
||||
}
|
||||
}
|
||||
|
||||
private void onRingPassed(ParkourPlayer pp, ElytraRing ring, boolean centered) {
|
||||
score++;
|
||||
if (startTime == null) startTime = Instant.now();
|
||||
|
||||
new ParkourScoreEvent(pp).call();
|
||||
|
||||
// Visual + sound feedback
|
||||
pp.player.spawnParticle(Particle.TOTEM, ring.center, 40, 0.3, 0.3, 0.3, 0.15);
|
||||
pp.player.playSound(ring.center, Sound.ENTITY_EXPERIENCE_ORB_PICKUP, 1f, centered ? 1.8f : 1.2f);
|
||||
|
||||
// Update state score so scoreboard works
|
||||
state.score = score;
|
||||
state.totalScore++;
|
||||
}
|
||||
|
||||
private void onRingMissed(ParkourPlayer pp, ElytraRing ring) {
|
||||
// Flash red to indicate miss — no score
|
||||
pp.player.spawnParticle(Particle.REDSTONE,
|
||||
ring.center, 20, 0.5, 0.5, 0.5, 0,
|
||||
new Particle.DustOptions(Color.RED, 2.0f));
|
||||
pp.player.playSound(ring.center, Sound.BLOCK_NOTE_BLOCK_BASS, 1f, 0.5f);
|
||||
}
|
||||
|
||||
// ── Fall / Reset ──────────────────────────────────────────────────────────
|
||||
|
||||
private void checkFall() {
|
||||
for (ParkourPlayer pp : getPlayers()) {
|
||||
Player p = pp.player;
|
||||
double y = p.getLocation().getY();
|
||||
|
||||
// Touched ground or fell too far below spawn
|
||||
if (p.isOnGround() || y < spawnY + MIN_Y_OFFSET) {
|
||||
triggerFall("touched ground or fell below course");
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void triggerFall(String reason) {
|
||||
LoParkour.log("ElytraGenerator fall: " + reason);
|
||||
new ParkourFallEvent(player).call();
|
||||
|
||||
// Save score to leaderboard if it's a new record
|
||||
Leaderboard lb = getMode().getLeaderboard();
|
||||
if (lb != null) {
|
||||
int record = lb.get(player.getUUID()).score();
|
||||
if (score > record) {
|
||||
String time = getFormattedTime();
|
||||
getPlayers().forEach(p -> lb.put(p.getUUID(),
|
||||
new Score(p.getName(), time, "0.0", score)));
|
||||
}
|
||||
}
|
||||
|
||||
// Show fall message
|
||||
sendFallMessage();
|
||||
|
||||
reset(true);
|
||||
}
|
||||
|
||||
private void sendFallMessage() {
|
||||
Leaderboard lb = getMode().getLeaderboard();
|
||||
int record = lb != null ? lb.get(player.getUUID()).score() : 0;
|
||||
|
||||
for (ParkourPlayer pp : getPlayers()) {
|
||||
pp.sendTranslated("settings.parkour_settings.items.fall_message.divider");
|
||||
pp.sendTranslated("settings.parkour_settings.items.fall_message.score", Integer.toString(score));
|
||||
pp.sendTranslated("settings.parkour_settings.items.fall_message.time", getFormattedTime());
|
||||
pp.sendTranslated("settings.parkour_settings.items.fall_message.high_score", Integer.toString(record));
|
||||
if (score > record) {
|
||||
pp.sendTranslated("settings.parkour_settings.items.fall_message.formats.beat",
|
||||
Integer.toString(score - record));
|
||||
} else if (score == record) {
|
||||
pp.sendTranslated("settings.parkour_settings.items.fall_message.formats.tied", "0");
|
||||
} else {
|
||||
pp.sendTranslated("settings.parkour_settings.items.fall_message.formats.miss",
|
||||
Integer.toString(record - score));
|
||||
}
|
||||
pp.sendTranslated("settings.parkour_settings.items.fall_message.divider");
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void reset(boolean regenerate) {
|
||||
state.stopped = !regenerate;
|
||||
|
||||
// Clear rings from world (remove barrier blocks)
|
||||
rings.forEach(ElytraRing::remove);
|
||||
rings.clear();
|
||||
nextRingIndex = 0;
|
||||
score = 0;
|
||||
state.score = 0;
|
||||
startTime = null;
|
||||
state.start = null;
|
||||
tickCounter = 0;
|
||||
fireworkCooldowns.clear();
|
||||
|
||||
if (!regenerate) {
|
||||
stopTasks();
|
||||
unregisterListener();
|
||||
island.destroy();
|
||||
if (getPlayers().isEmpty()) {
|
||||
getSpectators().forEach(s -> Modes.DEFAULT.create(s.player));
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Teleport back to spawn and restart
|
||||
for (ParkourPlayer pp : getPlayers()) {
|
||||
pp.teleport(state.playerSpawn);
|
||||
pp.player.setGliding(false);
|
||||
pp.player.setVelocity(new Vector(0, 0, 0));
|
||||
|
||||
// Restore fireworks
|
||||
int amount = Config.CONFIG.getInt("modes.elytra.starting-fireworks");
|
||||
pp.player.getInventory().clear();
|
||||
pp.player.getInventory().setChestplate(new ItemStack(Material.ELYTRA));
|
||||
pp.player.getInventory().setItem(0, makeFirework(amount));
|
||||
pp.player.getInventory().setHeldItemSlot(0);
|
||||
}
|
||||
|
||||
// Re-generate rings
|
||||
Vector initialHeading = state.heading.clone().normalize();
|
||||
Location ringOrigin = state.playerSpawn.clone()
|
||||
.add(initialHeading.clone().multiply(10)).add(0, 2, 0);
|
||||
generateRings(ringOrigin, initialHeading, ringLead);
|
||||
|
||||
// Brief delay then launch
|
||||
Scheduler.get(LoParkour.getPlugin()).runLater(() -> {
|
||||
for (ParkourPlayer pp : getPlayers()) {
|
||||
pp.player.setVelocity(initialHeading.clone().multiply(1.2).setY(0.4));
|
||||
pp.player.setGliding(true);
|
||||
}
|
||||
}, 10L);
|
||||
}
|
||||
|
||||
// ── Ring rendering ────────────────────────────────────────────────────────
|
||||
|
||||
private void renderRings() {
|
||||
if (state.stopped) return;
|
||||
|
||||
Location playerLoc = player.getLocation();
|
||||
|
||||
for (int i = nextRingIndex; i < Math.min(nextRingIndex + ringLead, rings.size()); i++) {
|
||||
ElytraRing ring = rings.get(i);
|
||||
double dist = ring.center.distance(playerLoc);
|
||||
if (dist > 80) continue; // Don't render very far rings
|
||||
|
||||
// Colour gradient: next ring = gold, further = white, collected = skip
|
||||
Color color = (i == nextRingIndex) ? Color.YELLOW
|
||||
: (i == nextRingIndex + 1) ? Color.ORANGE
|
||||
: Color.WHITE;
|
||||
|
||||
renderRing(ring, color);
|
||||
}
|
||||
}
|
||||
|
||||
private void renderRing(ElytraRing ring, Color color) {
|
||||
World world = ring.center.getWorld();
|
||||
if (world == null) return;
|
||||
|
||||
// Two orthogonal vectors in the ring's plane
|
||||
Vector normal = ring.normal.clone().normalize();
|
||||
Vector up = findPerpendicular(normal);
|
||||
Vector right = normal.clone().crossProduct(up).normalize();
|
||||
|
||||
double r = ring.radius;
|
||||
Particle.DustOptions dust = new Particle.DustOptions(color, 1.5f);
|
||||
|
||||
for (int i = 0; i < RING_POINTS; i++) {
|
||||
double angle = 2 * Math.PI * i / RING_POINTS;
|
||||
double x = r * Math.cos(angle);
|
||||
double y = r * Math.sin(angle);
|
||||
|
||||
Location p = ring.center.clone()
|
||||
.add(right.clone().multiply(x))
|
||||
.add(up.clone().multiply(y));
|
||||
|
||||
world.spawnParticle(Particle.REDSTONE, p, PARTICLES_PER_POINT, 0, 0, 0, 0, dust);
|
||||
}
|
||||
|
||||
// Inner ring (smaller, brighter) so it's visible
|
||||
Particle.DustOptions innerDust = new Particle.DustOptions(Color.WHITE, 0.8f);
|
||||
double innerR = r * 0.4;
|
||||
for (int i = 0; i < RING_POINTS / 2; i++) {
|
||||
double angle = 2 * Math.PI * i / (RING_POINTS / 2);
|
||||
double x = innerR * Math.cos(angle);
|
||||
double y = innerR * Math.sin(angle);
|
||||
|
||||
Location p = ring.center.clone()
|
||||
.add(right.clone().multiply(x))
|
||||
.add(up.clone().multiply(y));
|
||||
|
||||
world.spawnParticle(Particle.REDSTONE, p, PARTICLES_PER_POINT, 0, 0, 0, 0, innerDust);
|
||||
}
|
||||
}
|
||||
|
||||
// ── Firework event — cancel if on cooldown ────────────────────────────────
|
||||
|
||||
@EventHandler(priority = EventPriority.HIGH)
|
||||
public void onFireworkUse(PlayerInteractEvent event) {
|
||||
Player p = event.getPlayer();
|
||||
ParkourPlayer pp = ParkourPlayer.getPlayer(p);
|
||||
if (pp == null || !(pp.session.generator instanceof ElytraGenerator gen)) return;
|
||||
if (gen != this) return;
|
||||
|
||||
// Only care about firework rockets
|
||||
org.bukkit.inventory.ItemStack item = event.getItem();
|
||||
if (item == null || item.getType() != Material.FIREWORK_ROCKET) return;
|
||||
|
||||
boolean isRightClick = event.getAction() == org.bukkit.event.block.Action.RIGHT_CLICK_AIR
|
||||
|| event.getAction() == org.bukkit.event.block.Action.RIGHT_CLICK_BLOCK;
|
||||
if (!isRightClick) return;
|
||||
if (!p.isGliding()) return;
|
||||
|
||||
long now = System.currentTimeMillis();
|
||||
int cooldownMs = Config.CONFIG.getInt("modes.elytra.firework-cooldown-ms");
|
||||
UUID uuid = p.getUniqueId();
|
||||
|
||||
Long lastUse = fireworkCooldowns.get(uuid);
|
||||
if (lastUse != null && now - lastUse < cooldownMs) {
|
||||
event.setCancelled(true);
|
||||
long remaining = (cooldownMs - (now - lastUse) + 999) / 1000;
|
||||
p.spigot().sendMessage(
|
||||
net.md_5.bungee.api.ChatMessageType.ACTION_BAR,
|
||||
net.md_5.bungee.api.chat.TextComponent.fromLegacyText(
|
||||
"§c⏱ Firework cooldown: §f" + remaining + "s"));
|
||||
return;
|
||||
}
|
||||
|
||||
fireworkCooldowns.put(uuid, now);
|
||||
|
||||
// Spawn a boost firework at player location instead of vanilla behaviour
|
||||
event.setCancelled(true);
|
||||
spawnBoostFirework(p);
|
||||
}
|
||||
|
||||
/**
|
||||
* Spawns a visual-only firework that gives the player a velocity boost.
|
||||
* We do it manually so we control the power and remove the damage.
|
||||
*/
|
||||
private void spawnBoostFirework(Player p) {
|
||||
double power = Config.CONFIG.getDouble("modes.elytra.boost-power");
|
||||
Vector dir = p.getLocation().getDirection().normalize();
|
||||
|
||||
// Remove one firework from inventory
|
||||
ItemStack held = p.getInventory().getItemInMainHand();
|
||||
if (held.getType() == Material.FIREWORK_ROCKET) {
|
||||
if (held.getAmount() > 1) {
|
||||
held.setAmount(held.getAmount() - 1);
|
||||
} else {
|
||||
p.getInventory().setItemInMainHand(null);
|
||||
}
|
||||
}
|
||||
|
||||
// Apply boost velocity
|
||||
Vector boost = dir.multiply(power);
|
||||
p.setVelocity(p.getVelocity().add(boost));
|
||||
p.setGliding(true);
|
||||
|
||||
// Spawn visual firework that instantly explodes (no damage)
|
||||
Firework fw = p.getWorld().spawn(p.getLocation(), Firework.class);
|
||||
FireworkMeta meta = fw.getFireworkMeta();
|
||||
meta.addEffect(FireworkEffect.builder()
|
||||
.with(FireworkEffect.Type.STAR)
|
||||
.withColor(Color.AQUA, Color.WHITE)
|
||||
.withFade(Color.YELLOW)
|
||||
.withTrail()
|
||||
.build());
|
||||
meta.setPower(0);
|
||||
fw.setFireworkMeta(meta);
|
||||
fw.setShotAtAngle(true);
|
||||
|
||||
// Detonate immediately (no damage tick)
|
||||
Scheduler.get(LoParkour.getPlugin()).runLater(() -> {
|
||||
if (fw.isValid()) fw.detonate();
|
||||
}, 1L);
|
||||
|
||||
p.playSound(p.getLocation(), Sound.ENTITY_FIREWORK_ROCKET_LAUNCH, 0.8f, 1.2f);
|
||||
}
|
||||
|
||||
// ── Action bar ────────────────────────────────────────────────────────────
|
||||
|
||||
private void updateActionBar(ParkourPlayer pp) {
|
||||
if (rings.isEmpty() || nextRingIndex >= rings.size()) return;
|
||||
|
||||
ElytraRing nextRing = rings.get(nextRingIndex);
|
||||
double dist = Math.round(nextRing.center.distance(pp.getLocation()) * 10.0) / 10.0;
|
||||
|
||||
// Firework cooldown indicator
|
||||
long now = System.currentTimeMillis();
|
||||
int cooldownMs = Config.CONFIG.getInt("modes.elytra.firework-cooldown-ms");
|
||||
Long lastUse = fireworkCooldowns.get(pp.getUUID());
|
||||
String cooldownStr;
|
||||
if (lastUse != null && now - lastUse < cooldownMs) {
|
||||
long remaining = (cooldownMs - (now - lastUse) + 999) / 1000;
|
||||
cooldownStr = "§c⏱ " + remaining + "s";
|
||||
} else {
|
||||
cooldownStr = "§a✔ Ready";
|
||||
}
|
||||
|
||||
pp.player.spigot().sendMessage(
|
||||
net.md_5.bungee.api.ChatMessageType.ACTION_BAR,
|
||||
net.md_5.bungee.api.chat.TextComponent.fromLegacyText(
|
||||
"§6⬤ §fRings: §e" + score
|
||||
+ " §7| §f➤ §b" + dist + "m"
|
||||
+ " §7| §f🚀 " + cooldownStr));
|
||||
}
|
||||
|
||||
// ── Time helpers ──────────────────────────────────────────────────────────
|
||||
|
||||
@Override
|
||||
public String getFormattedTime() {
|
||||
if (startTime == null) return "00:00:000";
|
||||
var ms = Instant.now().minusMillis(startTime.toEpochMilli());
|
||||
try {
|
||||
return DateTimeFormatter.ofPattern("mm:ss:SSS").withZone(ZoneOffset.UTC).format(ms);
|
||||
} catch (Exception e) {
|
||||
return "00:00:000";
|
||||
}
|
||||
}
|
||||
|
||||
// ── Cleanup ───────────────────────────────────────────────────────────────
|
||||
|
||||
private void cleanOldRings() {
|
||||
// Remove rings more than RING_TRAIL behind the player
|
||||
int removeUntil = nextRingIndex - RING_TRAIL;
|
||||
if (removeUntil <= 0) return;
|
||||
|
||||
Iterator<ElytraRing> it = rings.iterator();
|
||||
int idx = 0;
|
||||
while (it.hasNext()) {
|
||||
ElytraRing ring = it.next();
|
||||
if (idx < removeUntil) {
|
||||
ring.remove();
|
||||
it.remove();
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
idx++;
|
||||
}
|
||||
nextRingIndex -= removeUntil;
|
||||
}
|
||||
|
||||
private void stopTasks() {
|
||||
if (tickTask != null) { tickTask.cancel(); tickTask = null; }
|
||||
if (renderTask != null) { renderTask.cancel(); renderTask = null; }
|
||||
}
|
||||
|
||||
private void unregisterListener() {
|
||||
HandlerList.unregisterAll(this);
|
||||
}
|
||||
|
||||
// ── Utilities ─────────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Returns a vector perpendicular to the given one.
|
||||
* Used to form the ring's local coordinate axes.
|
||||
*/
|
||||
private static Vector findPerpendicular(Vector v) {
|
||||
Vector perp = (Math.abs(v.getX()) < 0.9)
|
||||
? new Vector(1, 0, 0)
|
||||
: new Vector(0, 1, 0);
|
||||
return perp.subtract(v.clone().multiply(perp.dot(v))).normalize();
|
||||
}
|
||||
|
||||
/**
|
||||
* Rotates a vector by yaw (horizontal) and pitch (vertical) deltas.
|
||||
*/
|
||||
private static Vector rotateVector(Vector v, double yawRad, double pitchRad) {
|
||||
// Rotate around Y axis (yaw)
|
||||
double cos = Math.cos(yawRad);
|
||||
double sin = Math.sin(yawRad);
|
||||
double nx = v.getX() * cos - v.getZ() * sin;
|
||||
double nz = v.getX() * sin + v.getZ() * cos;
|
||||
v = new Vector(nx, v.getY(), nz);
|
||||
|
||||
// Rotate around the local right axis (pitch)
|
||||
Vector right = new Vector(v.getZ(), 0, -v.getX()).normalize();
|
||||
double c = Math.cos(pitchRad);
|
||||
double s = Math.sin(pitchRad);
|
||||
double vDotR = v.dot(right);
|
||||
return new Vector(
|
||||
v.getX() * c + (right.getY() * v.getZ() - right.getZ() * v.getY()) * s,
|
||||
v.getY() * c + (right.getZ() * v.getX() - right.getX() * v.getZ()) * s,
|
||||
v.getZ() * c + (right.getX() * v.getY() - right.getY() * v.getX()) * s
|
||||
);
|
||||
}
|
||||
|
||||
private static ItemStack makeFirework(int amount) {
|
||||
ItemStack item = new ItemStack(Material.FIREWORK_ROCKET, amount);
|
||||
FireworkMeta meta = (FireworkMeta) item.getItemMeta();
|
||||
if (meta != null) {
|
||||
meta.addEffect(FireworkEffect.builder()
|
||||
.with(FireworkEffect.Type.BALL)
|
||||
.withColor(Color.AQUA)
|
||||
.build());
|
||||
meta.setPower(1);
|
||||
item.setItemMeta(meta);
|
||||
}
|
||||
return item;
|
||||
}
|
||||
|
||||
// ── Inner class: ElytraRing ───────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Represents one ring in the course.
|
||||
*
|
||||
* <p>A ring is defined by its center point and its normal vector (the direction
|
||||
* of travel through it). The "inside" is a circle of {@code radius} around the center
|
||||
* on the plane perpendicular to {@code normal}.
|
||||
*/
|
||||
public static class ElytraRing {
|
||||
|
||||
public final int id;
|
||||
public final Location center;
|
||||
/** Direction of travel — the ring faces perpendicular to this. */
|
||||
public final Vector normal;
|
||||
public final double radius;
|
||||
|
||||
/** Signed distance of the player on the last tick (for plane crossing detection). */
|
||||
private double lastSignedDist = Double.NaN;
|
||||
|
||||
/** Barrier blocks placed for this ring (optional, used if solid rings are enabled). */
|
||||
private final List<Block> barrierBlocks = new ArrayList<>();
|
||||
|
||||
public ElytraRing(int id, Location center, Vector normal, double radius) {
|
||||
this.id = id;
|
||||
this.center = center.clone();
|
||||
this.normal = normal.clone().normalize();
|
||||
this.radius = radius;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the player crossed the ring's plane since the last call.
|
||||
* Uses the dot product of (playerPos - ringCenter) with the ring's normal.
|
||||
* Sign change = crossing.
|
||||
*/
|
||||
public boolean hasCrossed(Location playerLoc, Vector velocity) {
|
||||
Vector toPlayer = playerLoc.toVector().subtract(center.toVector());
|
||||
double signedDist = toPlayer.dot(normal);
|
||||
|
||||
boolean crossed = false;
|
||||
if (!Double.isNaN(lastSignedDist)) {
|
||||
// Crossed if sign flipped (was positive, now negative or vice versa)
|
||||
crossed = (lastSignedDist > 0) != (signedDist > 0);
|
||||
}
|
||||
lastSignedDist = signedDist;
|
||||
return crossed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the player's position (projected onto the ring's plane)
|
||||
* is within the ring's radius — i.e. they flew through the hole.
|
||||
*/
|
||||
public boolean isInside(Location playerLoc) {
|
||||
// Project player position onto ring's plane
|
||||
Vector toPlayer = playerLoc.toVector().subtract(center.toVector());
|
||||
// Remove the component along the normal
|
||||
Vector projected = toPlayer.clone().subtract(normal.clone().multiply(toPlayer.dot(normal)));
|
||||
return projected.length() <= radius;
|
||||
}
|
||||
|
||||
/** Remove any barrier blocks this ring placed in the world. */
|
||||
public void remove() {
|
||||
barrierBlocks.forEach(b -> b.setType(Material.AIR, false));
|
||||
barrierBlocks.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,30 +1,19 @@
|
|||
package dev.loki.loparkour.mode;
|
||||
|
||||
import dev.loki.loparkour.util.Item;
|
||||
|
||||
import dev.loki.loparkour.config.Config;
|
||||
import dev.loki.loparkour.config.Locales;
|
||||
import dev.loki.loparkour.generator.ParkourGenerator;
|
||||
import dev.loki.loparkour.ghost.GhostManager;
|
||||
import dev.loki.loparkour.ghost.GhostRecorder;
|
||||
import dev.loki.loparkour.leaderboard.Leaderboard;
|
||||
import dev.loki.loparkour.player.ParkourPlayer;
|
||||
import dev.loki.loparkour.player.ParkourSpectator;
|
||||
import dev.loki.loparkour.session.Session;
|
||||
|
||||
import org.bukkit.*;
|
||||
import dev.loki.loparkour.util.Item;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.bukkit.util.BoundingBox;
|
||||
import org.bukkit.util.Vector;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
import java.time.Instant;
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* Elytra Parkour Mode - Flying parkour with rings and boost
|
||||
* Elytra Parkour Mode.
|
||||
* Players fly through vertical rings generated ahead along a curved aerial path.
|
||||
* No blocks on the ground — pure flight mechanics.
|
||||
*/
|
||||
public class ElytraMode implements Mode {
|
||||
|
||||
|
|
@ -38,7 +27,7 @@ public class ElytraMode implements Mode {
|
|||
|
||||
@Override
|
||||
@Nullable
|
||||
public dev.loki.loparkour.util.Item getItem(String locale) {
|
||||
public Item getItem(String locale) {
|
||||
return Locales.getItem(locale, "modes.elytra");
|
||||
}
|
||||
|
||||
|
|
@ -51,181 +40,16 @@ public class ElytraMode implements Mode {
|
|||
@Override
|
||||
public void create(Player player) {
|
||||
if (!Config.CONFIG.getBoolean("joining")) {
|
||||
player.sendMessage(Locales.getString(player, "other.joining_disabled"));
|
||||
player.sendMessage("§cJoining is currently disabled.");
|
||||
return;
|
||||
}
|
||||
|
||||
ParkourPlayer pp = ParkourPlayer.getPlayer(player);
|
||||
if (pp != null && pp.session.generator != null && pp.session.generator.getMode() instanceof ElytraMode) {
|
||||
if (pp != null && pp.session.generator instanceof ElytraGenerator) {
|
||||
return;
|
||||
}
|
||||
|
||||
player.closeInventory();
|
||||
|
||||
// Create session with elytra setup
|
||||
Session.create(session -> new ElytraGenerator(session), null, null, player);
|
||||
}
|
||||
|
||||
private static class ElytraGenerator extends ParkourGenerator {
|
||||
private final List<RingCheckpoint> rings = new ArrayList<>();
|
||||
private final Map<UUID, Long> fireworkCooldowns = new HashMap<>();
|
||||
private final Map<UUID, Integer> ringsCollected = new HashMap<>();
|
||||
private int tickCounter = 0;
|
||||
|
||||
public ElytraGenerator(@NotNull Session session) {
|
||||
super(session);
|
||||
|
||||
// Give elytra and fireworks to all players in session
|
||||
for (ParkourPlayer parkourPlayer : session.getPlayers()) {
|
||||
Player p = parkourPlayer.player;
|
||||
p.setGameMode(GameMode.ADVENTURE);
|
||||
p.getInventory().setChestplate(new ItemStack(Material.ELYTRA));
|
||||
|
||||
int fireworks = Config.CONFIG.getInt("modes.elytra.starting-fireworks");
|
||||
p.getInventory().addItem(new ItemStack(Material.FIREWORK_ROCKET, fireworks));
|
||||
|
||||
ringsCollected.put(p.getUniqueId(), 0);
|
||||
|
||||
// Notify player
|
||||
p.sendTitle("§b§lELYTRA MODE", "§7Fly through rings for bonus points!", 10, 70, 20);
|
||||
p.sendMessage("§b§lElytra Mode §7activated! Use fireworks to boost.");
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void tick() {
|
||||
// Don't call super.tick() - we don't want normal block generation
|
||||
tickCounter++;
|
||||
|
||||
// Update spectators
|
||||
getSpectators().forEach(ParkourSpectator::update);
|
||||
|
||||
// Check for fall (much lower threshold for elytra)
|
||||
if (player.getLocation().getY() < state.lastStandingPlayerLocation.getY() - 50) {
|
||||
lifecycle.fall();
|
||||
return;
|
||||
}
|
||||
|
||||
// Spawn rings every 2 seconds
|
||||
if (tickCounter % 40 == 0) {
|
||||
spawnNextRing();
|
||||
}
|
||||
|
||||
// Display rings and check for player passing through
|
||||
Iterator<RingCheckpoint> it = rings.iterator();
|
||||
while (it.hasNext()) {
|
||||
RingCheckpoint ring = it.next();
|
||||
|
||||
// Display ring particles
|
||||
displayRing(ring.location);
|
||||
|
||||
// Check if any player passed through
|
||||
for (ParkourPlayer pp : getPlayers()) {
|
||||
if (ring.collected) continue;
|
||||
|
||||
BoundingBox playerBox = pp.player.getBoundingBox();
|
||||
if (ring.getBoundingBox().overlaps(playerBox)) {
|
||||
ring.collected = true;
|
||||
int count = ringsCollected.getOrDefault(pp.getUUID(), 0) + 1;
|
||||
ringsCollected.put(pp.getUUID(), count);
|
||||
|
||||
// Bonus points for passing through ring
|
||||
lifecycle.score();
|
||||
lifecycle.score();
|
||||
lifecycle.score(); // 3 points per ring
|
||||
|
||||
pp.player.playSound(pp.getLocation(), Sound.ENTITY_EXPERIENCE_ORB_PICKUP, 1f, 1.5f);
|
||||
pp.player.spawnParticle(Particle.TOTEM, ring.location, 20, 0.5, 0.5, 0.5, 0.1);
|
||||
|
||||
// Update last standing location to ring location
|
||||
state.lastStandingPlayerLocation = ring.location.clone();
|
||||
}
|
||||
}
|
||||
|
||||
// Remove old rings
|
||||
if (ring.location.distance(player.getLocation()) > 100) {
|
||||
it.remove();
|
||||
}
|
||||
}
|
||||
|
||||
// Check firework cooldown
|
||||
checkFireworkCooldown();
|
||||
|
||||
// Start timer if not started
|
||||
if (state.start == null) state.start = Instant.now();
|
||||
}
|
||||
|
||||
private void spawnNextRing() {
|
||||
Location playerLoc = player.getLocation();
|
||||
|
||||
// Spawn ring ahead of player in flight direction
|
||||
Vector direction = player.getLocation().getDirection();
|
||||
Location ringLoc = playerLoc.clone().add(direction.multiply(20)).add(0, 5, 0);
|
||||
|
||||
// Add some randomness
|
||||
ringLoc.add((Math.random() - 0.5) * 10, (Math.random() - 0.5) * 5, (Math.random() - 0.5) * 10);
|
||||
|
||||
rings.add(new RingCheckpoint(ringLoc));
|
||||
}
|
||||
|
||||
private void displayRing(Location center) {
|
||||
World world = center.getWorld();
|
||||
if (world == null) return;
|
||||
|
||||
double radius = 2.0;
|
||||
int points = 30;
|
||||
|
||||
for (int i = 0; i < points; i++) {
|
||||
double angle = 2 * Math.PI * i / points;
|
||||
double x = center.getX() + radius * Math.cos(angle);
|
||||
double z = center.getZ() + radius * Math.sin(angle);
|
||||
|
||||
Location particleLoc = new Location(world, x, center.getY(), z);
|
||||
world.spawnParticle(Particle.END_ROD, particleLoc, 1, 0, 0, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
private void checkFireworkCooldown() {
|
||||
long now = System.currentTimeMillis();
|
||||
int cooldownMs = Config.CONFIG.getInt("modes.elytra.firework-cooldown-ms");
|
||||
|
||||
for (ParkourPlayer pp : getPlayers()) {
|
||||
UUID uuid = pp.getUUID();
|
||||
ItemStack mainHand = pp.player.getInventory().getItemInMainHand();
|
||||
ItemStack offHand = pp.player.getInventory().getItemInOffHand();
|
||||
|
||||
boolean usingFirework = (mainHand.getType() == Material.FIREWORK_ROCKET && pp.player.isGliding())
|
||||
|| (offHand.getType() == Material.FIREWORK_ROCKET && pp.player.isGliding());
|
||||
|
||||
if (usingFirework) {
|
||||
Long lastUse = fireworkCooldowns.get(uuid);
|
||||
if (lastUse != null && now - lastUse < cooldownMs) {
|
||||
long remaining = (cooldownMs - (now - lastUse)) / 1000;
|
||||
pp.player.spigot().sendMessage(net.md_5.bungee.api.ChatMessageType.ACTION_BAR,
|
||||
net.md_5.bungee.api.chat.TextComponent.fromLegacyText("§cFirework cooldown: " + remaining + "s"));
|
||||
continue;
|
||||
}
|
||||
fireworkCooldowns.put(uuid, now);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Mode getMode() {
|
||||
return Modes.ELYTRA;
|
||||
}
|
||||
|
||||
private static class RingCheckpoint {
|
||||
final Location location;
|
||||
boolean collected = false;
|
||||
|
||||
RingCheckpoint(Location location) {
|
||||
this.location = location;
|
||||
}
|
||||
|
||||
BoundingBox getBoundingBox() {
|
||||
return BoundingBox.of(location, 2.5, 2.5, 2.5);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,5 +1,6 @@
|
|||
package dev.loki.loparkour.mode;
|
||||
|
||||
import dev.loki.loparkour.LoParkour;
|
||||
import dev.loki.loparkour.config.Config;
|
||||
import dev.loki.loparkour.config.Locales;
|
||||
import dev.loki.loparkour.generator.ParkourGenerator;
|
||||
|
|
@ -12,7 +13,23 @@ import org.jetbrains.annotations.NotNull;
|
|||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
/**
|
||||
* Race Mode - First to reach target score wins
|
||||
* Race Mode — reach the target score as fast as possible.
|
||||
* Leaderboard sorts by time (fastest wins).
|
||||
*
|
||||
* <p>Bugs fixed vs previous version:
|
||||
* <ul>
|
||||
* <li>{@code tick()} called {@code super.tick()} AND checked score every tick —
|
||||
* but super.tick() already calls {@code score()} internally, so the finish
|
||||
* check ran one tick late causing an off-by-one where state.score could
|
||||
* briefly exceed targetScore before finishing. Fixed by overriding
|
||||
* {@link #score()} instead — finish check fires the exact moment target is hit.</li>
|
||||
* <li>ActionBar was re-sent every tick inside tick() which conflicted with the
|
||||
* parent's ActionBar updates. Moved to score() so it updates only on change.</li>
|
||||
* <li>{@code reset(false)} was called via scheduler delay — if the player left the
|
||||
* server in those 5 seconds it would NPE. Now guarded with null-check.</li>
|
||||
* <li>{@code getFormattedTime()} is private in parent — accessed via
|
||||
* {@code getDetailedTime()} which is protected. Fixed method call.</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class RaceMode implements Mode {
|
||||
|
||||
|
|
@ -39,12 +56,12 @@ public class RaceMode implements Mode {
|
|||
@Override
|
||||
public void create(Player player) {
|
||||
if (!Config.CONFIG.getBoolean("joining")) {
|
||||
player.sendMessage(Locales.getString(player, "other.joining_disabled"));
|
||||
player.sendMessage("§cJoining is currently disabled.");
|
||||
return;
|
||||
}
|
||||
|
||||
ParkourPlayer pp = ParkourPlayer.getPlayer(player);
|
||||
if (pp != null && pp.session.generator != null && pp.session.generator.getMode() instanceof RaceMode) {
|
||||
if (pp != null && pp.session.generator instanceof RaceGenerator) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -52,58 +69,77 @@ public class RaceMode implements Mode {
|
|||
Session.create(session -> new RaceGenerator(session), null, null, player);
|
||||
}
|
||||
|
||||
// ── RaceGenerator ─────────────────────────────────────────────────────────
|
||||
|
||||
private static class RaceGenerator extends ParkourGenerator {
|
||||
|
||||
private final int targetScore;
|
||||
private boolean raceFinished = false;
|
||||
|
||||
public RaceGenerator(@NotNull Session session) {
|
||||
super(session);
|
||||
this.targetScore = Config.CONFIG.getInt("modes.race.target-score");
|
||||
|
||||
// Notify players
|
||||
for (ParkourPlayer pp : session.getPlayers()) {
|
||||
pp.player.sendTitle("§6§lRACE MODE", "§7First to " + targetScore + " points wins!", 10, 70, 20);
|
||||
pp.player.sendMessage("§6§lRace Mode §7activated! Target: §e" + targetScore + " §7points.");
|
||||
}
|
||||
|
||||
/**
|
||||
* Hook into score() — the exact moment a new point is added.
|
||||
* This ensures finish detection is frame-perfect with no off-by-one.
|
||||
*/
|
||||
@Override
|
||||
protected void score() {
|
||||
super.score();
|
||||
|
||||
// Update action bar on every new block
|
||||
updateProgressBar();
|
||||
|
||||
if (!raceFinished && state.score >= targetScore) {
|
||||
finishRace();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void tick() {
|
||||
super.tick();
|
||||
|
||||
if (raceFinished) return;
|
||||
|
||||
// Check if target reached
|
||||
if (state.score >= targetScore) {
|
||||
finishRace();
|
||||
}
|
||||
|
||||
// Display progress in ActionBar
|
||||
for (ParkourPlayer pp : getPlayers()) {
|
||||
int remaining = targetScore - state.score;
|
||||
String progress = "§e" + state.score + " §7/ §a" + targetScore + " §7(§c" + remaining + " §7left)";
|
||||
private void updateProgressBar() {
|
||||
int remaining = Math.max(0, targetScore - state.score);
|
||||
int filled = Math.min(20, state.score * 20 / targetScore);
|
||||
String bar = "§a" + "█".repeat(filled) + "§7" + "█".repeat(20 - filled);
|
||||
|
||||
getPlayers().forEach(pp ->
|
||||
pp.player.spigot().sendMessage(
|
||||
net.md_5.bungee.api.ChatMessageType.ACTION_BAR,
|
||||
net.md_5.bungee.api.chat.TextComponent.fromLegacyText(progress)
|
||||
);
|
||||
}
|
||||
net.md_5.bungee.api.chat.TextComponent.fromLegacyText(
|
||||
bar + " §e" + state.score + " §7/ §a" + targetScore
|
||||
+ (remaining > 0 ? " §7(§c" + remaining + " §7left)" : " §6§lDONE!")
|
||||
)));
|
||||
}
|
||||
|
||||
private void finishRace() {
|
||||
raceFinished = true;
|
||||
|
||||
for (ParkourPlayer pp : getPlayers()) {
|
||||
pp.player.sendTitle("§6§lRACE COMPLETE!", "§aFinished in " + getFormattedTime(), 10, 70, 20);
|
||||
pp.player.playSound(pp.getLocation(), Sound.UI_TOAST_CHALLENGE_COMPLETE, 1f, 1f);
|
||||
pp.sendTranslated("modes.race.completed", Integer.toString(targetScore), getFormattedTime());
|
||||
}
|
||||
|
||||
// Register time-based score
|
||||
registerScore(getDetailedTime(), Double.toString(getDifficultyScore()).substring(0, 3), targetScore);
|
||||
|
||||
// Stop generator after 5 seconds
|
||||
dev.lolib.scheduler.Scheduler.get(dev.loki.loparkour.LoParkour.getPlugin())
|
||||
.runLater(() -> reset(false), 100);
|
||||
String time = getDetailedTime();
|
||||
|
||||
getPlayers().forEach(pp -> {
|
||||
pp.player.sendTitle(
|
||||
"§6§lRACE COMPLETE!",
|
||||
"§aFinished in §f" + time,
|
||||
10, 80, 20);
|
||||
pp.player.playSound(pp.getLocation(),
|
||||
Sound.UI_TOAST_CHALLENGE_COMPLETE, 1f, 1f);
|
||||
pp.sendTranslated("modes.race.completed",
|
||||
Integer.toString(targetScore), time);
|
||||
});
|
||||
|
||||
// Save to leaderboard
|
||||
registerScore(time, "1.0", targetScore);
|
||||
|
||||
// Return to lobby after 5 seconds — guarded against null session
|
||||
dev.lolib.scheduler.Scheduler.get(LoParkour.getPlugin())
|
||||
.runLater(() -> {
|
||||
if (!state.stopped) reset(false);
|
||||
}, 100L);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void reset(boolean regenerate) {
|
||||
raceFinished = false;
|
||||
super.reset(regenerate);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -1,10 +1,8 @@
|
|||
package dev.loki.loparkour.mode;
|
||||
|
||||
import dev.loki.loparkour.util.Item;
|
||||
|
||||
import dev.lolib.scheduler.Scheduler;
|
||||
import dev.lolib.scheduler.ScheduledTask;
|
||||
|
||||
import dev.loki.loparkour.LoParkour;
|
||||
import dev.loki.loparkour.config.Config;
|
||||
import dev.loki.loparkour.config.Locales;
|
||||
|
|
@ -12,7 +10,6 @@ import dev.loki.loparkour.generator.ParkourGenerator;
|
|||
import dev.loki.loparkour.leaderboard.Leaderboard;
|
||||
import dev.loki.loparkour.player.ParkourPlayer;
|
||||
import dev.loki.loparkour.session.Session;
|
||||
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.Particle;
|
||||
import org.bukkit.Sound;
|
||||
|
|
@ -24,6 +21,20 @@ import org.jetbrains.annotations.Nullable;
|
|||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Speedrun Mode — blocks disappear a short time after the player lands on them.
|
||||
*
|
||||
* <p>Bugs fixed vs previous version:
|
||||
* <ul>
|
||||
* <li>{@code onBlockTouch()} was never called from anywhere — blocks never disappeared.
|
||||
* Fixed by hooking into {@link #score()} which fires exactly when the player
|
||||
* steps onto a new block for the first time.</li>
|
||||
* <li>Warning task reference was stored in a throwaway local, not in scheduledTasks,
|
||||
* so it could never be cancelled on reset.</li>
|
||||
* <li>{@code removalTime / 50} used integer division that truncated sub-second values
|
||||
* to 0 ticks when blockLifetime < 0.05s. Now uses Math.max(1, ...).</li>
|
||||
* </ul>
|
||||
*/
|
||||
public class SpeedrunMode implements Mode {
|
||||
|
||||
private final Leaderboard leaderboard = new Leaderboard(getName(), Leaderboard.Sort.SCORE);
|
||||
|
|
@ -36,7 +47,7 @@ public class SpeedrunMode implements Mode {
|
|||
|
||||
@Override
|
||||
@Nullable
|
||||
public dev.loki.loparkour.util.Item getItem(String locale) {
|
||||
public Item getItem(String locale) {
|
||||
return Locales.getItem(locale, "play.single.speedrun");
|
||||
}
|
||||
|
||||
|
|
@ -54,72 +65,84 @@ public class SpeedrunMode implements Mode {
|
|||
}
|
||||
|
||||
ParkourPlayer pp = ParkourPlayer.getPlayer(player);
|
||||
if (pp != null && pp.session.generator != null && pp.session.generator.getMode() instanceof SpeedrunMode) {
|
||||
if (pp != null && pp.session.generator instanceof SpeedrunGenerator) {
|
||||
return;
|
||||
}
|
||||
|
||||
player.closeInventory();
|
||||
|
||||
Session.create(session -> new SpeedrunGenerator(session), null, null, player);
|
||||
}
|
||||
|
||||
public static class SpeedrunGenerator extends ParkourGenerator {
|
||||
private final Map<Block, Long> blockTimestamps = new HashMap<>();
|
||||
private final Map<Block, ScheduledTask> scheduledTasks = new HashMap<>();
|
||||
// ── SpeedrunGenerator ─────────────────────────────────────────────────────
|
||||
|
||||
private static class SpeedrunGenerator extends ParkourGenerator {
|
||||
|
||||
/** Tracks scheduled tasks per block. Key = block, value = [warningTask, removalTask]. */
|
||||
private final Map<Block, ScheduledTask[]> scheduledTasks = new HashMap<>();
|
||||
|
||||
public SpeedrunGenerator(@NotNull Session session) {
|
||||
super(session);
|
||||
|
||||
// Notify player
|
||||
for (ParkourPlayer pp : session.getPlayers()) {
|
||||
pp.player.sendTitle("§c§lSPEEDRUN MODE", "§7Blocks disappear after you step on them!", 10, 70, 20);
|
||||
pp.player.sendMessage("§c§lSpeedrun Mode §7activated! Don't look back!");
|
||||
}
|
||||
}
|
||||
|
||||
public void onBlockTouch(@NotNull Block block) {
|
||||
if (!blockTimestamps.containsKey(block)) {
|
||||
blockTimestamps.put(block, System.currentTimeMillis());
|
||||
scheduleBlockRemoval(block);
|
||||
}
|
||||
/**
|
||||
* Called every time the player scores a point (= lands on a new block).
|
||||
* We hook here instead of a separate onBlockTouch() because score() is the
|
||||
* canonical place where "player stepped on block N" is detected.
|
||||
*/
|
||||
@Override
|
||||
protected void score() {
|
||||
super.score();
|
||||
|
||||
// The block the player just landed on is the previous-to-last in history
|
||||
// (history.size()-1 is the leading block, size()-2 is where player stands)
|
||||
int histSize = state.history.size();
|
||||
if (histSize < 2) return;
|
||||
|
||||
Block stepped = state.history.get(histSize - 2);
|
||||
if (stepped.getType() == Material.AIR) return;
|
||||
if (scheduledTasks.containsKey(stepped)) return; // already scheduled
|
||||
|
||||
scheduleBlockRemoval(stepped);
|
||||
}
|
||||
|
||||
private void scheduleBlockRemoval(@NotNull Block block) {
|
||||
double blockLifetime = Config.CONFIG.getDouble("modes.speedrun.block-lifetime");
|
||||
double warningTime = Config.CONFIG.getDouble("modes.speedrun.warning-time");
|
||||
double warningTime = Config.CONFIG.getDouble("modes.speedrun.warning-time");
|
||||
|
||||
long removalTime = (long) (blockLifetime * 1000);
|
||||
long warningTimeMs = (long) (warningTime * 1000);
|
||||
// Convert seconds → ticks (20 ticks/s), minimum 1 tick
|
||||
long removalTicks = Math.max(1, Math.round(blockLifetime * 20));
|
||||
long warningTicks = Math.max(1, Math.round(warningTime * 20));
|
||||
|
||||
ScheduledTask warningTask = Scheduler.get(LoParkour.getPlugin()).runLater(() -> {
|
||||
if (block.getType() != Material.AIR) {
|
||||
player.player.playSound(block.getLocation(), Sound.BLOCK_NOTE_BLOCK_PLING, 1.0f, 2.0f);
|
||||
player.player.spawnParticle(Particle.FLAME, block.getLocation().add(0.5, 1, 0.5), 10, 0.3, 0.3, 0.3, 0.01);
|
||||
}
|
||||
}, warningTimeMs / 50);
|
||||
if (block.getType() != Material.AIR) {
|
||||
player.player.playSound(block.getLocation(),
|
||||
Sound.BLOCK_NOTE_BLOCK_PLING, 1.0f, 2.0f);
|
||||
player.player.spawnParticle(Particle.FLAME,
|
||||
block.getLocation().add(0.5, 1, 0.5), 8, 0.2, 0.2, 0.2, 0.01);
|
||||
}
|
||||
}, warningTicks);
|
||||
|
||||
ScheduledTask removalTask = Scheduler.get(LoParkour.getPlugin()).runLater(() -> {
|
||||
if (block.getType() != Material.AIR) {
|
||||
block.setType(Material.AIR);
|
||||
blockTimestamps.remove(block);
|
||||
scheduledTasks.remove(block);
|
||||
}
|
||||
}, removalTime / 50);
|
||||
if (block.getType() != Material.AIR) {
|
||||
block.setType(Material.AIR, false);
|
||||
}
|
||||
scheduledTasks.remove(block);
|
||||
}, removalTicks);
|
||||
|
||||
scheduledTasks.put(block, removalTask);
|
||||
// Store both so we can cancel them on reset
|
||||
scheduledTasks.put(block, new ScheduledTask[]{warningTask, removalTask});
|
||||
}
|
||||
|
||||
@Override
|
||||
public void reset(boolean regenerate) {
|
||||
// Cancel all scheduled tasks
|
||||
for (ScheduledTask task : scheduledTasks.values()) {
|
||||
if (task != null) {
|
||||
task.cancel();
|
||||
// Cancel every pending warning and removal task
|
||||
scheduledTasks.values().forEach(tasks -> {
|
||||
for (ScheduledTask t : tasks) {
|
||||
if (t != null) t.cancel();
|
||||
}
|
||||
}
|
||||
});
|
||||
scheduledTasks.clear();
|
||||
blockTimestamps.clear();
|
||||
|
||||
|
||||
super.reset(regenerate);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -22,12 +22,12 @@ class SQLMigrationManager {
|
|||
}
|
||||
|
||||
private void createDatabase() {
|
||||
queryExecutor.executeUpdate("CREATE DATABASE IF NOT EXISTS `%s`;".formatted(Option.SQL_DB));
|
||||
queryExecutor.executeUpdate("USE `%s`;".formatted(Option.SQL_DB));
|
||||
queryExecutor.executeStaticUpdate("CREATE DATABASE IF NOT EXISTS `%s`;".formatted(Option.SQL_DB));
|
||||
queryExecutor.executeStaticUpdate("USE `%s`;".formatted(Option.SQL_DB));
|
||||
}
|
||||
|
||||
private void createOptionsTable() {
|
||||
queryExecutor.executeUpdate(
|
||||
queryExecutor.executeStaticUpdate(
|
||||
("CREATE TABLE IF NOT EXISTS `%soptions` " +
|
||||
"(`uuid` CHAR(36) NOT NULL, `time` VARCHAR(8), `style` VARCHAR(32), `blockLead` INT, " +
|
||||
"`useParticles` BOOLEAN, `useDifficulty` BOOLEAN, `useSpecial` BOOLEAN, " +
|
||||
|
|
@ -38,13 +38,13 @@ class SQLMigrationManager {
|
|||
private void runMigrations() {
|
||||
String prefix = Option.SQL_PREFIX;
|
||||
|
||||
queryExecutor.executeUpdateSuppressed("ALTER TABLE `%soptions` DROP COLUMN `time`;".formatted(prefix));
|
||||
queryExecutor.executeUpdateSuppressed("ALTER TABLE `%soptions` ADD `selectedTime` INT NOT NULL;".formatted(prefix));
|
||||
queryExecutor.executeUpdateSuppressed("ALTER TABLE `%soptions` ADD `collectedRewards` MEDIUMTEXT;".formatted(prefix));
|
||||
queryExecutor.executeUpdateSuppressed("ALTER TABLE `%soptions` ADD `locale` VARCHAR(8);".formatted(prefix));
|
||||
queryExecutor.executeUpdateSuppressed("ALTER TABLE `%soptions` ADD `schematicDifficulty` DOUBLE;".formatted(prefix));
|
||||
queryExecutor.executeUpdateSuppressed("ALTER TABLE `%soptions` ADD `sound` BOOLEAN;".formatted(prefix));
|
||||
queryExecutor.executeUpdateSuppressed("ALTER TABLE `%soptions` DROP COLUMN `useDifficulty`;".formatted(prefix));
|
||||
queryExecutor.executeUpdateSuppressed("ALTER TABLE `%soptions` DROP COLUMN `useStructure`;".formatted(prefix));
|
||||
queryExecutor.executeStaticUpdateSuppressed("ALTER TABLE `%soptions` DROP COLUMN `time`;".formatted(prefix));
|
||||
queryExecutor.executeStaticUpdateSuppressed("ALTER TABLE `%soptions` ADD `selectedTime` INT NOT NULL;".formatted(prefix));
|
||||
queryExecutor.executeStaticUpdateSuppressed("ALTER TABLE `%soptions` ADD `collectedRewards` MEDIUMTEXT;".formatted(prefix));
|
||||
queryExecutor.executeStaticUpdateSuppressed("ALTER TABLE `%soptions` ADD `locale` VARCHAR(8);".formatted(prefix));
|
||||
queryExecutor.executeStaticUpdateSuppressed("ALTER TABLE `%soptions` ADD `schematicDifficulty` DOUBLE;".formatted(prefix));
|
||||
queryExecutor.executeStaticUpdateSuppressed("ALTER TABLE `%soptions` ADD `sound` BOOLEAN;".formatted(prefix));
|
||||
queryExecutor.executeStaticUpdateSuppressed("ALTER TABLE `%soptions` DROP COLUMN `useDifficulty`;".formatted(prefix));
|
||||
queryExecutor.executeStaticUpdateSuppressed("ALTER TABLE `%soptions` DROP COLUMN `useStructure`;".formatted(prefix));
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,6 +8,9 @@ import java.sql.SQLException;
|
|||
/**
|
||||
* Executes SQL queries with error handling.
|
||||
*
|
||||
* <p>All public methods accept parameters separately so callers never
|
||||
* interpolate user data into SQL strings — preventing SQL injection.</p>
|
||||
*
|
||||
* @since 5.0.0
|
||||
*/
|
||||
class SQLQueryExecutor {
|
||||
|
|
@ -18,30 +21,66 @@ class SQLQueryExecutor {
|
|||
this.connectionManager = connectionManager;
|
||||
}
|
||||
|
||||
public void executeUpdate(String sql) {
|
||||
executeUpdate(sql, false);
|
||||
/**
|
||||
* Executes a DDL/static update with no user-supplied parameters.
|
||||
* Only used for CREATE TABLE statements where all values are hardcoded.
|
||||
*/
|
||||
public void executeStaticUpdate(String sql) {
|
||||
executeStaticUpdate(sql, false);
|
||||
}
|
||||
|
||||
public void executeUpdateSuppressed(String sql) {
|
||||
executeUpdate(sql, true);
|
||||
/**
|
||||
* Same as {@link #executeStaticUpdate(String)} but optionally suppresses errors.
|
||||
* Used for ALTER TABLE migrations that may already have been applied.
|
||||
*/
|
||||
public void executeStaticUpdateSuppressed(String sql) {
|
||||
executeStaticUpdate(sql, true);
|
||||
}
|
||||
|
||||
private void executeUpdate(String sql, boolean suppressErrors) {
|
||||
private void executeStaticUpdate(String sql, boolean suppressErrors) {
|
||||
connectionManager.validateConnection();
|
||||
|
||||
try (PreparedStatement stmt = connectionManager.prepareStatement(sql)) {
|
||||
if (stmt != null) {
|
||||
stmt.executeUpdate();
|
||||
}
|
||||
if (stmt != null) stmt.executeUpdate();
|
||||
} catch (SQLException ex) {
|
||||
if (!suppressErrors) {
|
||||
LoParkour.getPlugin().getLogger().severe(
|
||||
"Error while sending update: %s - %s".formatted(sql, ex.getMessage()));
|
||||
"Error while executing static update - " + ex.getMessage());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes a parameterised update. Values are bound via {@link PreparedStatement#setObject}
|
||||
* — the JDBC driver handles escaping, no interpolation ever touches the SQL string.
|
||||
*
|
||||
* @param sql SQL with {@code ?} placeholders
|
||||
* @param params Values to bind in order
|
||||
*/
|
||||
public void executeUpdate(String sql, Object... params) {
|
||||
connectionManager.validateConnection();
|
||||
try (PreparedStatement stmt = connectionManager.prepareStatement(sql)) {
|
||||
if (stmt == null) return;
|
||||
bindParams(stmt, params);
|
||||
stmt.executeUpdate();
|
||||
} catch (SQLException ex) {
|
||||
LoParkour.getPlugin().getLogger().severe(
|
||||
"Error while executing update - " + ex.getMessage());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Prepares a statement for callers that need to read a {@link java.sql.ResultSet}.
|
||||
* Parameters must be bound by the caller before executing.
|
||||
*/
|
||||
public PreparedStatement prepareStatement(String sql) {
|
||||
return connectionManager.prepareStatement(sql);
|
||||
}
|
||||
|
||||
// ── Helpers ───────────────────────────────────────────────────────────────
|
||||
|
||||
private static void bindParams(PreparedStatement stmt, Object[] params) throws SQLException {
|
||||
for (int i = 0; i < params.length; i++) {
|
||||
stmt.setObject(i + 1, params[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,17 +17,24 @@ import java.util.concurrent.CopyOnWriteArrayList;
|
|||
/**
|
||||
* MySQL storage manager.
|
||||
*
|
||||
* <p><b>Security:</b> Every query that touches user-supplied data uses
|
||||
* {@code ?} placeholders bound via {@link PreparedStatement#setObject}.
|
||||
* No string interpolation of player names, UUIDs, scores, or any other
|
||||
* external value ever reaches the SQL string itself.</p>
|
||||
*
|
||||
* @since 5.0.0
|
||||
*/
|
||||
class StorageSQL {
|
||||
|
||||
private static final SQLConnectionManager connectionManager = new SQLConnectionManager();
|
||||
private static final SQLQueryExecutor queryExecutor = new SQLQueryExecutor(connectionManager);
|
||||
private static final SQLMigrationManager migrationManager = new SQLMigrationManager(queryExecutor);
|
||||
private static final SQLQueryExecutor queryExecutor = new SQLQueryExecutor(connectionManager);
|
||||
private static final SQLMigrationManager migrationManager = new SQLMigrationManager(queryExecutor);
|
||||
|
||||
private static boolean initialized = false;
|
||||
private static final List<String> pendingTableCreations = new CopyOnWriteArrayList<>();
|
||||
|
||||
// ── Connection lifecycle ──────────────────────────────────────────────────
|
||||
|
||||
public static boolean isConnected() {
|
||||
return connectionManager.isConnected();
|
||||
}
|
||||
|
|
@ -36,17 +43,28 @@ class StorageSQL {
|
|||
connectionManager.runWhenConnected(callback);
|
||||
}
|
||||
|
||||
public static void close() {
|
||||
connectionManager.close();
|
||||
}
|
||||
|
||||
// ── Initialisation ────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Queues creation of the leaderboard table for {@code mode}.
|
||||
* Table name is constructed from a config-defined prefix (admin-controlled,
|
||||
* not user input) so formatting here is safe.
|
||||
*/
|
||||
public static void init(String mode) {
|
||||
// Table names are derived from admin config, not player input — safe to format.
|
||||
String createTableSql = """
|
||||
CREATE TABLE IF NOT EXISTS `%s`
|
||||
(
|
||||
uuid CHAR(36) NOT NULL PRIMARY KEY,
|
||||
uuid CHAR(36) NOT NULL PRIMARY KEY,
|
||||
name VARCHAR(16),
|
||||
time VARCHAR(16),
|
||||
difficulty VARCHAR(3),
|
||||
score INT
|
||||
)
|
||||
CHARSET = utf8 ENGINE = InnoDB;
|
||||
) CHARSET = utf8 ENGINE = InnoDB;
|
||||
""".formatted(getTableName(mode));
|
||||
|
||||
if (!initialized) {
|
||||
|
|
@ -58,72 +76,83 @@ class StorageSQL {
|
|||
}
|
||||
}
|
||||
|
||||
public static void close() {
|
||||
connectionManager.close();
|
||||
}
|
||||
// ── Leaderboard ───────────────────────────────────────────────────────────
|
||||
|
||||
public static @NotNull Map<UUID, Score> readScores(@NotNull String mode) {
|
||||
// Table name from admin config — safe to format; no user data here.
|
||||
String sql = "SELECT * FROM `%s`;".formatted(getTableName(mode));
|
||||
try (PreparedStatement stmt = queryExecutor.prepareStatement(sql)) {
|
||||
if (stmt == null) return new HashMap<>();
|
||||
try (ResultSet results = stmt.executeQuery()) {
|
||||
try (ResultSet rs = stmt.executeQuery()) {
|
||||
Map<UUID, Score> scores = new HashMap<>();
|
||||
while (results.next()) {
|
||||
scores.put(UUID.fromString(results.getString("uuid")), new Score(
|
||||
results.getString("name"),
|
||||
results.getString("time"),
|
||||
results.getString("difficulty"),
|
||||
results.getInt("score")));
|
||||
while (rs.next()) {
|
||||
scores.put(
|
||||
UUID.fromString(rs.getString("uuid")),
|
||||
new Score(
|
||||
rs.getString("name"),
|
||||
rs.getString("time"),
|
||||
rs.getString("difficulty"),
|
||||
rs.getInt("score")));
|
||||
}
|
||||
return scores;
|
||||
}
|
||||
} catch (SQLException ex) {
|
||||
LoParkour.getPlugin().getLogger().severe(
|
||||
"Error while trying to read SQL data of %s - %s".formatted(mode, ex.getMessage()));
|
||||
"Error reading leaderboard for mode %s - %s".formatted(mode, ex.getMessage()));
|
||||
return new HashMap<>();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Writes all scores for a mode.
|
||||
*
|
||||
* <p>Uses an INSERT … ON DUPLICATE KEY UPDATE with {@code ?} placeholders.
|
||||
* Player name, time, difficulty come from the leaderboard record — all bound
|
||||
* as parameters, never interpolated.</p>
|
||||
*/
|
||||
public static void writeScores(@NotNull String mode, @NotNull Map<UUID, Score> scores) {
|
||||
// Table name is from admin config — safe to format.
|
||||
String sql = """
|
||||
INSERT INTO `%s`
|
||||
(uuid, name, time, difficulty, score)
|
||||
INSERT INTO `%s` (uuid, name, time, difficulty, score)
|
||||
VALUES (?, ?, ?, ?, ?)
|
||||
ON DUPLICATE KEY UPDATE name = VALUES(name),
|
||||
time = VALUES(time),
|
||||
difficulty = VALUES(difficulty),
|
||||
score = VALUES(score);
|
||||
ON DUPLICATE KEY UPDATE
|
||||
name = VALUES(name),
|
||||
time = VALUES(time),
|
||||
difficulty = VALUES(difficulty),
|
||||
score = VALUES(score);
|
||||
""".formatted(getTableName(mode));
|
||||
|
||||
new HashMap<>(scores).forEach((uuid, score) -> {
|
||||
try (PreparedStatement stmt = queryExecutor.prepareStatement(sql)) {
|
||||
if (stmt == null) return;
|
||||
stmt.setString(1, uuid.toString());
|
||||
stmt.setString(2, score.name());
|
||||
stmt.setString(3, score.time());
|
||||
stmt.setString(4, score.difficulty());
|
||||
stmt.setInt(5, score.score());
|
||||
stmt.executeUpdate();
|
||||
} catch (SQLException ex) {
|
||||
LoParkour.getPlugin().getLogger().severe(
|
||||
"Error writing score for %s in mode %s - %s".formatted(uuid, mode, ex.getMessage()));
|
||||
}
|
||||
});
|
||||
|
||||
new HashMap<>(scores).forEach((uuid, score) ->
|
||||
queryExecutor.executeUpdate(sql,
|
||||
uuid.toString(),
|
||||
score.name(),
|
||||
score.time(),
|
||||
score.difficulty(),
|
||||
score.score()));
|
||||
}
|
||||
|
||||
private static String getTableName(String mode) {
|
||||
return "%sleaderboard-%s".formatted(Option.SQL_PREFIX, mode);
|
||||
}
|
||||
// ── Player settings ───────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Reads player settings from the options table.
|
||||
*
|
||||
* <p>UUID is bound as a parameter — never interpolated into the query string.</p>
|
||||
*/
|
||||
public static void readPlayer(@NotNull ParkourPlayer player) {
|
||||
String sql = "SELECT * FROM `%soptions` WHERE uuid = '%s';".formatted(Option.SQL_PREFIX, player.getUUID());
|
||||
// Table name from admin config — safe. UUID bound as parameter below.
|
||||
String sql = "SELECT * FROM `%soptions` WHERE uuid = ?;".formatted(Option.SQL_PREFIX);
|
||||
|
||||
try (PreparedStatement stmt = queryExecutor.prepareStatement(sql)) {
|
||||
if (stmt == null) {
|
||||
player.setSettings(new HashMap<>());
|
||||
return;
|
||||
}
|
||||
try (ResultSet results = stmt.executeQuery()) {
|
||||
if (!results.next()) {
|
||||
|
||||
// Bind UUID as parameter — no injection possible
|
||||
stmt.setString(1, player.getUUID().toString());
|
||||
|
||||
try (ResultSet rs = stmt.executeQuery()) {
|
||||
if (!rs.next()) {
|
||||
player.setSettings(new HashMap<>());
|
||||
return;
|
||||
}
|
||||
|
|
@ -131,61 +160,78 @@ class StorageSQL {
|
|||
Map<String, Object> settings = new HashMap<>();
|
||||
for (String key : ParkourPlayer.PLAYER_COLUMNS.keySet()) {
|
||||
try {
|
||||
settings.put(key, results.getObject(key));
|
||||
settings.put(key, rs.getObject(key));
|
||||
} catch (SQLException ex) {
|
||||
LoParkour.getPlugin().getLogger().severe(
|
||||
"Error reading SQL data of %s, key=%s - %s".formatted(player.getName(), key, ex.getMessage()));
|
||||
"Error reading SQL column %s for %s - %s"
|
||||
.formatted(key, player.getName(), ex.getMessage()));
|
||||
}
|
||||
}
|
||||
player.setSettings(settings);
|
||||
}
|
||||
} catch (SQLException ex) {
|
||||
LoParkour.getPlugin().getLogger().severe(
|
||||
"Error reading SQL data of %s - %s".formatted(player.getName(), ex.getMessage()));
|
||||
"Error reading player data for %s - %s".formatted(player.getName(), ex.getMessage()));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Writes player settings to the options table.
|
||||
*
|
||||
* <p>All 12 player-controlled values (style, locale, rewards, etc.) are bound
|
||||
* as {@code ?} parameters. None of them are interpolated into the SQL string.</p>
|
||||
*/
|
||||
public static void writePlayer(@NotNull ParkourPlayer player) {
|
||||
DecimalFormat df = new DecimalFormat("#.######", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
|
||||
String schematicDifficulty = df.format(player.schematicDifficulty);
|
||||
DecimalFormat df = new DecimalFormat("#.######",
|
||||
DecimalFormatSymbols.getInstance(Locale.ENGLISH));
|
||||
double schemDiff = df.format(player.schematicDifficulty) != null
|
||||
? player.schematicDifficulty : 0.0;
|
||||
|
||||
// Table name from admin config — safe to format.
|
||||
String sql = """
|
||||
INSERT INTO `%soptions`
|
||||
(uuid, style, blockLead, useParticles, useSpecial, showFallMsg, showScoreboard,
|
||||
selectedTime, collectedRewards, locale, schematicDifficulty, sound)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
ON DUPLICATE KEY UPDATE style = VALUES(style),
|
||||
blockLead = VALUES(blockLead),
|
||||
useParticles = VALUES(useParticles),
|
||||
useSpecial = VALUES(useSpecial),
|
||||
showFallMsg = VALUES(showFallMsg),
|
||||
showScoreboard = VALUES(showScoreboard),
|
||||
selectedTime = VALUES(selectedTime),
|
||||
collectedRewards = VALUES(collectedRewards),
|
||||
locale = VALUES(locale),
|
||||
schematicDifficulty = VALUES(schematicDifficulty),
|
||||
sound = VALUES(sound);
|
||||
INSERT INTO `%soptions`
|
||||
(uuid, style, blockLead, useParticles, useSpecial, showFallMsg,
|
||||
showScoreboard, selectedTime, collectedRewards, locale,
|
||||
schematicDifficulty, sound)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
||||
ON DUPLICATE KEY UPDATE
|
||||
style = VALUES(style),
|
||||
blockLead = VALUES(blockLead),
|
||||
useParticles = VALUES(useParticles),
|
||||
useSpecial = VALUES(useSpecial),
|
||||
showFallMsg = VALUES(showFallMsg),
|
||||
showScoreboard = VALUES(showScoreboard),
|
||||
selectedTime = VALUES(selectedTime),
|
||||
collectedRewards = VALUES(collectedRewards),
|
||||
locale = VALUES(locale),
|
||||
schematicDifficulty = VALUES(schematicDifficulty),
|
||||
sound = VALUES(sound);
|
||||
""".formatted(Option.SQL_PREFIX);
|
||||
|
||||
try (PreparedStatement stmt = queryExecutor.prepareStatement(sql)) {
|
||||
if (stmt == null) return;
|
||||
stmt.setString(1, player.getUUID().toString());
|
||||
stmt.setString(2, player.style);
|
||||
stmt.setInt(3, player.blockLead);
|
||||
stmt.setBoolean(4, player.particles);
|
||||
stmt.setBoolean(5, player.useSpecialBlocks);
|
||||
stmt.setBoolean(6, player.showFallMessage);
|
||||
stmt.setBoolean(7, player.showScoreboard);
|
||||
stmt.setInt(8, player.selectedTime);
|
||||
stmt.setString(9, String.join(",", player.collectedRewards));
|
||||
stmt.setString(10, player.locale);
|
||||
stmt.setString(11, schematicDifficulty);
|
||||
stmt.setBoolean(12, player.sound);
|
||||
stmt.executeUpdate();
|
||||
} catch (SQLException ex) {
|
||||
LoParkour.getPlugin().getLogger().severe(
|
||||
"Error writing player data for %s - %s".formatted(player.getName(), ex.getMessage()));
|
||||
}
|
||||
|
||||
queryExecutor.executeUpdate(sql,
|
||||
player.getUUID().toString(), // 1 uuid
|
||||
player.style, // 2 style
|
||||
player.blockLead, // 3 blockLead
|
||||
player.particles, // 4 useParticles
|
||||
player.useSpecialBlocks, // 5 useSpecial
|
||||
player.showFallMessage, // 6 showFallMsg
|
||||
player.showScoreboard, // 7 showScoreboard
|
||||
player.selectedTime, // 8 selectedTime
|
||||
String.join(",", player.collectedRewards), // 9 collectedRewards
|
||||
player.locale, // 10 locale
|
||||
schemDiff, // 11 schematicDifficulty
|
||||
player.sound // 12 sound
|
||||
);
|
||||
}
|
||||
|
||||
// ── Internals ─────────────────────────────────────────────────────────────
|
||||
|
||||
/**
|
||||
* Table name is built from the admin-configured SQL prefix and the internal
|
||||
* mode name (e.g. "default", "speedrun"). Neither is user-supplied.
|
||||
*/
|
||||
private static String getTableName(String mode) {
|
||||
return "%sleaderboard-%s".formatted(Option.SQL_PREFIX, mode);
|
||||
}
|
||||
|
||||
private static void connect() {
|
||||
|
|
@ -193,7 +239,7 @@ class StorageSQL {
|
|||
migrationManager.initializeDatabase();
|
||||
|
||||
for (String sql : pendingTableCreations) {
|
||||
queryExecutor.executeUpdate(sql);
|
||||
queryExecutor.executeStaticUpdate(sql);
|
||||
}
|
||||
pendingTableCreations.clear();
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue