How to use

IEnergyGrid

in

appeng.api.networking.energy

private static boolean isPowered( final IGrid grid )
{
  if( grid == null )
  {
    return false;
  }
  final IEnergyGrid eg = grid.getCache( IEnergyGrid.class );
  return eg.isNetworkPowered();
}

@Override
public void onThresholdPass( final IEnergyGrid energyGrid )
{
  this.lastReportedValue = (long) energyGrid.getStoredPower();
  this.updateState();
}

private int userPower( final int ticksPassed, final int bonusValue, final double acceleratorTax )
{
  try
  {
    return (int) ( this.getProxy()
        .getEnergy()
        .extractAEPower( ticksPassed * bonusValue * acceleratorTax, Actionable.MODULATE,
            PowerMultiplier.CONFIG ) / acceleratorTax );
  }
  catch( final GridAccessException e )
  {
    return 0;
  }
}

if( eg != null )
  this.setAverageAddition( (long) ( 100.0 * eg.getAvgPowerInjection() ) );
  this.setPowerUsage( (long) ( 100.0 * eg.getAvgPowerUsage() ) );
  this.setCurrentPower( (long) ( 100.0 * eg.getStoredPower() ) );
  this.setMaxPower( (long) ( 100.0 * eg.getMaxStoredPower() ) );

if( eg != null )
  this.setCurrentPower( (long) ( 100.0 * eg.getStoredPower() ) );
  this.setMaxPower( (long) ( 100.0 * eg.getMaxStoredPower() ) );
  this.setRequiredPower( (long) ( 100.0 * sc.requiredPower() ) );
  this.setEfficency( (long) ( 100.0f * sc.currentEfficiency() ) );

this.outputMsg( player, "GridEnergy: " + eg.getStoredPower() + " : " + eg.getEnergyDemand( Double.MAX_VALUE ) );

@BasicObjectMethod.Inject(
  value = IGrid.class, modId = AppEng.MOD_ID,
  doc = "function():int -- Get the energy usage of this AE network"
)
public static Object[] getNetworkEnergyUsage(IContext<IGrid> context, Object[] args) {
  IEnergyGrid energy = context.getTarget().getCache(IEnergyGrid.class);
  return new Object[]{energy.getAvgPowerUsage()};
}

@Override
protected double getFunnelPowerDemand( final double maxReceived )
{
  try
  {
    final IEnergyGrid grid = this.getProxy().getEnergy();
    return grid.getEnergyDemand( maxReceived );
  }
  catch( final GridAccessException e )
  {
    // no grid? use local...
    return super.getFunnelPowerDemand( maxReceived );
  }
}

@Override
protected double getFunnelPowerDemand( final double maxRequired )
{
  try
  {
    final IEnergyGrid grid = this.getProxy().getEnergy();
    return grid.getEnergyDemand( maxRequired );
  }
  catch( final GridAccessException e )
  {
    return this.getInternalMaxPower();
  }
}

public boolean isPowered()
{
  try
  {
    return this.getEnergy().isNetworkPowered();
  }
  catch( final GridAccessException e )
  {
    return false;
  }
}

@BasicObjectMethod.Inject(
  value = IGrid.class, modId = AppEng.MOD_ID,
  doc = "function():int -- Get the energy stored usage in this AE network"
)
public static Object[] getNetworkEnergyStored(IContext<IGrid> context, Object[] args) {
  IEnergyGrid energy = context.getTarget().getCache(IEnergyGrid.class);
  return new Object[]{energy.getStoredPower()};
}

protected void queueTunnelDrain( final PowerUnits unit, final double f )
{
  final double ae_to_tax = unit.convertTo( PowerUnits.AE, f * AEConfig.TUNNEL_POWER_LOSS );
  try
  {
    this.getProxy().getEnergy().extractAEPower( ae_to_tax, Actionable.MODULATE, PowerMultiplier.ONE );
  }
  catch( final GridAccessException e )
  {
    // :P
  }
}

public boolean isPowered()
{
  if( Platform.isClient() )
  {
    return ( this.constructed & this.powered ) == this.powered && this.constructed != -1;
  }
  try
  {
    return this.getProxy().getEnergy().isNetworkPowered();
  }
  catch( final GridAccessException e )
  {
    // :P
  }
  return false;
}

this.lastReportedValue = (long) this.getProxy().getEnergy().getStoredPower();
this.updateState();

@Override
protected double extractAEPower( final double amt, final Actionable mode )
{
  double stash = 0.0;
  try
  {
    final IEnergyGrid eg = this.getProxy().getEnergy();
    stash = eg.extractAEPower( amt, mode, PowerMultiplier.ONE );
    if( stash >= amt )
    {
      return stash;
    }
  }
  catch( final GridAccessException e )
  {
    // no grid :(
  }
  // local battery!
  return super.extractAEPower( amt - stash, mode ) + stash;
}

@Override
public boolean isPowered()
{
  if( Platform.isServer() )
  {
    try
    {
      return this.getProxy().getEnergy().isNetworkPowered();
    }
    catch( final GridAccessException e )
    {
      return false;
    }
  }
  return this.hasPower;
}

private void updatePowerState()
{
  boolean newState = false;
  try
  {
    newState = this.getProxy().isActive() && this.getProxy().getEnergy().extractAEPower( 1, Actionable.SIMULATE, PowerMultiplier.CONFIG ) > 0.0001;
  }
  catch( final GridAccessException ignored )
  {
  }
  if( newState != this.isPowered )
  {
    this.isPowered = newState;
    this.markForUpdate();
  }
}

@Override
public final boolean isPowered()
{
  try
  {
    if( Platform.isServer() )
    {
      return this.getProxy().getEnergy().isNetworkPowered();
    }
    else
    {
      return( ( this.getClientFlags() & PartPanel.POWERED_FLAG ) == PartPanel.POWERED_FLAG );
    }
  }
  catch( final GridAccessException e )
  {
    return false;
  }
}

private boolean storeFluid( IAEFluidStack stack, boolean modulate )
{
  try
  {
    final IStorageGrid storage = this.getProxy().getStorage();
    final IMEInventory<IAEFluidStack> inv = storage.getInventory( AEApi.instance().storage().getStorageChannel( IFluidStorageChannel.class ) );
    if( modulate )
    {
      final IEnergyGrid energy = this.getProxy().getEnergy();
      return Platform.poweredInsert( energy, inv, stack, this.mySrc ) == null;
    }
    else
    {
      final float requiredPower = stack.getStackSize() / Math.min( 1.0f, stack.getChannel().transferFactor() );
      final IEnergyGrid energy = this.getProxy().getEnergy();
      if( energy.extractAEPower( requiredPower, Actionable.SIMULATE, PowerMultiplier.CONFIG ) < requiredPower )
      {
        return false;
      }
      final IAEFluidStack leftOver = inv.injectItems( stack, Actionable.SIMULATE, this.mySrc );
      return leftOver == null || leftOver.getStackSize() == 0;
    }
  }
  catch( final GridAccessException e )
  {
    // :P
  }
  return false;
}

@Override
public void writeToStream( final ByteBuf data ) throws IOException
{
  super.writeToStream( data );
  try
  {
    data.writeBoolean( this.getProxy().getEnergy().isNetworkPowered() );
  }
  catch( final GridAccessException e )
  {
    data.writeBoolean( false );
  }
}