452 lines
9.1 KiB
Java
452 lines
9.1 KiB
Java
/*
|
|
* This file is part of Applied Energistics 2.
|
|
* Copyright (c) 2013 - 2015, AlgorithmX2, All rights reserved.
|
|
*
|
|
* Applied Energistics 2 is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Lesser General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Applied Energistics 2 is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with Applied Energistics 2. If not, see <http://www.gnu.org/licenses/lgpl>.
|
|
*/
|
|
|
|
package appeng.me.helpers;
|
|
|
|
|
|
import java.util.Collections;
|
|
import java.util.EnumSet;
|
|
|
|
import com.mojang.authlib.GameProfile;
|
|
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.util.EnumFacing;
|
|
|
|
import appeng.api.AEApi;
|
|
import appeng.api.networking.GridFlags;
|
|
import appeng.api.networking.GridNotification;
|
|
import appeng.api.networking.IGrid;
|
|
import appeng.api.networking.IGridBlock;
|
|
import appeng.api.networking.IGridHost;
|
|
import appeng.api.networking.IGridNode;
|
|
import appeng.api.networking.crafting.ICraftingGrid;
|
|
import appeng.api.networking.energy.IEnergyGrid;
|
|
import appeng.api.networking.events.MENetworkPowerIdleChange;
|
|
import appeng.api.networking.pathing.IPathingGrid;
|
|
import appeng.api.networking.security.ISecurityGrid;
|
|
import appeng.api.networking.storage.IStorageGrid;
|
|
import appeng.api.networking.ticking.ITickManager;
|
|
import appeng.api.util.AEColor;
|
|
import appeng.api.util.DimensionalCoord;
|
|
import appeng.api.util.IOrientable;
|
|
import appeng.core.worlddata.WorldData;
|
|
import appeng.hooks.TickHandler;
|
|
import appeng.me.GridAccessException;
|
|
import appeng.me.cache.P2PCache;
|
|
import appeng.parts.networking.PartCable;
|
|
import appeng.tile.AEBaseTile;
|
|
import appeng.util.Platform;
|
|
|
|
|
|
public class AENetworkProxy implements IGridBlock
|
|
{
|
|
|
|
private final IGridProxyable gp;
|
|
private final boolean worldNode;
|
|
private final String nbtName; // name
|
|
private AEColor myColor = AEColor.TRANSPARENT;
|
|
private NBTTagCompound data = null; // input
|
|
private ItemStack myRepInstance;
|
|
private boolean isReady = false;
|
|
private IGridNode node = null;
|
|
private EnumSet<EnumFacing> validSides;
|
|
private EnumSet<GridFlags> flags = EnumSet.noneOf( GridFlags.class );
|
|
private double idleDraw = 1.0;
|
|
private EntityPlayer owner;
|
|
|
|
public AENetworkProxy( final IGridProxyable te, final String nbtName, final ItemStack visual, final boolean inWorld )
|
|
{
|
|
this.gp = te;
|
|
this.nbtName = nbtName;
|
|
this.worldNode = inWorld;
|
|
this.myRepInstance = visual;
|
|
this.validSides = EnumSet.allOf( EnumFacing.class );
|
|
}
|
|
|
|
public void setVisualRepresentation( final ItemStack is )
|
|
{
|
|
this.myRepInstance = is;
|
|
}
|
|
|
|
public void writeToNBT( final NBTTagCompound tag )
|
|
{
|
|
if( this.node != null )
|
|
{
|
|
this.node.saveToNBT( this.nbtName, tag );
|
|
}
|
|
}
|
|
|
|
public void setValidSides( final EnumSet<EnumFacing> validSides )
|
|
{
|
|
this.validSides = validSides;
|
|
if( this.node != null )
|
|
{
|
|
this.node.updateState();
|
|
}
|
|
}
|
|
|
|
public void validate()
|
|
{
|
|
if( this.gp instanceof AEBaseTile )
|
|
{
|
|
TickHandler.INSTANCE.addInit( (AEBaseTile) this.gp );
|
|
}
|
|
}
|
|
|
|
public void onChunkUnload()
|
|
{
|
|
this.isReady = false;
|
|
this.invalidate();
|
|
}
|
|
|
|
public void invalidate()
|
|
{
|
|
this.isReady = false;
|
|
if( this.node != null )
|
|
{
|
|
this.node.destroy();
|
|
this.node = null;
|
|
}
|
|
}
|
|
|
|
public void onReady()
|
|
{
|
|
this.isReady = true;
|
|
|
|
// send orientation based directionality to the node.
|
|
if( this.gp instanceof IOrientable )
|
|
{
|
|
final IOrientable ori = (IOrientable) this.gp;
|
|
if( ori.canBeRotated() )
|
|
{
|
|
ori.setOrientation( ori.getForward(), ori.getUp() );
|
|
}
|
|
}
|
|
|
|
this.getNode();
|
|
}
|
|
|
|
public IGridNode getNode()
|
|
{
|
|
if( this.node == null && Platform.isServer() && this.isReady )
|
|
{
|
|
this.node = AEApi.instance().createGridNode( this );
|
|
this.readFromNBT( this.data );
|
|
this.node.updateState();
|
|
}
|
|
|
|
return this.node;
|
|
}
|
|
|
|
public void readFromNBT( final NBTTagCompound tag )
|
|
{
|
|
this.data = tag;
|
|
if( this.node != null && this.data != null )
|
|
{
|
|
this.node.loadFromNBT( this.nbtName, this.data );
|
|
this.data = null;
|
|
}
|
|
else if( this.node != null && this.owner != null )
|
|
{
|
|
final GameProfile profile = this.owner.getGameProfile();
|
|
final int playerID = WorldData.instance().playerData().getPlayerID( profile );
|
|
|
|
this.node.setPlayerID( playerID );
|
|
this.owner = null;
|
|
}
|
|
}
|
|
|
|
public IPathingGrid getPath() throws GridAccessException
|
|
{
|
|
final IGrid grid = this.getGrid();
|
|
if( grid == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
final IPathingGrid pg = grid.getCache( IPathingGrid.class );
|
|
if( pg == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
return pg;
|
|
}
|
|
|
|
/**
|
|
* short cut!
|
|
*
|
|
* @return grid of node
|
|
*
|
|
* @throws GridAccessException of node or grid is null
|
|
*/
|
|
public IGrid getGrid() throws GridAccessException
|
|
{
|
|
if( this.node == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
final IGrid grid = this.node.getGrid();
|
|
if( grid == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
return grid;
|
|
}
|
|
|
|
public ITickManager getTick() throws GridAccessException
|
|
{
|
|
final IGrid grid = this.getGrid();
|
|
if( grid == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
final ITickManager pg = grid.getCache( ITickManager.class );
|
|
if( pg == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
return pg;
|
|
}
|
|
|
|
public IStorageGrid getStorage() throws GridAccessException
|
|
{
|
|
final IGrid grid = this.getGrid();
|
|
if( grid == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
|
|
final IStorageGrid pg = grid.getCache( IStorageGrid.class );
|
|
|
|
if( pg == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
|
|
return pg;
|
|
}
|
|
|
|
public P2PCache getP2P() throws GridAccessException
|
|
{
|
|
final IGrid grid = this.getGrid();
|
|
if( grid == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
|
|
final P2PCache pg = grid.getCache( P2PCache.class );
|
|
|
|
if( pg == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
|
|
return pg;
|
|
}
|
|
|
|
public ISecurityGrid getSecurity() throws GridAccessException
|
|
{
|
|
final IGrid grid = this.getGrid();
|
|
if( grid == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
|
|
final ISecurityGrid sg = grid.getCache( ISecurityGrid.class );
|
|
|
|
if( sg == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
|
|
return sg;
|
|
}
|
|
|
|
public ICraftingGrid getCrafting() throws GridAccessException
|
|
{
|
|
final IGrid grid = this.getGrid();
|
|
if( grid == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
|
|
final ICraftingGrid sg = grid.getCache( ICraftingGrid.class );
|
|
|
|
if( sg == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
|
|
return sg;
|
|
}
|
|
|
|
@Override
|
|
public double getIdlePowerUsage()
|
|
{
|
|
return this.idleDraw;
|
|
}
|
|
|
|
@Override
|
|
public EnumSet<GridFlags> getFlags()
|
|
{
|
|
return this.flags;
|
|
}
|
|
|
|
@Override
|
|
public boolean isWorldAccessible()
|
|
{
|
|
return this.worldNode;
|
|
}
|
|
|
|
@Override
|
|
public DimensionalCoord getLocation()
|
|
{
|
|
return this.gp.getLocation();
|
|
}
|
|
|
|
@Override
|
|
public AEColor getGridColor()
|
|
{
|
|
return this.getColor();
|
|
}
|
|
|
|
@Override
|
|
public void onGridNotification( final GridNotification notification )
|
|
{
|
|
if( this.gp instanceof PartCable )
|
|
{
|
|
( (PartCable) this.gp ).markForUpdate();
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void setNetworkStatus( final IGrid grid, final int channelsInUse )
|
|
{
|
|
|
|
}
|
|
|
|
@Override
|
|
public EnumSet<EnumFacing> getConnectableSides()
|
|
{
|
|
return this.validSides;
|
|
}
|
|
|
|
@Override
|
|
public IGridHost getMachine()
|
|
{
|
|
return this.gp;
|
|
}
|
|
|
|
@Override
|
|
public void gridChanged()
|
|
{
|
|
this.gp.gridChanged();
|
|
}
|
|
|
|
@Override
|
|
public ItemStack getMachineRepresentation()
|
|
{
|
|
return this.myRepInstance;
|
|
}
|
|
|
|
public void setFlags( final GridFlags... requireChannel )
|
|
{
|
|
final EnumSet<GridFlags> flags = EnumSet.noneOf( GridFlags.class );
|
|
|
|
Collections.addAll( flags, requireChannel );
|
|
|
|
this.flags = flags;
|
|
}
|
|
|
|
public void setIdlePowerUsage( final double idle )
|
|
{
|
|
this.idleDraw = idle;
|
|
|
|
if( this.node != null )
|
|
{
|
|
try
|
|
{
|
|
final IGrid g = this.getGrid();
|
|
g.postEvent( new MENetworkPowerIdleChange( this.node ) );
|
|
}
|
|
catch( final GridAccessException e )
|
|
{
|
|
// not ready for this yet..
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean isReady()
|
|
{
|
|
return this.isReady;
|
|
}
|
|
|
|
public boolean isActive()
|
|
{
|
|
if( this.node == null )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return this.node.isActive();
|
|
}
|
|
|
|
public boolean isPowered()
|
|
{
|
|
try
|
|
{
|
|
return this.getEnergy().isNetworkPowered();
|
|
}
|
|
catch( final GridAccessException e )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public IEnergyGrid getEnergy() throws GridAccessException
|
|
{
|
|
final IGrid grid = this.getGrid();
|
|
if( grid == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
final IEnergyGrid eg = grid.getCache( IEnergyGrid.class );
|
|
if( eg == null )
|
|
{
|
|
throw new GridAccessException();
|
|
}
|
|
return eg;
|
|
}
|
|
|
|
public void setOwner( final EntityPlayer player )
|
|
{
|
|
this.owner = player;
|
|
}
|
|
|
|
public AEColor getColor()
|
|
{
|
|
return this.myColor;
|
|
}
|
|
|
|
public void setColor( final AEColor myColor )
|
|
{
|
|
this.myColor = myColor;
|
|
}
|
|
}
|