@Override
  public void handlePacketData(ByteBuf dataStream) {
    if (!worldObj.isRemote) {
      int type = dataStream.readInt();

      switch (type) {
        case 0:
          if (getReactor() != null) getReactor().setInjectionRate(dataStream.readInt());
          break;
      }

      return;
    }

    super.handlePacketData(dataStream);

    if (worldObj.isRemote) {
      boolean formed = dataStream.readBoolean();

      if (formed) {
        if (getReactor() == null || !((FusionReactor) getReactor()).formed) {
          Mekanism.proxy.doGenericSparkle(
              this,
              new INodeChecker() {
                @Override
                public boolean isNode(TileEntity tile) {
                  return tile instanceof TileEntityReactorBlock;
                }
              });
        }

        if (getReactor() == null) {
          setReactor(new FusionReactor(this));
          MekanismUtils.updateBlock(worldObj, xCoord, yCoord, zCoord);
        }

        ((FusionReactor) getReactor()).formed = true;
        getReactor().setPlasmaTemp(dataStream.readDouble());
        getReactor().setCaseTemp(dataStream.readDouble());
        getReactor().setInjectionRate(dataStream.readInt());
        getReactor().setBurning(dataStream.readBoolean());
        fuelTank.setGas(new GasStack(GasRegistry.getGas("fusionFuelDT"), dataStream.readInt()));
        deuteriumTank.setGas(new GasStack(GasRegistry.getGas("deuterium"), dataStream.readInt()));
        tritiumTank.setGas(new GasStack(GasRegistry.getGas("tritium"), dataStream.readInt()));
        waterTank.setCapacity(dataStream.readInt());
        waterTank.setFluid(new FluidStack(FluidRegistry.getFluid("water"), dataStream.readInt()));
        steamTank.setCapacity(dataStream.readInt());
        steamTank.setFluid(new FluidStack(FluidRegistry.getFluid("steam"), dataStream.readInt()));
      } else if (getReactor() != null) {
        setReactor(null);
        MekanismUtils.updateBlock(worldObj, xCoord, yCoord, zCoord);
      }
    }
  }
示例#2
0
  @Override
  public FluidTankInfo[] getTankInfo(ForgeDirection direction) {
    FluidTank compositeTank = new FluidTank(tank.getCapacity());

    TileTank tile = getBottomTank();

    int capacity = tank.getCapacity();

    if (tile != null && tile.tank.getFluid() != null) {
      compositeTank.setFluid(tile.tank.getFluid().copy());
    } else {
      return new FluidTankInfo[] {compositeTank.getInfo()};
    }

    tile = getTankAbove(tile);

    while (tile != null) {

      FluidStack liquid = tile.tank.getFluid();
      if (liquid == null || liquid.amount == 0) {
        // NOOP
      } else if (!compositeTank.getFluid().isFluidEqual(liquid)) {
        break;
      } else {
        compositeTank.getFluid().amount += liquid.amount;
      }

      capacity += tile.tank.getCapacity();
      tile = getTankAbove(tile);
    }

    compositeTank.setCapacity(capacity);
    return new FluidTankInfo[] {compositeTank.getInfo()};
  }
示例#3
0
  // called only clientside to sync with the server
  @SideOnly(Side.CLIENT)
  public void updateFluidTo(FluidStack fluid) {
    int oldAmount = tank.getFluidAmount();
    tank.setFluid(fluid);

    if (fluid == null) {
      tank.setCapacity(0);
      recipe = null;
    } else if (recipe == null) {
      recipe = findRecipe(fluid.getFluid());
      if (recipe != null) {
        tank.setCapacity(recipe.fluid.amount);
      }
    }

    renderOffset += tank.getFluidAmount() - oldAmount;
  }
示例#4
0
  protected void reset() {
    timer = 0;
    recipe = null;
    tank.setCapacity(0);
    tank.setFluid(null);

    if (!worldObj.isRemote && worldObj instanceof WorldServer) {
      TinkerNetwork.sendToClients((WorldServer) worldObj, pos, new FluidUpdatePacket(pos, null));
    }
  }
  @Override
  public void readFromNBT(NBTTagCompound nbtTags) {
    super.readFromNBT(nbtTags);

    tier = FluidTankTier.values()[nbtTags.getInteger("tier")];
    clientActive = isActive = nbtTags.getBoolean("isActive");
    editMode = ContainerEditMode.values()[nbtTags.getInteger("editMode")];

    if (nbtTags.hasKey("fluidTank")) {
      fluidTank.setCapacity(tier.storage);
      fluidTank.readFromNBT(nbtTags.getCompoundTag("fluidTank"));
    }
  }
示例#6
0
  @Override
  public int fill(EnumFacing from, FluidStack resource, boolean doFill) {
    // this is where all the action happens
    if (!canFill(from, resource.getFluid())) {
      return 0;
    }

    // if empty, find a new recipe
    if (this.tank.getFluidAmount() == 0) {
      CastingRecipe recipe = findRecipe(resource.getFluid());
      if (recipe == null) {
        // no recipe found -> can't fill
        return 0;
      }

      int capacity = recipe.fluid.amount;
      IFluidTank calcTank = new FluidTank(capacity);

      // no extra checks needed for the tank since it's empty and we have to set the capacity anyway
      if (doFill) {
        this.recipe = recipe;
        tank.setCapacity(capacity);
        calcTank = tank;
      }

      int filled = calcTank.fill(resource, doFill);
      if (filled > 0 && doFill) {
        renderOffset = filled;
        if (!worldObj.isRemote && worldObj instanceof WorldServer) {
          TinkerNetwork.sendToClients(
              (WorldServer) worldObj, pos, new FluidUpdatePacket(pos, tank.getFluid()));
        }
      }
      return filled;
    }

    // non-empty tank. just try to fill
    int filled = tank.fill(resource, doFill);
    if (filled > 0 && doFill) {
      renderOffset += filled;
      if (!worldObj.isRemote && worldObj instanceof WorldServer) {
        TinkerNetwork.sendToClients(
            (WorldServer) worldObj, pos, new FluidUpdatePacket(pos, tank.getFluid()));
      }
    }

    return filled;
  }
  @Override
  public boolean upgrade(BaseTier upgradeTier) {
    if (upgradeTier.ordinal() != tier.ordinal() + 1) {
      return false;
    }

    tier = FluidTankTier.values()[upgradeTier.ordinal()];
    fluidTank.setCapacity(tier.storage);

    Mekanism.packetHandler.sendToReceivers(
        new TileEntityMessage(Coord4D.get(this), getNetworkedData(new ArrayList())),
        new Range4D(Coord4D.get(this)));
    markDirty();

    return true;
  }
  @Override
  public void handlePacketData(ByteBuf dataStream) {
    super.handlePacketData(dataStream);

    if (FMLCommonHandler.instance().getEffectiveSide().isClient()) {
      FluidTankTier prevTier = tier;

      tier = FluidTankTier.values()[dataStream.readInt()];
      fluidTank.setCapacity(tier.storage);

      clientActive = dataStream.readBoolean();
      valve = dataStream.readInt();
      editMode = ContainerEditMode.values()[dataStream.readInt()];

      if (valve > 0) {
        valveFluid = FluidRegistry.getFluid(PacketHandler.readString(dataStream));
      } else {
        valveFluid = null;
      }

      if (dataStream.readInt() == 1) {
        fluidTank.setFluid(
            new FluidStack(
                FluidRegistry.getFluid(PacketHandler.readString(dataStream)),
                dataStream.readInt()));
      } else {
        fluidTank.setFluid(null);
      }

      if (prevTier != tier || (updateDelay == 0 && clientActive != isActive)) {
        updateDelay = general.UPDATE_DELAY;
        isActive = clientActive;
        MekanismUtils.updateBlock(worldObj, getPos());
      }
    }
  }
示例#9
0
  @Override
  public FluidTankInfo[] getTankInfo(ForgeDirection direction) {
    FluidTank compositeTank = new FluidTank(tank.getCapacity());

    int capacity = tank.getCapacity();

    if (tank.getFluid() != null) {
      compositeTank.setFluid(tank.getFluid().copy());
    } else {
      return new FluidTankInfo[] {compositeTank.getInfo()};
    }

    FluidStack liquid = tank.getFluid();
    if (liquid == null || liquid.amount == 0) {

    } else {
      compositeTank.getFluid().amount += liquid.amount;
    }

    capacity += tank.getCapacity();

    compositeTank.setCapacity(capacity);
    return new FluidTankInfo[] {compositeTank.getInfo()};
  }
  @Override
  public void updateEntity() {

    super.updateEntity();

    oldCurX = curX;
    oldCurY = curY;
    oldCurZ = curZ;
    if (PneumaticCraftUtils.distBetween(getPosition(), targetX, targetY, targetZ) <= getSpeed()) {
      curX = targetX;
      curY = targetY;
      curZ = targetZ;
    } else {
      Vec3 vec =
          Vec3.createVectorHelper(targetX - curX, targetY - curY, targetZ - curZ).normalize();
      curX += vec.xCoord * getSpeed();
      curY += vec.yCoord * getSpeed();
      curZ += vec.zCoord * getSpeed();
    }

    if (!worldObj.isRemote) {
      getAIManager();
      if (worldObj.getTotalWorldTime() % 40 == 0) {
        dispenserUpgrades = getUpgrades(ItemMachineUpgrade.UPGRADE_DISPENSER_DAMAGE);
        speedUpgrades = getUpgrades(ItemMachineUpgrade.UPGRADE_SPEED_DAMAGE);

        for (int i = getDroneSlots(); i < 36; i++) {
          ItemStack stack = getFakePlayer().inventory.getStackInSlot(i);
          if (stack != null) {
            worldObj.spawnEntityInWorld(
                new EntityItem(worldObj, xCoord + 0.5, yCoord + 1.5, zCoord + 0.5, stack));
            getFakePlayer().inventory.setInventorySlotContents(i, null);
          }
        }

        tank.setCapacity((dispenserUpgrades + 1) * 16000);
        if (tank.getFluidAmount() > tank.getCapacity()) {
          tank.getFluid().amount = tank.getCapacity();
        }
      }
      for (int i = 0; i < 4; i++) {
        getFakePlayer().theItemInWorldManager.updateBlockRemoving();
      }
      if (getPressure(ForgeDirection.UNKNOWN) >= getMinWorkingPressure()) {
        if (!aiManager.isIdling()) addAir(-10, ForgeDirection.UNKNOWN);
        aiManager.onUpdateTasks();
      }
    } else {
      if (drone == null || drone.isDead) {
        drone = new EntityProgrammableController(worldObj, this);
        drone.posX = curX;
        drone.posY = curY;
        drone.posZ = curZ;
        worldObj.spawnEntityInWorld(drone);
      }
      drone.setPosition(curX, curY, curZ);
      // drone.getMoveHelper().setMoveTo(curX, curY, curZ, 0);
      /*   drone.prevPosX = oldCurX;
      drone.prevPosY = oldCurY;
      drone.prevPosZ = oldCurZ;*/
      // drone.getMoveHelper().setMoveTo(curX, curY, curZ, getSpeed());
    }
  }