CutsceneActivity.java

package com.osroyale.content.activity.impl.cutscene;
 
import com.osroyale.content.activity.Activity;
import com.osroyale.content.activity.ActivityType;
import com.osroyale.game.world.World;
import com.osroyale.game.world.entity.mob.Mob;
import com.osroyale.game.world.entity.mob.npc.Npc;
import com.osroyale.game.world.entity.mob.player.Player;
import com.osroyale.game.world.position.Position;
import com.osroyale.net.packet.out.SendCameraReset;
import com.osroyale.net.packet.out.SendCameraTurn;
import com.osroyale.net.packet.out.SendMinimapState;
import com.osroyale.net.packet.out.SendScreenFade;
import com.osroyale.net.packet.out.CameraViewPacket;
import com.osroyale.net.packet.context.CameraContext;
import com.osroyale.net.packet.context.CameraContext.CameraType;
 
import java.util.ArrayList;
import java.util.List;

 
public abstract class CutsceneActivity extends Activity {
    
    protected static final int[] HIDDEN_TABS = new int[] { 0, 1, 2, 3, 4, 5, 6, 11, 12 };
    
    protected final List<Npc> npcs = new ArrayList<>();
    
    private final boolean fadeIn;
    
    protected Position originalPosition;
    
    protected Player player;
    
    private int fadeStage = 0;
    
    public CutsceneActivity(Player player, int cooldown, boolean fadeIn) {
        super(cooldown, Mob.DEFAULT_INSTANCE);
        this.player = player;
        this.fadeIn = fadeIn;
    }
    
    public CutsceneActivity(Player player, int cooldown) {
        this(player, cooldown, true);
    }
    
    @Override
    protected void start() {
        if (player == null) {
            return;
        }
        
        originalPosition = player.getPosition().copy();
        player.locking.lock();
        
        if (fadeIn) {
            executeStartSequence();
        } else {
            immediateStart();
        }
    }
    
    private void executeStartSequence() {
        fadeStage = 0;
        World.schedule(1, () -> handleFadeIn());
    }
    
    private void handleFadeIn() {
        switch (fadeStage++) {
            case 0:
                // Skip fade for now - directly setup cutscene
                setupCutscene();
                World.schedule(1, this::handleFadeIn);
                break;
            case 1:
                onFadeIn();
                break;
        }
    }
    
    private void immediateStart() {
        setupCutscene();
        onFadeIn();
    }
    
    private void setupCutscene() {
        player.send(new SendMinimapState(SendMinimapState.MinimapState.HIDDEN));
        hideTabs();
        player.move(getStartPosition());
        player.movement.reset();
        player.interfaceManager.close();
    }
    
    @Override
    public void finish() {
        cleanup();
        
        if (fadeIn) {
            executeEndSequence();
        } else {
            immediateEnd();
        }
    }
    
    private void executeEndSequence() {
        fadeStage = 0;
        World.schedule(1, () -> handleFadeOut());
    }
    
    private void handleFadeOut() {
        switch (fadeStage++) {
            case 0:
                restorePlayer();
                World.schedule(1, this::handleFadeOut);
                break;
            case 1:
                onFadeOut();
                remove(player);
                break;
        }
    }
    
    private void immediateEnd() {
        restorePlayer();
        onFadeOut();
        remove(player);
    }
    
    private void restorePlayer() {
        if (originalPosition != null) {
            player.move(originalPosition);
        }
        player.send(new SendMinimapState(SendMinimapState.MinimapState.NORMAL));
        restoreTabs();
        player.send(new SendCameraReset());
        player.locking.unlock();
        player.movement.reset();
    }
    
    @Override
    public void cleanup() {
        for (Npc npc : npcs) {
            if (npc != null && npc.isRegistered()) {
                npc.unregister();
            }
        }
        npcs.clear();
    }
    
    protected void spawnNpc(int id, Position position) {
        Npc npc = new Npc(id, position);
        add(npc); // This will set the instance properly
        npcs.add(npc);
    }
    
    protected void spawnNpc(int id, int x, int y, int z) {
        spawnNpc(id, new Position(x, y, z));
    }
    
    protected void camera(int x, int y, int xRot, int yRot, int height, int speed) {
        Position base = getStartPosition();
        Position loc = new Position(base.getX() + x, base.getY() + y, 0);
        player.send(new CameraViewPacket(new CameraContext(player, CameraType.POSITION, loc.getX(), loc.getY(), height, speed, 1)));
    }
    
    protected void shakeCamera(int intensity, int duration) {
        // Skip camera shake for now to avoid crashes
    }
    
    protected void resetCamera() {
        player.send(new SendCameraReset());
    }
    
    protected void moveCamera(Position position, int height, int speed) {
        player.send(new CameraViewPacket(new CameraContext(player, CameraType.POSITION, position.getX(), position.getY(), height, speed, 1)));
    }
    
    protected void hideTabs() {
        for (int tab : getHiddenTabs()) {
            player.interfaceManager.setSidebar(tab, -1);
        }
    }
    
    protected void restoreTabs() {
        player.playerAssistant.setSidebar(false, false);
    }
    
    protected void dialogue(String... messages) {
        if (messages.length == 0) {
            return;
        }
        
        player.dialogueFactory.sendStatement(messages).execute();
    }
    
    protected void playerDialogue(String... messages) {
        player.dialogueFactory.sendPlayerChat(messages).execute();
    }
    
    protected void npcDialogue(int npcId, String... messages) {
        player.dialogueFactory.sendNpcChat(npcId, messages).execute();
    }
    
    @Override
    public boolean canLogout(Player player) {
        return false;
    }
    
    @Override
    public ActivityType getType() {
        return ActivityType.CUTSCENE;
    }
    
    protected abstract void onFadeIn();
    
    protected void onFadeOut() {
        
    }
    
    protected abstract Position getStartPosition();
    
    protected int[] getHiddenTabs() {
        return HIDDEN_TABS;
    }
    
    public static CutsceneActivity create(Player player) {
        CutsceneActivity activity = createInstance(player);
        activity.add(player);
        activity.resetCooldown();
        return activity;
    }
    
    protected static CutsceneActivity createInstance(Player player) {
        return null; // To be overridden
    }
}