DreamCamPath.java

Go to the documentation of this file.

/*
 * MIT License
 *
 * Copyright (c) 2025 Dreamfire Studio
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
package com.dreamfirestudios.dreamcore.DreamCam;
 
import com.dreamfirestudios.dreamcore.DreamCore;
import com.dreamfirestudios.dreamcore.DreamJava.DreamClassID;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
 
import java.util.*;
 
public class DreamCamPath extends DreamClassID {
    private final List<UUID> players = new ArrayList<>();
    private List<DreamCamSet> camSets = new ArrayList<>();
 
    private final Map<UUID, GameMode> playersGamemodesBefore = new HashMap<>();
    private final Map<UUID, Location> playersLocationsBefore = new HashMap<>();
    private final Map<UUID, Boolean> playersFlyingBefore = new HashMap<>();
    private BukkitRunnable bukkitRunnable;
 
    public List<DreamCamSet> getCamSets() { return camSets; }
 
    public List<UUID> getPlayers() { return players; }
 
    public void addPlayer(Player... players) {
        for (var player : players) addPlayer(player);
    }
 
    public void addPlayer(Player player) {
        if (new CamPathPlayerAddedEvent(this, player).isCancelled()) return;
        players.add(player.getUniqueId());
    }
 
    public void removeAllPlayers(boolean hasFinished) {
        for (var playerUUID : new ArrayList<>(players)) {
            var player = Bukkit.getPlayer(playerUUID);
            if (player != null) removePlayerFromPath(player, hasFinished);
        }
    }
 
    public void removePlayerFromPath(Player player, boolean hasFinished) {
        if (!players.contains(player.getUniqueId())) return;
        new CamPathPlayerLeaveEvent(this, player, hasFinished);
        player.setGameMode(playersGamemodesBefore.getOrDefault(player.getUniqueId(), player.getGameMode()));
        player.teleport(playersLocationsBefore.getOrDefault(player.getUniqueId(), player.getLocation()));
        player.setFlying(playersFlyingBefore.getOrDefault(player.getUniqueId(), player.isFlying()));
        players.remove(player.getUniqueId());
    }
 
    public void startCamPath() {
        if (bukkitRunnable != null) return;
        for (var playerUUID : players) {
            var player = Bukkit.getPlayer(playerUUID);
            if (player == null) continue;
            playersGamemodesBefore.put(playerUUID, player.getGameMode());
            playersLocationsBefore.put(playerUUID, player.getLocation());
            playersFlyingBefore.put(playerUUID, player.isFlying());
            player.setGameMode(GameMode.SPECTATOR);
        }
        new CamPathStartEvent(this);
        bukkitRunnable = new DreamCamPathRunnable(this);
        bukkitRunnable.runTaskTimer(DreamCore.DreamCore, 0L, 1L);
    }
 
    public void endCamPath(boolean hasFinished) {
        for (var playerUUID : new ArrayList<>(players)) {
            var player = Bukkit.getPlayer(playerUUID);
            if (player != null) removePlayerFromPath(player, hasFinished);
        }
        new CamPathStopEvent(this);
        if (bukkitRunnable != null) {
            bukkitRunnable.cancel();
            bukkitRunnable = null;
        }
    }
 
    public void onDisable() {
        removeAllPlayers(false);
    }
 
    public void onPlayerLeave(Player player) {
        removePlayerFromPath(player, false);
    }
 
    // ---- Builder ----
 
    public static class CamPathBuilder {
        private final List<DreamCamSet> camSets = new ArrayList<>();
        private final List<Player> players = new ArrayList<>();
 
        public CamPathBuilder addTravelPath(Location start, Location end, LookAtType lookAtType, Object data, int durationInTicks) {
            if (durationInTicks <= 0) throw new IllegalArgumentException("durationInTicks must be > 0");
 
            var pathLocations = new ArrayList<Location>();
            pathLocations.add(start.clone());
 
            var stepX = (end.getX() - start.getX()) / durationInTicks;
            var stepY = (end.getY() - start.getY()) / durationInTicks;
            var stepZ = (end.getZ() - start.getZ()) / durationInTicks;
            var stepYaw = (end.getYaw() - start.getYaw()) / durationInTicks;
            var stepPitch = (end.getPitch() - start.getPitch()) / durationInTicks;
 
            var step = new Location(start.getWorld(), stepX, stepY, stepZ, (float) stepYaw, (float) stepPitch);
 
            for (int i = 1; i <= durationInTicks; i++) {
                var prevLocation = pathLocations.get(i - 1).clone();
                var next = prevLocation.add(step);
                next.setYaw(next.getYaw() + stepYaw);
                next.setPitch(next.getPitch() + stepPitch);
                pathLocations.add(next);
            }
 
            camSets.add(new DreamCamSet(pathLocations, lookAtType, data));
            return this;
        }
 
        public CamPathBuilder players(Player... players) {
            this.players.addAll(Arrays.asList(players));
            return this;
        }
 
        public DreamCamPath create() {
            var path = new DreamCamPath();
            path.camSets = camSets;
            players.forEach(path::addPlayer);
            return DreamCore.DreamCamPaths.put(path.getClassID(), path);
        }
    }
}