[Open Source] Level Up Listener

[Mad 86]

Hey guys i made a little level up listener since the message listener is pretty unreliable.

 

I wrote this for topbot, so you'll need to change a few of the imports to match dreambot, I cba to do it.

I think just the Skills class is all that needs to be changed.

 

 

LevelManager.java

package org.maddev;

import org.tbot.bot.TBot;
import org.tbot.methods.Skills;

import java.util.*;

/**
 * Created by mad on 4/15/16.
 */
public class LevelManager
{

    private int listenerDelay;
    private boolean destroyDispatcher;
    private final List<LevelListener> listeners;

    public LevelManager()
    {
        this.listeners = Collections.synchronizedList(new ArrayList<LevelListener>());
        this.listenerDelay = 300;
        changeListener().start();
    }

    public void destroyDispatcher()
    {
        this.destroyDispatcher = true;
    }

    public void setListenerDelay(int listenerDelay)
    {
        this.listenerDelay = listenerDelay;
    }

    public LevelManager appendListener(LevelListener e)
    {
        listeners.add(e);
        return this;
    }

    public LevelManager removeListener(LevelListener e)
    {
        listeners.remove(e);
        return this;
    }

    private void fireChangeEvent(LevelEvent event)
    {
        for (EventListener listener : listeners)
        {
            final LevelListener l = (LevelListener) listener;
            l.onLevelUp(event);
        }
    }

    private Thread changeListener()
    {
        return new Thread(new Runnable()
        {
            @Override
            public void run()
            {
                try
                {
                    initDifferenceChecker();
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
        });
    }

    private void initDifferenceChecker() throws InterruptedException
    {
        Map<Skills.Skill, Integer> cache = updateCache();
        boolean isRunning = true;
        while (isRunning && !destroyDispatcher)
        {
            isRunning = TBot.getBot().getScriptHandler().getScript() != null;
            final Skills.Skill[] currentSkills = Skills.Skill.values();
            for(int i = 0; i < currentSkills.length; i++)
            {
                final Skills.Skill current = currentSkills[i];
                if(current == null)
                {
                    continue;
                }
                final int level = Skills.getRealLevel(current);
                final int cachedLevel = cache.get(current);
                if(level != cachedLevel)
                {
                    fireChangeEvent(new LevelEvent(current));
                    cache = updateCache();
                }
            }
            Thread.sleep(this.listenerDelay);
        }
    }

    private Map<Skills.Skill, Integer> updateCache()
    {
        final Map<Skills.Skill, Integer> cache = new HashMap<>();
        for (Skills.Skill skill : Skills.Skill.values())
        {
            cache.put(skill, Skills.getRealLevel(skill));
        }
        return cache;
    }
}

LevelEvent.java

package org.maddev;

import org.tbot.methods.Skills;

import java.util.EventObject;

/**
 * Created by mad on 4/15/16.
 */
public class LevelEvent extends EventObject
{
    private final Object source;

    public LevelEvent(Object source)
    {
        super(source);
        this.source = source;
    }

    public Skills.Skill getSkillChanged()
    {
        Skills.Skill changed = (Skills.Skill) source;
        return changed;
    }

    @Override
    public Object getSource()
    {
        return source;
    }
}

LevelListener.java

package org.maddev;

import java.util.EventListener;

/**
 * Created by mad on 4/15/16.
 */
public interface LevelListener extends EventListener
{
    void onLevelUp(LevelEvent event);
}

Usage:

package org.maddev;

import org.tbot.internal.AbstractScript;
import org.tbot.internal.Manifest;
import org.tbot.methods.Skills;

/**
 * Created by mad on 4/15/16.
 */
@Manifest(authors = "Mad", name = "LevelListener Test")
public class App extends AbstractScript implements LevelListener
{

    public boolean onStart()
    {
        final LevelManager manager = new LevelManager();
        manager.appendListener(this);
        manager.setListenerDelay(400);
        return true;
    }

    @Override
    public void onLevelUp(LevelEvent event)
    {
        Skills.Skill changed = event.getSkillChanged();
        System.out.println(changed);
    }
 

You create an instance of LevelManager, and add a listener of the current class that implements LevelListener.

You can also set the delay for how often it checks, and also destroy the listener.

[Dogerina 330]

Hey man, advertising other bots is against the rules.

[Calculus 30]

Little more complicated than it needs to be I think....

[Mad 86]

Little more complicated than it needs to be I think....

How so?

[Rabrg 83]

    @Override

    public void onGameMessage(final Message message) {

        if (message.getMessage().startsWith("Congratulations, you just advanced")) {

            final Skill skill = Skill.valueOf(message.getMessage().split(" level.")[0].split(" ")[5].toUpperCase());

            // skill leveled up

        }

    }