Cooldown Manager

hyym, I using code like that in my projects:

Code:java

import java.util.HashMap;
import java.util.EnumMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.UUID;
 
import org.bukkit.configuration.serialization.ConfigurationSerializable;
import org.bukkit.configuration.serialization.ConfigurationSerialization;
 
public class Cooldown implements ConfigurationSerializable
{
    static
    {
        ConfigurationSerialization.registerClass(Cooldown.class);
        ConfigurationSerialization.registerClass(CooldownPlayer.class);
        Cooldown.instance = new Cooldown();
    }
 
    /**
    * returns instance of that class
    * I'm using it as object to use ConfigurationSerializable
    */
    public static Cooldown getInstance()
    {
        if (Cooldown.instance == null) // just for sure...
        {
            Cooldown.instance = new Cooldown();
        }
        return Cooldown.instance;
    }
 
    private static Cooldown instance;
 
    /**
    * Enum of possible types of Cooldown, it's much simpler and easier that using strings (for me :P)
    */
    public static enum CooldownType
    {
        FIRST_TYPE(1000 * 30), // 30 sec
        COMMAND(1000 * 60), // 1 min
        SOMETHING(1000 * 60 * 10), // 10 min
        YOU_CAN_ADD_MORE(1000 * 60 * 60), // 1 hour
        private long time;
 
        CooldownType(final long time)
        {
            this.time = time;
        }
 
        /**
        * returns time in milliseconds
        */
        public long getTime()
        {
            return this.time;
        }
 
        /**
        * Set new time of cooldown -> if you want loading it from confg file
        *
        * @param time
        *          new time
        */
        public void setTime(final long time)
        {
            this.time = time;
        }
 
        /**
        * returns difference between selected time.
        *
        * @param time
        *          other time
        */
        public long getDelta(final long time)
        {
            return time - this.getTime();
        }
    }
 
    /**
    * Object for storing data about player
    */
    public static final class CooldownPlayer implements ConfigurationSerializable
    {
        // You can add field with player nickname/UUID here if you need.
 
        /**
        * map for storing time of cooldowns
        */
        private final EnumMap<CooldownType, Long> cooldown = new EnumMap<>(CooldownType.class);
 
        /**
        * returns map
        */
        public EnumMap<CooldownType, Long> getCooldownMap()
        {
            return this.cooldown;
        }
 
        /**
        * to add other map of cooldowns
        */
        public void addCooldowns(final Map<CooldownType, Long> map)
        {
            this.cooldown.putAll(map);
        }
 
        /**
        * add new cooldown
        *
        * @param type
        *          type of it.
        * @param time
        *          time of start
        */
        public void addCooldown(final CooldownType type, final Long time)
        {
            this.cooldown.put(type, time);
        }
 
        /**
        * add new cooldown with actual time
        *
        * @param type
        *          type of it
        */
        public void addCooldown(final CooldownType type)
        {
            this.cooldown.put(type, Cooldown.getATime());
        }
 
        /**
        * returns time of start for selected type
        */
        public long getLastUse(final CooldownType type)
        {
            final Long lastUse = this.cooldown.get(type);
            if (lastUse == null)
                return 0;
            return lastUse;
        }
 
        /**
        * returns difference between selected time and time of cooldown start
        */
        public long getDelta(final CooldownType type, final long aTime)
        {
            return aTime - this.getLastUse(type);
        }
 
        /**
        * returns difference between actual time and time of cooldown start
        */
        public long getDelta(final CooldownType type)
        {
            return Cooldown.getATime() - this.getLastUse(type);
        }
 
        /**
        * returns result.
        * If cooldown is already ended, it will start next. // you can change that if you need
        */
        public CooldownResult getResult(final CooldownType type)
        {
            final long aTime = Cooldown.getATime();
            final long delta = type.getDelta(aTime);
            final boolean canUse = delta > type.getTime();
            if (canUse)
                this.addCooldown(type, aTime);
            return new CooldownResult(delta, canUse);
        }
 
        @Override
        public int hashCode()
        {
            final int prime = 31;
            int result = 1;
            result = (prime * result) + ((this.cooldown == null) ? 0 : this.cooldown.hashCode());
            return result;
        }
 
        @Override
        public boolean equals(final Object obj)
        {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (this.getClass() != obj.getClass())
                return false;
            final CooldownPlayer other = (CooldownPlayer) obj;
            if (this.cooldown == null)
            {
                if (other.cooldown != null)
                    return false;
            } else if (!this.cooldown.equals(other.cooldown))
                return false;
            return true;
        }
 
        @Override
        public Map<String, Object> serialize()
        {
            final Map<String, Object> map = new HashMap<>();
            for (final Entry<CooldownType, Long> entry : this.cooldown.entrySet())
            {
                map.put(entry.getKey().name(), entry.getValue());
            }
            return map;
        }
 
        public CooldownPlayer()
        {}
 
        public CooldownPlayer(final Map<String, Object> map)
        {
            for (final Entry<String, Object> entry : map.entrySet())
            {
                this.addCooldown(CooldownType.valueOf(entry.getKey()), ((Number) entry.getValue()).longValue()); //config like get number as int if possible, so I always casting to Number and then using one of methods to get correct type ;)
            }
        }
    }
 
    /**
    * Object for storing result
    */
    public static final class CooldownResult
    {
 
        private final long delta;
        private final boolean result;
        private CooldownResult(final long delta, final boolean result)
        {
            this.delta = delta;
            this.result = result;
        }
 
        /**
        * Returns time to use - can be negative
        */
        public long getDelta()
        {
            return this.delta;
        }
 
        /**
        * If that returns true -> player can use what they want, if false -> cooldown is active.
        */
        public boolean getResult()
        {
            return this.result;
        }
 
        @Override
        public int hashCode()
        {
            final int prime = 31;
            int result = 1;
            result = (prime * result) + (int) (this.delta ^ (this.delta >>> 32));
            result = (prime * result) + (this.result ? 1231 : 1237);
            return result;
        }
 
        @Override
        public boolean equals(final Object obj)
        {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (this.getClass() != obj.getClass())
                return false;
            final CooldownResult other = (CooldownResult) obj;
            if (this.delta != other.delta)
                return false;
            if (this.result != other.result)
                return false;
            return true;
        }
    }
 
    /**
    * Map for storing all players
    */
    private final Map<UUID, CooldownPlayer> cooldowns = new HashMap<>();
 
    public Map<UUID, CooldownPlayer> getCooldownsMap()
    {
        return this.cooldowns;
    }
 
    /**
    * Resturns result for selected player and type of cooldown, PS: it will start new cooldown if needed.
    * That is the only method that you need -> or static method some lines below.
    */
    public CooldownResult getResult(final UUID playerID, final CooldownType type)
    {
        final CooldownPlayer player = this.getPlayer(playerID);
        return player.getResult(type);
    }
 
    /**
    * Delete player from map -> use when player logout and save cooldowns if you want.
    */
    public void removePlayer(final UUID playerID)
    {
        this.cooldowns.remove(playerID);
    }
 
    /**
    * add player to map -> when you load it from file if you using saving.
    */
    public void addPlayer(final UUID playerID, final CooldownPlayer player)
    {
        this.cooldowns.put(playerID, player);
    }
 
    /**
    * returns player from map or create new
    */
    public CooldownPlayer getPlayer(final UUID playerID)
    {
        CooldownPlayer player = this.cooldowns.get(playerID);
        if (player == null)
        {
            player = new CooldownPlayer();
            this.cooldowns.put(playerID, player);
        }
        return player;
    }
 
    /**
    * Static method to access "getResult" method
    * returns result for selected player and type of cooldown.
    *
    * If you don't need save cooldowns to files (to handle reloads/restarts etc..) then it's the only one method that you need.
    */
    public static CooldownResult getResultS(final UUID playerID, final CooldownType type)
    {
        return Cooldown.getInstance().getResult(playerID, type);
    }
 
    public static long getATime()
    {
        return System.currentTimeMillis();
    }
 
    @SuppressWarnings("unchecked")
    public Cooldown(final Map<String, Object> map)
    {
        for (final Entry<String, Object> entry : map.entrySet())
        {
            this.addPlayer(UUID.fromString(entry.getKey()), (CooldownPlayer) entry.getValue());
        }
    }
 
    @Override
    public Map<String, Object> serialize()
    {
        final Map<String, Object> map = new HashMap<>();
        for (final Entry<UUID, CooldownPlayer> entry : this.cooldowns.entrySet())
        {
            map.put(entry.getKey().toString(), entry.getValue());
        }
        return map;
    }
}
 

I must change some methods to remove calls to my plugin, but it still should works fine (maybe :<)

And it's very easy to use!
eg: command with cooldown

Code:java

@Override
public boolean onCommand(final CommandSender sender, final Command cmd, final String alias, final String[] args)
{
    if (! (sender instanceof Player))
    {
        return true;
    }
    Player player = (Player) sender;
    UUID id = player.getUniqueId();
    CooldownResult result = Cooldown.getResultS(id, CooldownType.HOME_CMD);
    if(result.getResult())
    {
        player.sendMessage("You can use that command!");
    }
    else
    {
        player.sendMessage("You must still wait: "+(result.getDelta()/1000)+" seconds to use that command!");
    }
}

And you don't must do anything more -> any registers, any creating players etc.
Only add own CooldownTypes

And if you need... then also some system to save it to file/files


Maybe it's not perfect, but I still love it

 

Smerfa It's a good code too I am in my phone but when I get in my computer I read all of your code