Система временных эффектов (Замена Potion)

public class Buff {

    public final int id;

    private String name;

    //Число, определяющее координаты иконки баффа в файле с текстурами.
    private int iconIndex;

    //keepOnDeath определяет, сохранять ли бафф при смерти.
    //isPersistent определяет бессрочность эффекта, эффект не исчезнет ни при смерти, ни со временем.
    private boolean keepOnDeath, isPersistent;

    //Создаём массив объектов.
    public static List<Buff> buffs = new ArrayList<Buff>();

    public Buff() {

        //Присваеваем идентификатор.
        this.id = buffs.size();

        //Добавляем созданный объект в массив ArrayList.
        this.buffs.add(this);
    }

    public static Buff of(int buffId) {

        return buffs.get(buffId);
    }

    //Метод, который применяет эффект баффа если isReady() возвращает true.
    protected void onActive(EntityLivingBase entityLivingBase, World world, ActiveBuff buff) {

        int
        tier = buff.getTier(),
        duration = buff.getDuration();
    }

    //Служебный метод, определяющий возможность применить эффект в onActive().
    protected boolean isReady(ActiveBuff buff) {

        int
        tier = buff.getTier(),
        duration = buff.getDuration();

        return false;
    }

    //Добавляем эффект баффа на сервере.
    public void applyBuffEffect(EntityLivingBase entityLivingBase, World world, ActiveBuff buff) {

        if (!world.isRemote) {

            int
            id = buff.getId(),
            tier = buff.getTier();
        }
    }


    //Удаляем эффект баффа на сервере.
    public void removeBuffEffect(EntityLivingBase entityLivingBase, World world, ActiveBuff buff) {

        if (!world.isRemote) {

            int
            id = buff.getId(),
            tier = buff.getTier();
        }
    }

    //Сеттеры для описания свойств и геттеры.

    protected Buff setName(String name) {

        this.name = name;

        return this;
    }

    public String getName() {

        return this.name;
    }

    protected Buff setIconIndex(int x, int y) {

        this.iconIndex = x + y * 8;

        return this;
    }

    public int getIconIndex() {

        return this.iconIndex;
    }

    protected Buff keepOnDeath() {

        this.keepOnDeath = true;

        return this;
    }

    public boolean shouldKeepOnDeath() {

        return this.keepOnDeath;
    }

    protected Buff setPersistent() {

        this.isPersistent = true;

        return this;
    }

    public boolean isPersistent() {

        return this.isPersistent;
    }

    public String getDurationForDisplay(ActiveBuff buff) {

        //Возвращает оставшееся время до истечения действия баффа в формате "мм:сс".
        //Если флаг isPersistent = true, то вернёт строку "-:-", так как бафф постоянен.

        int
        i = buff.getDuration(),
        j = i / 20,
        k = j / 60;

        j %= 60;

        return Buff.of(buff.getId()).isPersistent ? "-:-" : j < 10 ? String.valueOf(k) + ":0" + String.valueOf(j) : String.valueOf(k) + ":" + String.valueOf(j);
    }
}

public class ActiveBuff {

    private int id, duration, tier;

    public ActiveBuff(int buffId, int buffTier, int buffDuration) {

        this.id = buffId;
        this.tier = buffTier;
        this.duration = buffDuration;
    }

    public ActiveBuff(int buffId, int buffDuration) {

        this.id = buffId;
        this.tier = 0;
        this.duration = buffDuration;
    }

    //Для удобства наложения постоянных баффов.
    public ActiveBuff(int buffId) {

        this.id = buffId;
        this.tier = 0;
        this.duration = 0;
    }


    //Метод, обновляющий бафф путём декремента продолжительности действия (duration), возвращает true если время действия не истекло.
    public boolean updateBuff(EntityLivingBase entityLivingBase, World world) {

        if (Buff.of(this.id).isPersistent() || this.duration > 0) {

            //Проверка допустимости применения эффекта (для эффектов с периодическим действием (прим. регенерация, отравление и т.д.).
            if (Buff.of(this.id).isReady(this)) {
 
                //Применение эффекта.
                Buff.of(this.id).onActive(entityLivingBase, world, this);
            }

            //Уменьшаем оставшееся время действия.
            if (!Buff.of(this.id).isPersistent()) {
            
                this.duration--;
            }
        }

        //true - время действия ещё не истекло, false - истекло, удаляем бафф.
        return Buff.of(this.id).isPersistent() || this.duration > 0;
    }

    //Комбинирование бафов с одинаковыми уровнями.
    public void combineBuffs(ActiveBuff buff) {

        //Обновляем время действия только если новый бафф будет активен дольше.
        if (buff.duration > this.duration) {
 
            this.duration = buff.duration;
        }
    }

    //Геттеры свойств.

    public int getId() {

        return this.id;
    }

    public int getDuration() {

        return this.duration;
    }

    public int getTier() {

        return this.tier;
    }

    public String getBuffName() {

        return Buff.of(this.id).getName();
    }

    //Упаковка баффа в NBTTagCompound.
    public NBTTagCompound saveBuffToNBT(ActiveBuff buff) {

        NBTTagCompound tagCompound = new NBTTagCompound();

        tagCompound.setByte("id", (byte) buff.getId());
        tagCompound.setByte("tier", (byte) buff.getTier());
        tagCompound.setInteger("duration", buff.getDuration());

        return tagCompound;
    }

    //Распаковка баффа из NBTTagCompound.
    public static ActiveBuff readBuffFromNBT(NBTTagCompound tagCompound) {

        return new ActiveBuff(tagCompound.getByte("id"), tagCompound.getByte("tier"), tagCompound.getInteger("duration"));
    }
}

public class BuffsLivingBase implements IExtendedEntityProperties {

    public final static String EEP_NAME = "BuffsLivingEEP";

    private EntityLivingBase livingBase;//Создаём поле EntityLivingBase.

    private World world;//Создаём поле World для удобства.

    public BuffsLivingBase() {}

    //Для регистрации.
    public static final void register(EntityLivingBase entity) {

        entity.registerExtendedProperties(BuffsLivingBase.EEP_NAME, new BuffsLivingBase());
    }

    //Для доступа к EEP.
    public static final BuffsLivingBase get(EntityLivingBase entityLiving) {

        return (BuffsLivingBase) entityLiving.getExtendedProperties(EEP_NAME);
    }

    @Override
    public void saveNBTData(NBTTagCompound mainCompound) {

        //Во избежание конфликтов с другими модами создаём собственный NBTTagCompound.
        NBTTagCompound buffsCompound = new NBTTagCompound();

        //Все наши данные храним в нашем компаунде.

        //Сохраняем его в общий NBTTagCompound, используя наш уникальный ключ - имя EEP.
        mainCompound.setTag(EEP_NAME, buffsCompound);
    }

    @Override
    public void loadNBTData(NBTTagCompound mainCompound) {

        //Загружаем наш NBTTagCompound.
        NBTTagCompound buffsCompound = (NBTTagCompound) mainCompound.getTag(EEP_NAME);
    }

    //Инициализируем наши поля
    @Override
    public void init(Entity entity, World world) {

        this.livingBase = (EntityLivingBase) entity;

        this.world = world;
    }

    //Создаем для них геттеры.
    public EntityLivingBase getEntityLiving() {

        return this.livingBase;
    }

    public World getWorld() {

        return this.world;
    }
}

public class BuffsEvents {

    //Регистрация EEP.
    @SubscribeEvent
    public void onEntityConstructing(EntityConstructing event) {

        //Регистрируем EEP для всех entity, которые наследуются от EntityLivingBase.
        if (event.entity instanceof EntityLivingBase) {

            if (BuffsLivingBase.get((EntityLivingBase) event.entity) == null) {

                BuffsLivingBase.register((EntityLivingBase) event.entity);
            }
        }
    }

    //Синхронизация баффов игрока при входе в мир.
    @SubscribeEvent
    public void onEntityJoinWorld(EntityJoinWorldEvent event) {

        if (event.entity instanceof EntityPlayer) {
         
            if (!event.entity.worldObj.isRemote) {
 
                EntityPlayer player = (EntityPlayer) event.entity;
 
                BuffsLivingBase eLivingBase = BuffsLivingBase.get(player);//Получении EEP с эффектами для игрока.
                 
                //Проверка карты на наличие баффов.
                if (eLivingBase.haveActiveBuffs()) {
     
                    //Перебор элементов коллекции активных эффектов.
                    for (ActiveBuff buff : eLivingBase.activeBuffsCollection()) {
                     
                        //Синхронизируем бафф с клиентом.
                        NetworkHandler.sendTo(new SyncBuff(buff), (EntityPlayerMP) player);
                    }
                }
            }
        }
    }

    //Вызов метода обновления эффектов всех ентити.
    @SubscribeEvent
    public void onPlayerUpdate(LivingUpdateEvent event) {

        if (event.entityLiving instanceof EntityLivingBase) {

            BuffsLivingBase.get(event.entityLiving).updateBuffs();
        }
    }

    //В случае смерти игрока снимаем все удаляемые эффекты.
    @SubscribeEvent
    public void onLivingDeath(LivingDeathEvent event) {

        if (event.entityLiving instanceof EntityPlayer) {

            if (!event.entityLiving.worldObj.isRemote) {

                //Вызываем метод удаления баффов.
                BuffsLivingBase.get(event.entityLiving).clearBuffs(true);
            }
        }
    }

    //В случае смерти или переходе между мирами загружаем наши эффекты для новой сущности игрока.
    @SubscribeEvent
    public void onPlayerClone(PlayerEvent.Clone event) {

        BuffsLivingBase eLivingBase = BuffsLivingBase.get(event.entityPlayer);

        NBTTagCompound tagCompound = new NBTTagCompound();

        BuffsLivingBase.get(event.original).saveNBTData(tagCompound);
        eLivingBase.loadNBTData(tagCompound);
    }
}

public class BuffsOverlay {

    private static BuffsOverlay instance = new BuffsOverlay();

    private static Minecraft mc = Minecraft.getMinecraft();

    //Указываем путь к файлу иконок и действительное название.
    private static final ResourceLocation buffIcons = new ResourceLocation(BuffsMain.MODID, "textures/gui/buffIcons.png");

    private BuffsOverlay() {}

    public static BuffsOverlay getInstance() {

        return instance;
    }

    public void renderBuffs() {

        if (this.mc.inGameHasFocus) {

            EntityPlayer player = this.mc.thePlayer;

            BuffsLivingBase eLivingBase = BuffsLivingBase.get(player);

            ScaledResolution scaledResolution = new ScaledResolution(this.mc, this.mc.displayWidth, this.mc.displayHeight);

            int
            i = scaledResolution.getScaledWidth() / 2 + 240,
            j = scaledResolution.getScaledHeight() - 30,
            counter = 0,
            index = 0;

            if (eLivingBase.haveActiveBuffs()) {
 
                //Перебор элементов коллекции активных эффектов.
                for (ActiveBuff buff : eLivingBase.activeBuffsCollection()) {
 
                    index = Buff.of(buff.getId()).getIconIndex();
 
                    counter++; 
 
                    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
                    GL11.glDisable(GL11.GL_LIGHTING); 
                    GL11.glEnable(GL11.GL_BLEND);
                                 
                    GL11.glPushMatrix();
 
                    GL11.glTranslatef(i + 5, j + 25 - 24 * counter, 0.0F);
                    GL11.glScalef(0.5F, 0.5F, 0.5F);
 
                    this.mc.getTextureManager().bindTexture(buffIcons);
                    this.drawTexturedRect(0, 0, index % 8 * 32, index / 8 * 32, 32, 32, 32, 32); //Рендерим иконку.
 
                    GL11.glPopMatrix();
 
                    GL11.glPushMatrix();
 
                    GL11.glTranslatef(i + 15, j + 42 - 24 * counter, 0.0F);               
                    GL11.glScalef(0.7F, 0.7F, 0.7F);
     
                    int durLength = Buff.of(buff.getId()).getDurationForDisplay(buff).length();
                 
                    this.mc.fontRenderer.drawStringWithShadow(Buff.of(buff.getId()).getDurationForDisplay(buff), - durLength * 3, 0, 8421504);//Рендерим оставшееся время действия.
 
                    String tier = "";
 
                    if (buff.getTier() == 0) {
     
                        tier = "I";
                    }
 
                    else if (buff.getTier() == 1) {
     
                        tier = "II";
                    }
 
                    else if (buff.getTier() == 2) {
     
                        tier = "III";
                    }
 
                    this.mc.fontRenderer.drawStringWithShadow(tier, 7 - tier.length() * 3, - 23, 8421504);//И уровень эффекта.
     
                    GL11.glPopMatrix();
 
                    GL11.glDisable(GL11.GL_BLEND);                                
                    GL11.glEnable(GL11.GL_LIGHTING);
                }
            }
        }
    }

    private void drawTexturedRect(int x, int y, int u, int v, int width, int height, int textureWidth, int textureHeight) {

        float f = 1.0F / (float) textureWidth;
        float f1 = 1.0F / (float) textureHeight;

        Tessellator tessellator = Tessellator.instance;

        tessellator.startDrawingQuads();

        tessellator.addVertexWithUV((double) (x), (double) (y + height), 0, (double) ((float) (u) * f), (double) ((float) (v + height) * f1));
        tessellator.addVertexWithUV((double) (x + width), (double) (y + height), 0, (double) ((float) (u + width) * f), (double) ((float) (v + height) * f1));
        tessellator.addVertexWithUV((double) (x + width), (double) (y), 0, (double) ((float) (u + width) * f), (double) ((float) (v) * f1));
        tessellator.addVertexWithUV((double) (x), (double) (y), 0, (double) ((float) (u) * f), (double) ((float) (v) * f1));

        tessellator.draw();
    }
}

public interface IBuffs {

    //Проверка наличия эффектов.
    boolean haveActiveBuffs();

    //Быстрая проверка на наличие указанного баффа.
    boolean isBuffActive(int buffId);

    //Возвращает сет ключей-идентификаторов.
    Set<Integer> activeBuffsIdSet();

    //Возвращает коллекцию активных баффов (ActiveBuff).
    Collection<ActiveBuff> activeBuffsCollection();

    //Вспомогательный метод для синхронизационного пакета.
    void putActiveBuffToMap(ActiveBuff buff);

    //Вспомогательный метод для пакета удаления эффекта.
    void removeActiveBuffFromMap(int buffId);

    //Копирование баффов из коллекции.
    void copyActiveBuffs(Collection<ActiveBuff> collection);

    //Получение активного баффа.
    ActiveBuff getActiveBuff(int buffId);

    //Добавление баффа ентити.
    void addBuff(ActiveBuff buff, EntityLivingBase livingBase);

    //Удаляем бафф и его эффект. Нужен так же для внешнего удаления баффа с флагом isPersistent.
    void removeBuff(EntityLivingBase livingBase, int buffId);

    //Метод для очищения активных баффов. Вызывается либо для полной очистки эффектов, либо при смерти.
    void clearBuffs(EntityLivingBase livingBase, boolean onDeath);

    //Метод обновления активных баффов. Вызывается в LivingUpdateEvent для EntityLivingBase на обеих сторонах.
    void updateBuffs(EntityLivingBase livingBase);
}

public class Buffs implements IBuffs {

    //Карта активных баффов, которые имеет ентити. В качестве ключа используется идентификатор баффа,
    //а значением является экземпляр класса ActiveBuff, описывающий идентификатор, уровень и продолжительность эффекта.
    private final Map<Integer, ActiveBuff> activeBuffs = new HashMap<Integer, ActiveBuff>();

    @Override
    public boolean haveActiveBuffs() {

        return !this.activeBuffs.isEmpty();
    }

    @Override
    public boolean isBuffActive(int buffId) {

        return this.activeBuffs.containsKey(buffId);
    }

    @Override
    public Set<Integer> activeBuffsIdSet() {

        return this.activeBuffs.keySet();
    }

    @Override
    public Collection<ActiveBuff> activeBuffsCollection() {

        return this.activeBuffs.values();
    }

    @Override
    public void putActiveBuffToMap(ActiveBuff buff) {

        this.activeBuffs.put(buff.getId(), buff);
    }

    @Override
    public void removeActiveBuffFromMap(int buffId) {

        this.activeBuffs.remove(buffId);
    }

    @Override
    public void copyActiveBuffs(Collection<ActiveBuff> collection) {

        for (ActiveBuff buff : collection) {

            this.activeBuffs.put(buff.getId(), buff);
        }
    }

    @Override
    public ActiveBuff getActiveBuff(int buffId) {

        return this.activeBuffs.get(buffId);
    }

    @Override
    public void addBuff(ActiveBuff buff, EntityLivingBase livingBase) {

        //Проверка наличия баффа с идентичным идентификатором.
        if (this.isBuffActive(buff.getId())) {

            //Если такой есть, достаем бафф из карты и сверяем уровни.
            //Если уровни совпадают, комбинируем (просто присваеваем активному баффу время действия добовляемого).
            //Если не совпадают, то во избежание сбоев при удалении эффекта (к примеру с атрибутами) по истечению времени
            //действия удаляем активный бафф и добавляем новый другого уровня.

            ActiveBuff activeBuff = this.getActiveBuff(buff.getId());

            if (activeBuff.getTier() == buff.getTier()) {
    
                activeBuff.combineBuffs(buff);

                if (livingBase instanceof EntityPlayer) {
         
                    if (!livingBase.world.isRemote) {
                 
                        //Уедомляем игрока если бафф был добавлен на сервере.
                        NetworkHandler.sendTo(new SyncBuff(activeBuff), (EntityPlayerMP) livingBase);
                    }
                }
            }

            else {
    
                this.removeBuff(livingBase, activeBuff.getId());
    
                this.activeBuffs.put(buff.getId(), buff);
    
                Buff.of(buff.getId()).applyBuffEffect(livingBase, livingBase.world, buff);

               if (livingBase instanceof EntityPlayer) {
         
                   if (!livingBase.world.isRemote) {
             
                       //Синхронизируем бафф игрока с клиентом если бафф был добавлен на сервере.
                       NetworkHandler.sendTo(new SyncBuff(buff), (EntityPlayerMP) livingBase);
                   }
               }
            }
        }

        else {

            //Если баффа нет, добавляем в карту.
            this.activeBuffs.put(buff.getId(), buff);

            //Применяем эффект баффа.
            Buff.of(buff.getId()).applyBuffEffect(livingBase, livingBase.world, buff);

            if (livingBase instanceof EntityPlayer) {
         
                if (!livingBase.world.isRemote) {
             
                    //Синхронизируем бафф игрока с клиентом если бафф был добавлен на сервере.
                    NetworkHandler.sendTo(new SyncBuff(buff), (EntityPlayerMP) livingBase);
                }
            }
        }
    }

    @Override
    public void removeBuff(EntityLivingBase livingBase, int buffId) {

        if (this.isBuffActive(buffId)) {

            ActiveBuff activeBuff = this.getActiveBuff(buffId);

            Buff.of(buffId).removeBuffEffect(livingBase, livingBase.world, activeBuff);

            this.activeBuffs.remove(buffId);

            if (livingBase instanceof EntityPlayer) {
         
                if (!livingBase.world.isRemote) {
             
                    //Уведомляем игрока об удалении баффа если удаление произошло на сервере.
                    NetworkHandler.sendTo(new RemoveBuff(buffId), (EntityPlayerMP) livingBase);
                }
            }
        }
    }

    @Override
    public void clearBuffs(EntityLivingBase livingBase, boolean onDeath) {

        if (this.haveActiveBuffs()) {

            Iterator buffsIterator = this.activeBuffsIdSet().iterator();

            while (buffsIterator.hasNext()) {

                int buffId = (Integer) buffsIterator.next();

                ActiveBuff buff = this.getActiveBuff(buffId);

                if (!livingBase.world.isRemote) {                                       
        
                    //Сохранение баффов при смерти доступно только для игрока.
                    if (livingBase instanceof EntityPlayer) {
            
                        //В зависимости от переданного параметра удаляются либо все эффекты, либо только те, которые не сохраняются при смерти.
                        if (onDeath) {
                                  
                            //Удаляем баффы без флага keepOnDeath и isPersistent.
                            if (!Buff.of(buffId).shouldKeepOnDeath() && !Buff.of(buffId).isPersistent()) {
                            
                                //Удаляем эффект баффа.
                                Buff.of(buffId).removeBuffEffect(livingBase, livingBase.world, buff);
        
                                //Удаляем бафф на клиентской стороне.
                                NetworkHandler.sendTo(new RemoveBuff(buffId), (EntityPlayerMP) livingBase);
                
                                //Удаляем бафф на серверной стороне.
                                buffsIterator.remove();
                            }
                        }
        
                        else {                                   
            
                            //Если очистка производится по иным причинам, удаляем всё.
                
                            Buff.of(buffId).removeBuffEffect(livingBase, livingBase.world, buff);
        
                            NetworkHandler.sendTo(new RemoveBuff(buffId), (EntityPlayerMP) livingBase);
            
                            buffsIterator.remove();
                        }
                    }
        
                    else {
            
                        //С других ентити снимаем все в любом случае.
            
                        Buff.of(buffId).removeBuffEffect(livingBase, livingBase.world, buff);
                                
                        buffsIterator.remove();
                    }
                }
            }
        }
    }

    @Override
    public void updateBuffs(EntityLivingBase livingBase) {

        //Проверка наличия активных баффов.
        if (this.haveActiveBuffs()) {

            //Итератор по идентификаторам.
            Iterator buffsIterator = this.activeBuffsIdSet().iterator();

            while (buffsIterator.hasNext()) {

                int buffId = (Integer) buffsIterator.next();

                //Достаём бафф из карты используя идентификатор.
                ActiveBuff buff = this.getActiveBuff(buffId);

                //Вызов метода обновления баффа и одновременно проверка на истечения времени действия.
                if (!buff.updateBuff(livingBase, livingBase.world)) {
    
                    if (!livingBase.world.isRemote) {

                        //Снимаем эффект.
                        Buff.of(buffId).removeBuffEffect(livingBase, livingBase.world, buff);
            
                        if (livingBase instanceof EntityPlayer) {
                
                            //Удаляем бафф с игрока на клиенте.
                            NetworkHandler.sendTo(new RemoveBuff(buffId), (EntityPlayerMP) livingBase);
                        }
            
                        //Удаляем на сервере.
                        buffsIterator.remove();
                    }
                }
            }
        }
    }
}

public class BuffsStorage  implements IStorage<IBuffs> {

    @Override
    public NBTBase writeNBT(Capability<IBuffs> capability, IBuffs instance, EnumFacing side) {
    
        NBTTagCompound buffsCompound = new NBTTagCompound();
    
        //Проверка карты на наличие баффов.
        if (instance.haveActiveBuffs()) {

            //Создаём NBTTagList, в который запишем все активные баффы.
            NBTTagList tagList = new NBTTagList();

            //Перебор элементов коллекции активных эффектов.
            for (ActiveBuff buff : instance.activeBuffsCollection()) {
    
                //Добавляем бафф в NBTTagList. Для этого предварительно упаковываем бафф в NBTTagCompound.
                tagList.appendTag(buff.saveBuffToNBT(buff));
            }

            //Сохраняем NBTTagList в NBTTagCompound.
            buffsCompound.setTag("buffs", tagList);
        }

        return buffsCompound;
    }

    @Override
    public void readNBT(Capability<IBuffs> capability, IBuffs instance, EnumFacing side, NBTBase nbt) {

        //Загружаем наш NBTTagCompound.
        NBTTagCompound buffsCompound = (NBTTagCompound) nbt;

        //Проверяем, содержит ли NBT данные с указанным ключём. Второй параметр, цифра 9 - идентификатор типа NBTBase, в данном случае NBTTagList.
        if (buffsCompound.hasKey("buffs", 9)) {

            //Достаём NBTTagList из NBT.
            NBTTagList tagList = buffsCompound.getTagList("buffs", 10);//10 для NBTTagCompound.

            //Цикл, длиной равный кол-ву элементов в NBTTagList.
            for (int i = 0; i < tagList.tagCount(); ++i) {
    
                //Получаем NBTTagCompound по текущему номеру операции в цикле.
                NBTTagCompound tagCompound = tagList.getCompoundTagAt(i);
    
                //Распаковываем бафф из NBTTagCompound.
                ActiveBuff buff = ActiveBuff.readBuffFromNBT(tagCompound);

                if (buff != null) {
        
                    //Добавляем в карту активных баффов используя идентификатор как ключ и распакованный бафф как значение.
                    instance.putActiveBuffToMap(buff);
                }
            }
        }
    }
}

public class BuffsProvider implements ICapabilitySerializable<NBTBase> {

    @CapabilityInject(IBuffs.class)
    public static final Capability<IBuffs> BUFFS_CAP = null;

    private IBuffs instance = BUFFS_CAP.getDefaultInstance();

    @Override
    public boolean hasCapability(Capability<?> capability, EnumFacing facing) {

        return capability == BUFFS_CAP;
    }

    @Override
    public <T> T getCapability(Capability<T> capability, EnumFacing facing) {

        return capability == BUFFS_CAP ? BUFFS_CAP.<T> cast(this.instance) : null;
    }

    @Override
    public NBTBase serializeNBT() {

        return BUFFS_CAP.getStorage().writeNBT(BUFFS_CAP, this.instance, null);
    }

    @Override
    public void deserializeNBT(NBTBase nbt) {

        BUFFS_CAP.getStorage().readNBT(BUFFS_CAP, this.instance, null, nbt);
    }
}