2020-08-25 01:01:11 +02:00
|
|
|
package com.songoda.ultimatestacker.stackable.entity;
|
|
|
|
|
|
|
|
import com.songoda.ultimatestacker.UltimateStacker;
|
|
|
|
import com.songoda.ultimatestacker.utils.Methods;
|
|
|
|
import org.bukkit.Bukkit;
|
|
|
|
import org.bukkit.ChatColor;
|
|
|
|
import org.bukkit.Chunk;
|
|
|
|
import org.bukkit.World;
|
|
|
|
import org.bukkit.entity.Entity;
|
2023-02-04 14:48:13 +01:00
|
|
|
import org.bukkit.entity.EntityType;
|
2020-08-25 01:01:11 +02:00
|
|
|
import org.bukkit.entity.LivingEntity;
|
2023-02-22 09:59:28 +01:00
|
|
|
import org.bukkit.entity.Player;
|
|
|
|
import org.bukkit.metadata.FixedMetadataValue;
|
2020-08-25 01:01:11 +02:00
|
|
|
|
2020-09-01 20:44:39 +02:00
|
|
|
import java.util.Collection;
|
|
|
|
import java.util.Collections;
|
|
|
|
import java.util.HashMap;
|
|
|
|
import java.util.Map;
|
|
|
|
import java.util.UUID;
|
2020-08-25 01:01:11 +02:00
|
|
|
|
|
|
|
public class EntityStackManager {
|
|
|
|
|
|
|
|
private final UltimateStacker plugin;
|
|
|
|
|
|
|
|
public EntityStackManager(UltimateStacker plugin) {
|
|
|
|
this.plugin = plugin;
|
|
|
|
}
|
|
|
|
|
2023-02-04 14:48:13 +01:00
|
|
|
public EntityStack createStack(LivingEntity entity, int amount) {
|
|
|
|
return new EntityStack(entity, amount);
|
|
|
|
}
|
|
|
|
|
|
|
|
public boolean isStackedEntity(Entity entity) {
|
|
|
|
return entity.hasMetadata("US_AMOUNT");
|
|
|
|
}
|
|
|
|
|
|
|
|
public int getAmount(Entity entity) {
|
|
|
|
if (!isStackedEntity(entity)) return 1;
|
|
|
|
if (entity.getMetadata("US_AMOUNT").isEmpty()) return 1;
|
|
|
|
return entity.getMetadata("US_AMOUNT").get(0).asInt();
|
2020-08-25 01:01:11 +02:00
|
|
|
}
|
|
|
|
|
2023-02-22 09:59:28 +01:00
|
|
|
public String getLastPlayerDamage(Entity entity) {
|
|
|
|
if (!entity.hasMetadata("US_LAST_PLAYER_DAMAGE")) return null;
|
|
|
|
if (entity.getMetadata("US_LAST_PLAYER_DAMAGE").isEmpty()) return null;
|
|
|
|
return entity.getMetadata("US_LAST_PLAYER_DAMAGE").get(0).asString();
|
|
|
|
}
|
|
|
|
|
|
|
|
public void setLastPlayerDamage(Entity entity, Player player) {
|
|
|
|
if (player == null) return;
|
|
|
|
if (entity == null) return;
|
|
|
|
if (entity instanceof Player) return;
|
|
|
|
entity.setMetadata("US_LAST_PLAYER_DAMAGE", new FixedMetadataValue(plugin, player.getName()));
|
|
|
|
}
|
|
|
|
|
2020-08-25 01:01:11 +02:00
|
|
|
public EntityStack addStack(LivingEntity entity) {
|
2023-02-04 14:48:13 +01:00
|
|
|
return addStack(entity, getAmount(entity) == 1 ? 1 : getAmount(entity));
|
2020-08-25 01:01:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public EntityStack addStack(LivingEntity entity, int amount) {
|
|
|
|
if (entity == null) return null;
|
2023-02-04 14:48:13 +01:00
|
|
|
if (isStackedEntity(entity)) {
|
|
|
|
EntityStack stack = getStack(entity);
|
|
|
|
stack.addEntityToStack(amount);
|
|
|
|
return stack;
|
2020-08-25 01:01:11 +02:00
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
|
|
|
|
public EntityStack getStack(UUID uuid) {
|
2023-02-04 14:48:13 +01:00
|
|
|
Entity entity = Bukkit.getEntity(uuid);
|
|
|
|
if (entity == null) return null;
|
|
|
|
if (isStackedEntity(entity)) {
|
|
|
|
if (entity instanceof LivingEntity) {
|
|
|
|
return new EntityStack((LivingEntity) entity);
|
|
|
|
}
|
2020-08-25 01:01:11 +02:00
|
|
|
}
|
2023-02-04 14:48:13 +01:00
|
|
|
return null;
|
2020-08-25 01:01:11 +02:00
|
|
|
}
|
|
|
|
|
2023-02-04 14:48:13 +01:00
|
|
|
public EntityStack getStack(LivingEntity entity) {
|
|
|
|
if (!isStackedEntity(entity)) return null;
|
|
|
|
return new EntityStack(entity);
|
2020-08-25 01:01:11 +02:00
|
|
|
}
|
|
|
|
|
2023-02-04 14:48:13 +01:00
|
|
|
public EntityStack decreaseStack(Entity entity) {
|
|
|
|
EntityStack stack = getStack((LivingEntity) entity);
|
2020-08-25 01:01:11 +02:00
|
|
|
if (stack == null) return null;
|
2023-02-04 14:48:13 +01:00
|
|
|
stack.removeEntityFromStack(1);
|
2020-08-25 01:01:11 +02:00
|
|
|
return stack;
|
|
|
|
}
|
|
|
|
|
2023-02-04 14:48:13 +01:00
|
|
|
public EntityStack decreaseStack(Entity entity, int amount) {
|
|
|
|
EntityStack stack = getStack((LivingEntity) entity);
|
|
|
|
if (stack == null) return null;
|
|
|
|
stack.removeEntityFromStack(amount);
|
|
|
|
return stack;
|
2020-08-25 01:01:11 +02:00
|
|
|
}
|
|
|
|
|
2023-02-04 14:48:13 +01:00
|
|
|
public EntityStack updateStack(LivingEntity entity) {
|
|
|
|
EntityStack stack = getStack(entity);
|
|
|
|
if (stack == null) return null;
|
|
|
|
stack.updateNameTag();
|
|
|
|
return stack;
|
2020-08-25 01:01:11 +02:00
|
|
|
}
|
|
|
|
|
2023-02-05 13:14:44 +01:00
|
|
|
/**
|
|
|
|
* Transfers the stack from one entity to another.
|
|
|
|
* (e.g. slimes split)
|
|
|
|
* @param oldEntity The old entity to transfer the stack from.
|
|
|
|
* @param newEntity The new entity to transfer the stack to.
|
|
|
|
* @return The new stack.
|
|
|
|
*/
|
|
|
|
public EntityStack transferStack(LivingEntity oldEntity, LivingEntity newEntity) {
|
|
|
|
EntityStack stack = getStack(oldEntity);
|
|
|
|
if (stack == null) return null;
|
|
|
|
EntityStack newStack = new EntityStack(newEntity, stack.getAmount());
|
|
|
|
stack.destroy();
|
|
|
|
return newStack;
|
|
|
|
}
|
|
|
|
|
2023-02-04 14:48:13 +01:00
|
|
|
public EntityStack updateStack(LivingEntity oldEntity, LivingEntity newEntity) {
|
|
|
|
EntityStack stack = getStack(oldEntity);
|
|
|
|
if (stack == null) return null;
|
2023-02-05 13:14:44 +01:00
|
|
|
int amount = stack.getAmount()-1;
|
2020-08-25 01:01:11 +02:00
|
|
|
stack.destroy();
|
2023-02-17 16:33:28 +01:00
|
|
|
if (amount == 0 && newEntity != null) {
|
|
|
|
newEntity.remove();
|
|
|
|
return null;
|
|
|
|
}
|
2023-02-04 14:48:13 +01:00
|
|
|
return createStack(newEntity, amount);
|
2020-08-25 01:01:11 +02:00
|
|
|
}
|
|
|
|
|
2023-02-04 14:48:13 +01:00
|
|
|
public void setStack(LivingEntity newEntity, int amount) {
|
|
|
|
if (isStackedEntity(newEntity)) {
|
|
|
|
EntityStack stack = getStack(newEntity);
|
|
|
|
stack.setAmount(amount);
|
|
|
|
} else {
|
|
|
|
createStack(newEntity, amount);
|
2020-08-25 01:01:11 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|