Java IAspectContainer类代码示例

import thaumcraft.api.aspects.IAspectContainer; //导入依赖的package包/类
@Override
public <T extends TileEntity & IAspectContainer> boolean addAspectContainerTileToExtractPermissions(	final Class<T> tileClass,
																										final int capacity )
{
	// Ensure we have a tile
	if( tileClass != null )
	{
		// Set capacity
		this.tileCapacities.put( tileClass, capacity );

		// Is it not already registered?
		if( this.tileExtractWhiteList.add( tileClass ) )
		{
			// Log the addition
			ThELog.info( "Added \"%s\" with capacity (%d) to extraction whitelist.", tileClass.toString(), capacity );
		}

		return true;
	}

	return false;
}
 

import thaumcraft.api.aspects.IAspectContainer; //导入依赖的package包/类
@Override
public <T extends TileEntity & IAspectContainer> boolean addAspectContainerTileToInjectPermissions( final Class<T> tileClass, final int capacity )
{
	// Ensure we have a tile
	if( tileClass != null )
	{
		// Set capacity
		this.tileCapacities.put( tileClass, capacity );

		// Is it not already registered?
		if( this.tileInjectWhiteList.add( tileClass ) )
		{
			// Log the addition
			ThELog.info( "Added \"%s\" with capacity (%d) to injection whitelist.", tileClass.toString(), capacity );
		}

		return true;
	}

	return false;
}
 

import thaumcraft.api.aspects.IAspectContainer; //导入依赖的package包/类
@Override
public void addInformation(World world, int x, int y, int z, TileEntity te, List<String> infoList){
    if(te instanceof IAspectContainer) {
        IAspectContainer container = (IAspectContainer)te;
        AspectList aspects = container.getAspects();
        if(aspects != null && aspects.size() > 0) {
            infoList.add("blockTracker.info.thaumcraft");
            for(Map.Entry<Aspect, Integer> entry : aspects.aspects.entrySet()) {
                infoList.add("-" + entry.getValue() + "x " + entry.getKey().getName());
            }
        } else {
            infoList.add(I18n.format("blockTracker.info.thaumcraft") + " -");
        }
        if(container instanceof INode) {
            INode node = (INode)container;
            infoList.add(I18n.format("blockTracker.info.thaumcraft.nodetype") + " " + I18n.format("nodetype." + node.getNodeType() + ".name"));
            if(node.getNodeModifier() != null) infoList.add(I18n.format("blockTracker.info.thaumcraft.nodeModifier") + " " + I18n.format("nodemod." + node.getNodeModifier() + ".name"));
        }
    }
}
 

import thaumcraft.api.aspects.IAspectContainer; //导入依赖的package包/类
@ScriptCallable(returnTypes = ReturnType.TABLE, description = "Get the map of aspects stored in the block (summed, if there are multiple entries)")
public Map<String, Integer> getAspectsSum(IAspectContainer container) {
	AspectList aspectList = container.getAspects();
	if (aspectList == null) return null;
	Map<String, Integer> result = Maps.newHashMap();
	for (Aspect aspect : aspectList.getAspects()) {
		if (aspect == null) continue;
		String name = aspect.getName();
		int amount = Objects.firstNonNull(result.get(name), 0);
		result.put(name, amount + aspectList.getAmount(aspect));
	}
	return result;
}
 

import thaumcraft.api.aspects.IAspectContainer; //导入依赖的package包/类
@ScriptCallable(returnTypes = ReturnType.NUMBER, description = "Get amount of specific aspect stored in this block")
public int getAspectCount(IAspectContainer container,
		@Arg(name = "aspect", description = "Aspect to be checked") String aspectName) {

	Aspect aspect = Aspect.getAspect(aspectName.toLowerCase(Locale.ENGLISH));
	Preconditions.checkNotNull(aspect, "Invalid aspect name");
	AspectList list = container.getAspects();
	if (list == null) return 0;
	return list.getAmount(aspect);
}
 

import thaumcraft.api.aspects.IAspectContainer; //导入依赖的package包/类
@ScriptCallable(returnTypes = ReturnType.TABLE, description = "Get the Aspects stored in the block")
public List<Map<String, Object>> getAspects(IAspectContainer container) {
	List<Map<String, Object>> result = ConverterAspectList.aspectsToMap(container.getAspects());
	if (result.isEmpty()) {
		Aspect filter = ASPECT_FILTER.get(container);
		if (filter != null) ConverterAspectList.appendAspectEntry(result, filter, 0);
	}

	return result;
}
 

import thaumcraft.api.aspects.IAspectContainer; //导入依赖的package包/类
@Override
public <T extends TileEntity & IAspectContainer> boolean addAspectContainerTileToBothPermissions( final Class<T> tileClass, final int capacity )
{
	// Add to both
	return( this.addAspectContainerTileToInjectPermissions( tileClass, capacity ) | this.addAspectContainerTileToExtractPermissions( tileClass,
		capacity ) );
}
 

import thaumcraft.api.aspects.IAspectContainer; //导入依赖的package包/类
@Override
public int getAspectContainerTileCapacity( final IAspectContainer container )
{
	// Is the capacity registered?
	if( this.tileCapacities.containsKey( container.getClass() ) )
	{
		return this.tileCapacities.get( container.getClass() );
	}

	return -1;
}
 

import thaumcraft.api.aspects.IAspectContainer; //导入依赖的package包/类
/**
 * Extracts essentia from a container based on the specified fluid stack
 * type and amount.
 *
 * @param container
 * @param request
 * @param mode
 * @return
 */
public FluidStack extractFromContainer( final IAspectContainer container, final FluidStack request, final Actionable mode )
{
	// Ensure there is a request
	if( ( request == null ) || ( request.getFluid() == null ) || ( request.amount == 0 ) )
	{
		// No request
		return null;
	}

	// Get the fluid
	Fluid fluid = request.getFluid();

	// Ensure it is a gas
	if( !( fluid instanceof GaseousEssentia ) )
	{
		// Not a gas
		return null;
	}

	// Get the gas's aspect
	Aspect gasAspect = ( (GaseousEssentia)fluid ).getAspect();

	// Get the amount to extract
	long amountToDrain_EU = EssentiaConversionHelper.INSTANCE.convertFluidAmountToEssentiaAmount( request.amount );

	// Extract
	long extractedAmount_EU = this.extractFromContainer( container, (int)amountToDrain_EU, gasAspect, mode );

	// Was any extracted?
	if( extractedAmount_EU <= 0 )
	{
		// None extracted
		return null;
	}

	// Return the extracted amount
	return new FluidStack( fluid, (int)EssentiaConversionHelper.INSTANCE.convertEssentiaAmountToFluidAmount( extractedAmount_EU ) );
}
 

import thaumcraft.api.aspects.IAspectContainer; //导入依赖的package包/类
/**
 * Returns the aspect of the essentia in the container.
 *
 * @param container
 * @return
 */
public Aspect getAspectInContainer( final IAspectContainer container )
{
	// Get the aspect list from the container
	IAspectStack containerStack = this.getAspectStackFromContainer( container );

	// Did we get a stack?
	if( containerStack == null )
	{
		return null;
	}

	return containerStack.getAspect();
}
 

import thaumcraft.api.aspects.IAspectContainer; //导入依赖的package包/类
public IAspectStack getAspectStackFromContainer( final IAspectContainer container )
{
	// Ensure we have a container
	if( container == null )
	{
		return null;
	}

	// Get the list of aspects in the container
	AspectList aspectList = container.getAspects();

	if( aspectList == null )
	{
		return null;
	}

	// Create the stack
	IAspectStack aspectStack = new AspectStack();

	// Set the aspect
	aspectStack.setAspect( aspectList.getAspectsSortedAmount()[0] );

	if( !aspectStack.hasAspect() )
	{
		return null;
	}

	// Set the amount
	aspectStack.setStackSize( aspectList.getAmount( aspectStack.getAspect() ) );

	return aspectStack;
}
 

import thaumcraft.api.aspects.IAspectContainer; //导入依赖的package包/类
/**
 * Gets the list of aspects in the container.
 *
 * @param container
 * @return
 */
public List<IAspectStack> getAspectStacksFromContainer( final IAspectContainer container )
{
	List<IAspectStack> stacks = new ArrayList<IAspectStack>();

	// Ensure we have a container
	if( container == null )
	{
		return stacks;
	}

	// Get the list of aspects in the container
	AspectList aspectList = container.getAspects();

	if( aspectList == null )
	{
		return stacks;
	}

	// Populate the list
	for( Entry<Aspect, Integer> essentia : aspectList.aspects.entrySet() )
	{
		if( ( essentia != null ) && ( essentia.getValue() != 0 ) )
		{
			stacks.add( new AspectStack( essentia.getKey(), essentia.getValue() ) );
		}
	}

	return stacks;

}
 

import thaumcraft.api.aspects.IAspectContainer; //导入依赖的package包/类
public int getContainerStoredAmount( final IAspectContainer container )
{
	int stored = 0;

	// Get the essentia list
	for( IAspectStack essentia : this.getAspectStacksFromContainer( container ) )
	{
		if( essentia != null )
		{
			stored += (int)essentia.getStackSize();
		}
	}

	return stored;
}
 

import thaumcraft.api.aspects.IAspectContainer; //导入依赖的package包/类
/**
 * Attempts to inject the fluid into the container.
 * Returns the amount that was injected in milibuckets.
 *
 * @param container
 * @param fluidStack
 * @param mode
 * @return
 */
public long injectFluidIntoContainer( final IAspectContainer container, final IAEFluidStack fluidStack, final Actionable mode )
{
	// Do we have an input?
	if( fluidStack == null )
	{
		// No input
		return 0;
	}

	// Is the container whitelisted?
	if( !this.perms.canInjectToAspectContainerTile( container ) )
	{
		// Not whitelisted
		return 0;
	}

	// Get the fluid.
	Fluid fluid = fluidStack.getFluid();

	// Ensure it is a gas
	if( !( fluid instanceof GaseousEssentia ) )
	{
		// Not essentia gas
		return 0;
	}

	// Get the aspect of the gas
	Aspect gasAspect = ( (GaseousEssentia)fluid ).getAspect();

	// Get the amount to fill
	long amountToFill = EssentiaConversionHelper.INSTANCE.convertFluidAmountToEssentiaAmount( fluidStack.getStackSize() );

	// Inject
	long injectedAmount_EU = this.injectEssentiaIntoContainer( container, (int)amountToFill, gasAspect, mode );

	return EssentiaConversionHelper.INSTANCE.convertEssentiaAmountToFluidAmount( injectedAmount_EU );
}
 

import thaumcraft.api.aspects.IAspectContainer; //导入依赖的package包/类
@Override
public void onNeighborChanged()
{
	// Ignored client side
	if( EffectiveSide.isClientSide() )
	{
		return;
	}

	// Set that we are not facing a container
	this.facingContainer = null;

	// Get the tile we are facing
	TileEntity tileEntity = this.getFacingTile();

	// Are we facing a container?
	if( tileEntity instanceof IAspectContainer )
	{
		this.facingContainer = (IAspectContainer)tileEntity;
	}

	// Is the bus pulse controlled?
	if( this.redstoneMode == RedstoneMode.SIGNAL_PULSE )
	{
		// Did the state of the redstone change?
		if( this.isReceivingRedstonePower() != this.lastRedstone )
		{
			// Set the previous redstone state
			this.lastRedstone = this.isReceivingRedstonePower();

			// Do work
			this.doWork( this.getTransferAmountPerSecond() );
		}
	}
}