@Override
  public void writeToNBT(NBTTagCompound nbtTags) {
    super.writeToNBT(nbtTags);

    nbtTags.setBoolean("finishedCalc", finishedCalc);

    if (fluidTank.getFluid() != null) {
      nbtTags.setTag("fluidTank", fluidTank.writeToNBT(new NBTTagCompound()));
    }

    NBTTagList activeList = new NBTTagList();

    for (Coord4D wrapper : activeNodes) {
      NBTTagCompound tagCompound = new NBTTagCompound();
      wrapper.write(tagCompound);
      activeList.appendTag(tagCompound);
    }

    if (activeList.tagCount() != 0) {
      nbtTags.setTag("activeNodes", activeList);
    }

    NBTTagList usedList = new NBTTagList();

    for (Coord4D obj : usedNodes) {
      activeList.appendTag(obj.write(new NBTTagCompound()));
    }

    if (activeList.tagCount() != 0) {
      nbtTags.setTag("usedNodes", usedList);
    }
  }
Beispiel #2
0
  @Override
  public void writeToNBT(final NBTTagCompound tag) {
    super.writeToNBT(tag);

    final NBTTagCompound inventoriesTag = new NBTTagCompound();
    final NBTTagCompound ownerTag = new NBTTagCompound();

    for (final Entry<String, Map<Integer, ItemStack>> inventoryEntry :
        this.inventories.entrySet()) {
      final NBTTagList inventoryTag = new NBTTagList();

      for (final Entry<Integer, ItemStack> slotEntry : inventoryEntry.getValue().entrySet()) {
        final NBTTagCompound slotTag = new NBTTagCompound();

        slotEntry.getValue().writeToNBT(slotTag);
        slotTag.setByte("slot", slotEntry.getKey().byteValue());

        inventoryTag.appendTag(slotTag);
      }

      inventoriesTag.setTag(inventoryEntry.getKey(), inventoryTag);
    }

    NBTUtil.writeGameProfile(ownerTag, this.owner);

    tag.setLong("age", this.age);
    tag.setTag("inventories", inventoriesTag);
    tag.setTag("owner", ownerTag);
  }
  @Override
  public void writeToNBT(NBTTagCompound nbt, MappingRegistry registry) {
    nbt.setByte("mode", (byte) mode.ordinal());
    nbt.setInteger("x", x);
    nbt.setInteger("y", y);
    nbt.setInteger("z", z);

    if (schematic != null) {
      NBTTagCompound schematicNBT = new NBTTagCompound();
      SchematicFactory.getFactory(schematic.getClass())
          .saveSchematicToWorldNBT(schematicNBT, schematic, registry);
      nbt.setTag("schematic", schematicNBT);
    }

    NBTTagList nbtStacks = new NBTTagList();

    if (stackConsumed != null) {
      for (ItemStack stack : stackConsumed) {
        NBTTagCompound nbtStack = new NBTTagCompound();
        stack.writeToNBT(nbtStack);
        nbtStacks.appendTag(nbtStack);
      }
    }

    nbt.setTag("stackConsumed", nbtStacks);
  }
Beispiel #4
0
  public void writeToNBT(NBTTagCompound nbttagcompound) {
    transport.writeToNBT(nbttagcompound);
    logic.writeToNBT(nbttagcompound);

    // Save pulser if any
    if (gate != null) {
      NBTTagCompound nbttagcompoundC = new NBTTagCompound();
      gate.writeToNBT(nbttagcompoundC);
      nbttagcompound.setTag("Gate", nbttagcompoundC);
      // Wire states are stored for pipes with gates only
      for (int i = 0; i < 4; ++i)
        nbttagcompound.setBoolean("wireState[" + i + "]", broadcastSignal[i]);
      nbttagcompound.setBoolean("redstoneState", broadcastRedstone);
    }

    for (int i = 0; i < 4; ++i) nbttagcompound.setBoolean("wireSet[" + i + "]", wireSet[i]);

    for (int i = 0; i < 8; ++i) {
      nbttagcompound.setInteger(
          "action[" + i + "]", activatedActions[i] != null ? activatedActions[i].getId() : 0);
      nbttagcompound.setInteger(
          "trigger[" + i + "]", activatedTriggers[i] != null ? activatedTriggers[i].getId() : 0);
    }

    for (int i = 0; i < 8; ++i)
      if (triggerParameters[i] != null) {
        NBTTagCompound cpt = new NBTTagCompound();
        triggerParameters[i].writeToNBT(cpt);
        nbttagcompound.setTag("triggerParameters[" + i + "]", cpt);
      }
  }
  @Override
  public void writeToNBT(NBTTagCompound nbtTags) {
    super.writeToNBT(nbtTags);

    if (fluidTank.getFluid() != null) {
      nbtTags.setTag("fluidTank", fluidTank.writeToNBT(new NBTTagCompound()));
    }

    NBTTagList recurringList = new NBTTagList();

    for (Object3D wrapper : recurringNodes) {
      NBTTagCompound tagCompound = new NBTTagCompound();
      wrapper.write(tagCompound);
      recurringList.appendTag(tagCompound);
    }

    if (recurringList.tagCount() != 0) {
      nbtTags.setTag("recurringNodes", recurringList);
    }

    NBTTagList cleaningList = new NBTTagList();

    for (Object3D obj : cleaningNodes) {
      cleaningList.appendTag(obj.write(new NBTTagCompound()));
    }

    if (cleaningList.tagCount() != 0) {
      nbtTags.setTag("cleaningNodes", cleaningList);
    }
  }
  public void writeToNBT(NBTTagCompound p_98280_1_) {
    p_98280_1_.setString("EntityId", this.getEntityNameToSpawn());
    p_98280_1_.setShort("Delay", (short) this.spawnDelay);
    p_98280_1_.setShort("MinSpawnDelay", (short) this.minSpawnDelay);
    p_98280_1_.setShort("MaxSpawnDelay", (short) this.maxSpawnDelay);
    p_98280_1_.setShort("SpawnCount", (short) this.spawnCount);
    p_98280_1_.setShort("MaxNearbyEntities", (short) this.maxNearbyEntities);
    p_98280_1_.setShort("RequiredPlayerRange", (short) this.activatingRangeFromPlayer);
    p_98280_1_.setShort("SpawnRange", (short) this.spawnRange);

    if (this.getRandomMinecart() != null) {
      p_98280_1_.setTag("SpawnData", this.getRandomMinecart().field_98222_b.copy());
    }

    if (this.getRandomMinecart() != null
        || this.minecartToSpawn != null && this.minecartToSpawn.size() > 0) {
      NBTTagList var2 = new NBTTagList();

      if (this.minecartToSpawn != null && this.minecartToSpawn.size() > 0) {
        Iterator var3 = this.minecartToSpawn.iterator();

        while (var3.hasNext()) {
          MobSpawnerBaseLogic.WeightedRandomMinecart var4 =
              (MobSpawnerBaseLogic.WeightedRandomMinecart) var3.next();
          var2.appendTag(var4.func_98220_a());
        }
      } else {
        var2.appendTag(this.getRandomMinecart().func_98220_a());
      }

      p_98280_1_.setTag("SpawnPotentials", var2);
    }
  }
Beispiel #7
0
  public NBTTagCompound writeCrucibleToNBT(TECrucible te) {
    NBTTagCompound nbt = new NBTTagCompound();

    nbt.setInteger("temp", te.temperature);

    NBTTagList nbttaglist = new NBTTagList();
    Iterator iter = te.metals.values().iterator();
    while (iter.hasNext()) {
      MetalPair m = (MetalPair) iter.next();
      if (m != null) {
        NBTTagCompound nbttagcompound1 = new NBTTagCompound();
        nbttagcompound1.setInteger("ID", m.type.IngotID);
        nbttagcompound1.setFloat("AmountF", m.amount);
        nbttaglist.appendTag(nbttagcompound1);
      }
    }
    nbt.setTag("Metals", nbttaglist);

    nbttaglist = new NBTTagList();
    for (int i = 0; i < te.storage.length; i++) {
      if (te.storage[i] != null) {
        NBTTagCompound nbttagcompound1 = new NBTTagCompound();
        nbttagcompound1.setByte("Slot", (byte) i);
        te.storage[i].writeToNBT(nbttagcompound1);
        nbttaglist.appendTag(nbttagcompound1);
      }
    }

    nbt.setTag("Items", nbttaglist);

    return nbt;
  }
  public void writeToNBT(NBTTagCompound nbt) {
    super.writeToNBT(nbt);

    NBTTagCompound energyTag = new NBTTagCompound();
    this.storage.writeToNBT(energyTag);
    nbt.setTag("storage", energyTag);
    nbt.setBoolean("flag", this.flag);
    nbt.setBoolean("flag1", this.flag1);
    NBTTagList list = new NBTTagList();

    for (int i = 0; i < this.slots.length; ++i) {
      if (this.slots[i] != null) {
        NBTTagCompound compound = new NBTTagCompound();
        compound.setByte("Slot", (byte) i);
        this.slots[i].writeToNBT(compound);
        list.appendTag(compound);
      }
    }

    nbt.setTag("Items", list);

    if (this.isInventoryNameLocalized()) {
      nbt.setString("CustomName", this.localizedName);
    }
  }
  // This is where you save any data that you don't want to lose when the tile entity unloads
  // In this case, it saves the state of the furnace (burn time etc) and the itemstacks stored in
  // the fuel, input, and output slots
  @Override
  public void writeToNBT(NBTTagCompound parentNBTTagCompound) {
    super.writeToNBT(
        parentNBTTagCompound); // The super call is required to save and load the tiles location

    //		// Save the stored item stacks

    // to use an analogy with Java, this code generates an array of hashmaps
    // The itemStack in each slot is converted to an NBTTagCompound, which is effectively a hashmap
    // of key->value pairs such
    //   as slot=1, id=2353, count=1, etc
    // Each of these NBTTagCompound are then inserted into NBTTagList, which is similar to an array.
    NBTTagList dataForAllSlots = new NBTTagList();
    for (int i = 0; i < this.itemStacks.length; ++i) {
      if (this.itemStacks[i] != null) {
        NBTTagCompound dataForThisSlot = new NBTTagCompound();
        dataForThisSlot.setByte("Slot", (byte) i);
        this.itemStacks[i].writeToNBT(dataForThisSlot);
        dataForAllSlots.appendTag(dataForThisSlot);
      }
    }
    // the array of hashmaps is then inserted into the parent hashmap for the container
    parentNBTTagCompound.setTag("Items", dataForAllSlots);

    // Save everything else
    parentNBTTagCompound.setShort("CookTime", cookTime);
    parentNBTTagCompound.setTag("burnTimeRemaining", new NBTTagIntArray(burnTimeRemaining));
    parentNBTTagCompound.setTag("burnTimeInitial", new NBTTagIntArray(burnTimeInitialValue));
  }
  @Override
  public NBTTagCompound writeToNBT(NBTTagCompound compound) {
    super.writeToNBT(compound);

    if (this instanceof IStructurePart) {
      if (((IStructurePart) this).getStructure() != null) {
        compound.setInteger(
            CoreReferences.NBT.StructureData.DIMENSION, getWorld().provider.getDimension());
        compound.setTag(
            CoreReferences.NBT.STRUCTURE,
            ((IStructurePart) this).getStructure().getMasterLocation().toCompound());
      }
    }

    if (getState().requiresNBTStorage())
      compound.setTag(CoreReferences.NBT.STATE, this.getState().writeToNBTTagCompound());

    if (this instanceof IItemStorage)
      compound.setTag(CoreReferences.NBT.INVENTORY, this.writeInventoryToCompound());

    if (this instanceof IFluidContainingEntity)
      compound.setTag(CoreReferences.NBT.FLUIDS, this.writeFluidsToCompound());

    if (this.hasCustomName()) {
      compound.setString(CoreReferences.NBT.NAME, name);
    }

    return compound;
  }
Beispiel #11
0
 @Override
 public NBTTagCompound writeToNBT(NBTTagCompound tag) {
   super.writeToNBT(tag);
   if (inventory.size() > 0) {
     NBTTagList list = new NBTTagList();
     for (int i = 0; i < inventory.size(); i++) {;
       if (inventory.get(i) != null) {
         list.appendTag(inventory.get(i).writeToNBT(new NBTTagCompound()));
       }
     }
     tag.setTag("inventory", list);
   }
   if (incenses.size() > 0) {
     NBTTagList list = new NBTTagList();
     for (int i = 0; i < incenses.size(); i++) {;
       if (incenses.get(i) != null) {
         list.appendTag(incenses.get(i).writeToNBT(new NBTTagCompound()));
       }
     }
     tag.setTag("incenses", list);
   }
   if (ritualName != null) {
     tag.setString("ritualName", ritualName);
   }
   tag.setInteger("progress", progress);
   return tag;
 }
	@Override
	public void writeToNBT(NBTTagCompound tag)
	{
		super.writeToNBT(tag);
		NBTTagList nbttaglist;
		if (_inventory.length > 0)
		{
			nbttaglist = new NBTTagList();
			for(int i = 0; i < _inventory.length; i++)
			{
				if (_inventory[i] != null && _inventory[i].stackSize > 0)
				{
					NBTTagCompound slot = new NBTTagCompound();
					slot.setByte("Slot", (byte)i);
					_inventory[i].writeToNBT(slot);
					nbttaglist.appendTag(slot);
				}
			}
			tag.setTag("Items", nbttaglist);
		}
		
		IFluidTank[] _tanks = getTanks();
		if (_tanks.length > 0)
		{
			NBTTagList tanks = new NBTTagList();
			for(int i = 0, n = _tanks.length; i < n; i++)
			{
				if(_tanks[i].getFluid() != null)
				{
					NBTTagCompound nbttagcompound1 = new NBTTagCompound();
					nbttagcompound1.setByte("Tank", (byte)i);
					
					FluidStack l = _tanks[i].getFluid();
					l.writeToNBT(nbttagcompound1);
					tanks.appendTag(nbttagcompound1);
				}
			}
			tag.setTag("mTanks", tanks);
		}
		
		if (this.isInvNameLocalized())
		{
			NBTTagCompound display = new NBTTagCompound();
			display.setString("Name", getInvName());
			tag.setCompoundTag("display", display);
		}
		
		if (failedDrops != null)
		{
			nbttaglist = new NBTTagList();
			for (ItemStack item : failedDrops)
			{
				NBTTagCompound nbttagcompound1 = new NBTTagCompound();
				item.writeToNBT(nbttagcompound1);
				nbttaglist.appendTag(nbttagcompound1);
			}
			tag.setTag("DropItems", nbttaglist);
		}
	}
 private NBTTagList getNBTRecipes(EntityPlayer ep) {
   String key = "recipes";
   NBTTagCompound tag = this.getNBT(ep);
   if (!tag.hasKey(key)) tag.setTag(key, new NBTTagList());
   NBTTagList li = tag.getTagList(key, NBTTypes.INT.ID);
   tag.setTag(key, li);
   return li;
 }
  /*
  public Collection<CastingRecipe> getRecipesPerformed(EntityPlayer ep) {
  	Collection<CastingRecipe> c = new HashSet();
  	NBTTagList li = this.getNBTRecipes(ep);
  	for (Object o : li.tagList) {
  		NBTTagCompound tag = (NBTTagCompound)o;
  		ItemStack is = ItemStack.loadItemStackFromNBT(tag);
  		c.addAll(RecipesCastingTable.instance.getAllRecipesMaking(is));
  	}
  	return c;
  }

  private NBTTagList getNBTRecipes(EntityPlayer ep) {
  	String key = "recipes";
  	NBTTagCompound tag = this.getNBT(ep);
  	if (!tag.hasKey(key))
  		tag.setTag(key, new NBTTagList());
  	NBTTagList li = tag.getTagList(key, NBTTypes.COMPOUND.ID);
  	tag.setTag(key, li);
  	return li;
  }

  public boolean givePlayerRecipe(EntityPlayer ep, CastingRecipe cr) {
  	if (!this.playerHasRecipe(ep, cr)) {
  		NBTTagCompound tag = new NBTTagCompound();
  		cr.getOutput().writeToNBT(tag);
  		this.getNBTRecipes(ep).appendTag(tag);
  		if (ep instanceof EntityPlayerMP)
  			ReikaPlayerAPI.syncCustomData((EntityPlayerMP)ep);
  		this.notifyPlayerOfProgression(ep, cr);
  		return true;
  	}
  	return false;
  }

  public boolean playerHasRecipe(EntityPlayer ep, CastingRecipe cr) {
  	return this.getRecipesPerformed(ep).contains(cr);
  }
   */
  private NBTTagList getNBTFragments(EntityPlayer ep) {
    String key = "fragments";
    NBTTagCompound tag = this.getNBT(ep);
    if (!tag.hasKey(key)) tag.setTag(key, new NBTTagList());
    NBTTagList li = tag.getTagList(key, NBTTypes.STRING.ID);
    tag.setTag(key, li);
    return li;
  }
Beispiel #15
0
  public void addPulverizerRecipe(ItemStack input, ItemStack output, int energy) {
    NBTTagCompound nbtTags = new NBTTagCompound();

    nbtTags.setInteger("energy", energy);
    nbtTags.setTag("input", input.writeToNBT(new NBTTagCompound()));
    nbtTags.setTag("primaryOutput", output.writeToNBT(new NBTTagCompound()));

    FMLInterModComms.sendMessage("mekanism", "PulverizerRecipe", nbtTags);
  }
  public void encode() {
    ItemStack output = this.patternSlotOUT.getStack();

    final ItemStack[] in = this.getInputs();
    final ItemStack[] out = this.getOutputs();

    // if there is no input, this would be silly.
    if (in == null || out == null) {
      return;
    }

    // first check the output slots, should either be null, or a pattern
    if (output != null && !this.isPattern(output)) {
      return;
    } // if nothing is there we should snag a new pattern.
    else if (output == null) {
      output = this.patternSlotIN.getStack();
      if (output == null || !this.isPattern(output)) {
        return; // no blanks.
      }

      // remove one, and clear the input slot.
      output.stackSize--;
      if (output.stackSize == 0) {
        this.patternSlotIN.putStack(null);
      }

      // add a new encoded pattern.
      for (final ItemStack encodedPatternStack :
          AEApi.instance().definitions().items().encodedPattern().maybeStack(1).asSet()) {
        output = encodedPatternStack;
        this.patternSlotOUT.putStack(output);
      }
    }

    // encode the slot.
    final NBTTagCompound encodedValue = new NBTTagCompound();

    final NBTTagList tagIn = new NBTTagList();
    final NBTTagList tagOut = new NBTTagList();

    for (final ItemStack i : in) {
      tagIn.appendTag(this.createItemTag(i));
    }

    for (final ItemStack i : out) {
      tagOut.appendTag(this.createItemTag(i));
    }

    encodedValue.setTag("in", tagIn);
    encodedValue.setTag("out", tagOut);
    encodedValue.setBoolean("crafting", this.isCraftingMode());
    encodedValue.setBoolean("substitute", this.isSubstitute());

    output.setTagCompound(encodedValue);
  }
  @Override
  public void writeToNBT(NBTTagCompound data) {
    super.writeToNBT(data);

    NBTTagList itemList = new NBTTagList();
    NBTTagList sideItemList = new NBTTagList();
    NBTTagCompound configData;

    data.setBoolean("shareRS", isRSShared);

    for (int i = 0; i < 3; i++) {

      if (inventory.getStackInSlot(i) != null) {
        NBTTagCompound itemCompound = new NBTTagCompound();
        itemCompound.setInteger("slot", i);
        inventory.getStackInSlot(i).writeToNBT(itemCompound);
        itemList.appendTag(itemCompound);
      }

      if (tanks[i].getFluid() != null) {
        data.setInteger("tankCap" + i, tanks[i].getCapacity());
        data.setTag("Fluid" + i, tanks[i].getFluid().writeToNBT(new NBTTagCompound()));
      }

      data.setBoolean("rsControl" + i, rsControl[i]);
      data.setBoolean("rsLatch" + i, rsLatch[i]);
    }

    data.setTag("items", itemList);

    for (int i = 0; i < 6; i++) {
      data.setInteger("side" + i, sides[i]);
      configData = new NBTTagCompound();
      configs[i].writeToNBT(configData);
      data.setCompoundTag("config" + i, configData);
      data.setBoolean("rs" + i, sideRS[i]);
      data.setBoolean("lock" + i, sideLocked[i]);
      data.setInteger("facID" + i, facID[i]);
      data.setInteger("facMeta" + i, facMeta[i]);

      if (sideInventory.getStackInSlot(i) != null) {
        NBTTagCompound itemCompound = new NBTTagCompound();
        itemCompound.setInteger("slot", i);
        sideInventory.getStackInSlot(i).writeToNBT(itemCompound);
        sideItemList.appendTag(itemCompound);
      }
    }

    data.setTag("sideItems", sideItemList);

    if (capacitor != null) {
      data.setInteger("realPower", capacitor.getEnergyStored());
      capacitor.writeToNBT(data);
      data.setInteger("powerCap2", capacitor.getMaxEnergyStored());
    }
  }
  @Override
  public void writeToNBT(NBTTagCompound nbtTags) {
    super.writeToNBT(nbtTags);

    nbtTags.setBoolean("isActive", isActive);
    nbtTags.setInteger("controlType", controlType.ordinal());
    nbtTags.setInteger("operatingTicks", operatingTicks);
    nbtTags.setTag("injectTank", injectTank.write(new NBTTagCompound()));
    nbtTags.setTag("gasTank", outputTank.write(new NBTTagCompound()));
  }
  public Entity func_98265_a(Entity p_98265_1_) {
    if (this.getRandomMinecart() != null) {
      NBTTagCompound var2 = new NBTTagCompound();
      p_98265_1_.writeToNBTOptional(var2);
      Iterator var3 = this.getRandomMinecart().field_98222_b.func_150296_c().iterator();

      while (var3.hasNext()) {
        String var4 = (String) var3.next();
        NBTBase var5 = this.getRandomMinecart().field_98222_b.getTag(var4);
        var2.setTag(var4, var5.copy());
      }

      p_98265_1_.readFromNBT(var2);

      if (p_98265_1_.worldObj != null) {
        p_98265_1_.worldObj.spawnEntityInWorld(p_98265_1_);
      }

      NBTTagCompound var11;

      for (Entity var10 = p_98265_1_; var2.func_150297_b("Riding", 10); var2 = var11) {
        var11 = var2.getCompoundTag("Riding");
        Entity var12 = EntityList.createEntityByName(var11.getString("id"), p_98265_1_.worldObj);

        if (var12 != null) {
          NBTTagCompound var6 = new NBTTagCompound();
          var12.writeToNBTOptional(var6);
          Iterator var7 = var11.func_150296_c().iterator();

          while (var7.hasNext()) {
            String var8 = (String) var7.next();
            NBTBase var9 = var11.getTag(var8);
            var6.setTag(var8, var9.copy());
          }

          var12.readFromNBT(var6);
          var12.setLocationAndAngles(
              var10.posX, var10.posY, var10.posZ, var10.rotationYaw, var10.rotationPitch);

          if (p_98265_1_.worldObj != null) {
            p_98265_1_.worldObj.spawnEntityInWorld(var12);
          }

          var10.mountEntity(var12);
        }

        var10 = var12;
      }
    } else if (p_98265_1_ instanceof EntityLivingBase && p_98265_1_.worldObj != null) {
      ((EntityLiving) p_98265_1_).onSpawnWithEgg((IEntityLivingData) null);
      this.getSpawnerWorld().spawnEntityInWorld(p_98265_1_);
    }

    return p_98265_1_;
  }
 public NBTTagCompound toNbt() {
   NBTTagCompound tag = new NBTTagCompound();
   NBTTagList elements = new NBTTagList();
   for (Map.Entry<Key, Integer> e : _elements.entrySet()) {
     NBTTagCompound element = new NBTTagCompound();
     element.setTag("key", e.getKey().toNbt());
     element.setInteger("count", e.getValue());
     elements.appendTag(element);
   }
   tag.setTag("elements", elements);
   tag.setInteger("size", _size);
   return tag;
 }
    public static void addGrinderRecipe(ItemStack input, ItemStack output, int turns) {
      NBTTagCompound msg = new NBTTagCompound();
      NBTTagCompound in = new NBTTagCompound();
      NBTTagCompound out = new NBTTagCompound();

      input.writeToNBT(in);
      output.writeToNBT(out);

      msg.setTag("in", in);
      msg.setTag("out", out);
      msg.setInteger("turns", turns);

      sendInterModMessage("appliedenergistics2", "add-grindable", msg);
    }
  private void handleFireworks(WorldServer world) {
    if (random.nextFloat() < 0.05) {
      // Calculate a bounding box for all players in the world.
      double minPosX = 1000000000.0f;
      double minPosZ = 1000000000.0f;
      double maxPosX = -1000000000.0f;
      double maxPosZ = -1000000000.0f;
      for (Object playerEntity : world.playerEntities) {
        EntityPlayer player = (EntityPlayer) playerEntity;
        if (player.posX > maxPosX) {
          maxPosX = player.posX;
        }
        if (player.posX < minPosX) {
          minPosX = player.posX;
        }
        if (player.posZ > maxPosZ) {
          maxPosZ = player.posZ;
        }
        if (player.posZ < minPosZ) {
          minPosZ = player.posZ;
        }
      }
      double posX = random.nextFloat() * (maxPosX - minPosX + 60.0f) + minPosX - 30.0f;
      double posZ = random.nextFloat() * (maxPosZ - minPosZ + 60.0f) + minPosZ - 30.0f;

      ItemStack fireworkStack = new ItemStack(Items.fireworks);
      NBTTagCompound tag = new NBTTagCompound();

      NBTTagCompound fireworks = new NBTTagCompound();
      fireworks.setByte("Flight", (byte) 2);

      NBTTagList explosions = new NBTTagList();
      explosions.appendTag(makeExplosion(tag));
      fireworks.setTag("Explosions", explosions);

      tag.setTag("Fireworks", fireworks);

      fireworkStack.setTagCompound(tag);

      int y = world.getTopSolidOrLiquidBlock((int) posX, (int) posZ);
      if (y == -1) {
        y = 64;
      } else {
        y += 3;
      }
      EntityFireworkRocket entityfireworkrocket =
          new EntityFireworkRocket(world, posX, y, posZ, fireworkStack);
      world.spawnEntityInWorld(entityfireworkrocket);
    }
  }
  @Override
  public void writeCustomNBT(NBTTagCompound nbt, boolean descPacket) {
    super.writeCustomNBT(nbt, descPacket);
    nbt.setInteger("facing", facing);
    energyStorage.writeToNBT(nbt);

    NBTTagCompound tankTag = tank.writeToNBT(new NBTTagCompound());
    nbt.setTag("tank", tankTag);

    nbt.setTag("inventory", Utils.writeInventory(inventory));

    nbt.setTag("predictedOutput", Utils.writeInventory(predictedOutput));

    nbt.setIntArray("process", process);
  }
 @Override
 public void writeToNBT(NBTTagCompound tag) {
   super.writeToNBT(tag);
   tag.setString("owningPlayer", owningPlayer);
   tag.setTag(
       "bookInventory", InventoryTools.writeInventoryToNBT(bookInventory, new NBTTagCompound()));
   tag.setTag(
       "resourceInventory",
       InventoryTools.writeInventoryToNBT(resourceInventory, new NBTTagCompound()));
   tag.setBoolean("useAdjacentInventory", useAdjacentInventory);
   tag.setDouble("storedEnergy", storedEnergy);
   tag.setInteger("orientation", orientation.ordinal());
   tag.setInteger("inventoryDirection", inventoryDirection.ordinal());
   tag.setInteger("inventorySide", inventorySide.ordinal());
 }
Beispiel #25
0
  private NBTTagCompound writeInternal(NBTTagCompound compound) {
    String s = (String) classToNameMap.get(this.getClass());

    if (s == null) {
      throw new RuntimeException(this.getClass() + " is missing a mapping! This is a bug!");
    } else {
      compound.setString("id", s);
      compound.setInteger("x", this.pos.getX());
      compound.setInteger("y", this.pos.getY());
      compound.setInteger("z", this.pos.getZ());
      if (this.customTileData != null) compound.setTag("ForgeData", this.customTileData);
      if (this.capabilities != null) compound.setTag("ForgeCaps", this.capabilities.serializeNBT());
      return compound;
    }
  }
 @Override
 public void writeCustomNBT(NBTTagCompound nbt, boolean descPacket) {
   super.writeCustomNBT(nbt, descPacket);
   nbt.setInteger("facing", facing);
   NBTTagCompound tankTag = tank0.writeToNBT(new NBTTagCompound());
   nbt.setTag("tank0", tankTag);
   tankTag = tank1.writeToNBT(new NBTTagCompound());
   nbt.setTag("tank1", tankTag);
   tankTag = tank2.writeToNBT(new NBTTagCompound());
   nbt.setTag("tank2", tankTag);
   energyStorage.writeToNBT(nbt);
   if (!descPacket) {
     nbt.setTag("inventory", Utils.writeInventory(inventory));
   }
 }
 @Override
 public void updatePacket(NBTTagCompound nbt) {
   super.updatePacket(nbt);
   for (int i = 0; i < connections.length; i++) {
     if (connections[i] != null) nbt.setTag("co" + i, connections[i].saveConnection());
   }
 }
 @Override
 public void saveTileExtra(NBTTagCompound nbt) {
   super.saveTileExtra(nbt);
   for (int i = 0; i < connections.length; i++) {
     if (connections[i] != null) nbt.setTag("co" + i, connections[i].saveConnection());
   }
 }
  // インベントリの保存
  public void save() {
    NBTTagList nbttaglist = new NBTTagList();

    for (int i = 0; i < this.containerItems.length; i++) {
      if (this.containerItems[i] != null) {
        NBTTagCompound nbttagcompound1 = new NBTTagCompound();
        nbttagcompound1.setByte("EquipmentSlot", (byte) i);
        this.containerItems[i].writeToNBT(nbttagcompound1);
        nbttaglist.appendTag(nbttagcompound1);
      }
    }

    // ItemStackのNBTに中身を保存
    NBTTagCompound nbttagcompound = this.baseChest.getEntityData();

    if (nbttagcompound == null) {
      nbttagcompound = new NBTTagCompound();
    }

    nbttagcompound.setTag("EquipmentItems", nbttaglist);

    // EntityLivingのequipmentと同期
    for (int slot = 0; slot < this.containerItems.length; slot++) {
      this.baseChest.setCurrentItemOrArmor(slot, this.containerItems[slot]);
    }
  }
 public ItemStack getItemStackWithData(World world, int x, int y, int z) {
   ItemStack stack = new ItemStack(world.getBlock(x, y, z), 1, 0);
   TileEntity tentity = world.getTileEntity(x, y, z);
   if (tentity instanceof TileVendorBlock) {
     TileVendorBlock te = (TileVendorBlock) tentity;
     NBTTagList itemList = new NBTTagList();
     NBTTagCompound tagCompound = new NBTTagCompound();
     for (int i = 0; i < te.getSizeInventory(); i++) {
       ItemStack invStack = te.getStackInSlot(i);
       if (invStack != null) {
         NBTTagCompound tag = new NBTTagCompound();
         tag.setByte("Slot", (byte) i);
         invStack.writeToNBT(tag);
         itemList.appendTag(tag);
       }
     }
     tagCompound.setTag("Inventory", itemList);
     tagCompound.setInteger("CoinSum", te.coinSum);
     tagCompound.setInteger("UserCoinSum", te.userCoinSum);
     tagCompound.setInteger("ItemPrice", te.itemPrice);
     tagCompound.setString("BlockOwner", te.blockOwner);
     tagCompound.setBoolean("Infinite", te.infiniteMode);
     stack.setTagCompound(tagCompound);
     return stack;
   } else return stack;
 }