Java Code Examples for net.minecraft.nbt.NBTTagCompound#setBoolean()

@Override
public void writeToNBT(NBTTagCompound tag){
    super.writeToNBT(tag);
    TileEntityBase.writeInventoryToNBT(tag, filters, "filters");

    NBTTagList tagList = new NBTTagList();
    for(int i = 0; i < fluidFilters.length; i++) {
        FluidTank filter = fluidFilters[i];
        if(filter.getFluid() != null) {
            NBTTagCompound t = new NBTTagCompound();
            t.setInteger("index", i);
            filter.writeToNBT(t);
            tagList.appendTag(t);
        }
    }
    tag.setTag("fluidFilters", tagList);

    tag.setBoolean("invisible", invisible);
}
 

/**
 * (abstract) Protected helper method to write subclass entity data to NBT.
 */
public void writeEntityToNBT(NBTTagCompound compound)
{
    super.writeEntityToNBT(compound);

    if (((Boolean)this.dataManager.get(POWERED)).booleanValue())
    {
        compound.setBoolean("powered", true);
    }

    compound.setShort("Fuse", (short)this.fuseTime);
    compound.setByte("ExplosionRadius", (byte)this.explosionRadius);
    compound.setBoolean("ignited", this.hasIgnited());
    compound.setBoolean("IsChickenJockey", this.chickenJockey);
    compound.setInteger("EggLayTime", this.timeUntilNextEgg);
}
 

@Override
public NBTTagCompound writeToNBT(NBTTagCompound data) {
    super.writeToNBT(data);
    data.setBoolean("Active", isActive);
    data.setBoolean("WasActive", wasActiveAndNeedUpdate);
    data.setFloat("FuelUnitsLeft", fuelUnitsLeft);
    data.setInteger("MaxProgress", maxProgressDuration);
    if (maxProgressDuration > 0) {
        data.setInteger("Progress", currentProgress);
        NBTTagList itemOutputs = new NBTTagList();
        for (ItemStack itemStack : outputsList) {
            itemOutputs.appendTag(itemStack.writeToNBT(new NBTTagCompound()));
        }
        data.setTag("Outputs", itemOutputs);
    }
    return data;
}
 

@Override
public void writeToNBT(NBTTagCompound tag){
    super.writeToNBT(tag);
    tag.setBoolean("clawClosing", shouldClawClose);
    tag.setFloat("clawProgress", clawProgress);
    tag.setFloat("speed", speed);
    tag.setBoolean("drilled", hasDrilledStack);
    tag.setBoolean("lasered", hasLaseredStack);
    // Write the ItemStacks in the inventory to NBT
    NBTTagList tagList = new NBTTagList();
    for(int currentIndex = 0; currentIndex < inventory.length; ++currentIndex) {
        if(inventory[currentIndex] != null) {
            NBTTagCompound tagCompound = new NBTTagCompound();
            tagCompound.setByte("Slot", (byte)currentIndex);
            inventory[currentIndex].writeToNBT(tagCompound);
            tagList.appendTag(tagCompound);
        }
    }
    tag.setTag("Items", tagList);
}
 

@Override
public boolean writeToNBT(NBTTagCompound tag) {
    tag.setByte(NBT_GROWTH, growth);
    tag.setByte(NBT_GAIN, gain);
    tag.setByte(NBT_STRENGTH, strength);
    tag.setBoolean(NBT_ANALYZED, analyzed);
    return true;
}
 

@Override
public NBTTagCompound writeToNBT(NBTTagCompound data) {
    super.writeToNBT(data);
    data.setInteger("CurrentTemperature", currentTemperature);
    data.setInteger("FuelBurnTicksLeft", fuelBurnTicksLeft);
    data.setBoolean("HasNoWater", hasNoWater);
    data.setInteger("ThrottlePercentage", throttlePercentage);
    return data;
}
 

@Override
public void readDataFromNetwork(ByteBuf in, byte packetId,
		NBTTagCompound nbt) {
	if(packetId == PACKET_REDSTONE_ID)
		nbt.setByte("state", in.readByte());
	else if(packetId == PACKET_TRACE_ID)
		nbt.setBoolean("trace", in.readBoolean());
}
 

@Override
public ActionResult<ItemStack> onItemRightClick(World worldIn, EntityPlayer playerIn, EnumHand handIn) {
	IC2.audioManager.playOnce(playerIn, toggleSound);
	if (IC2.platform.isSimulating()) {
		NBTTagCompound nbt = StackUtil.getOrCreateNbtData(playerIn.getHeldItem(handIn));
		boolean result = !nbt.getBoolean(ACTIVE);
		nbt.setBoolean(ACTIVE, result);
	}
	return ActionResult.newResult(EnumActionResult.SUCCESS, playerIn.getHeldItem(handIn));
}
 

@Override
public void writeToNBT(NBTTagCompound tag){
    super.writeToNBT(tag);
    if(filter != null) {
        saveItemStackByName(filter, tag);
    }
    tag.setBoolean("useMetadata", useMetadata);
    tag.setBoolean("useNBT", useNBT);
    tag.setBoolean("useOreDict", useOreDict);
    tag.setBoolean("useModSimilarity", useModSimilarity);
    tag.setInteger("specificMeta", specificMeta);
    tag.setString("variable", variable);
}
 

@Override
public NBTTagCompound writeToNBT(NBTTagCompound nbt) {
	super.writeToNBT(nbt);
	inventory.writeToNBT(nbt);

	nbt.setBoolean("researchingAtmosphere", researchingAtmosphere);
	nbt.setBoolean("researchingDistance", researchingDistance);
	nbt.setBoolean("researchingMass", researchingMass);
	nbt.setInteger("atmosphereProgress", atmosphereProgress);
	nbt.setInteger("distanceProgress", distanceProgress);
	nbt.setInteger("massProgress", massProgress);

	return nbt;
}
 

public static NBTTagCompound getNBTTagFromCulture(BioCulture bioCulture) {
    if (bioCulture == null)
        return new NBTTagCompound();
    NBTTagCompound ret = new NBTTagCompound();
    ret.setString("Name", bioCulture.name);
    //ret.setInteger("ID", bioCulture.ID);
    ret.setIntArray("Color", new int[]{bioCulture.color.getRed(), bioCulture.color.getGreen(), bioCulture.color.getBlue()});
    ret.setTag("Plasmid", BioData.getNBTTagFromBioData(BioData.convertBioPlasmidToBioData(bioCulture.plasmid)));
    ret.setTag("DNA", BioData.getNBTTagFromBioData(BioData.convertBioDNAToBioData(bioCulture.dDNA)));
    ret.setBoolean("Breedable", bioCulture.bBreedable);
    ret.setByte("Rarety", BW_Util.getByteFromRarity(bioCulture.rarity));
    if (bioCulture.bBreedable)
        ret.setString("Fluid", bioCulture.getFluid().getName());
    return ret;
}
 

@Override
public void writeTileNBT(@Nonnull NBTTagCompound tag) {
    Preconditions.checkNotNull(tag);
    tag.setBoolean(AgriNBT.CROSS_CROP, crossCrop);
    tag.setInteger(AgriNBT.META, growthStage);
    if (this.hasSeed()) {
        this.getSeed().getStat().writeToNBT(tag);
        tag.setString(AgriNBT.SEED, this.getSeed().getPlant().getId());
    }
}
 

@Override
public void writeEntityToNBT(NBTTagCompound nbttagcompound)
{
	super.writeEntityToNBT(nbttagcompound);
	nbttagcompound.setBoolean("Tamed", getIsTamed());
	nbttagcompound.setBoolean("Adult", getIsAdult());
	nbttagcompound.setInteger("Edad", getEdad());
	nbttagcompound.setString("Name", getName());
	nbttagcompound.setInteger("TypeInt", getType());
	nbttagcompound.setString("Owner", getOwnerName());
}
 

@Override
public NBTTagCompound writeToNBT(NBTTagCompound nbt) {
	super.writeToNBT(nbt);
	nbt.setInteger(NBT_ENERGYSTORED, this.storage);
	nbt.setBoolean(NBT_POTIONMODE, this.potionMode);
	nbt.setBoolean(NBT_XPMODE, this.xpMode);
	nbt.setBoolean(NBT_PORTALMODE, this.portalMode);
	return nbt;
}
 

@Override
public void writeCustomNBT(NBTTagCompound compound) {
    compound.setBoolean("input", isInputTile);
    compound.setBoolean("master", isMasterTile);
    if (holdingAspect != null) {
        compound.setString("aspect", holdingAspect.getTag());
    }
    compound.setInteger("amount", amount);
    compound.setInteger("maxAmount", maxAmount);
    compound.setBoolean("partOfMultiblock", isPartOfMultiblock);
    if(crystalEssentiaStack != null)
        NBTHelper.setStack(compound, "crystalStack", crystalEssentiaStack);
}
 

@Override
public void writeToNBT(NBTTagCompound tag){
    super.writeToNBT(tag);
    tag.setBoolean("emittingRedstone", emittingRedstone);
    tag.setInteger("thisFloor", thisFloor);
    if(camoStack != null) {
        NBTTagCompound camoTag = new NBTTagCompound();
        camoStack.writeToNBT(camoTag);
        tag.setTag("camoStack", camoTag);
    }
    tag.setBoolean("shouldUpdateNeighbors", shouldUpdateNeighbors);
}
 

@Override
public void writeToNBT(NBTTagCompound nbt) 
{
	nbt.setString("uuid", id.toString());
	if(down != null)
		nbt.setInteger("down", down.index);

	if(up != null)
		nbt.setInteger("up", up.index);
	nbt.setBoolean("isNode", isNode);
	nbt.setInteger("nodeNum", nodeNum);
}
 

@Override
public void writeEntityToNBT(NBTTagCompound root) {
  super.writeEntityToNBT(root);
  root.setBoolean("canBreakDoors", canBreakDoors);
}
 

@Override
public NBTTagCompound writeToNBT(NBTTagCompound compound){
    compound.setBoolean("forward", forward);
    return super.writeToNBT(compound);
}
 

@Override
public void writeToNBT(NBTTagCompound tag){
    super.writeToNBT(tag);
    tag.setBoolean("rightGoing", rightGoing);
}