net.minecraft.nbt.NBTTagDouble Java Examples

private static void setValidValue(Node<NamedNBT> node, String value){
	NamedNBT named = node.getObject();
	NBTBase base = named.getNBT();
	
	if (base instanceof NBTTagByte)
		named.setNBT(new NBTTagByte(ParseHelper.parseByte(value)));
	if (base instanceof NBTTagShort)
		named.setNBT(new NBTTagShort(ParseHelper.parseShort(value)));
	if (base instanceof NBTTagInt)
		named.setNBT(new NBTTagInt(ParseHelper.parseInt(value)));
	if (base instanceof NBTTagLong)
		named.setNBT(new NBTTagLong(ParseHelper.parseLong(value)));
	if(base instanceof NBTTagFloat)
		named.setNBT(new NBTTagFloat(ParseHelper.parseFloat(value)));
	if(base instanceof NBTTagDouble)
		named.setNBT(new NBTTagDouble(ParseHelper.parseDouble(value)));
	if(base instanceof NBTTagByteArray)
		named.setNBT(new NBTTagByteArray(ParseHelper.parseByteArray(value)));
	if(base instanceof NBTTagIntArray)
		named.setNBT(new NBTTagIntArray(ParseHelper.parseIntArray(value)));
	if (base instanceof NBTTagString)
		named.setNBT(new NBTTagString(value));
}
 

public static String toString(NBTBase base) {
    switch (GuiNBTNode.NBT_ICON_MAPPING[base.getId() - 1]) {
        case 0: {
            return "(TagCompound)";
        }
        case 1: {
            return "" + ((NBTTagByte) base).func_150290_f();
        }
        case 2: {
            return "" + ((NBTTagShort) base).func_150289_e();
        }
        case 3: {
            return "" + ((NBTTagInt) base).func_150287_d();
        }
        case 4: {
            return "" + ((NBTTagLong) base).func_150291_c();
        }
        case 5: {
            return "" + ((NBTTagFloat) base).func_150288_h();
        }
        case 6: {
            return "" + ((NBTTagDouble) base).func_150286_g();
        }
        case 7: {
            return ((NBTTagString) base).func_150285_a_();
        }
        case 8: {
            return "(TagList)";
        }
        case 9: {
            return base.toString();
        }
        case 10: {
            return base.toString();
        }
    }
    return "?";
}
 

public static String toString(NBTBase base) {
	switch(base.getId()) {
	case 1:
		return "" + ((NBTTagByte)base).func_150290_f();
	case 2:
		return "" + ((NBTTagShort)base).func_150289_e();
	case 3:
		return "" + ((NBTTagInt)base).func_150287_d();
	case 4:
		return "" + ((NBTTagLong)base).func_150291_c();
	case 5:
		return "" + ((NBTTagFloat)base).func_150288_h();
	case 6:
		return "" + ((NBTTagDouble)base).func_150286_g();
	case 7:
		return base.toString();
	case 8:
		return ((NBTTagString)base).func_150285_a_();
	case 9:
		return "(TagList)";
	case 10:
		return "(TagCompound)";
	case 11:
		return base.toString();
	default:
		return "?";
	}
}
 

public static NBTBase newTag(byte type){
	switch (type)
	{
	case 0:
		return new NBTTagEnd();
	case 1:
		return new NBTTagByte((byte) 0);
	case 2:
		return new NBTTagShort();
	case 3:
		return new NBTTagInt(0);
	case 4:
		return new NBTTagLong(0);
	case 5:
		return new NBTTagFloat(0);
	case 6:
		return new NBTTagDouble(0);
	case 7:
		return new NBTTagByteArray(new byte[0]);
	case 8:
		return new NBTTagString("");
	case 9:
		return new NBTTagList();
	case 10:
		return new NBTTagCompound();
	case 11:
		return new NBTTagIntArray(new int[0]);
	default:
		return null;
	}
}
 

@Nonnull
public static NBTTagList writeDoubles(double... values)
{
    NBTTagList tagList = new NBTTagList();

    for (double d : values)
    {
        tagList.appendTag(new NBTTagDouble(d));
    }

    return tagList;
}
 

protected NBTTagList newDoubleNBTList(double... par1ArrayOfDouble) {
	NBTTagList nbttaglist = new NBTTagList();
	double[] adouble = par1ArrayOfDouble;
	int i = par1ArrayOfDouble.length;

	for (int j = 0; j < i; ++j) {
		double d1 = adouble[j];
		nbttaglist.appendTag(new NBTTagDouble(d1));
	}

	return nbttaglist;
}
 

/**
 * creates a NBT list from the array of doubles passed to this function
 */
protected NBTTagList newDoubleNBTList(double ... p_70087_1_)
{
    NBTTagList nbttaglist = new NBTTagList();
    double[] adouble = p_70087_1_;
    int i = p_70087_1_.length;

    for (int j = 0; j < i; ++j)
    {
        double d1 = adouble[j];
        nbttaglist.appendTag(new NBTTagDouble(d1));
    }

    return nbttaglist;
}
 

/**
 * Reads an unknown object withPriority a known name from NBT
 * @param tag - tag to read the value from
 * @param key - name of the value
 * @return object or suggestionValue if nothing is found
 */
public Object load(NBTTagCompound tag, String key) {
	if (tag != null && key != null) {
		NBTBase saveTag = tag.getTag(key);

		if (saveTag instanceof NBTTagFloat) {
			return tag.getFloat(key);
		} else if (saveTag instanceof NBTTagDouble) {
			return tag.getDouble(key);
		} else if (saveTag instanceof NBTTagInt) {
			return tag.getInteger(key);
		} else if (saveTag instanceof NBTTagString) {
			if (tag.getBoolean(key + "::nova.isBigInteger")) {
				return new BigInteger(tag.getString(key));
			} else if (tag.getBoolean(key + "::nova.isBigDecimal")) {
				return new BigDecimal(tag.getString(key));
			} else {
				return tag.getString(key);
			}
		} else if (saveTag instanceof NBTTagShort) {
			return tag.getShort(key);
		} else if (saveTag instanceof NBTTagByte) {
			if (tag.getBoolean(key + "::nova.isBoolean")) {
				return tag.getBoolean(key);
			} else {
				return tag.getByte(key);
			}
		} else if (saveTag instanceof NBTTagLong) {
			return tag.getLong(key);
		} else if (saveTag instanceof NBTTagByteArray) {
			return tag.getByteArray(key);
		} else if (saveTag instanceof NBTTagIntArray) {
			return tag.getIntArray(key);
		} else if (saveTag instanceof NBTTagCompound) {
			NBTTagCompound innerTag = tag.getCompoundTag(key);
			return toNova(innerTag);
		}
	}
	return null;
}
 

/**
 * Reads an unknown object withPriority a known name from NBT
 * @param tag - tag to read the value from
 * @param key - name of the value
 * @return object or suggestionValue if nothing is found
 */
public Object load(NBTTagCompound tag, String key) {
	if (tag != null && key != null) {
		NBTBase saveTag = tag.getTag(key);

		if (saveTag instanceof NBTTagFloat) {
			return tag.getFloat(key);
		} else if (saveTag instanceof NBTTagDouble) {
			return tag.getDouble(key);
		} else if (saveTag instanceof NBTTagInt) {
			return tag.getInteger(key);
		} else if (saveTag instanceof NBTTagString) {
			if (tag.getBoolean(key + "::nova.isBigInteger")) {
				return new BigInteger(tag.getString(key));
			} else if (tag.getBoolean(key + "::nova.isBigDecimal")) {
				return new BigDecimal(tag.getString(key));
			} else {
				return tag.getString(key);
			}
		} else if (saveTag instanceof NBTTagShort) {
			return tag.getShort(key);
		} else if (saveTag instanceof NBTTagByte) {
			if (tag.getBoolean(key + "::nova.isBoolean")) {
				return tag.getBoolean(key);
			} else {
				return tag.getByte(key);
			}
		} else if (saveTag instanceof NBTTagLong) {
			return tag.getLong(key);
		} else if (saveTag instanceof NBTTagByteArray) {
			return tag.getByteArray(key);
		} else if (saveTag instanceof NBTTagIntArray) {
			return tag.getIntArray(key);
		} else if (saveTag instanceof NBTTagCompound) {
			NBTTagCompound innerTag = tag.getCompoundTag(key);
			return toNova(innerTag);
		}
	}
	return null;
}
 

/**
 * Reads an unknown object withPriority a known name from NBT
 * @param tag - tag to read the value from
 * @param key - name of the value
 * @return object or suggestionValue if nothing is found
 */
@Nullable
public Object load(@Nullable NBTTagCompound tag, @Nullable String key) {
	if (tag != null && key != null) {
		NBTBase saveTag = tag.getTag(key);

		if (saveTag instanceof NBTTagFloat) {
			return tag.getFloat(key);
		} else if (saveTag instanceof NBTTagDouble) {
			return tag.getDouble(key);
		} else if (saveTag instanceof NBTTagInt) {
			return tag.getInteger(key);
		} else if (saveTag instanceof NBTTagString) {
			return tag.getString(key);
		} else if (saveTag instanceof NBTTagShort) {
			return tag.getShort(key);
		} else if (saveTag instanceof NBTTagByte) {
			if (tag.getBoolean("isBoolean")) {
				return tag.getBoolean(key);
			} else {
				return tag.getByte(key);
			}
		} else if (saveTag instanceof NBTTagLong) {
			return tag.getLong(key);
		} else if (saveTag instanceof NBTTagByteArray) {
			return tag.getByteArray(key);
		} else if (saveTag instanceof NBTTagIntArray) {
			return tag.getIntArray(key);
		} else if (saveTag instanceof NBTTagCompound) {
			NBTTagCompound innerTag = tag.getCompoundTag(key);
			return toNova(innerTag);
		}
	}
	return null;
}
 

@Override
public void readNBT(Capability<ICapabilityAntiGravity> capability,
    ICapabilityAntiGravity instance, EnumFacing side,
    NBTBase nbt) {
    NBTTagDouble tagDouble = (NBTTagDouble) nbt;
    instance.setAntiGravity(tagDouble.getDouble());
}
 

private static void setValidValue(Node<NamedNBT> node, String value) {
    NamedNBT named = node.getObject();
    NBTBase base = named.getNBT();
    if (base instanceof NBTTagByte) {
        named.setNBT(new NBTTagByte(ParseHelper.parseByte(value)));
    }
    if (base instanceof NBTTagShort) {
        named.setNBT(new NBTTagShort(ParseHelper.parseShort(value)));
    }
    if (base instanceof NBTTagInt) {
        named.setNBT(new NBTTagInt(ParseHelper.parseInt(value)));
    }
    if (base instanceof NBTTagLong) {
        named.setNBT(new NBTTagLong(ParseHelper.parseLong(value)));
    }
    if (base instanceof NBTTagFloat) {
        named.setNBT(new NBTTagFloat(ParseHelper.parseFloat(value)));
    }
    if (base instanceof NBTTagDouble) {
        named.setNBT(new NBTTagDouble(ParseHelper.parseDouble(value)));
    }
    if (base instanceof NBTTagByteArray) {
        named.setNBT(new NBTTagByteArray(ParseHelper.parseByteArray(value)));
    }
    if (base instanceof NBTTagIntArray) {
        named.setNBT(new NBTTagIntArray(ParseHelper.parseIntArray(value)));
    }
    if (base instanceof NBTTagString) {
        named.setNBT(new NBTTagString(value));
    }
}
 

public static NBTBase newTag(byte type) {
    switch (type) {
        case 1: {
            return new NBTTagCompound();
        }
        case 2: {
            return new NBTTagByte((byte) 0);
        }
        case 3: {
            return new NBTTagShort();
        }
        case 4: {
            return new NBTTagInt(0);
        }
        case 5: {
            return new NBTTagLong(0L);
        }
        case 6: {
            return new NBTTagFloat(0.0f);
        }
        case 7: {
            return new NBTTagDouble(0.0);
        }
        case 8: {
            return new NBTTagString("");
        }
        case 9: {
            return new NBTTagList();
        }
        case 10: {
            return new NBTTagByteArray(new byte[0]);
        }
        case 11: {
            return new NBTTagIntArray(new int[0]);
        }
    }
    return null;
}
 

@Override
public void deserializeNBT(NBTTagDouble nbt) {
    ValkyrienSkiesWorld.ANTI_GRAVITY_CAPABILITY.getStorage()
        .readNBT(ValkyrienSkiesWorld.ANTI_GRAVITY_CAPABILITY, inst, null, nbt);
}
 

@Override
public NBTTagDouble serializeNBT() {
    return (NBTTagDouble) ValkyrienSkiesWorld.ANTI_GRAVITY_CAPABILITY.getStorage()
        .writeNBT(ValkyrienSkiesWorld.ANTI_GRAVITY_CAPABILITY, inst, null);
}
 

public void addEntitiesToWorld(World world, BlockPos posStart)
{
    if (this.placement.getIgnoreEntities())
    {
        return;
    }

    Mirror mirror = this.placement.getMirror();
    Rotation rotation = this.placement.getRotation();

    BlockPos posEnd = posStart.add(PositionUtils.getRelativeEndPositionFromAreaSize(this.size));
    BlockPos pos1 = PositionUtils.getMinCorner(posStart, posEnd);
    BlockPos pos2 = PositionUtils.getMaxCorner(posStart, posEnd).add(1, 1, 1);
    List<Entity> existingEntities = world.getEntitiesWithinAABBExcludingEntity(null, new AxisAlignedBB(pos1, pos2));

    for (TemplateEnderUtilities.TemplateEntityInfo entityInfo : this.entities)
    {
        BlockPos pos = transformedBlockPos(this.placement, entityInfo.blockPos).add(posStart);

        NBTTagCompound nbt = entityInfo.entityData;
        UUID uuidOriginal = nbt.getUniqueId("UUID");
        Vec3d vec3d = PositionUtils.transformedVec3d(entityInfo.pos, mirror, rotation);
        Vec3d vec3d1 = vec3d.add((double)posStart.getX(), (double)posStart.getY(), (double)posStart.getZ());
        NBTTagList tagList = new NBTTagList();
        tagList.appendTag(new NBTTagDouble(vec3d1.x));
        tagList.appendTag(new NBTTagDouble(vec3d1.y));
        tagList.appendTag(new NBTTagDouble(vec3d1.z));
        nbt.setTag("Pos", tagList);
        nbt.setUniqueId("UUID", UUID.randomUUID());
        Entity entity;

        try
        {
            entity = EntityList.createEntityFromNBT(nbt, world);
        }
        catch (Exception e)
        {
            entity = null;
        }

        if (entity != null)
        {
            if (entity instanceof EntityPainting)
            {
                entity.getMirroredYaw(mirror);
                entity.getRotatedYaw(rotation);
                entity.setPosition(pos.getX(), pos.getY(), pos.getZ());
                entity.setLocationAndAngles(vec3d1.x, vec3d1.y, vec3d1.z, entity.rotationYaw, entity.rotationPitch);
            }
            else
            {
                float f = entity.getMirroredYaw(mirror);
                f = f + (entity.rotationYaw - entity.getRotatedYaw(rotation));
                entity.setLocationAndAngles(vec3d1.x, vec3d1.y, vec3d1.z, f, entity.rotationPitch);
                // FIXME should call updateFacingWithBoundingBox(EnumFacing) for EntityHanging, otherwise a world reload is needed
                // for ItemFrames for example to visually update to the correct facing
            }

            // Use the original UUID if possible. If there is an entity with the same UUID within the pasted area,
            // then the old one will be killed. Otherwise if there is no entity currently in the world with
            // the same UUID, then the original UUID will be used.
            Entity existing = EntityUtils.findEntityByUUID(existingEntities, uuidOriginal);
            if (existing != null)
            {
                world.removeEntityDangerously(existing);
                entity.setUniqueId(uuidOriginal);
            }
            else if (world instanceof WorldServer && ((WorldServer) world).getEntityFromUuid(uuidOriginal) == null)
            {
                entity.setUniqueId(uuidOriginal);
            }

            world.spawnEntity(entity);
        }
    }
}
 

@Override
public NBTBase writeNBT(Capability<ICapabilityAntiGravity> capability,
    ICapabilityAntiGravity instance,
    EnumFacing side) {
    return new NBTTagDouble(instance.getAntiGravity());
}
 

@Override
public Double read(NBTBase tag) { return ((NBTTagDouble)tag).getDouble(); }
 

@Override
public NBTBase write(Double value) { return new NBTTagDouble(value); }
 

@Override
public boolean checkTagType(NBTBase tag) {
	return tag instanceof NBTTagDouble;
}