Anti-Bot.java

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.l2revive.antibot;

import com.l2revive.CustomConfig;
import com.l2revive.util.Util;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ScheduledFuture;
import java.util.logging.Logger;
import net.sf.l2j.Config;
import net.sf.l2j.gameserver.ThreadPoolManager;
import net.sf.l2j.gameserver.model.L2Object;
import net.sf.l2j.gameserver.model.actor.L2Character;
import net.sf.l2j.gameserver.model.actor.L2Summon;
import net.sf.l2j.gameserver.model.actor.instance.L2GrandBossInstance;
import net.sf.l2j.gameserver.model.actor.instance.L2PcInstance;
import net.sf.l2j.gameserver.model.actor.instance.L2RaidBossInstance;
import net.sf.l2j.gameserver.network.SystemMessageId;
import net.sf.l2j.gameserver.network.serverpackets.SystemMessage;
import net.sf.l2j.gameserver.skills.AbnormalEffect;
import net.sf.l2j.gameserver.util.IllegalPlayerAction;

public class AntiBot {

    private static final Logger _log = Logger.getLogger(AntiBot.class.getName());
    private CustomConfig _config;
    private Map<L2PcInstance, BotResults> _players;// player=>BotResults(success/fail)
    private Map<L2PcInstance, String> _codes;
    protected Map<L2PcInstance, BotEye> _activeEyes;

    public static AntiBot getInstance() {
        return SingletonHolder._instance;
    }

    public AntiBot() {
        _log.info("AntiBot: Loading...");
        _players = new HashMap<>();
        _codes = new HashMap<>();
        _activeEyes = new HashMap<>();
    }

    public void setConfig(CustomConfig config) {
        _config = config;
        String triggerChance = getConfig().getString("AntiBotTriggerChance");
        if (triggerChance == null) {
            _log.info("AntiBot: #setConfig invalid value for AntiBotTriggerChance; defaulting to 3.");
            getConfig().set("TriggerChance", "3");
        }
        String checkInterval = getConfig().getString("AntiBotReCheckInterval");
        if (checkInterval == null) {
            _log.info("AntiBot: #setConfig invalid value for AntiBotReCheckInterval; defaulting to 60.");
            getConfig().set("AntiBotReCheckInterval", "60");
        }
    }

    private CustomConfig getConfig() {
        return _config;
    }

    public void add(L2PcInstance player) {
        _players.put(player, new BotResults(0, 0));
        player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_SYSMSG_RED).addString("AntiBot: Initialized Successfully."));
    }

    public void remove(L2PcInstance player) {
        _players.remove(player);
    }

    public void onKill(L2Character character) {
        L2PcInstance player = null;
        L2Object target = (character != null) ? character.getTarget() : null;
        if (character instanceof L2PcInstance) {
            player = (L2PcInstance) character;
        } else if (character instanceof L2Summon) {
            player = ((L2Summon) character).getActingPlayer();
        }
        if (player == null) {
            _log.info("AntiBot: #onKill for null.");
            return;
        }
        /*
         * note: below disabled anti-bot on raids to prevent item stealing.
         */
        if (target instanceof L2RaidBossInstance || target instanceof L2GrandBossInstance) {
            return;
        }
        /*
         * note: below disabled anti-bot on players and summons to prevent pvp interruption.
         */
        if (target instanceof L2PcInstance || target instanceof L2Summon) {
            return;
        }
        if (!_players.containsKey(player)) {
            _players.put(player, new BotResults(0, 0));
            triggerCaptcha(player, true);
        }
        int triggerChance = getConfig().getInteger("AntiBotTriggerChance");
        if ((Math.random() * 100) < triggerChance && !_activeEyes.containsKey(player)) {
            triggerCaptcha(player, true);
        }
    }

    private void triggerCaptcha(L2PcInstance player, boolean setEffect) {
        int id = (int) ((Math.random() * 1000) + 1);
        if (id < 100) {
            id = id + 100;
        }
        String code = String.valueOf(id);
        //_log.info("code=" + code);
        _codes.put(player, code);
        DDSConverter.sendImage(player, id, DDSConverter.generateImage(code));
        //DDSConverter.sendImage(player, id, "data/images/image.png");
        int seconds = getConfig().getInteger("AntiBotReCheckInterval");
        String html = "<html><title>AntiBot</title><body><center><br><br>"
                + "<font color=\"AA00AA\">L2Makai Anti Bot System</font><br><br>"
                + "<img src=\"Crest.crest_" + Config.SERVER_ID + "_" + id + "\" width=128 height=32><br>"
                + "<edit width=120 var=\"code\"><br>"
                + "<button action=\"bypass -h antibot $code\" value=\"Submit Code\" width=75 height=21 back=\"L2UI_ch3.Btn1_normalOn\" fore=\"L2UI_ch3.Btn1_normal\">"
                + "<br><br>If you close this window, use <font color=\"LEVEL\">/code</font><br>"
                + "You have <font color=\"LEVEL\">" + seconds + " seconds</font> to complete the captcha!<br>"
                + "<a action=\"bypass -h antibot refresh\"><font color=\"990099\">Refresh Image Above</font></a><br>"
                + "</center></body></html>";
        Util.sendRawHtml(player, html);
        if (setEffect) {
            player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_SYSMSG_RED).addString("AntiBot: /code"));
            ((L2Character) player).startAbnormalEffect(AbnormalEffect.FIREROOT_STUN);
            player.setIsImmobilized(true);
            player.setIsInvul(true);
            _activeEyes.put(player, new BotEye(player, seconds));
        }
    }

    public void show(L2PcInstance player) {
        if (_activeEyes.containsKey(player)) {
            triggerCaptcha(player, false);
        }
    }

    public void validate(L2PcInstance player, String code) {
        //_log.log(Level.INFO, "validate={0}", code);
        code = code.trim();
        if (code == null || code.equalsIgnoreCase("refresh")) {
            triggerCaptcha(player, false);
            return;
        }
        String valid = _codes.get(player);
        boolean status = false;
        if (valid != null && valid.equalsIgnoreCase(code)) {
            player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_SYSMSG_RED).addString("AntiBot: Success! You have also been healed."));
            ((L2Character) player).stopAbnormalEffect(AbnormalEffect.FIREROOT_STUN);
            player.setIsImmobilized(false);
            player.setIsInvul(false);
            player.setCurrentHp(player.getMaxHp());
            if (_activeEyes.containsKey(player)) {
                _activeEyes.remove(player).cancel();
            }
            status = true;
        } else {
            player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.S1_SYSMSG_RED).addString("AntiBot: Incorrect! Please try again."));
            triggerCaptcha(player, false);
        }
        BotResults res = _players.get(player);
        _players.put(player, new BotResults(res._success + (status ? 1 : 0), res._fails + (!status ? 1 : 0)));
    }

    private static class SingletonHolder {

        protected static final AntiBot _instance = new AntiBot();
    }

    public static final class BotResults {

        public final int _success;
        public final int _fails;

        public BotResults(int success, int fails) {
            _success = success;
            _fails = fails;
        }
    }

    private final class BotEye implements Runnable {

        private ScheduledFuture _task;
        private int _delay;
        private L2PcInstance _player;

        public BotEye(L2PcInstance player, int delay) {
            _player = player;
            _delay = delay;
            run();
        }

        /*
         * if we reach here, then the player did not enter the code intime.
         */
        @Override
        public void run() {
            if (_delay < 1) {
                net.sf.l2j.gameserver.util.Util.handleIllegalPlayerAction(_player, "Player " + _player.getName() + " did not enter the antibot captcha intime.", IllegalPlayerAction.PUNISH_KICK);
                return;
            }
            handleTick();
            _task = ThreadPoolManager.getInstance().scheduleGeneral(this, 1000);
            _delay--;
        }

        public void cancel() {
            if (_task != null) {
                _task.cancel(true);
            }
        }

        private void handleTick() {
            switch (_delay) {
                case 30:
                case 10:
                case 5:
                case 4:
                case 3:
                case 2:
                case 1:
                    Util.sendMessageInBlue(_player, "AntiBot: You have " + _delay + " seconds to complete the captcha.");
                    break;
            }
        }
    }
}