Java ITeslaConsumer类代码示例

import net.darkhax.tesla.api.ITeslaConsumer; //导入依赖的package包/类
@Override
public void update() {
    if (inventory[0] != null && inventory[0].hasCapability(TeslaCapabilities.CAPABILITY_CONSUMER, EnumFacing.DOWN) &&
            inventory[0].hasCapability(TeslaCapabilities.CAPABILITY_HOLDER, EnumFacing.DOWN)) {
        ITeslaConsumer c = inventory[0].getCapability(TeslaCapabilities.CAPABILITY_CONSUMER, EnumFacing.DOWN);
        ITeslaHolder h = inventory[0].getCapability(TeslaCapabilities.CAPABILITY_HOLDER, EnumFacing.DOWN);
        if (h.getStoredPower() < h.getCapacity()) container.takePower(c.givePower(Math.min(container.getOutputRate(), container.getStoredPower()), false), false);
    }
    if(syncTick==10 && !worldObj.isRemote){
        if(pos!=null){
            int dim = 0;
            for(int i : DimensionManager.getIDs())
                if(DimensionManager.getWorld(i).equals(worldObj)) {
                    dim = i;
                    break;
                }
            ModSquad.channel.sendToAll(new TileDataSync(pos, serializeNBT().toString(), dim));
        }
        syncTick = 0;
    }else if(syncTick<10) ++syncTick;
}
 

import net.darkhax.tesla.api.ITeslaConsumer; //导入依赖的package包/类
@EventHandler
public void preInit (FMLPreInitializationEvent event) {
    
    CapabilityManager.INSTANCE.register(ITeslaConsumer.class, new CapabilityTeslaConsumer<ITeslaConsumer>(), BaseTeslaContainer.class);
    CapabilityManager.INSTANCE.register(ITeslaProducer.class, new CapabilityTeslaProducer<ITeslaProducer>(), BaseTeslaContainer.class);
    CapabilityManager.INSTANCE.register(ITeslaHolder.class, new CapabilityTeslaHolder<ITeslaHolder>(), BaseTeslaContainer.class);
}
 

import net.darkhax.tesla.api.ITeslaConsumer; //导入依赖的package包/类
public void outputToTile() {
	if(metaphaser.getTankConfig().getFluidAmount() <= 0) {
		return;
	}

	BlockPos outsidePos = metaphaser.getPos().offset(metaphaser.getTileFacing().getOpposite());
	if(metaphaser.getWorld().isAirBlock(outsidePos)) {
		return;
	}

	TileEntity outsideTile = metaphaser.getWorld().getTileEntity(outsidePos);
	if(outsideTile == null) {
		return;
	}

	if(!metaphaser.containsMetaphasedFlux()) {
		return;
	}

	if(!outsideTile.hasCapability(Capabilities.Tesla.RECEIVER, metaphaser.getTileFacing().getOpposite())) {
		return;
	}

	ITeslaConsumer consumer = outsideTile.getCapability(Capabilities.Tesla.RECEIVER, metaphaser.getTileFacing().getOpposite());
	int maxPowa = Math.min(50, metaphaser.getTankConfig().getFluidAmount());
	maxPowa = (int) Math.max(Integer.MAX_VALUE, consumer.givePower(takePower(maxPowa, true), true));
	if(maxPowa > 0) {
		consumer.givePower(takePower(maxPowa, false), false);
	}
}
 

import net.darkhax.tesla.api.ITeslaConsumer; //导入依赖的package包/类
@EventHandler
public void preInit (FMLPreInitializationEvent event) {

    CapabilityManager.INSTANCE.register(ITeslaConsumer.class, new CapabilityTeslaConsumer<>(), BaseTeslaContainer.class);
    CapabilityManager.INSTANCE.register(ITeslaProducer.class, new CapabilityTeslaProducer<>(), BaseTeslaContainer.class);
    CapabilityManager.INSTANCE.register(ITeslaHolder.class, new CapabilityTeslaHolder<>(), BaseTeslaContainer.class);
}
 

import net.darkhax.tesla.api.ITeslaConsumer; //导入依赖的package包/类
/**
 * Attempts to give power to all consumers touching the given BlockPos.
 *
 * @param world The world that this is happening in.
 * @param pos The position to search around.
 * @param amount The amount of power to offer to each individual face.
 * @param simulated Whether or not this is being ran as part of a simulation.
 * @return The amount of power that was consumed.
 */
public static long distributePowerToAllFaces (World world, BlockPos pos, long amount, boolean simulated) {

    long consumedPower = 0L;

    for (final ITeslaConsumer consumer : getConnectedCapabilities(TeslaCapabilities.CAPABILITY_CONSUMER, world, pos)) {
        consumedPower += consumer.givePower(amount, simulated);
    }

    return consumedPower;
}
 

import net.darkhax.tesla.api.ITeslaConsumer; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
@Optional.Method(modid = Configs.TESLA)
static Entry<Capability, Map<EnumFacing, Object>> createTeslaCapability(IRFReceiver receiver) {
	Map<EnumFacing, Object> forge = new HashMap<>();
	for (EnumFacing f : EnumFacing.VALUES) {
		forge.put(f, new ITeslaConsumer() {

			@Override
			public long givePower(long power, boolean simulated) {
				return receiver.receiveRF(f, power, simulated);
			}
		});
	}
	return new EmptyEntry<>(TeslaCapabilities.CAPABILITY_CONSUMER, forge);
}
 

import net.darkhax.tesla.api.ITeslaConsumer; //导入依赖的package包/类
/** Provide (push-only) adjacent energy */
public static void tryPushEnergy(TileEntityRF origin) {
	TileEntity adjacent;
	ITeslaProducer producer;
	ITeslaConsumer consumer;
	long calc;
	for(EnumFacing face : EnumFacing.values()) {
		// make sure the tile exists and isn't another export bus / LE generator
		if((adjacent = origin.getWorld().getTileEntity(origin.getPos().offset(face))) != null && 
				!(adjacent instanceof TileEntityRF)) {
			
			EnumFacing swap = face.getOpposite();
			
			// only push energy, unlike the RF handler
			if(origin.hasCapability(TeslaCapabilities.CAPABILITY_PRODUCER, face) && 
					adjacent.hasCapability(TeslaCapabilities.CAPABILITY_CONSUMER, swap)) {
				producer = origin.getCapability(TeslaCapabilities.CAPABILITY_PRODUCER, face);
				consumer = adjacent.getCapability(TeslaCapabilities.CAPABILITY_CONSUMER, swap);
			} else {
				continue; // nothing to do here
			}

			// make sure the operation is valid, then do it
			if((calc = producer.takePower(Long.MAX_VALUE, true)) > 0) {
				if(consumer.givePower(Long.MAX_VALUE, true) > 0) {
					long realTesla = consumer.givePower(calc, false);
					producer.takePower(realTesla, false);
				}
			}
		}
	}
}
 

import net.darkhax.tesla.api.ITeslaConsumer; //导入依赖的package包/类
@Override
public void update()
{
	if (attachedTile == null)
	{
		getAttachedTile();
	}
	
	if (connectedCoils != null)
	{
		IBlockState state = world.getBlockState(pos);
		EnumFacing facing = state.getValue(BlockTeslaCoil.FACING);
		
		ITeslaHolder holder = attachedTile.getCapability(TeslaCapabilities.CAPABILITY_HOLDER, facing.getOpposite()); 
				
		if (hasConnectedCapability(TeslaCapabilities.CAPABILITY_CONSUMER) && 
				attachedTile.hasCapability(TeslaCapabilities.CAPABILITY_PRODUCER, facing.getOpposite()) && 
				holder.getStoredPower() > 0)
		{
			List<ITeslaConsumer> consumers = getConnectedCapabilities(TeslaCapabilities.CAPABILITY_CONSUMER);
			ITeslaProducer producer = attachedTile.getCapability(TeslaCapabilities.CAPABILITY_PRODUCER, facing.getOpposite());
			
			for(ITeslaConsumer consumer : consumers)
			{
				producer.takePower(consumer.givePower(producer.takePower(Config.teslaCoilTransferRate, true), false), false);
			}
           }
	}
}
 

import net.darkhax.tesla.api.ITeslaConsumer; //导入依赖的package包/类
@Override
public IEnergyStorage getCapability(@Nullable ICapabilityProvider provider, @Nullable EnumFacing side) {
  if (provider == null) {
    return null;
  }
  ITeslaHolder capHolder = provider.getCapability(NullHelper.notnull(TeslaCapabilities.CAPABILITY_HOLDER, "Tesla broke"), side);
  ITeslaConsumer capConsumer = provider.getCapability(NullHelper.notnull(TeslaCapabilities.CAPABILITY_CONSUMER, "Tesla broke"), side);
  ITeslaProducer capProducer = provider.getCapability(NullHelper.notnull(TeslaCapabilities.CAPABILITY_PRODUCER, "Tesla broke"), side);
  if (capHolder == null && capConsumer == null && capProducer == null) {
    return null;
  }
  return new TeslaToForgeAdapter(capHolder, capConsumer, capProducer);
}
 

import net.darkhax.tesla.api.ITeslaConsumer; //导入依赖的package包/类
@Override
public NBTBase writeNBT (Capability<ITeslaConsumer> capability, ITeslaConsumer instance, EnumFacing side) {
    
    return null;
}
 

import net.darkhax.tesla.api.ITeslaConsumer; //导入依赖的package包/类
public static int chargeItem(ItemStack stack, int energy, boolean simulate) {
    ITeslaConsumer cap = stack.getCapability(TeslaCapabilities.CAPABILITY_CONSUMER, null);
    return (int) cap.givePower(energy, simulate);
}
 

import net.darkhax.tesla.api.ITeslaConsumer; //导入依赖的package包/类
@Override
public NBTBase writeNBT (Capability<ITeslaConsumer> capability, ITeslaConsumer instance, EnumFacing side) {

    return null;
}
 

import net.darkhax.tesla.api.ITeslaConsumer; //导入依赖的package包/类
@CapabilityInject(ITeslaConsumer.class)
public static void consumer(Capability tesla)
{
    TeslaControllerBase.CONSUMER = new Consumer(tesla);
}
 

import net.darkhax.tesla.api.ITeslaConsumer; //导入依赖的package包/类
public TeslaConsumerWrapper(ITeslaConsumer consumer)
{
    this.consumer = consumer;
}
 

import net.darkhax.tesla.api.ITeslaConsumer; //导入依赖的package包/类
public TeslaToForgeAdapter(ITeslaHolder capHolder, ITeslaConsumer capConsumer, ITeslaProducer capProducer) {
  this.capHolder = capHolder;
  this.capConsumer = capConsumer;
  this.capProducer = capProducer;
}