Teleportation

Dokumentace k teleportaci hráčů, spawn systému a warpům.

Obsah

| Soubor | Popis |
|--------|-------|
| TELEPORT_API.md | Teleport komponenta a API |
| SPAWN_SYSTEM.md | Spawn provider systém |
| WARPS.md | Warp systém a příkazy |

---

Rychlý Přehled

| Operace | Metoda |
|---------|--------|
| Teleport hráče | Teleport.createForPlayer(world, transform) |
| Získání spawn | spawnProvider.getSpawnPoint(world, uuid) |
| Teleport na warp | warp.toTeleport() |
| Uložit historii | TeleportHistory.append(world, pos, rot, desc) |
| Teleport zpět | TeleportHistory.back(ref, count) |

---

Teleport Komponenta

Pro teleportaci hráče se používá Teleport komponenta.

Základní Teleportace

// Vytvoření teleport komponenty
Transform targetTransform = new Transform(position, rotation);
Teleport teleportComponent = Teleport.createForPlayer(world, targetTransform);
// Přidání ke hráči (způsobí teleport)
store.addComponent(ref, Teleport.getComponentType(), teleportComponent);

Kompletní Příklad

public void teleportPlayer(Player player, Vector3d targetPosition) {
    World world = player.getWorld();
    world.execute(() -> {
        Ref ref = player.getRef();
        Store store = ref.getStore();
        // Získej současnou pozici pro historii
        TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
        HeadRotation headRotation = store.getComponent(ref, HeadRotation.getComponentType());
        if (transform != null && headRotation != null) {
            // Ulož historii (volitelné)
            Vector3d previousPos = transform.getPosition().clone();
            Vector3f previousRotation = headRotation.getRotation().clone();
            // Vytvoř teleport transform
            Transform targetTransform = new Transform(
                targetPosition,
                new Vector3f(0, 0, 0)  // Rotace
            );
            // Proveď teleport
            Teleport teleport = Teleport.createForPlayer(world, targetTransform);
            store.addComponent(ref, Teleport.getComponentType(), teleport);
        }
    });
}

---

Spawn Systém

Získání Spawn Pointů

// Získej spawn provider ze světa
ISpawnProvider spawnProvider = world.getWorldConfig().getSpawnProvider();
// Jeden spawn point (na základě UUID hráče)
Transform spawn = spawnProvider.getSpawnPoint(world, playerUuid);
// Všechny spawn pointy
Transform[] spawnPoints = spawnProvider.getSpawnPoints();
// Konkrétní spawn point podle indexu
int spawnIndex = 0;
if (spawnIndex >= 0 && spawnIndex < spawnPoints.length) {
    Transform spawn = spawnPoints[spawnIndex];
}

SpawnCommand Vzor

private static Transform resolveSpawn(
    CommandContext context,
    World world,
    PlayerRef playerRef,
    OptionalArg spawnIndexArg
) {
    ISpawnProvider spawnProvider = world.getWorldConfig().getSpawnProvider();
    if (spawnIndexArg.provided(context)) {
        int spawnIndex = spawnIndexArg.get(context);
        Transform[] spawnPoints = spawnProvider.getSpawnPoints();
        if (spawnIndex >= 0 && spawnIndex < spawnPoints.length) {
            return spawnPoints[spawnIndex];
        } else {
            int maxIndex = spawnPoints.length - 1;
            throw new GeneralCommandException(
                Message.translation("server.commands.errors.spawnIndexOutOfRange")
                    .param("index", spawnIndex)
                    .param("maxIndex", maxIndex)
            );
        }
    } else {
        // Výchozí spawn na základě UUID
        return spawnProvider.getSpawnPoint(world, playerRef.getUuid());
    }
}

---

Teleport Historie

TeleportPlugin implementuje historii teleportů pro /back příkaz.

TeleportHistory Komponenta

public class TeleportHistory implements Component {
    private final List history = new ArrayList<>();
    private static final int MAX_HISTORY = 10;
    public void append(World world, Vector3d position, Vector3f rotation, String description) {
        if (history.size() >= MAX_HISTORY) {
            history.remove(0);  // Odstraň nejstarší
        }
        history.add(new TeleportEntry(
            world.getName(),
            position.clone(),
            rotation.clone(),
            description
        ));
    }
    public TeleportEntry getLastEntry() {
        return history.isEmpty() ? null : history.get(history.size() - 1);
    }
    public TeleportEntry popLastEntry() {
        if (history.isEmpty()) return null;
        return history.remove(history.size() - 1);
    }
    @Override
    public Component clone() {
        TeleportHistory copy = new TeleportHistory();
        copy.history.addAll(this.history);
        return copy;
    }
    public record TeleportEntry(
        String worldName,
        Vector3d position,
        Vector3f rotation,
        String description
    ) {}
}

Použití Historie

// Před teleportem - ulož současnou pozici
TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
HeadRotation headRotation = store.getComponent(ref, HeadRotation.getComponentType());
TeleportHistory history = store.ensureAndGetComponent(ref, TeleportHistory.getComponentType());
history.append(
    world,
    transform.getPosition().clone(),
    headRotation.getRotation().clone(),
    "Teleport to spawn"
);
// Po teleportu - /back příkaz
TeleportHistory.TeleportEntry lastEntry = history.popLastEntry();
if (lastEntry != null) {
    World targetWorld = Universe.get().getWorld(lastEntry.worldName());
    // Teleportuj zpět...
}

---

Warp Systém

Warp Třída

public class Warp {
    private final String id;
    private final String world;
    private final Transform transform;
    public String getId() { return id; }
    public String getWorld() { return world; }
    public Transform getTransform() { return transform; }
    // Codec pro ukládání
    public static final Codec CODEC = ...;
    public static final ArrayCodec ARRAY_CODEC = Codec.array(CODEC);
}

Správa Warpů

public class WarpManager {
    private final Map warps = new ConcurrentHashMap<>();
    public void createWarp(String name, World world, Transform transform) {
        Warp warp = new Warp(name, world.getName(), transform);
        warps.put(name.toLowerCase(), warp);
        saveWarps();
    }
    public Warp getWarp(String name) {
        return warps.get(name.toLowerCase());
    }
    public void deleteWarp(String name) {
        warps.remove(name.toLowerCase());
        saveWarps();
    }
    public Collection getAllWarps() {
        return warps.values();
    }
}

Teleport na Warp

public void teleportToWarp(Player player, Warp warp) {
    World targetWorld = Universe.get().getWorld(warp.getWorld());
    if (targetWorld == null) {
        player.sendMessage(Message.raw("Svět warpu neexistuje!"));
        return;
    }
    targetWorld.execute(() -> {
        // Pokud je hráč v jiném světě, potřebuješ cross-world teleport
        Transform transform = warp.getTransform();
        Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
        Ref ref = player.getRef();
        Store store = ref.getStore();
        store.addComponent(ref, Teleport.getComponentType(), teleport);
        player.sendMessage(
            Message.translation("server.commands.warp.teleported")
                .param("name", warp.getId())
        );
    });
}

---

Transform

Vytvoření Transform

// Pozice + rotace
Vector3d position = new Vector3d(100, 64, 200);
Vector3f rotation = new Vector3f(0, 90, 0);  // pitch, yaw, roll
Transform transform = new Transform(position, rotation);
// Získání hodnot
Vector3d pos = transform.getPosition();
Vector3f rot = transform.getRotation();
float yaw = rot.getYaw();

Z Hráče

TransformComponent transformComp = store.getComponent(ref, TransformComponent.getComponentType());
Vector3d position = transformComp.getPosition();
Vector3f rotation = transformComp.getRotation();
HeadRotation headRotation = store.getComponent(ref, HeadRotation.getComponentType());
Vector3f headRot = headRotation.getRotation();

---

Cross-World Teleport

Pro teleport mezi světy:

public void teleportToWorld(Player player, World targetWorld, Vector3d position) {
    World currentWorld = player.getWorld();
    if (currentWorld == targetWorld) {
        // Stejný svět - jednoduchý teleport
        teleportInWorld(player, position);
    } else {
        // Jiný svět - potřeba přesunout hráče
        targetWorld.execute(() -> {
            Transform transform = new Transform(position, new Vector3f(0, 0, 0));
            Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
            // Získej ref v novém světě
            Ref ref = player.getRef();
            Store store = ref.getStore();
            store.addComponent(ref, Teleport.getComponentType(), teleport);
        });
    }
}

---

Shrnutí

| Operace | Metoda/Třída |
|---------|--------------|
| Teleport hráče | Teleport.createForPlayer(world, transform) |
| Získání spawn | spawnProvider.getSpawnPoint(world, uuid) |
| Všechny spawny | spawnProvider.getSpawnPoints() |
| Pozice hráče | TransformComponent.getPosition() |
| Rotace hlavy | HeadRotation.getRotation() |
| World config | world.getWorldConfig() |
| Spawn provider | worldConfig.getSpawnProvider() |