LINEAGE 2 🎪 Criação de Eventos Automáticos 🎪

[hamiltoncw 1.532]

HC CURSOS E TUTORIAIS

É necessário se cadastrar para acessar o conteúdo.

• Entre
• ou
• Cadastre-se

 

 

## 📝 Introdução
Eventos são fundamentais para manter os jogadores engajados e criar momentos especiais no servidor. Este tutorial ensina como criar um sistema completo de eventos automáticos com agendamento, mecânicas variadas e recompensas.

## 🎯 O que você vai aprender
- Sistema de agendamento de eventos
- Eventos PvP automáticos
- Eventos PvE cooperativos
- Sistema de recompensas dinâmicas
- Interface de gerenciamento de eventos

## 🏗️ Sistema Base de Eventos

### Event Manager Framework
```java
// EventManager.java
public class EventManager {
    
    private static final Map<String, AutomaticEvent> REGISTERED_EVENTS = new HashMap<>();
    private static final Map<String, EventSchedule> EVENT_SCHEDULES = new HashMap<>();
    private static final ScheduledExecutorService SCHEDULER = Executors.newScheduledThreadPool(3);
    
    private static AutomaticEvent currentEvent = null;
    private static long lastEventEnd = 0;
    
    static {
        registerEvents();
        startEventScheduler();
    }
    
    private static void registerEvents() {
        // Registrar todos os tipos de evento
        REGISTERED_EVENTS.put("team_vs_team", new TeamVsTeamEvent());
        REGISTERED_EVENTS.put("treasure_hunt", new TreasureHuntEvent());
        REGISTERED_EVENTS.put("boss_raid", new BossRaidEvent());
        REGISTERED_EVENTS.put("capture_flag", new CaptureFlagEvent());
        REGISTERED_EVENTS.put("monster_invasion", new MonsterInvasionEvent());
        REGISTERED_EVENTS.put("race_event", new RaceEvent());
        REGISTERED_EVENTS.put("survival_challenge", new SurvivalChallengeEvent());
    }
    
    private static void startEventScheduler() {
        // Verificar eventos a cada minuto
        SCHEDULER.scheduleAtFixedRate(() -> {
            checkScheduledEvents();
        }, 1, 1, TimeUnit.MINUTES);
        
        // Anunciar próximos eventos
        SCHEDULER.scheduleAtFixedRate(() -> {
            announceUpcomingEvents();
        }, 5, 5, TimeUnit.MINUTES);
    }
    
    public static void scheduleEvent(String eventType, String cronExpression, EventConfig config) {
        EventSchedule schedule = new EventSchedule(eventType, cronExpression, config);
        EVENT_SCHEDULES.put(eventType + "_" + System.currentTimeMillis(), schedule);
        
        System.out.println("Evento agendado: " + eventType + " - " + cronExpression);
    }
    
    public static boolean startEvent(String eventType, EventConfig config) {
        if (currentEvent != null && currentEvent.isActive()) {
            return false; // Já há evento ativo
        }
        
        AutomaticEvent event = REGISTERED_EVENTS.get(eventType);
        if (event == null) {
            System.out.println("Tipo de evento desconhecido: " + eventType);
            return false;
        }
        
        try {
            // Configurar evento
            event.configure(config);
            
            // Verificar se há players suficientes
            if (!hasMinimumPlayers(event.getMinPlayers())) {
                announceToAll("Evento " + event.getName() + " cancelado por falta de jogadores!");
                return false;
            }
            
            // Iniciar evento
            currentEvent = event;
            event.start();
            
            // Log do evento
            logEventStart(eventType, config);
            
            return true;
            
        } catch (Exception e) {
            System.err.println("Erro ao iniciar evento " + eventType + ": " + e.getMessage());
            return false;
        }
    }
    
    public static void endCurrentEvent(boolean forced) {
        if (currentEvent != null) {
            try {
                currentEvent.end(forced);
                logEventEnd(currentEvent.getEventType(), forced);
                lastEventEnd = System.currentTimeMillis();
            } catch (Exception e) {
                System.err.println("Erro ao finalizar evento: " + e.getMessage());
            } finally {
                currentEvent = null;
            }
        }
    }
    
    private static void checkScheduledEvents() {
        long currentTime = System.currentTimeMillis();
        
        // Cooldown entre eventos (mínimo 15 minutos)
        if (currentTime - lastEventEnd < 15 * 60 * 1000) {
            return;
        }
        
        for (EventSchedule schedule : EVENT_SCHEDULES.values()) {
            if (schedule.shouldTrigger(currentTime)) {
                startEvent(schedule.getEventType(), schedule.getConfig());
                break; // Apenas um evento por vez
            }
        }
    }
    
    private static void announceUpcomingEvents() {
        long currentTime = System.currentTimeMillis();
        long nextHour = currentTime + 60 * 60 * 1000; // Próxima hora
        
        for (EventSchedule schedule : EVENT_SCHEDULES.values()) {
            long nextTrigger = schedule.getNextTriggerTime(currentTime);
            
            if (nextTrigger > currentTime && nextTrigger <= nextHour) {
                long minutesUntil = (nextTrigger - currentTime) / (60 * 1000);
                
                AutomaticEvent event = REGISTERED_EVENTS.get(schedule.getEventType());
                if (event != null) {
                    announceToAll(String.format("🎪 %s começará em %d minutos!", 
                        event.getName(), minutesUntil));
                }
            }
        }
    }
    
    // Métodos auxiliares
    private static boolean hasMinimumPlayers(int minPlayers) {
        int onlinePlayers = L2World.getInstance().getAllPlayersCount();
        return onlinePlayers >= minPlayers;
    }
    
    private static void logEventStart(String eventType, EventConfig config) {
        System.out.println(String.format("[EVENT] %s iniciado - Config: %s", 
            eventType, config.toString()));
    }
    
    private static void logEventEnd(String eventType, boolean forced) {
        System.out.println(String.format("[EVENT] %s finalizado %s", 
            eventType, forced ? "(forçado)" : "(normal)"));
    }
    
    // Getters
    public static AutomaticEvent getCurrentEvent() { return currentEvent; }
    public static boolean hasActiveEvent() { return currentEvent != null && currentEvent.isActive(); }
}
```

### Base Event Class
```java
// AutomaticEvent.java
public abstract class AutomaticEvent {
    
    protected String eventType;
    protected String eventName;
    protected EventConfig config;
    protected boolean active = false;
    protected long startTime;
    protected long duration;
    
    protected List<L2PcInstance> participants = new ArrayList<>();
    protected EventState currentState = EventState.WAITING;
    
    public AutomaticEvent(String eventType, String eventName) {
        this.eventType = eventType;
        this.eventName = eventName;
    }
    
    public void configure(EventConfig config) {
        this.config = config;
        this.duration = config.getDurationMinutes() * 60 * 1000;
    }
    
    public final void start() {
        this.startTime = System.currentTimeMillis();
        this.active = true;
        this.currentState = EventState.REGISTRATION;
        
        // Anunciar início
        announceEventStart();
        
        // Período de registro
        ThreadPoolManager.getInstance().scheduleGeneral(() -> {
            if (active) {
                beginEvent();
            }
        }, config.getRegistrationTimeMinutes() * 60 * 1000);
        
        // Auto-finalizar após duração
        ThreadPoolManager.getInstance().scheduleGeneral(() -> {
            if (active) {
                end(false);
            }
        }, duration);
        
        // Chamada específica do evento
        onEventStart();
    }
    
    public final void end(boolean forced) {
        this.active = false;
        this.currentState = EventState.FINISHED;
        
        try {
            // Finalizar lógica específica
            onEventEnd(forced);
            
            // Distribuir recompensas finais
            distributeRewards();
            
            // Teleportar participantes de volta
            teleportParticipantsBack();
            
            // Anunciar fim
            announceEventEnd(forced);
            
        } catch (Exception e) {
            System.err.println("Erro ao finalizar evento: " + e.getMessage());
        }
    }
    
    protected void beginEvent() {
        this.currentState = EventState.ACTIVE;
        
        if (participants.size() < getMinPlayers()) {
            announceToAll("Evento cancelado: jogadores insuficientes!");
            end(true);
            return;
        }
        
        // Teleportar participantes
        teleportParticipantsToEvent();
        
        // Iniciar lógica específica
        onEventBegin();
    }
    
    public boolean registerPlayer(L2PcInstance player) {
        if (currentState != EventState.REGISTRATION) {
            player.sendMessage("Período de registro encerrado!");
            return false;
        }
        
        if (participants.contains(player)) {
            player.sendMessage("Você já está registrado neste evento!");
            return false;
        }
        
        if (!canPlayerParticipate(player)) {
            return false;
        }
        
        participants.add(player);
        onPlayerRegister(player);
        
        player.sendMessage("Você se registrou para o evento: " + eventName);
        announceToAll(player.getName() + " se registrou! (" + participants.size() + " participantes)");
        
        return true;
    }
    
    protected boolean canPlayerParticipate(L2PcInstance player) {
        // Verificações básicas
        if (player.getLevel() < config.getMinLevel()) {
            player.sendMessage("Level mínimo necessário: " + config.getMinLevel());
            return false;
        }
        
        if (player.getLevel() > config.getMaxLevel()) {
            player.sendMessage("Level máximo permitido: " + config.getMaxLevel());
            return false;
        }
        
        if (player.isInOlympiadMode() || player.isInDuel()) {
            player.sendMessage("Você não pode participar durante olympiad ou duel!");
            return false;
        }
        
        if (player.getKarma() > 0 && !config.allowsKarmaPlayers()) {
            player.sendMessage("Jogadores com karma não podem participar!");
            return false;
        }
        
        return true;
    }
    
    protected void teleportParticipantsToEvent() {
        EventLocation eventLoc = getEventLocation();
        
        for (L2PcInstance player : participants) {
            // Salvar localização anterior
            player.setVar("event_return_x", String.valueOf(player.getX()));
            player.setVar("event_return_y", String.valueOf(player.getY()));
            player.setVar("event_return_z", String.valueOf(player.getZ()));
            
            // Teleportar para evento
            player.teleToLocation(eventLoc.getX(), eventLoc.getY(), eventLoc.getZ());
            player.sendMessage("Você foi teleportado para o evento!");
            
            // Aplicar proteções
            applyEventProtections(player);
        }
    }
    
    protected void teleportParticipantsBack() {
        for (L2PcInstance player : participants) {
            // Remover proteções
            removeEventProtections(player);
            
            // Teleportar de volta
            try {
                int returnX = Integer.parseInt(player.getVar("event_return_x"));
                int returnY = Integer.parseInt(player.getVar("event_return_y"));  
                int returnZ = Integer.parseInt(player.getVar("event_return_z"));
                
                player.teleToLocation(returnX, returnY, returnZ);
                
                // Limpar variáveis
                player.unsetVar("event_return_x");
                player.unsetVar("event_return_y");
                player.unsetVar("event_return_z");
                
            } catch (Exception e) {
                // Fallback para cidade segura
                player.teleToLocation(83400, 147943, -3404); // Giran
            }
        }
    }
    
    protected void applyEventProtections(L2PcInstance player) {
        // Proteção contra logout
        player.setEventParticipant(true);
        
        // Buffs de evento se configurado
        if (config.providesBuffs()) {
            applyEventBuffs(player);
        }
        
        // Heal completo
        player.setCurrentHp(player.getMaxHp());
        player.setCurrentMp(player.getMaxMp());
        player.setCurrentCp(player.getMaxCp());
    }
    
    // Métodos abstratos que cada evento deve implementar
    protected abstract void onEventStart();
    protected abstract void onEventBegin();
    protected abstract void onEventEnd(boolean forced);
    protected abstract void onPlayerRegister(L2PcInstance player);
    protected abstract void distributeRewards();
    protected abstract EventLocation getEventLocation();
    public abstract int getMinPlayers();
    
    // Getters
    public String getEventType() { return eventType; }
    public String getName() { return eventName; }
    public boolean isActive() { return active; }
    public EventState getCurrentState() { return currentState; }
    public List<L2PcInstance> getParticipants() { return new ArrayList<>(participants); }
    
    // Enums
    public enum EventState {
        WAITING, REGISTRATION, ACTIVE, FINISHED
    }
}
```

## ⚔️ Eventos PvP

### Team vs Team Event
```java
// TeamVsTeamEvent.java
public class TeamVsTeamEvent extends AutomaticEvent {
    
    private List<L2PcInstance> teamRed = new ArrayList<>();
    private List<L2PcInstance> teamBlue = new ArrayList<>();
    private Map<L2PcInstance, Integer> playerKills = new HashMap<>();
    private Map<L2PcInstance, Integer> playerDeaths = new HashMap<>();
    
    private int redTeamScore = 0;
    private int blueTeamScore = 0;
    private final int SCORE_TO_WIN = 50;
    
    public TeamVsTeamEvent() {
        super("team_vs_team", "Team vs Team");
    }
    
    @Override
    protected void onEventStart() {
        announceToAll("🔥 TEAM VS TEAM iniciando!");
        announceToAll("Primeiro time a fazer " + SCORE_TO_WIN + " kills ganha!");
        announceToAll("Digite .join para participar!");
    }
    
    @Override
    protected void onEventBegin() {
        // Dividir players em times
        dividePlayersIntoTeams();
        
        // Teleportar times para lados opostos
        teleportTeamsToPositions();
        
        // Iniciar contagem regressiva
        startCountdown();
    }
    
    private void dividePlayersIntoTeams() {
        Collections.shuffle(participants);
        
        for (int i = 0; i < participants.size(); i++) {
            L2PcInstance player = participants.get(i);
            
            if (i % 2 == 0) {
                teamRed.add(player);
                player.setTeam(1); // Red team
                player.setTitle("Red Team");
                player.getAppearance().setNameColor(0xFF0000);
            } else {
                teamBlue.add(player);
                player.setTeam(2); // Blue team
                player.setTitle("Blue Team");
                player.getAppearance().setNameColor(0x0000FF);
            }
            
            player.broadcastUserInfo();
            playerKills.put(player, 0);
            playerDeaths.put(player, 0);
        }
        
        announceToAll("Times formados: Red (" + teamRed.size() + ") vs Blue (" + teamBlue.size() + ")");
    }
    
    private void teleportTeamsToPositions() {
        // Posições do evento (exemplo: Coliseum)
        EventLocation redSpawn = new EventLocation(150086, 46733, -3412);
        EventLocation blueSpawn = new EventLocation(150986, 46733, -3412);
        
        // Teleportar time vermelho
        for (L2PcInstance player : teamRed) {
            int x = redSpawn.getX() + Rnd.get(-100, 100);
            int y = redSpawn.getY() + Rnd.get(-100, 100);
            player.teleToLocation(x, y, redSpawn.getZ());
        }
        
        // Teleportar time azul
        for (L2PcInstance player : teamBlue) {
            int x = blueSpawn.getX() + Rnd.get(-100, 100);
            int y = blueSpawn.getY() + Rnd.get(-100, 100);
            player.teleToLocation(x, y, blueSpawn.getZ());
        }
    }
    
    private void startCountdown() {
        // Congelar players
        for (L2PcInstance player : participants) {
            player.setIsImmobilized(true);
        }
        
        // Countdown 5 segundos
        for (int i = 5; i >= 1; i--) {
            final int count = i;
            ThreadPoolManager.getInstance().scheduleGeneral(() -> {
                announceToParticipants("Começando em: " + count);
            }, (5 - i) * 1000);
        }
        
        // Liberar movimento e iniciar batalha
        ThreadPoolManager.getInstance().scheduleGeneral(() -> {
            for (L2PcInstance player : participants) {
                player.setIsImmobilized(false);
            }
            announceToParticipants("🚀 LUTA COMEÇOU! BOA SORTE!");
        }, 5000);
    }
    
    public void onPlayerKill(L2PcInstance killer, L2PcInstance victim) {
        if (!participants.contains(killer) || !participants.contains(victim)) {
            return;
        }
        
        // Aumentar kills do assassino
        int kills = playerKills.get(killer) + 1;
        playerKills.put(killer, kills);
        
        // Aumentar deaths da vítima
        int deaths = playerDeaths.get(victim) + 1;
        playerDeaths.put(victim, deaths);
        
        // Aumentar score do time
        if (teamRed.contains(killer)) {
            redTeamScore++;
            announceToParticipants(killer.getName() + " (Red) matou " + victim.getName() + 
                "! Score: Red " + redTeamScore + " - Blue " + blueTeamScore);
        } else {
            blueTeamScore++;
            announceToParticipants(killer.getName() + " (Blue) matou " + victim.getName() + 
                "! Score: Red " + redTeamScore + " - Blue " + blueTeamScore);
        }
        
        // Verificar vitória
        if (redTeamScore >= SCORE_TO_WIN) {
            endEventWithWinner("Red Team");
        } else if (blueTeamScore >= SCORE_TO_WIN) {
            endEventWithWinner("Blue Team");
        }
        
        // Ressuscitar vítima em local seguro
        ThreadPoolManager.getInstance().scheduleGeneral(() -> {
            revivePlayer(victim);
        }, 3000);
    }
    
    private void revivePlayer(L2PcInstance player) {
        if (player.isDead()) {
            player.doRevive();
            
            // Teleportar para spawn do time
            if (teamRed.contains(player)) {
                player.teleToLocation(150086, 46733, -3412);
            } else {
                player.teleToLocation(150986, 46733, -3412);
            }
            
            // Heal completo
            player.setCurrentHp(player.getMaxHp());
            player.setCurrentMp(player.getMaxMp());
            player.setCurrentCp(player.getMaxCp());
        }
    }
    
    private void endEventWithWinner(String winningTeam) {
        announceToAll("🏆 " + winningTeam + " VENCEU!");
        
        // Dar recompensas extras para o time vencedor
        List<L2PcInstance> winners = winningTeam.equals("Red Team") ? teamRed : teamBlue;
        for (L2PcInstance winner : winners) {
            giveWinnerRewards(winner);
        }
        
        end(false);
    }
    
    @Override
    protected void distributeRewards() {
        for (L2PcInstance player : participants) {
            int kills = playerKills.get(player);
            int deaths = playerDeaths.get(player);
            
            // Recompensa base
            int baseReward = 50000; // 50k adena
            
            // Bonus por kills
            int killBonus = kills * 10000; // 10k por kill
            
            // Penalty por deaths (máximo 50% da recompensa)
            int deathPenalty = Math.min(baseReward / 2, deaths * 5000);
            
            int totalReward = Math.max(10000, baseReward + killBonus - deathPenalty);
            
            // Dar recompensa
            player.addItem("EventReward", 57, totalReward, null, true);
            player.sendMessage(String.format("Recompensa TvT: %d adena (K:%d D:%d)", 
                totalReward, kills, deaths));
        }
    }
    
    private void giveWinnerRewards(L2PcInstance player) {
        // Recompensas extras para vencedores
        player.addItem("EventWinner", 6577, 1, null, true); // Blessed scroll
        player.addItem("EventWinner", 57, 100000, null, true); // 100k bonus
        player.sendMessage("🎉 Recompensa de vitória recebida!");
    }
    
    @Override
    protected void onEventEnd(boolean forced) {
        // Limpar teams
        for (L2PcInstance player : participants) {
            player.setTeam(0);
            player.setTitle("");
            player.getAppearance().setNameColor(0xFFFFFF);
            player.broadcastUserInfo();
        }
        
        if (!forced) {
            announceToAll("Team vs Team finalizado! Obrigado pela participação!");
        }
    }
    
    @Override
    protected void onPlayerRegister(L2PcInstance player) {
        // Preparação específica para TvT
    }
    
    @Override
    protected EventLocation getEventLocation() {
        return new EventLocation(150536, 46733, -3412); // Centro do coliseum
    }
    
    @Override
    public int getMinPlayers() {
        return 4; // Mínimo 2 vs 2
    }
}
```

### Capture the Flag Event
```java
// CaptureFlagEvent.java
public class CaptureFlagEvent extends AutomaticEvent {
    
    private L2NpcInstance redFlag;
    private L2NpcInstance blueFlag;
    private L2PcInstance redFlagCarrier;
    private L2PcInstance blueFlagCarrier;
    
    private int redCapturePoints = 0;
    private int blueCapturePoints = 0;
    private final int POINTS_TO_WIN = 3;
    
    public CaptureFlagEvent() {
        super("capture_flag", "Capture the Flag");
    }
    
    @Override
    protected void onEventBegin() {
        // Dividir em teams
        dividePlayersIntoTeams();
        
        // Spawnar bandeiras
        spawnFlags();
        
        // Iniciar mecânica de captura
        startFlagMechanics();
    }
    
    private void spawnFlags() {
        try {
            // Bandeira vermelha (base azul deve capturar)
            L2NpcTemplate redTemplate = NpcTable.getInstance().getTemplate(35001); // Custom flag NPC
            redFlag = new L2NpcInstance(IdFactory.getInstance().getNextId(), redTemplate);
            redFlag.spawnMe(150000, 46500, -3412);
            redFlag.setTitle("Red Flag");
            
            // Bandeira azul (base vermelha deve capturar)
            L2NpcTemplate blueTemplate = NpcTable.getInstance().getTemplate(35002);
            blueFlag = new L2NpcInstance(IdFactory.getInstance().getNextId(), blueTemplate);
            blueFlag.spawnMe(151000, 46500, -3412);
            blueFlag.setTitle("Blue Flag");
            
            announceToParticipants("Bandeiras spawnadas! Capture a bandeira inimiga!");
            
        } catch (Exception e) {
            System.err.println("Erro ao spawnar bandeiras: " + e.getMessage());
        }
    }
    
    public void onFlagClick(L2PcInstance player, L2NpcInstance flag) {
        if (!participants.contains(player)) return;
        
        if (flag == redFlag && player.getTeam() == 2) { // Blue player clicking red flag
            captureFlag(player, "red");
        } else if (flag == blueFlag && player.getTeam() == 1) { // Red player clicking blue flag
            captureFlag(player, "blue");
        } else {
            player.sendMessage("Você não pode capturar sua própria bandeira!");
        }
    }
    
    private void captureFlag(L2PcInstance player, String flagColor) {
        if (flagColor.equals("red") && redFlagCarrier != null) {
            player.sendMessage("A bandeira vermelha já foi capturada!");
            return;
        }
        
        if (flagColor.equals("blue") && blueFlagCarrier != null) {
            player.sendMessage("A bandeira azul já foi capturada!");
            return;
        }
        
        // Capturar bandeira
        if (flagColor.equals("red")) {
            redFlagCarrier = player;
            redFlag.deleteMe();
            player.setTitle("Carrying Red Flag");
        } else {
            blueFlagCarrier = player;
            blueFlag.deleteMe();
            player.setTitle("Carrying Blue Flag");
        }
        
        player.broadcastUserInfo();
        announceToParticipants(player.getName() + " capturou a bandeira " + flagColor + "!");
        
        // Marcar visualmente o portador
        player.startAbnormalEffect(L2Character.ABNORMAL_EFFECT_MAGIC_CIRCLE);
        
        // Verificar se chegou na base para pontuar
        startFlagDeliveryCheck(player, flagColor);
    }
    
    private void startFlagDeliveryCheck(L2PcInstance player, String flagColor) {
        ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(() -> {
            if (!participants.contains(player)) return;
            
            // Verificar se jogador morreu ou deslogou
            if (player.isDead() || !player.isOnline()) {
                dropFlag(player, flagColor);
                return;
            }
            
            // Verificar se chegou na base
            boolean atBase = false;
            
            if (flagColor.equals("red") && player.getTeam() == 2) { // Blue team
                atBase = player.getDistance(151000, 46500, -3412) < 100; // Blue base
            } else if (flagColor.equals("blue") && player.getTeam() == 1) { // Red team
                atBase = player.getDistance(150000, 46500, -3412) < 100; // Red base
            }
            
            if (atBase) {
                scorePoint(player, flagColor);
            }
            
        }, 1000, 1000); // Verificar a cada segundo
    }
    
    private void scorePoint(L2PcInstance player, String flagColor) {
        // Pontuação
        if (player.getTeam() == 1) { // Red team
            redCapturePoints++;
        } else {
            blueCapturePoints++;
        }
        
        announceToParticipants(String.format("%s pontuou! Red: %d - Blue: %d", 
            player.getName(), redCapturePoints, blueCapturePoints));
        
        // Reset flag
        resetFlag(player, flagColor);
        
        // Verificar vitória
        if (redCapturePoints >= POINTS_TO_WIN) {
            endEventWithWinner("Red Team");
        } else if (blueCapturePoints >= POINTS_TO_WIN) {
            endEventWithWinner("Blue Team");
        }
    }
    
    private void dropFlag(L2PcInstance player, String flagColor) {
        player.setTitle("");
        player.stopAbnormalEffect(L2Character.ABNORMAL_EFFECT_MAGIC_CIRCLE);
        player.broadcastUserInfo();
        
        announceToParticipants(player.getName() + " dropou a bandeira " + flagColor + "!");
        
        // Respawnar bandeira na posição original após 10 segundos
        ThreadPoolManager.getInstance().scheduleGeneral(() -> {
            resetFlag(player, flagColor);
        }, 10000);
    }
    
    private void resetFlag(L2PcInstance player, String flagColor) {
        player.setTitle("");
        player.stopAbnormalEffect(L2Character.ABNORMAL_EFFECT_MAGIC_CIRCLE);
        player.broadcastUserInfo();
        
        if (flagColor.equals("red")) {
            redFlagCarrier = null;
            // Respawnar bandeira vermelha
            try {
                L2NpcTemplate template = NpcTable.getInstance().getTemplate(35001);
                redFlag = new L2NpcInstance(IdFactory.getInstance().getNextId(), template);
                redFlag.spawnMe(150000, 46500, -3412);
                redFlag.setTitle("Red Flag");
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            blueFlagCarrier = null;
            // Respawnar bandeira azul
            try {
                L2NpcTemplate template = NpcTable.getInstance().getTemplate(35002);
                blueFlag = new L2NpcInstance(IdFactory.getInstance().getNextId(), template);
                blueFlag.spawnMe(151000, 46500, -3412);
                blueFlag.setTitle("Blue Flag");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    
    @Override
    protected void onEventEnd(boolean forced) {
        // Limpar bandeiras
        if (redFlag != null) redFlag.deleteMe();
        if (blueFlag != null) blueFlag.deleteMe();
        
        // Limpar efeitos dos players
        for (L2PcInstance player : participants) {
            player.setTitle("");
            player.setTeam(0);
            player.stopAbnormalEffect(L2Character.ABNORMAL_EFFECT_MAGIC_CIRCLE);
            player.broadcastUserInfo();
        }
    }
    
    // Implementar métodos abstratos restantes...
    @Override
    protected void onEventStart() {
        announceToAll("🏴 CAPTURE THE FLAG iniciando!");
    }
    
    @Override
    protected void distributeRewards() {
        // Distribuir recompensas baseadas na pontuação
        for (L2PcInstance player : participants) {
            int baseReward = 40000;
            player.addItem("CTFReward", 57, baseReward, null, true);
        }
    }
    
    @Override
    protected void onPlayerRegister(L2PcInstance player) {}
    
    @Override
    protected EventLocation getEventLocation() {
        return new EventLocation(150500, 46500, -3412);
    }
    
    @Override
    public int getMinPlayers() {
        return 4;
    }
}