CustomNPC-Plus/src/main/java/noppes/npcs/controllers/data/SpawnData.java

package noppes.npcs.controllers.data;

import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityList;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.WeightedRandom;
import net.minecraftforge.common.DimensionManager;
import noppes.npcs.NBTTags;
import noppes.npcs.api.IWorld;
import noppes.npcs.api.entity.IEntity;
import noppes.npcs.api.handler.data.INaturalSpawn;
import noppes.npcs.scripted.CustomNPCsException;
import noppes.npcs.scripted.NpcAPI;

import java.util.*;

public class SpawnData extends WeightedRandom.Item implements INaturalSpawn {
	public List<String> biomes = new ArrayList<>();
	public HashSet<Integer> dimensions = new HashSet<>();
	public int id = -1;
	public String name = "";

	public HashMap<Integer,NBTTagCompound> spawnCompounds = new HashMap<>();

	public boolean animalSpawning = true;
	public boolean monsterSpawning = false;
	public boolean liquidSpawning = false;
	public boolean airSpawning = false;

	public int spawnHeightMin;
	public int spawnHeightMax = 100;

	public SpawnData() {
		super(10);
	}

	public void readNBT(NBTTagCompound compound) {
		id = compound.getInteger("SpawnId");
		name = compound.getString("SpawnName");
		itemWeight = compound.getInteger("SpawnWeight");
		if(itemWeight == 0)
			itemWeight = 1;

		biomes = NBTTags.getStringList(compound.getTagList("SpawnBiomes", 10));
		if (!compound.hasKey("SpawnDimensions")) {
			dimensions.addAll(Arrays.asList(DimensionManager.getStaticDimensionIDs()));
		} else {
			dimensions = NBTTags.getIntegerSet(compound.getTagList("SpawnDimensions", 10));
		}

		this.spawnCompounds.clear();
		Set<?> keys = compound.func_150296_c();
		for (Object key : keys) {
			if (((String)key).startsWith("SpawnCompound")) {
				int i = Integer.parseInt(((String)key).replace("SpawnCompound",""));
				this.spawnCompounds.put(i,compound.getCompoundTag("SpawnCompound"+i));
			}
		}

		animalSpawning = compound.getBoolean("AnimalSpawning");
		monsterSpawning = compound.getBoolean("MonsterSpawning");
		liquidSpawning = compound.getBoolean("LiquidSpawning");
		airSpawning = compound.getBoolean("CaveSpawning");

		spawnHeightMin = compound.getInteger("HeightMin");
		if (!compound.hasKey("HeightMax")) {
			spawnHeightMax = 100;
		} else {
			spawnHeightMax = compound.getInteger("HeightMax");
		}
	}

	public NBTTagCompound writeNBT(NBTTagCompound compound) {
		compound.setInteger("SpawnId", id);
		compound.setString("SpawnName", name);
		compound.setInteger("SpawnWeight", itemWeight);
		
		compound.setTag("SpawnBiomes", NBTTags.nbtStringList(biomes));
		if (!this.dimensions.isEmpty()) {
			compound.setTag("SpawnDimensions", NBTTags.nbtIntegerSet(dimensions));
		}

		Set<Map.Entry<Integer,NBTTagCompound>> entries = this.spawnCompounds.entrySet();
		for (Map.Entry<Integer,NBTTagCompound> entry : entries) {
			compound.setTag("SpawnCompound" + entry.getKey(), entry.getValue() != null ? entry.getValue() : new NBTTagCompound());
		}

		compound.setBoolean("AnimalSpawning", animalSpawning);
		compound.setBoolean("MonsterSpawning", monsterSpawning);
		compound.setBoolean("LiquidSpawning", liquidSpawning);
		compound.setBoolean("CaveSpawning", airSpawning);

		compound.setInteger("HeightMin", spawnHeightMin);
		compound.setInteger("HeightMax", spawnHeightMax);
		return compound;
	}

	public void setName(String name) {
		if (name != null && !name.isEmpty()) {
			this.name = name;
		}
	}

	public String getName() {
		return this.name;
	}

	public void setEntity(IEntity entity, int slot) {
		NBTTagCompound compound = new NBTTagCompound();
		if (entity != null && !entity.getMCEntity().writeToNBTOptional(compound)) {
			throw new CustomNPCsException("Entity could not be written to NBT");
		} else {
			this.spawnCompounds.put(slot,compound);
		}
	}

	public IEntity getEntity(IWorld world, int slot) {
		if (!this.spawnCompounds.containsKey(slot)) {
			return null;
		}
		try {
			Entity entity = EntityList.createEntityFromNBT(this.spawnCompounds.get(slot), world.getMCWorld());
			return NpcAPI.Instance().getIEntity(entity);
		} catch (Exception e) {
			throw new CustomNPCsException("Error creating entity from spawn data:\n" + e.getMessage());
		}
	}

	public Integer[] getSlots() {
		return this.spawnCompounds.keySet().toArray(new Integer[0]);
	}

	public void setWeight(int weight) {
		if (weight < 1)
			weight = 1;
		if (weight > 100)
			weight = 100;

		this.itemWeight = weight;
	}

	public int getWeight() {
		return this.itemWeight;
	}

	public void setMinHeight(int height) {
		this.spawnHeightMin = height;
	}

	public int getMinHeight() {
		return this.spawnHeightMin;
	}

	public void setMaxHeight(int height) {
		this.spawnHeightMax = height;
	}

	public int getMaxHeight() {
		return this.spawnHeightMax;
	}

	public void spawnsLikeAnimal(boolean spawns) {
		this.animalSpawning = spawns;
	}

	public boolean spawnsLikeAnimal() {
		return animalSpawning;
	}

	public void spawnsLikeMonster(boolean spawns) {
		this.monsterSpawning = spawns;
	}

	public boolean spawnsLikeMonster() {
		return monsterSpawning;
	}

	public void spawnsInLiquid(boolean spawns) {
		this.liquidSpawning = spawns;
	}

	public boolean spawnsInLiquid() {
		return this.liquidSpawning;
	}

	public void spawnsInAir(boolean spawns) {
		this.airSpawning = spawns;
	}

	public boolean spawnsInAir() {
		return this.airSpawning;
	}

	public String[] getBiomes() {
		return biomes.toArray(new String[]{});
	}

	public void setBiomes(String[] biomes) {
		this.biomes = new ArrayList<>(Arrays.asList(biomes));
	}
}