erogenousbeef.bigreactors.api.registry.Reactants Java Examples

public void postInit() {
	BRConfig.CONFIGURATION.load();
	boolean autoAddUranium = BRConfig.CONFIGURATION.get("Compatibility", "autoAddUranium",
														true,
														"If true, automatically adds all "
														+"unregistered ingots found as clones"
														+"of standard yellorium fuel").getBoolean(true);
	if(autoAddUranium) {
		Reactants.registerSolid("ingotUranium", StandardReactants.yellorium);
	}

	BRConfig.CONFIGURATION.save();
	
	registerWithOtherMods();
	
	// Easter Egg - Check if today is valentine's day. If so, change all particles to hearts.
	Calendar calendar = Calendar.getInstance();
	BigReactors.isValentinesDay = (calendar.get(Calendar.MONTH) == 1 && calendar.get(Calendar.DAY_OF_MONTH) == 14);
}
 

public void deserialize(ByteBuf buffer) {
	capacity = buffer.readInt();
	for(int i = 0; i < tankNames.length; i++) {
		tanks[i] = null;

		boolean hasReactant = buffer.readBoolean();
		if(hasReactant) {
			String reactantName = ByteBufUtils.readUTF8String(buffer);
			int amount = buffer.readInt();
			
			if(!Reactants.isKnown(reactantName)) {
				BRLog.warning("Read an unknown reactant <%s> from a network message; tank %s will remain empty", reactantName, tankNames[i]);
			}
			else {
				tanks[i] = new ReactantStack(reactantName, amount);
				levelAtLastUpdate[i] = amount;
			}
		}
	}
}
 

@Override
public void loadAllRecipes() {
    for (OreDictToReactantMapping o : solidToReactant.values()) {
        ReactantData data = Reactants.getReactant(o.getProduct());
        if (data.isWaste()) {
            for (ItemStack ore : OreDictionary.getOres(o.getSource())) {
                this.arecipes.add(new CachedCyaniteReprocessorRecipe(ore, OreDictionary.getOres("ingotBlutonium").get(0)));
            }
        }
    }
}
 

@Override
public boolean isItemValid(ItemStack stack) {
	if(stack == null) { return false; }
	
	if(fuel) {
		return Reactants.isFuel(stack);
	}
	else {
		return Reactants.isWaste(stack);
	}
}
 

@Override
public boolean isItemValidForSlot(int slot, ItemStack itemstack) {
	if(itemstack == null) { return true; }
	
	if(slot == SLOT_OUTLET) {
		return Reactants.isFuel(itemstack);
	}
	else if(slot == SLOT_INLET) {
		return Reactants.isWaste(itemstack);
	}

	return false;
}
 

@Override
public boolean isItemValidForSlot(int slot, ItemStack itemstack) {
	if(itemstack == null) { return true; }

	if(slot == SLOT_INLET) {
		return Reactants.isFuel(itemstack);
	}
	else if(slot == SLOT_OUTLET) {
		return Reactants.isWaste(itemstack);
	}
	else {
		return false;
	}
}
 

/**
 * Consume items from the input slot.
 * Returns the amount of reactant produced.
 * @param reactantDesired The amount of reactant desired, in reactant units (mB)
 * @return The amount of reactant actually produced, in reactant units (mB)
 */
public int consumeReactantItem(int reactantDesired) {
	ItemStack inputItem = getStackInSlot(SLOT_INLET);
	if(inputItem == null) { return 0; }
	
	SourceProductMapping mapping = Reactants.getSolidToReactant(inputItem);
	if(mapping == null) { return 0; }
	
	int sourceItemsToConsume = Math.min(inputItem.stackSize, mapping.getSourceAmount(reactantDesired));
	
	if(sourceItemsToConsume <= 0) { return 0; }

	decrStackSize(SLOT_INLET, sourceItemsToConsume);
	return mapping.getProductAmount(sourceItemsToConsume);
}
 

public int getInputReactantAmount() {
	ItemStack inputItem = getStackInSlot(SLOT_INLET);
	if(inputItem == null) { return 0; }

	SourceProductMapping mapping = Reactants.getSolidToReactant(inputItem);
	return mapping != null ? mapping.getProductAmount(inputItem.stackSize) : 0;
}
 

/**
 * Eject fuel contained in the reactor.
 * @param dumpAll If true, any remaining fuel will simply be lost.
 * @param destination If not null, then fuel will only be distributed to a port matching these coordinates.
 */
public void ejectFuel(boolean dumpAll, CoordTriplet destination) {
	// For now, we can optimize by only running this when we have enough waste to product an ingot
	int amtEjected = 0;

	String fuelReactantType = fuelContainer.getFuelType();
	if(fuelReactantType == null) { 
		return;
	}

	int minimumReactantAmount = Reactants.getMinimumReactantToProduceSolid(fuelReactantType);
	if(fuelContainer.getFuelAmount() >= minimumReactantAmount) {

		for(TileEntityReactorAccessPort port : attachedAccessPorts) {
			if(fuelContainer.getFuelAmount() < minimumReactantAmount) {
				continue;
			}
			
			if(!port.isConnected()) { continue; }
			if(destination != null && !destination.equals(port.xCoord, port.yCoord, port.zCoord)) {
				continue;
			}
			
			int reactantEjected = port.emitReactant(fuelReactantType, fuelContainer.getFuelAmount());
			fuelContainer.dumpFuel(reactantEjected);
			amtEjected += reactantEjected;
		}
	}

	if(dumpAll)
	{
		amtEjected += fuelContainer.getFuelAmount();
		fuelContainer.setFuel(null);
	}

	if(amtEjected > 0) {
		markReferenceCoordForUpdate();
		markReferenceCoordDirty();
	}
}
 

@Override
public boolean isReactantValidForStack(int idx, String name) {
	switch(idx) {
	case FUEL:
		return Reactants.isFuel(name);
	case WASTE:
		// Allow anything into our output slot, in case someone wants to do breeders or something
		return true;
	default:
		return false;
	}
}
 

@Override
public void loadUsageRecipes(ItemStack ingred) {
    super.loadUsageRecipes(ingred);
    for (OreDictToReactantMapping o : solidToReactant.values()) {
        ReactantData data = Reactants.getReactant(o.getProduct());
        if (data.isWaste()) {
            for (ItemStack ore : OreDictionary.getOres(o.getSource())) {
                if (Utils.areStacksSameTypeCraftingSafe(ore, ingred)) {
                    this.arecipes.add(new CachedCyaniteReprocessorRecipe(ore, OreDictionary.getOres("ingotBlutonium").get(0)));
                }
            }
        }
    }
}
 

protected void refuel() {
	// For now, we only need to check fuel ports when we have more space than can accomodate 1 ingot
	if(fuelContainer.getRemainingSpace() < Reactants.standardSolidReactantAmount) {
		return;
	}
	
	int amtAdded = 0;
	
	// Loop: Consume input reactants from all ports
	for(TileEntityReactorAccessPort port : attachedAccessPorts)
	{
		if(fuelContainer.getRemainingSpace() <= 0) { break; }

		if(!port.isConnected())	{ continue; }

		// See what type of reactant the port contains; if none, skip it.
		String portReactantType = port.getInputReactantType();
		int portReactantAmount = port.getInputReactantAmount();
		if(portReactantType == null || portReactantAmount <= 0) { continue; }
		
		if(!Reactants.isFuel(portReactantType)) { continue; } // Skip nonfuels

		// HACK; TEMPORARY
		// Alias blutonium to yellorium temporarily, until mixed fuels are implemented
		if(portReactantType.equals(StandardReactants.blutonium)) {
			portReactantType = StandardReactants.yellorium;
		}
		
		// How much fuel can we actually add from this type of reactant?
		int amountToAdd = fuelContainer.addFuel(portReactantType, portReactantAmount, false);
		if(amountToAdd <= 0) { continue; }
		
		int portCanAdd = port.consumeReactantItem(amountToAdd);
		if(portCanAdd <= 0) { continue; }
		
		amtAdded = fuelContainer.addFuel(portReactantType, portReactantAmount, true);
	}
	
	if(amtAdded > 0) {
		markReferenceCoordForUpdate();
		markReferenceCoordDirty();
	}
}
 

@Override
public void prepare() {
    solidToReactant = ReflectionHelper.getPrivateValue(Reactants.class, null, "_solidToReactant");
    API.setGuiOffset(GuiCyaniteReprocessor.class, 8, 17);
}
 

public ReactantToFluidMapping(String reactantName, String fluidName, int fluidAmount) {
	super(reactantName, Reactants.standardFluidReactantAmount, fluidName, fluidAmount);
}
 

public ReactantToFluidMapping(String reactantName, Fluid fluid, int fluidAmount) {
	super(reactantName, Reactants.standardFluidReactantAmount, fluid.getName(), fluidAmount);
}
 

public ReactantToFluidMapping(String reactantName, FluidStack fluidStack) {
	super(reactantName, Reactants.standardFluidReactantAmount, fluidStack.getFluid().getName(), fluidStack.amount);
}
 

public ReactantToFluidMapping(String reactantName, String fluidName) {
	super(reactantName, Reactants.standardFluidReactantAmount, fluidName, Reactants.standardFluidReactantAmount);
}
 

public String getInputReactantType() {
	ItemStack inputItem = getStackInSlot(SLOT_INLET);
	if(inputItem == null) { return null; }
	SourceProductMapping mapping = Reactants.getSolidToReactant(inputItem);
	return mapping != null ? mapping.getProduct() : null;
}
 

public ReactantToFluidMapping(String reactantName, Fluid fluid) {
	super(reactantName, Reactants.standardFluidReactantAmount, fluid.getName(), Reactants.standardFluidReactantAmount);
}
 

public FluidToReactantMapping(String fluidName, int fluidAmount, String reactantName) {
	super(fluidName, fluidAmount, reactantName, Reactants.standardFluidReactantAmount);
}
 

public OreDictToReactantMapping(String oreDictName, int oreAmount, String reactantName) {
	super(oreDictName, oreAmount, reactantName, Reactants.standardSolidReactantAmount);
}
 

public OreDictToReactantMapping(String oreDictName, String reactantName) {
	super(oreDictName, 1, reactantName, Reactants.standardSolidReactantAmount);
}
 

public static void register() {
	Reactants.registerReactant(yellorium, 0, colorYellorium);
	Reactants.registerReactant(cyanite, 1, colorCyanite);
	Reactants.registerReactant(blutonium, 0, colorYellorium);
}
 

public FluidToReactantMapping(Fluid fluid, String reactantName) {
	super(fluid.getName(), Reactants.standardFluidReactantAmount, reactantName, Reactants.standardFluidReactantAmount);
}
 

public FluidToReactantMapping(String fluidName, String reactantName) {
	super(fluidName, Reactants.standardFluidReactantAmount, reactantName, Reactants.standardFluidReactantAmount);
}
 

public FluidToReactantMapping(FluidStack fluidStack, String reactantName) {
	super(fluidStack.getFluid().getName(), fluidStack.amount, reactantName, Reactants.standardFluidReactantAmount);
}
 

public FluidToReactantMapping(Fluid fluid, int fluidAmount, String reactantName) {
	super(fluid.getName(), fluidAmount, reactantName, Reactants.standardFluidReactantAmount);
}