Exemplo n.º 1
0
  @Override
  public void handleDataPacket(NBTTagCompound nbt) {
    if (!worldObj.isRemote) {
      if (nbt.hasKey("fluidID")) {
        if (nbt.getByte("fluidID") == -1) fluid = null;
      } else if (nbt.hasKey("mode")) {
        mode = nbt.getByte("mode");
      } else if (nbt.hasKey("seal")) {
        sealed = nbt.getBoolean("seal");
        if (!sealed) {
          unsealtime = (int) TFC_Time.getTotalHours();
          sealtime = 0;
        } else {
          sealtime = (int) TFC_Time.getTotalHours();
          unsealtime = 0;
        }
      }

      if (nbt.hasKey("tab")) {
        int tab = nbt.getByte("tab");
        if (tab == 0)
          worldObj
              .getPlayerEntityByName(nbt.getString("player"))
              .openGui(TerraFirmaCraft.instance, 35, worldObj, xCoord, yCoord, zCoord);
        else if (tab == 1)
          worldObj
              .getPlayerEntityByName(nbt.getString("player"))
              .openGui(TerraFirmaCraft.instance, 36, worldObj, xCoord, yCoord, zCoord);
      }
    }
  }
 @Override
 public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean b1) {
   if (stack.hasTagCompound()) {
     NBTTagCompound tagCompound = stack.getTagCompound();
     if (tagCompound.hasKey(ThermalScienceNBTTags.Dim)
         && tagCompound.hasKey(ThermalScienceNBTTags.XCoord)
         && tagCompound.hasKey(ThermalScienceNBTTags.YCoord)
         && tagCompound.hasKey(ThermalScienceNBTTags.ZCoord)) {
       list.add(
           StringHelper.RED + "Dimension: " + tagCompound.getInteger(ThermalScienceNBTTags.Dim));
       list.add(
           StringHelper.PURPLE
               + "X: "
               + tagCompound.getInteger(ThermalScienceNBTTags.XCoord)
               + "; Y: "
               + tagCompound.getInteger(ThermalScienceNBTTags.YCoord)
               + "; Z: "
               + tagCompound.getInteger(ThermalScienceNBTTags.ZCoord));
     } else if (tagCompound.hasKey(ThermalScienceNBTTags.Id)) {
       list.add(
           StringHelper.RED
               + "Controller Id: "
               + tagCompound.getInteger(ThermalScienceNBTTags.Id));
     }
   }
 }
  /** Reads a tile entity from NBT. */
  public void readFromNBT(NBTTagCompound par1NBTTagCompound) {
    super.readFromNBT(par1NBTTagCompound);
    NBTTagList nbttaglist = par1NBTTagCompound.getTagList("Items", Constants.NBT.TAG_COMPOUND);
    this.chestContents = new ItemStack[this.getSizeInventory()];

    if (par1NBTTagCompound.hasKey("chestID")) {
      this.id = par1NBTTagCompound.getInteger("chestID");
    }

    if (par1NBTTagCompound.hasKey("myAccessTick")) {
      this.accessTicks = par1NBTTagCompound.getInteger("myAccessTick");
    }

    if (par1NBTTagCompound.hasKey("CustomName")) {
      this.customName = par1NBTTagCompound.getString("CustomName");
    }

    for (int i = 0; i < nbttaglist.tagCount(); ++i) {
      NBTTagCompound nbttagcompound1 = (NBTTagCompound) nbttaglist.getCompoundTagAt(i);
      int j = nbttagcompound1.getByte("Slot") & 255;

      if (j >= 0 && j < this.chestContents.length) {
        this.chestContents[j] = ItemStack.loadItemStackFromNBT(nbttagcompound1);
      }
    }
  }
  @Override
  public void setupFromNBT(NBTTagCompound tagCompound, int dim, int x, int y, int z) {
    if (tagCompound != null) {
      line = tagCompound.getString("text");
      if (tagCompound.hasKey("color")) {
        color = tagCompound.getInteger("color");
      } else {
        color = 0xffffff;
      }
      if (tagCompound.hasKey("rfcolor")) {
        rfcolor = tagCompound.getInteger("rfcolor");
      } else {
        rfcolor = 0xffffff;
      }
      if (tagCompound.hasKey("rfcolor_neg")) {
        rfcolorNeg = tagCompound.getInteger("rfcolor_neg");
      } else {
        rfcolorNeg = 0xffffff;
      }

      hidebar = tagCompound.getBoolean("hidebar");
      hidetext = tagCompound.getBoolean("hidetext");
      showdiff = tagCompound.getBoolean("showdiff");
      showpct = tagCompound.getBoolean("showpct");

      format = FormatStyle.values()[tagCompound.getInteger("format")];
    }
  }
  @Override
  public void writeSpawnData(ByteArrayDataOutput data) {
    NBTTagCompound tags = returnStack.getTagCompound().getCompoundTag("InfiTool");
    data.writeShort(returnStack.itemID);
    data.writeFloat(rotationYaw);
    data.writeInt(tags.getInteger("RenderHandle"));
    data.writeInt(tags.getInteger("RenderHead"));
    data.writeInt(tags.getInteger("RenderAccessory"));

    int effects = 0;
    if (tags.hasKey("Effect1")) effects++;
    if (tags.hasKey("Effect2")) effects++;
    if (tags.hasKey("Effect3")) effects++;
    if (tags.hasKey("Effect4")) effects++;
    if (tags.hasKey("Effect5")) effects++;
    if (tags.hasKey("Effect6")) effects++;
    data.writeInt(effects);

    switch (effects) {
      case 6:
        data.writeInt(tags.getInteger("Effect6"));
      case 5:
        data.writeInt(tags.getInteger("Effect5"));
      case 4:
        data.writeInt(tags.getInteger("Effect4"));
      case 3:
        data.writeInt(tags.getInteger("Effect3"));
      case 2:
        data.writeInt(tags.getInteger("Effect2"));
      case 1:
        data.writeInt(tags.getInteger("Effect1"));
    }
  }
Exemplo n.º 6
0
  private void func_143027_a(World world) {
    if (this.itemData == null) {
      this.itemData = world.loadItemData(MapGenStructureData.class, this.getStructureName());

      if (this.itemData == null) {
        this.itemData = new MapGenStructureData(this.getStructureName());
        world.setItemData(this.getStructureName(), this.itemData);
      } else {
        NBTTagCompound var2 = this.itemData.getTag();

        for (String var4 : var2.getKeySet()) {
          NBTBase var5 = var2.getTag(var4);

          if (var5.getType() == 10) {
            NBTTagCompound var6 = (NBTTagCompound) var5;

            if (var6.hasKey("ChunkX") && var6.hasKey("ChunkZ")) {
              int x = var6.getInteger("ChunkX");
              int z = var6.getInteger("ChunkZ");
              StructureStart var9 = MapGenStructureIO.func_143035_a(var6);

              if (var9 != null) {
                this.structureMap.put(ChunkPos.toLong(x, z), var9);
              }
            }
          }
        }
      }
    }
  }
Exemplo n.º 7
0
 @Override
 public void readFromNBT(NBTTagCompound tag) {
   super.readFromNBT(tag);
   inventory = new ArrayList<ItemStack>();
   if (tag.hasKey("inventory")) {
     NBTTagList list = tag.getTagList("inventory", Constants.NBT.TAG_COMPOUND);
     for (int i = 0; i < list.tagCount(); i++) {
       inventory.add(ItemStack.loadItemStackFromNBT(list.getCompoundTagAt(i)));
     }
   }
   incenses = new ArrayList<ItemStack>();
   if (tag.hasKey("incenses")) {
     NBTTagList list = tag.getTagList("incenses", Constants.NBT.TAG_COMPOUND);
     for (int i = 0; i < list.tagCount(); i++) {
       incenses.add(ItemStack.loadItemStackFromNBT(list.getCompoundTagAt(i)));
     }
   }
   if (tag.hasKey("ritualName")) {
     ritualName = tag.getString("ritualName");
     ritual = RitualManager.getRitualFromName(ritualName);
     System.out.println("Ritual name: " + ritualName);
   }
   if (tag.hasKey("progress")) {
     progress = tag.getInteger("progress");
   }
 }
 /**
  * @param stack to extract the info from
  * @return
  */
 public static ItemStructureSettings getSettingsFor(ItemStack stack) {
   ItemStructureSettings settings = new ItemStructureSettings();
   NBTTagCompound tag;
   if (stack.hasTagCompound() && stack.getTagCompound().hasKey("structData")) {
     tag = stack.getTagCompound().getCompoundTag("structData");
   } else {
     tag = new NBTTagCompound();
   }
   for (int i = 0; i < 4; i++) {
     settings.setKeys[i] = false;
   }
   if (tag.hasKey("pos1")) {
     settings.pos1.read(tag.getCompoundTag("pos1"));
     settings.setKeys[0] = true;
   }
   if (tag.hasKey("pos2")) {
     settings.pos2.read(tag.getCompoundTag("pos2"));
     settings.setKeys[1] = true;
   }
   if (tag.hasKey("buildKey")) {
     settings.key.read(tag.getCompoundTag("buildKey"));
     settings.setKeys[2] = true;
     settings.buildFace = tag.getCompoundTag("buildKey").getInteger("face");
   }
   if (tag.hasKey("name")) {
     settings.name = tag.getString("name");
     settings.setKeys[3] = true;
   }
   return settings;
 }
Exemplo n.º 9
0
  float calculateStrength(NBTTagCompound tags, Block block, int meta) {
    float mineSpeed = tags.getInteger("MiningSpeed");
    int heads = 1;
    if (tags.hasKey("MiningSpeed2")) {
      mineSpeed += tags.getInteger("MiningSpeed2");
      heads++;
    }

    if (tags.hasKey("MiningSpeedHandle")) {
      mineSpeed += tags.getInteger("MiningSpeedHandle");
      heads++;
    }

    if (tags.hasKey("MiningSpeedExtra")) {
      mineSpeed += tags.getInteger("MiningSpeedExtra");
      heads++;
    }
    float trueSpeed = mineSpeed / (heads * 100f);
    int hlvl = MinecraftForge.getBlockHarvestLevel(block, meta, getHarvestType());
    int durability = tags.getInteger("Damage");

    float stonebound = tags.getFloat("Shoddy");
    float bonusLog = (float) Math.log(durability / 72f + 1) * 2 * stonebound;
    trueSpeed += bonusLog;

    if (hlvl <= tags.getInteger("HarvestLevel")) return trueSpeed;
    return 0.1f;
  }
Exemplo n.º 10
0
  @Override
  public void readFromNBT(NBTTagCompound nbttagcompound) {
    super.readFromNBT(nbttagcompound);

    inv.readFromNBT(nbttagcompound);

    if (nbttagcompound.hasKey("box")) {
      box.initialize(nbttagcompound.getCompoundTag("box"));
    }

    if (nbttagcompound.hasKey("path")) {
      path = new LinkedList<BlockIndex>();
      NBTTagList list = nbttagcompound.getTagList("path", Constants.NBT.TAG_COMPOUND);

      for (int i = 0; i < list.tagCount(); ++i) {
        path.add(new BlockIndex(list.getCompoundTagAt(i)));
      }
    }

    done = nbttagcompound.getBoolean("done");
    fluidTank.readFromNBT(nbttagcompound);

    // The rest of load has to be done upon initialize.
    initNBT = (NBTTagCompound) nbttagcompound.getCompoundTag("bptBuilder").copy();
  }
Exemplo n.º 11
0
 public void readFromNBT(NBTTagCompound compound) {
   this.pos =
       new BlockPos(compound.getInteger("x"), compound.getInteger("y"), compound.getInteger("z"));
   if (compound.hasKey("ForgeData")) this.customTileData = compound.getCompoundTag("ForgeData");
   if (this.capabilities != null && compound.hasKey("ForgeCaps"))
     this.capabilities.deserializeNBT(compound.getCompoundTag("ForgeCaps"));
 }
  @Override
  public void readFromNBT(NBTTagCompound nbtTags) {
    super.readFromNBT(nbtTags);

    finishedCalc = nbtTags.getBoolean("finishedCalc");

    if (nbtTags.hasKey("fluidTank")) {
      fluidTank.readFromNBT(nbtTags.getCompoundTag("fluidTank"));
    }

    if (nbtTags.hasKey("activeNodes")) {
      NBTTagList tagList = nbtTags.getTagList("activeNodes", NBT.TAG_COMPOUND);

      for (int i = 0; i < tagList.tagCount(); i++) {
        activeNodes.add(Coord4D.read((NBTTagCompound) tagList.getCompoundTagAt(i)));
      }
    }

    if (nbtTags.hasKey("usedNodes")) {
      NBTTagList tagList = nbtTags.getTagList("usedNodes", NBT.TAG_COMPOUND);

      for (int i = 0; i < tagList.tagCount(); i++) {
        usedNodes.add(Coord4D.read((NBTTagCompound) tagList.getCompoundTagAt(i)));
      }
    }
  }
  @Override
  public void readFromNBT(NBTTagCompound compound) {
    super.readFromNBT(compound);

    if (this instanceof IStructurePart && compound.hasKey(CoreReferences.NBT.STRUCTURE)) {
      int dim;
      if (getWorld() == null) dim = compound.getInteger(CoreReferences.NBT.StructureData.DIMENSION);
      else dim = getWorld().provider.getDimension();

      ((IStructurePart) this)
          .setStructure(
              StructureRegistry.getInstance()
                  .getStructure(
                      dim,
                      Coordinate3D.fromNBT(compound.getCompoundTag(CoreReferences.NBT.STRUCTURE))));
    }

    if (getState().requiresNBTStorage())
      this.getState().readFromNBTTagCompound(compound.getTag(CoreReferences.NBT.STATE));

    if (this instanceof IItemStorage)
      this.readInventoryFromCompound(compound.getTag(CoreReferences.NBT.INVENTORY));

    if (this instanceof IFluidContainingEntity)
      this.readFluidsFromCompound(compound.getTag(CoreReferences.NBT.FLUIDS));

    if (compound.hasKey(CoreReferences.NBT.NAME)) {
      this.name = compound.getString(CoreReferences.NBT.NAME);
    }
  }
Exemplo n.º 14
0
  /** (abstract) Protected helper method to read subclass entity data from NBT. */
  protected void readEntityFromNBT(NBTTagCompound tagCompund) {
    if (tagCompund.getBoolean("CustomDisplayTile")) {
      int i = tagCompund.getInteger("DisplayData");

      if (tagCompund.hasKey("DisplayTile", 8)) {
        Block block = Block.getBlockFromName(tagCompund.getString("DisplayTile"));

        if (block == null) {
          this.func_174899_a(Blocks.air.getDefaultState());
        } else {
          this.func_174899_a(block.getStateFromMeta(i));
        }
      } else {
        Block block1 = Block.getBlockById(tagCompund.getInteger("DisplayTile"));

        if (block1 == null) {
          this.func_174899_a(Blocks.air.getDefaultState());
        } else {
          this.func_174899_a(block1.getStateFromMeta(i));
        }
      }

      this.setDisplayTileOffset(tagCompund.getInteger("DisplayOffset"));
    }

    if (tagCompund.hasKey("CustomName", 8) && tagCompund.getString("CustomName").length() > 0) {
      this.entityName = tagCompund.getString("CustomName");
    }
  }
 @Override
 public void readEntityFromNBT(NBTTagCompound tag) {
   super.readEntityFromNBT(tag);
   if (tag.hasKey("phase") && tag.hasKey("phaseDamage")) {
     float f = this.getMaxHealth() / 5;
     switch (tag.getInteger("phase")) {
       case 0:
         f *= 5;
         break;
       case 1:
         f *= 4;
         break;
       case 2:
         f *= 3;
         break;
       case 3:
         f *= 2;
         break;
       case 4:
       default:
         break;
     }
     this.setHealth(f - tag.getFloat("phaseDamage"));
   }
   if (tag.hasKey("phaseTicks")) this.setPhaseTicks(tag.getInteger("phaseTicks"));
 }
Exemplo n.º 16
0
  /** (abstract) Protected helper method to read subclass entity data from NBT. */
  public void readEntityFromNBT(NBTTagCompound tagCompund) {
    super.readEntityFromNBT(tagCompund);
    this.setEatingHaystack(tagCompund.getBoolean("EatingHaystack"));
    this.func_110242_l(tagCompund.getBoolean("Bred"));
    this.setChested(tagCompund.getBoolean("ChestedHorse"));
    this.setHasReproduced(tagCompund.getBoolean("HasReproduced"));
    this.setHorseType(tagCompund.getInteger("Type"));
    this.setHorseVariant(tagCompund.getInteger("Variant"));
    this.setTemper(tagCompund.getInteger("Temper"));
    this.setHorseTamed(tagCompund.getBoolean("Tame"));

    if (tagCompund.hasKey("OwnerUUID", 8)) {
      this.func_152120_b(tagCompund.getString("OwnerUUID"));
    }

    IAttributeInstance iattributeinstance =
        this.getAttributeMap().getAttributeInstanceByName("Speed");

    if (iattributeinstance != null) {
      this.getEntityAttribute(SharedMonsterAttributes.movementSpeed)
          .setBaseValue(iattributeinstance.getBaseValue() * 0.25D);
    }

    if (this.isChested()) {
      NBTTagList nbttaglist = tagCompund.getTagList("Items", 10);
      this.func_110226_cD();

      for (int i = 0; i < nbttaglist.tagCount(); ++i) {
        NBTTagCompound nbttagcompound1 = nbttaglist.getCompoundTagAt(i);
        int j = nbttagcompound1.getByte("Slot") & 255;

        if (j >= 2 && j < this.horseChest.getSizeInventory()) {
          this.horseChest.setInventorySlotContents(
              j, ItemStack.loadItemStackFromNBT(nbttagcompound1));
        }
      }
    }

    ItemStack itemstack;

    if (tagCompund.hasKey("ArmorItem", 10)) {
      itemstack = ItemStack.loadItemStackFromNBT(tagCompund.getCompoundTag("ArmorItem"));

      if (itemstack != null && func_146085_a(itemstack.getItem())) {
        this.horseChest.setInventorySlotContents(1, itemstack);
      }
    }

    if (tagCompund.hasKey("SaddleItem", 10)) {
      itemstack = ItemStack.loadItemStackFromNBT(tagCompund.getCompoundTag("SaddleItem"));

      if (itemstack != null && itemstack.getItem() == Items.saddle) {
        this.horseChest.setInventorySlotContents(0, itemstack);
      }
    } else if (tagCompund.getBoolean("Saddle")) {
      this.horseChest.setInventorySlotContents(0, new ItemStack(Items.saddle));
    }

    this.func_110232_cE();
  }
  public void readFromNBT(NBTTagCompound par1NBTTagCompound) {
    this.entityName = par1NBTTagCompound.getString("EntityId");
    this.spawnDelay = par1NBTTagCompound.getShort("Delay");
    powered = par1NBTTagCompound.getBoolean("Powered");
    spawnSpeed = par1NBTTagCompound.getShort("Speed");
    requiresPlayer = par1NBTTagCompound.getBoolean("RequiresPlayer");
    ignoreSpawnRequirements = par1NBTTagCompound.getBoolean("IgnoreSpawnRequirements");
    skeletonType = par1NBTTagCompound.getInteger("SkeletonType");

    this.minSpawnDelay = par1NBTTagCompound.getShort("MinSpawnDelay");
    this.maxSpawnDelay = par1NBTTagCompound.getShort("MaxSpawnDelay");
    this.spawnCount = par1NBTTagCompound.getShort("SpawnCount");

    if (par1NBTTagCompound.hasKey("MaxNearbyEntities", 99)) {
      this.maxNearbyEntities = par1NBTTagCompound.getShort("MaxNearbyEntities");
      this.activatingRangeFromPlayer = par1NBTTagCompound.getShort("RequiredPlayerRange");
    }

    if (par1NBTTagCompound.hasKey("SpawnRange", 99)) {
      this.spawnRange = par1NBTTagCompound.getShort("SpawnRange");
    }

    if (this.getSpawnerWorld() != null && this.getSpawnerWorld().isRemote) {
      this.renderedEntity = null;
    }
  }
  @Override
  public void readFromNBT(NBTTagCompound nbttagcompound) {
    super.readFromNBT(nbttagcompound);

    if (!nbttagcompound.hasKey("altarData")) return;

    NBTTagCompound altarCompound = nbttagcompound.getCompoundTag("altarData");

    NBTTagList allAddedItems =
        altarCompound.getTagList("allAddedItems", Constants.NBT.TAG_COMPOUND);
    NBTTagList currentAddedItems =
        altarCompound.getTagList("currentAddedItems", Constants.NBT.TAG_COMPOUND);

    this.isCrafting = altarCompound.getBoolean("isCrafting");
    this.currentKey = altarCompound.getInteger("currentKey");
    this.currentSpellName = altarCompound.getString("currentSpellName");

    if (altarCompound.hasKey("phylactery")) {
      NBTTagCompound phylactery = altarCompound.getCompoundTag("phylactery");
      if (phylactery != null) this.addedPhylactery = ItemStack.loadItemStackFromNBT(phylactery);
    }

    if (altarCompound.hasKey("catalyst")) {
      NBTTagCompound catalyst = altarCompound.getCompoundTag("catalyst");
      if (catalyst != null) this.addedBindingCatalyst = ItemStack.loadItemStackFromNBT(catalyst);
    }

    this.allAddedItems.clear();
    for (int i = 0; i < allAddedItems.tagCount(); ++i) {
      NBTTagCompound addedItem = (NBTTagCompound) allAddedItems.getCompoundTagAt(i);
      if (addedItem == null) continue;
      ItemStack stack = ItemStack.loadItemStackFromNBT(addedItem);
      if (stack == null) continue;
      this.allAddedItems.add(stack);
    }

    this.currentAddedItems.clear();
    for (int i = 0; i < currentAddedItems.tagCount(); ++i) {
      NBTTagCompound addedItem = (NBTTagCompound) currentAddedItems.getCompoundTagAt(i);
      if (addedItem == null) continue;
      ItemStack stack = ItemStack.loadItemStackFromNBT(addedItem);
      if (stack == null) continue;
      this.currentAddedItems.add(stack);
    }

    this.spellDef.clear();
    for (ArrayList<KeyValuePair<ISpellPart, byte[]>> groups : shapeGroups) groups.clear();

    NBTTagCompound currentSpellDef = altarCompound.getCompoundTag("spellDef");
    this.spellDef.addAll(NBTToISpellPartList(currentSpellDef));

    NBTTagList currentShapeGroups =
        altarCompound.getTagList("shapeGroups", Constants.NBT.TAG_COMPOUND);

    for (int i = 0; i < currentShapeGroups.tagCount(); ++i) {
      NBTTagCompound compound = (NBTTagCompound) currentShapeGroups.getCompoundTagAt(i);
      shapeGroups.get(i).addAll(NBTToISpellPartList(compound));
    }
  }
 @Override
 public void readCustomNBT(NBTTagCompound cmp) {
   super.readCustomNBT(cmp);
   if (cmp.hasKey(TAG_UUID_LEAST) && cmp.hasKey(TAG_UUID_MOST)) {
     golemConnected = new UUID(cmp.getLong(TAG_UUID_MOST), cmp.getLong(TAG_UUID_LEAST));
     // verifyGolem();
   }
 }
Exemplo n.º 20
0
 public Connection(NBTTagCompound nbt) {
   if (nbt.hasKey("x")) {
     coord = new ChunkCoordinates(nbt.getInteger("x"), nbt.getInteger("y"), nbt.getInteger("z"));
   }
   if (nbt.hasKey("vx")) {
     vec = new LittleTileVec(nbt.getByte("vx"), nbt.getByte("vy"), nbt.getByte("vz"));
   }
 }
Exemplo n.º 21
0
 public void readItemNBT(NBTTagCompound tag) {
   if (tag.hasKey("e")) {
     enabledSides = tag.getByte("e");
   }
   if (tag.hasKey("i")) {
     invertedSides = tag.getByte("i");
   }
 }
  @Override
  public void readFromNBT(NBTTagCompound data) {
    super.readFromNBT(data);
    if (data.hasKey("StorageSlots")) inv.readFromNBT(data, "StorageSlots");

    if (data.hasKey("items")) craftingSlots.readFromNBT(data);
    else craftingSlots.readFromNBT(data, "craftingSlots");
  }
Exemplo n.º 23
0
 @Override
 public void readEntityFromNBT(NBTTagCompound tag) {
   super.readEntityFromNBT(tag);
   if (tag.hasKey("texture")) this.setTextureID(tag.getByte("texture"));
   if (tag.hasKey("cryseType")) this.setCryseType(tag.getByte("cryseType"));
   if (tag.hasKey("spinTicks")) this.setSpinTicks(tag.getInteger("spinTicks"));
   if (tag.hasKey("attackTime")) this.setAttackTime(tag.getInteger("attackTime"));
   if (tag.hasKey("flutterTicks")) this.setFlutterTicks(tag.getInteger("flutterTicks"));
 }
Exemplo n.º 24
0
  public static void teleportPlayerOutOfMachineDimension(EntityPlayerMP player) {
    NBTTagCompound playerNBT = player.getEntityData();

    // Grab the CompactMachines entry from the player NBT data
    NBTTagCompound cmNBT = null;
    if (playerNBT.hasKey(Reference.MOD_ID)) {
      cmNBT = playerNBT.getCompoundTag(Reference.MOD_ID);
    }

    int targetDimension = 0;
    double targetX;
    double targetY;
    double targetZ;

    if (cmNBT != null && cmNBT.hasKey("oldPosX")) {
      // First try to grab the original position by looking at the CompactMachines NBT Tag
      targetDimension = cmNBT.getInteger("oldDimension");
      targetX = cmNBT.getDouble("oldPosX");
      targetY = cmNBT.getDouble("oldPosY");
      targetZ = cmNBT.getDouble("oldPosZ");
    } else if (playerNBT.hasKey("oldDimension")
        && playerNBT.getInteger("oldDimension") != ConfigurationHandler.dimensionId) {
      // Backwards compatibility - but these values are also being set by RandomThings
      // A problem exists in two cases:
      // a) A player entered the SpiritDimension from the CM dimension, RandomThings would set the
      // oldDimension to the CM dimension
      // b) A player entered the CM dimension from the SpectreDimension, CM did previously set the
      // oldDimension to the SpectreDimension
      // In both cases the player gets trapped in a loop between the two dimensions and has no way
      // of getting back to the overworld
      // We want to allow backwards compatibility with our old settings so players in a CM during an
      // update to a version containing this commit
      // would still be trapped in the two dimensions. We can break this cycle by not allowing to
      // get back to another CM using the
      // old system.
      // That's because CM never writes its own dimension into the oldDimension tag, only
      // RandomThings would do that.
      targetDimension = playerNBT.getInteger("oldDimension");
      targetX = playerNBT.getDouble("oldPosX");
      targetY = playerNBT.getDouble("oldPosY");
      targetZ = playerNBT.getDouble("oldPosZ");
    } else {
      ChunkCoordinates cc =
          MinecraftServer.getServer().worldServerForDimension(0).provider.getRandomizedSpawnPoint();
      targetX = cc.posX;
      targetY = cc.posY;
      targetZ = cc.posZ;
    }

    MinecraftServer.getServer()
        .getConfigurationManager()
        .transferPlayerToDimension(
            player,
            targetDimension,
            new TeleporterCM(MinecraftServer.getServer().worldServerForDimension(targetDimension)));
    player.setPositionAndUpdate(targetX, targetY, targetZ);
  }
Exemplo n.º 25
0
 @Override
 protected void readEntityFromNBT(NBTTagCompound var1) {
   super.readEntityFromNBT(var1);
   if (var1.hasKey("mirrorRoll")) {
     dataWatcher.updateObject(IS_MIRROR_ROTE, var1.getBoolean("mirrorRoll") ? (byte) 1 : (byte) 0);
   }
   if (var1.hasKey("wheelSize")) {
     dataWatcher.updateObject(SIZE, var1.getByte("wheelSize"));
   }
 }
Exemplo n.º 26
0
 @Override
 public void readEntityFromNBT(NBTTagCompound nbt) {
   super.readEntityFromNBT(nbt);
   this.fuseTicks = nbt.getShort("Fuse");
   if (nbt.hasKey("ex")) {
     ex = ExplosiveRegistry.get(nbt.getString("ex"));
     ex_size = Math.max(nbt.getDouble("size"), 1.0);
     if (nbt.hasKey("ex_data")) ex_data = nbt.getCompoundTag("ex_data");
   }
 }
Exemplo n.º 27
0
 @Override
 public void readCommonNBT(NBTTagCompound nbt) {
   super.readCommonNBT(nbt);
   if (nbt.hasKey("isRedstonePowerd")) isRedstonePowered = nbt.getBoolean("isRedstonePowerd");
   if (nbt.hasKey("burning")) burning = nbt.getInteger("burning");
   if (nbt.hasKey("burningItem")) {
     NBTTagCompound tag = (NBTTagCompound) nbt.getTag("burningItem");
     burningItem = ItemStack.loadItemStackFromNBT(tag);
   }
 }
Exemplo n.º 28
0
 /// Reads this entity from NBT.
 @Override
 public void readEntityFromNBT(NBTTagCompound tag) {
   super.readEntityFromNBT(tag);
   NBTTagCompound saveTag = SpecialMobData.getSaveLocation(tag);
   if (saveTag.hasKey("Babies")) {
     this.babies = saveTag.getByte("Babies");
   } else if (tag.hasKey("Babies")) {
     this.babies = tag.getByte("Babies");
   }
 }
  @Override
  public void readFromNBT(NBTTagCompound nbttagcompound) {
    this.owner = nbttagcompound.getString("owner").replace(".", "");
    this.spaceStationName = nbttagcompound.getString("spaceStationName");

    if (nbttagcompound.hasKey("dataCompound")) {
      this.dataCompound = nbttagcompound.getCompoundTag("dataCompound");
    } else {
      this.dataCompound = new NBTTagCompound();
    }

    if (nbttagcompound.hasKey("homePlanet")) {
      this.homePlanet = nbttagcompound.getInteger("homePlanet");
    } else {
      GCLog.info(
          "Home planet data not found in space station save file for \""
              + this.spaceStationName
              + "\". Using default overworld.");
      this.homePlanet = 0; // Overworld dimension ID
    }

    if (nbttagcompound.hasKey("dimensionIdStatic")) {
      this.dimensionIdStatic = nbttagcompound.getInteger("dimensionIdStatic");
    } else {
      GCLog.info(
          "Static dimension ID not found in space station save file for \""
              + this.spaceStationName
              + "\". Using default overworld.");
      this.dimensionIdStatic = ConfigManagerCore.idDimensionOverworldOrbitStatic;
    }

    if (nbttagcompound.hasKey("dimensionIdDynamic")) {
      this.dimensionIdDynamic = nbttagcompound.getInteger("dimensionIdDynamic");
    } else {
      GCLog.info(
          "Dynamic dimension ID not found in space station save file for \""
              + this.spaceStationName
              + "\". Using default overworld.");
      this.dimensionIdDynamic = ConfigManagerCore.idDimensionOverworldOrbit;
    }

    this.allowAllPlayers = nbttagcompound.getBoolean("allowedAll");

    final NBTTagList var2 = nbttagcompound.getTagList("allowedPlayers", 10);
    this.allowedPlayers.clear();

    for (int var3 = 0; var3 < var2.tagCount(); ++var3) {
      final NBTTagCompound var4 = var2.getCompoundTagAt(var3);
      final String var5 = var4.getString("allowedPlayer");

      if (!this.allowedPlayers.contains(var5)) {
        this.allowedPlayers.add(var5);
      }
    }
  }
Exemplo n.º 30
0
 public static NBTTagCompound filterSpongeCustomData(NBTTagCompound rootCompound) {
   if (rootCompound.hasKey(FORGE_DATA_TAG, TAG_COMPOUND)) {
     final NBTTagCompound forgeCompound = rootCompound.getCompoundTag(FORGE_DATA_TAG);
     if (forgeCompound.hasKey(SPONGE_DATA, TAG_COMPOUND)) {
       cleanseInnerCompound(forgeCompound, SPONGE_DATA);
     }
   } else if (rootCompound.hasKey(SPONGE_DATA, TAG_COMPOUND)) {
     cleanseInnerCompound(rootCompound, SPONGE_DATA);
   }
   return rootCompound;
 }