418 lines
10 KiB
Java
418 lines
10 KiB
Java
package world.bentobox.limits.objects;
|
|
|
|
import java.util.EnumMap;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
|
|
import org.bukkit.Material;
|
|
import org.bukkit.entity.EntityType;
|
|
|
|
import com.google.gson.annotations.Expose;
|
|
|
|
import world.bentobox.bentobox.database.objects.DataObject;
|
|
import world.bentobox.bentobox.database.objects.Table;
|
|
|
|
/**
|
|
* @author tastybento
|
|
*
|
|
*/
|
|
@Table(name = "IslandBlockCount")
|
|
public class IslandBlockCount implements DataObject {
|
|
|
|
@Expose
|
|
private Map<Material, Integer> blockCounts = new EnumMap<>(Material.class);
|
|
|
|
/**
|
|
* Permission based limits
|
|
*/
|
|
@Expose
|
|
private Map<Material, Integer> blockLimits = new EnumMap<>(Material.class);
|
|
|
|
@Expose
|
|
private Map<Material, Integer> blockLimitsOffset = new EnumMap<>(Material.class);
|
|
|
|
private boolean changed;
|
|
|
|
@Expose
|
|
private Map<String, Integer> entityGroupLimits = new HashMap<>();
|
|
@Expose
|
|
private Map<String, Integer> entityGroupLimitsOffset = new HashMap<>();
|
|
@Expose
|
|
private Map<EntityType, Integer> entityLimits = new EnumMap<>(EntityType.class);
|
|
@Expose
|
|
private Map<EntityType, Integer> entityLimitsOffset = new EnumMap<>(EntityType.class);
|
|
@Expose
|
|
private String gameMode;
|
|
@Expose
|
|
private String uniqueId;
|
|
|
|
/**
|
|
* Create an island block count object
|
|
*
|
|
* @param islandId - unique Island ID string
|
|
* @param gameMode - Game mode name from gm.getDescription().getName()
|
|
*/
|
|
public IslandBlockCount(String islandId, String gameMode) {
|
|
this.uniqueId = islandId;
|
|
this.gameMode = gameMode;
|
|
setChanged();
|
|
}
|
|
|
|
/**
|
|
* Add a material to the count
|
|
*
|
|
* @param material - material
|
|
*/
|
|
public void add(Material material) {
|
|
getBlockCounts().merge(material, 1, Integer::sum);
|
|
setChanged();
|
|
}
|
|
|
|
/**
|
|
* Clear all island-specific entity group limits
|
|
*/
|
|
public void clearEntityGroupLimits() {
|
|
entityGroupLimits.clear();
|
|
setChanged();
|
|
}
|
|
|
|
/**
|
|
* Clear all island-specific entity type limits
|
|
*/
|
|
public void clearEntityLimits() {
|
|
entityLimits.clear();
|
|
setChanged();
|
|
}
|
|
|
|
/**
|
|
* Get the block count for this material for this island
|
|
*
|
|
* @param m - material
|
|
* @return count
|
|
*/
|
|
public Integer getBlockCount(Material m) {
|
|
return getBlockCounts().getOrDefault(m, 0);
|
|
}
|
|
|
|
/**
|
|
* @return the blockCount
|
|
*/
|
|
public Map<Material, Integer> getBlockCounts() {
|
|
if (blockCounts == null) {
|
|
blockCounts = new EnumMap<>(Material.class);
|
|
}
|
|
return blockCounts;
|
|
}
|
|
|
|
/**
|
|
* Get the block limit for this material for this island
|
|
*
|
|
* @param m - material
|
|
* @return limit or -1 for unlimited
|
|
*/
|
|
public int getBlockLimit(Material m) {
|
|
return getBlockLimits().getOrDefault(m, -1);
|
|
}
|
|
|
|
/**
|
|
* Get the block offset for this material for this island
|
|
*
|
|
* @param m - material
|
|
* @return offset
|
|
*/
|
|
public int getBlockLimitOffset(Material m) {
|
|
return getBlockLimitsOffset().getOrDefault(m, 0);
|
|
}
|
|
|
|
/**
|
|
* @return the blockLimits
|
|
*/
|
|
public Map<Material, Integer> getBlockLimits() {
|
|
return Objects.requireNonNullElse(blockLimits, new EnumMap<>(Material.class));
|
|
}
|
|
|
|
/**
|
|
* @return the blockLimitsOffset
|
|
*/
|
|
public Map<Material, Integer> getBlockLimitsOffset() {
|
|
if (blockLimitsOffset == null) {
|
|
blockLimitsOffset = new EnumMap<>(Material.class);
|
|
}
|
|
return blockLimitsOffset;
|
|
}
|
|
|
|
/**
|
|
* Get the limit for an entity group
|
|
*
|
|
* @param name - entity group
|
|
* @return limit or -1 for unlimited
|
|
*/
|
|
public int getEntityGroupLimit(String name) {
|
|
return getEntityGroupLimits().getOrDefault(name, -1);
|
|
}
|
|
|
|
/**
|
|
* Get the offset for an entity group
|
|
*
|
|
* @param name - entity group
|
|
* @return offset
|
|
*/
|
|
public int getEntityGroupLimitOffset(String name) {
|
|
return getEntityGroupLimitsOffset().getOrDefault(name, 0);
|
|
}
|
|
|
|
/**
|
|
* @return the entityGroupLimits
|
|
*/
|
|
public Map<String, Integer> getEntityGroupLimits() {
|
|
return Objects.requireNonNullElse(entityGroupLimits, new HashMap<>());
|
|
}
|
|
|
|
/**
|
|
* @return the entityGroupLimitsOffset
|
|
*/
|
|
public Map<String, Integer> getEntityGroupLimitsOffset() {
|
|
if (entityGroupLimitsOffset == null) {
|
|
entityGroupLimitsOffset = new HashMap<>();
|
|
}
|
|
return entityGroupLimitsOffset;
|
|
}
|
|
|
|
/**
|
|
* Get the limit for an entity type
|
|
*
|
|
* @param t - entity type
|
|
* @return limit or -1 for unlimited
|
|
*/
|
|
public int getEntityLimit(EntityType t) {
|
|
return getEntityLimits().getOrDefault(t, -1);
|
|
}
|
|
|
|
/**
|
|
* Get the limit offset for an entity type
|
|
*
|
|
* @param t - entity type
|
|
* @return offset
|
|
*/
|
|
public int getEntityLimitOffset(EntityType t) {
|
|
return getEntityLimitsOffset().getOrDefault(t, 0);
|
|
}
|
|
|
|
/**
|
|
* @return the entityLimits
|
|
*/
|
|
public Map<EntityType, Integer> getEntityLimits() {
|
|
return Objects.requireNonNullElse(entityLimits, new EnumMap<>(EntityType.class));
|
|
}
|
|
|
|
/**
|
|
* @return the entityLimitsOffset
|
|
*/
|
|
public Map<EntityType, Integer> getEntityLimitsOffset() {
|
|
if (entityLimitsOffset == null) {
|
|
entityLimitsOffset = new EnumMap<>(EntityType.class);
|
|
}
|
|
return entityLimitsOffset;
|
|
}
|
|
|
|
/**
|
|
* @return the gameMode
|
|
*/
|
|
public String getGameMode() {
|
|
return gameMode;
|
|
}
|
|
|
|
/*
|
|
* (non-Javadoc)
|
|
*
|
|
* @see world.bentobox.bentobox.database.objects.DataObject#getUniqueId()
|
|
*/
|
|
@Override
|
|
public String getUniqueId() {
|
|
return uniqueId;
|
|
}
|
|
|
|
/**
|
|
* Check if no more of this material can be added to this island
|
|
*
|
|
* @param m - material
|
|
* @return true if no more material can be added
|
|
*/
|
|
public boolean isAtLimit(Material m) {
|
|
// Check island limits first
|
|
return getBlockLimits().containsKey(m)
|
|
&& getBlockCounts().getOrDefault(m, 0) >= getBlockLimit(m) + this.getBlockLimitOffset(m);
|
|
}
|
|
|
|
/**
|
|
* Check if this material is at or over a limit
|
|
*
|
|
* @param material - block material
|
|
* @param limit - limit to check
|
|
* @return true if count is >= limit
|
|
*/
|
|
public boolean isAtLimit(Material material, int limit) {
|
|
return getBlockCounts().getOrDefault(material, 0) >= limit + this.getBlockLimitOffset(material);
|
|
}
|
|
|
|
public boolean isBlockLimited(Material m) {
|
|
return getBlockLimits().containsKey(m);
|
|
}
|
|
|
|
/**
|
|
* @return the changed
|
|
*/
|
|
public boolean isChanged() {
|
|
return changed;
|
|
}
|
|
|
|
public boolean isGameMode(String gameMode) {
|
|
return getGameMode().equals(gameMode);
|
|
}
|
|
|
|
/**
|
|
* Remove a material from the count
|
|
*
|
|
* @param material - material
|
|
*/
|
|
public void remove(Material material) {
|
|
getBlockCounts().put(material, getBlockCounts().getOrDefault(material, 0) - 1);
|
|
getBlockCounts().values().removeIf(v -> v <= 0);
|
|
setChanged();
|
|
}
|
|
|
|
/**
|
|
* @param blockCounts the blockCount to set
|
|
*/
|
|
public void setBlockCounts(Map<Material, Integer> blockCounts) {
|
|
this.blockCounts = blockCounts;
|
|
setChanged();
|
|
}
|
|
|
|
/**
|
|
* Set the block limit for this material for this island
|
|
*
|
|
* @param m - material
|
|
* @param limit - maximum number allowed
|
|
*/
|
|
public void setBlockLimit(Material m, int limit) {
|
|
getBlockLimits().put(m, limit);
|
|
setChanged();
|
|
}
|
|
|
|
/**
|
|
* @param blockLimits the blockLimits to set
|
|
*/
|
|
public void setBlockLimits(Map<Material, Integer> blockLimits) {
|
|
this.blockLimits = blockLimits;
|
|
setChanged();
|
|
}
|
|
|
|
/**
|
|
* Set an offset to a block limit. This will increase/decrease the value of the
|
|
* limit.
|
|
*
|
|
* @param m material
|
|
* @param blockLimitsOffset the blockLimitsOffset to set
|
|
*/
|
|
public void setBlockLimitsOffset(Material m, Integer blockLimitsOffset) {
|
|
getBlockLimitsOffset().put(m, blockLimitsOffset);
|
|
}
|
|
|
|
/**
|
|
* Mark changed
|
|
*/
|
|
public void setChanged() {
|
|
this.changed = true;
|
|
}
|
|
|
|
/**
|
|
* @param changed the changed to set
|
|
*/
|
|
public void setChanged(boolean changed) {
|
|
this.changed = changed;
|
|
}
|
|
|
|
/**
|
|
* Set an island-specific entity group limit
|
|
*
|
|
* @param name - entity group
|
|
* @param limit - limit
|
|
*/
|
|
public void setEntityGroupLimit(String name, int limit) {
|
|
getEntityGroupLimits().put(name, limit);
|
|
setChanged();
|
|
}
|
|
|
|
/**
|
|
* @param entityGroupLimits the entityGroupLimits to set
|
|
*/
|
|
public void setEntityGroupLimits(Map<String, Integer> entityGroupLimits) {
|
|
this.entityGroupLimits = entityGroupLimits;
|
|
setChanged();
|
|
}
|
|
|
|
/**
|
|
* Set an offset to an entity group limit. This will increase/decrease the value
|
|
* of the limit.
|
|
*
|
|
* @param name group name
|
|
* @param entityGroupLimitsOffset the entityGroupLimitsOffset to set
|
|
*/
|
|
public void setEntityGroupLimitsOffset(String name, Integer entityGroupLimitsOffset) {
|
|
getEntityGroupLimitsOffset().put(name, entityGroupLimitsOffset);
|
|
}
|
|
|
|
/**
|
|
* Set an island-specific entity type limit
|
|
*
|
|
* @param t - entity type
|
|
* @param limit - limit
|
|
*/
|
|
public void setEntityLimit(EntityType t, int limit) {
|
|
getEntityLimits().put(t, limit);
|
|
setChanged();
|
|
}
|
|
|
|
/**
|
|
* @param entityLimits the entityLimits to set
|
|
*/
|
|
public void setEntityLimits(Map<EntityType, Integer> entityLimits) {
|
|
this.entityLimits = entityLimits;
|
|
setChanged();
|
|
}
|
|
|
|
/**
|
|
* Set an offset to an entity limit. This will increase/decrease the value of
|
|
* the limit.
|
|
*
|
|
* @param type Entity Type
|
|
* @param entityLimitsOffset the entityLimitsOffset to set
|
|
*/
|
|
public void setEntityLimitsOffset(EntityType type, Integer entityLimitsOffset) {
|
|
this.getEntityLimitsOffset().put(type, entityLimitsOffset);
|
|
}
|
|
|
|
/**
|
|
* @param gameMode the gameMode to set
|
|
*/
|
|
public void setGameMode(String gameMode) {
|
|
this.gameMode = gameMode;
|
|
setChanged();
|
|
}
|
|
|
|
/*
|
|
* (non-Javadoc)
|
|
*
|
|
* @see
|
|
* world.bentobox.bentobox.database.objects.DataObject#setUniqueId(java.lang.
|
|
* String)
|
|
*/
|
|
@Override
|
|
public void setUniqueId(String uniqueId) {
|
|
this.uniqueId = uniqueId;
|
|
setChanged();
|
|
}
|
|
}
|