Giant multiblock refactor

This commit is contained in:
mezz committed 2015-07-19 22:35:34 -07:00
1 parent 201111cb83
commit aa47599278
259 files changed
+10117 -6495

No files matched your search

@@ -0,0 +1,78 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture;
import net.minecraft.item.ItemStack;
import forestry.api.apiculture.BeeManager;
import forestry.api.apiculture.EnumBeeType;
import forestry.api.apiculture.IBeeHousingInventory;
import forestry.core.interfaces.IAccessHandler;
import forestry.core.inventory.InvTools;
import forestry.core.inventory.InventoryAdapterRestricted;
import forestry.core.utils.GuiUtil;
public class BeeHousingInventory extends InventoryAdapterRestricted implements IBeeHousingInventory {
public static final int SLOT_QUEEN = 0;
public static final int SLOT_DRONE = 1;
public static final int SLOT_PRODUCT_1 = 2;
public static final int SLOT_PRODUCT_COUNT = 7;
public BeeHousingInventory(int size, String name, IAccessHandler accessHandler) {
super(size, name, accessHandler);
}
@Override
public boolean canSlotAccept(int slotIndex, ItemStack itemStack) {
EnumBeeType beeType = BeeManager.beeRoot.getType(itemStack);
if (slotIndex == SLOT_QUEEN) {
return beeType == EnumBeeType.QUEEN || beeType == EnumBeeType.PRINCESS;
} else if (slotIndex == SLOT_DRONE) {
return beeType == EnumBeeType.DRONE;
}
return false;
}
@Override
public boolean canExtractItem(int slotIndex, ItemStack itemstack, int side) {
if (!super.canExtractItem(slotIndex, itemstack, side)) {
return false;
}
return GuiUtil.isIndexInRange(slotIndex, SLOT_PRODUCT_1, SLOT_PRODUCT_COUNT);
}
@Override
public final ItemStack getQueen() {
return getStackInSlot(SLOT_QUEEN);
}
@Override
public final ItemStack getDrone() {
return getStackInSlot(SLOT_DRONE);
}
@Override
public final void setQueen(ItemStack itemstack) {
setInventorySlotContents(SLOT_QUEEN, itemstack);
}
@Override
public final void setDrone(ItemStack itemstack) {
setInventorySlotContents(SLOT_DRONE, itemstack);
}
@Override
public final boolean addProduct(ItemStack product, boolean all) {
return InvTools.tryAddStack(this, product, SLOT_PRODUCT_1, SLOT_PRODUCT_COUNT, all, true);
}
}
@@ -0,0 +1,49 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.apiculture.IBeeListener;
import forestry.api.genetics.IIndividual;
public class BeeHousingListener implements IBeeListener {
private final IBeeHousing beeHousing;
public BeeHousingListener(IBeeHousing beeHousing) {
this.beeHousing = beeHousing;
}
@Override
public void wearOutEquipment(int amount) {
for (IBeeListener beeListener : beeHousing.getBeeListeners()) {
beeListener.wearOutEquipment(amount);
}
}
@Override
public void onQueenDeath() {
for (IBeeListener beeListener : beeHousing.getBeeListeners()) {
beeListener.onQueenDeath();
}
}
@Override
public boolean onPollenRetrieved(IIndividual pollen) {
for (IBeeListener beeListener : beeHousing.getBeeListeners()) {
if (beeListener.onPollenRetrieved(pollen)) {
return true;
}
}
return false;
}
}
@@ -0,0 +1,117 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.apiculture.IBeeModifier;
public class BeeHousingModifier implements IBeeModifier {
private final IBeeHousing beeHousing;
public BeeHousingModifier(IBeeHousing beeHousing) {
this.beeHousing = beeHousing;
}
@Override
public float getTerritoryModifier(IBeeGenome genome, final float currentModifier) {
float modifierValue = 1.0f;
for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
modifierValue *= modifier.getTerritoryModifier(genome, modifierValue * currentModifier);
}
return modifierValue;
}
@Override
public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, final float currentModifier) {
float modifierValue = 1.0f;
for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
modifierValue *= modifier.getMutationModifier(genome, mate, modifierValue * currentModifier);
}
return modifierValue;
}
@Override
public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, final float currentModifier) {
float modifierValue = 1.0f;
for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
modifierValue *= modifier.getLifespanModifier(genome, mate, modifierValue * currentModifier);
}
return modifierValue;
}
@Override
public float getProductionModifier(IBeeGenome genome, final float currentModifier) {
float modifierValue = 1.0f;
for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
modifierValue *= modifier.getProductionModifier(genome, modifierValue * currentModifier);
}
return modifierValue;
}
@Override
public float getFloweringModifier(IBeeGenome genome, final float currentModifier) {
float modifierValue = 1.0f;
for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
modifierValue *= modifier.getFloweringModifier(genome, modifierValue * currentModifier);
}
return modifierValue;
}
@Override
public float getGeneticDecay(IBeeGenome genome, final float currentModifier) {
float modifierValue = 1.0f;
for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
modifierValue *= modifier.getGeneticDecay(genome, modifierValue * currentModifier);
}
return modifierValue;
}
@Override
public boolean isSealed() {
for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
if (modifier.isSealed()) {
return true;
}
}
return false;
}
@Override
public boolean isSelfLighted() {
for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
if (modifier.isSelfLighted()) {
return true;
}
}
return false;
}
@Override
public boolean isSunlightSimulated() {
for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
if (modifier.isSunlightSimulated()) {
return true;
}
}
return false;
}
@Override
public boolean isHellish() {
for (IBeeModifier modifier : beeHousing.getBeeModifiers()) {
if (modifier.isHellish()) {
return true;
}
}
return false;
}
}
@@ -10,6 +10,9 @@
******************************************************************************/
package forestry.apiculture;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Set;
import java.util.Stack;
@@ -17,76 +20,97 @@ import java.util.Stack;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.world.World;
import forestry.api.apiculture.BeeManager;
import forestry.api.apiculture.EnumBeeType;
import forestry.api.apiculture.IApiaristTracker;
import forestry.api.apiculture.IBee;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.apiculture.IBeeHousingInventory;
import forestry.api.apiculture.IBeeListener;
import forestry.api.apiculture.IBeeModifier;
import forestry.api.apiculture.IBeekeepingLogic;
import forestry.api.core.IErrorLogic;
import forestry.api.core.IErrorState;
import forestry.api.genetics.IEffectData;
import forestry.api.genetics.IIndividual;
import forestry.apiculture.network.PacketBeekeepingLogicActive;
import forestry.core.EnumErrorCode;
import forestry.core.config.Defaults;
import forestry.core.config.ForestryItem;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
import forestry.core.network.IStreamable;
import forestry.core.proxy.Proxies;
import forestry.plugins.PluginApiculture;
public class BeekeepingLogic implements IBeekeepingLogic {
public class BeekeepingLogic implements IBeekeepingLogic, IStreamable {
private static final int MAX_POLLINATION_ATTEMPTS = 20;
private static final int totalBreedingTime = Defaults.APIARY_BREEDING_TIME;
private static final int ticksPerCheckQueenCanWork = 10;
private final IBeeHousing housing;
private final boolean housingSupportsMultipleErrorStates;
private final IBeeModifier beeModifier;
private final IBeeListener beeListener;
private int beeProgress;
private int beeProgressMax;
// Breeding
private int breedingTime;
private int queenWorkCycleThrottle;
private IEffectData effectData[] = new IEffectData[2];
private IBee queen;
private IIndividual pollen;
private int attemptedPollinations = 0;
private final Stack<ItemStack> spawn = new Stack<ItemStack>();
// Cached flowers check
private boolean hasFlowersCached = false;
private int hasFlowersCooldown = 0;
private Set<IErrorState> queenCanWorkCached = Collections.emptySet();
private int queenCanWorkCooldown = 0;
private final HasFlowersCache hasFlowersCache = new HasFlowersCache();
private final QueenCanWorkCache queenCanWorkCache = new QueenCanWorkCache();
private final PollenHandler pollenHandler = new PollenHandler();
// Client
private boolean active;
private IBee queen;
private ItemStack queenStack; // used to detect server changes and sync clientQueen
public BeekeepingLogic(IBeeHousing housing) {
this.housing = housing;
Set<IErrorState> errorStateSet = null;
try {
errorStateSet = housing.getErrorStates();
} catch (Throwable ignored) {
}
housingSupportsMultipleErrorStates = (errorStateSet != null);
this.beeModifier = new BeeHousingModifier(housing);
this.beeListener = new BeeHousingListener(housing);
}
// / SAVING & LOADING
@Override
public void readFromNBT(NBTTagCompound nbttagcompound) {
breedingTime = nbttagcompound.getInteger("BreedingTime");
beeProgress = nbttagcompound.getInteger("BreedingTime");
queenWorkCycleThrottle = nbttagcompound.getInteger("Throttle");
NBTTagCompound queenNBT = nbttagcompound.getCompoundTag("queen");
queenStack = ItemStack.loadItemStackFromNBT(queenNBT);
queen = BeeManager.beeRoot.getMember(queenStack);
setActive(nbttagcompound.getBoolean("Active"));
hasFlowersCache.readFromNBT(nbttagcompound);
NBTTagList nbttaglist = nbttagcompound.getTagList("Offspring", 10);
for (int i = 0; i < nbttaglist.tagCount(); i++) {
spawn.add(ItemStack.loadItemStackFromNBT(nbttaglist.getCompoundTagAt(i)));
}
}
@Override
public void writeToNBT(NBTTagCompound nbttagcompound) {
nbttagcompound.setInteger("BreedingTime", breedingTime);
nbttagcompound.setInteger("BreedingTime", beeProgress);
nbttagcompound.setInteger("Throttle", queenWorkCycleThrottle);
if (queenStack != null) {
NBTTagCompound queenNBT = new NBTTagCompound();
queenStack.writeToNBT(queenNBT);
nbttagcompound.setTag("queen", queenNBT);
}
nbttagcompound.setBoolean("Active", active);
hasFlowersCache.writeToNBT(nbttagcompound);
Stack<ItemStack> spawnCopy = new Stack<ItemStack>();
spawnCopy.addAll(spawn);
NBTTagList nbttaglist = new NBTTagList();
@@ -96,108 +120,112 @@ public class BeekeepingLogic implements IBeekeepingLogic {
nbttaglist.appendTag(nbttagcompound1);
}
nbttagcompound.setTag("Offspring", nbttaglist);
}
// / STATE INFORMATION
@Override
public int getBreedingTime() {
return this.breedingTime;
}
@Override
public int getTotalBreedingTime() {
return totalBreedingTime;
public void writeData(DataOutputStreamForestry data) throws IOException {
data.writeBoolean(active);
if (active) {
data.writeItemStack(queenStack);
}
}
@Override
public IBee getQueen() {
return this.queen;
public void readData(DataInputStreamForestry data) throws IOException {
boolean active = data.readBoolean();
setActive(active);
if (active) {
queenStack = data.readItemStack();
queen = BeeManager.beeRoot.getMember(queenStack);
}
}
@Override
public IBeeHousing getHousing() {
return this.housing;
/* Activatable */
private void setActive(boolean active) {
if (this.active == active) {
return;
}
this.active = active;
if (!housing.getWorld().isRemote) {
Proxies.net.sendNetworkPacket(new PacketBeekeepingLogicActive(housing));
}
}
@Override
public IEffectData[] getEffectData() {
return this.effectData;
public boolean isActive() {
return active;
}
/* UPDATING */
@Override
public boolean canWork() {
if (housingSupportsMultipleErrorStates) {
Set<IErrorState> errorStates = housing.getErrorStates();
for (IErrorState errorState : errorStates) {
housing.setErrorCondition(false, errorState);
IErrorLogic errorLogic = housing.getErrorLogic();
errorLogic.clearErrors();
IBeeHousingInventory beeInventory = housing.getBeeInventory();
boolean hasSpace = addPendingProducts(beeInventory, spawn);
errorLogic.setCondition(!hasSpace, EnumErrorCode.NOSPACE);
ItemStack queenStack = beeInventory.getQueen();
// check if we're breeding
if (ForestryItem.beePrincessGE.isItemEqual(queenStack)) {
boolean hasDrone = BeeManager.beeRoot.isDrone(beeInventory.getDrone());
errorLogic.setCondition(!hasDrone, EnumErrorCode.NODRONE);
setActive(false); // not active (no bee FX) when we are breeding
return !errorLogic.hasErrors();
}
if (ForestryItem.beeQueenGE.isItemEqual(queenStack)) {
if (!isQueenAlive(queenStack)) {
IBee dyingQueen = BeeManager.beeRoot.getMember(queenStack);
Collection<ItemStack> spawned = killQueen(dyingQueen, housing, beeListener);
spawn.addAll(spawned);
queenStack = null;
}
} else {
queenStack = null;
}
boolean hasSpace = addPendingProducts();
if (hasBreedablePrincess()) {
return hasSpace;
if (!ItemStack.areItemStacksEqual(this.queenStack, queenStack)) {
this.queen = BeeManager.beeRoot.getMember(queenStack);
this.queenStack = queenStack;
}
if (hasHealthyQueen()) {
boolean canWork = queenCanWork();
boolean hasFlowers = hasFlowers();
return hasSpace && canWork && hasFlowers;
if (errorLogic.setCondition(queen == null, EnumErrorCode.NOQUEEN)) {
setActive(false);
return false;
}
return false;
Set<IErrorState> queenErrors = queenCanWorkCache.queenCanWork(queen, housing);
for (IErrorState errorState : queenErrors) {
errorLogic.setCondition(true, errorState);
}
boolean hasFlowers = hasFlowersCache.hasFlowers(queen, housing);
errorLogic.setCondition(!hasFlowers, EnumErrorCode.NOFLOWER);
boolean canWork = !errorLogic.hasErrors();
setActive(canWork);
return canWork;
}
@Override
public void doWork() {
if (hasBreedablePrincess()) {
IBeeHousingInventory beeInventory = housing.getBeeInventory();
ItemStack queenStack = beeInventory.getQueen();
if (ForestryItem.beePrincessGE.isItemEqual(queenStack)) {
tickBreed();
} else if (queen != null) {
queenWorkTick();
}
}
@Override
public void update() {
if (canWork()) {
doWork();
}
}
private boolean hasFlowers() {
if (queen == null) {
return true;
}
if (hasFlowersCooldown <= 0) {
hasFlowersCached = queen.hasFlower(housing);
hasFlowersCooldown = PluginApiculture.ticksPerBeeWorkCycle;
// check more often if we haven't found flowers
if (!hasFlowersCached) {
hasFlowersCooldown /= 2;
}
} else {
hasFlowersCooldown--;
queenWorkTick(queen);
}
if (housingSupportsMultipleErrorStates) {
housing.setErrorCondition(!hasFlowersCached, EnumErrorCode.NOFLOWER);
} else {
if (hasFlowersCached) {
housing.setErrorState(EnumErrorCode.OK);
} else {
housing.setErrorState(EnumErrorCode.NOFLOWER);
}
}
return hasFlowersCached;
}
private void queenWorkTick() {
private void queenWorkTick(IBee queen) {
if (queen == null) {
return;
}
@@ -210,90 +238,53 @@ public class BeekeepingLogic implements IBeekeepingLogic {
if (queenWorkCycleThrottle >= PluginApiculture.ticksPerBeeWorkCycle) {
queenWorkCycleThrottle = 0;
doProduction();
doProduction(queen, housing, beeListener);
queen.plantFlowerRandom(housing);
doPollination();
pollenHandler.doPollination(queen, housing, beeListener);
// Age the queen
queen.age(housing.getWorld(), housing.getLifespanModifier(queen.getGenome(), queen.getMate(), 0f));
updateQueenItemNBT();
float lifespanModifier = beeModifier.getLifespanModifier(queen.getGenome(), queen.getMate(), 1.0f);
queen.age(housing.getWorld(), lifespanModifier);
// Write the changed queen back into the item stack.
NBTTagCompound nbttagcompound = new NBTTagCompound();
queen.writeToNBT(nbttagcompound);
housing.getBeeInventory().getQueen().setTagCompound(nbttagcompound);
}
beeProgress = queen.getHealth();
beeProgressMax = queen.getMaxHealth();
}
private void doProduction() {
if (queen == null) {
return;
}
private static void doProduction(IBee queen, IBeeHousing beeHousing, IBeeListener beeListener) {
// Produce and add stacks
ItemStack[] products = queen.produceStacks(housing);
ItemStack[] products = queen.produceStacks(beeHousing);
if (products == null) {
return;
}
housing.wearOutEquipment(1);
beeListener.wearOutEquipment(1);
IBeeHousingInventory beeInventory = beeHousing.getBeeInventory();
for (ItemStack stack : products) {
housing.addProduct(stack, false);
beeInventory.addProduct(stack, false);
}
}
private void doPollination() {
if (queen == null) {
return;
}
// Get pollen if none available yet
if (pollen == null) {
pollen = queen.retrievePollen(housing);
attemptedPollinations = 0;
if (pollen != null) {
if (housing.onPollenRetrieved(queen, pollen, false)) {
pollen = null;
}
}
}
if (pollen != null) {
attemptedPollinations++;
if (queen.pollinateRandom(housing, pollen) || attemptedPollinations >= MAX_POLLINATION_ATTEMPTS) {
pollen = null;
}
}
}
private void updateQueenItemNBT() {
if (queen == null) {
return;
}
// Write the changed queen back into the item stack.
NBTTagCompound nbttagcompound = new NBTTagCompound();
queen.writeToNBT(nbttagcompound);
housing.getQueen().setTagCompound(nbttagcompound);
}
private boolean addPendingProducts() {
EnumErrorCode housingErrorState = null;
private static boolean addPendingProducts(IBeeHousingInventory beeInventory, Stack<ItemStack> spawn) {
boolean housingHasSpace = true;
while (!spawn.isEmpty()) {
ItemStack next = spawn.peek();
if (housing.addProduct(next, true)) {
if (beeInventory.addProduct(next, true)) {
spawn.pop();
housingErrorState = EnumErrorCode.OK;
} else {
housingErrorState = EnumErrorCode.NOSPACE;
housingHasSpace = false;
break;
}
}
if (housingErrorState != null) {
if (housingSupportsMultipleErrorStates) {
boolean hasSpace = (housingErrorState == EnumErrorCode.OK);
housing.setErrorCondition(!hasSpace, EnumErrorCode.NOSPACE);
} else {
housing.setErrorState(housingErrorState);
}
}
return housingErrorState != EnumErrorCode.NOSPACE;
return housingHasSpace;
}
/** Checks if a queen is alive. Much faster than reading the whole bee nbt */
@@ -303,170 +294,68 @@ public class BeekeepingLogic implements IBeekeepingLogic {
return health > 0;
}
private boolean hasHealthyQueen() {
boolean hasQueen = true;
EnumErrorCode housingErrorState = null;
ItemStack queenStack = housing.getQueen();
if (queenStack == null || !ForestryItem.beeQueenGE.isItemEqual(queenStack)) {
housingErrorState = EnumErrorCode.NOQUEEN;
hasQueen = false;
queen = null;
} else if (!isQueenAlive(queenStack)) {
if (queen == null) {
queen = BeeManager.beeRoot.getMember(queenStack);
}
killQueen();
housingErrorState = EnumErrorCode.OK;
hasQueen = false;
queen = null;
}
if (housingSupportsMultipleErrorStates) {
housing.setErrorCondition(!hasQueen, EnumErrorCode.NOQUEEN);
} else {
if (housingErrorState != null) {
housing.setErrorState(housingErrorState);
}
}
if (hasQueen && queen == null) {
queen = BeeManager.beeRoot.getMember(queenStack);
}
return hasQueen;
}
private boolean hasBreedablePrincess() {
boolean isBreedingPrincess = false;
if (ForestryItem.beePrincessGE.isItemEqual(housing.getQueen())) {
boolean hasDrone = ForestryItem.beeDroneGE.isItemEqual(housing.getDrone());
if (housingSupportsMultipleErrorStates) {
housing.setErrorCondition(!hasDrone, EnumErrorCode.NODRONE);
} else {
if (hasDrone) {
housing.setErrorState(EnumErrorCode.OK);
} else {
housing.setErrorState(EnumErrorCode.NODRONE);
}
}
isBreedingPrincess = true;
}
return isBreedingPrincess;
}
private boolean queenCanWork() {
if (queenCanWorkCooldown > 0) {
queenCanWorkCooldown--;
} else {
if (queen == null) {
return false;
}
queenCanWorkCached = checkQueenCanWork();
queenCanWorkCooldown = ticksPerCheckQueenCanWork;
}
Set<IErrorState> errorStates = queenCanWorkCached;
if (errorStates.size() > 0) {
if (housingSupportsMultipleErrorStates) {
for (IErrorState errorState : errorStates) {
housing.setErrorCondition(true, errorState);
}
} else {
IErrorState state = errorStates.iterator().next();
housing.setErrorState(state);
}
return false;
} else {
return true;
}
}
private Set<IErrorState> checkQueenCanWork() {
try {
return queen.getCanWork(housing);
} catch (Throwable ignored) {
// queen might not support getCanWork
}
IErrorState state = queen.canWork(housing);
if (state != EnumErrorCode.OK) {
return Collections.singleton(state);
}
return Collections.emptySet();
}
// / BREEDING
private void tickBreed() {
if (!tryBreed()) {
breedingTime = 0;
beeProgressMax = totalBreedingTime;
IBeeHousingInventory beeInventory = housing.getBeeInventory();
ItemStack droneStack = beeInventory.getDrone();
ItemStack princessStack = beeInventory.getQueen();
if (!ForestryItem.beeDroneGE.isItemEqual(droneStack) || !ForestryItem.beePrincessGE.isItemEqual(princessStack)) {
beeProgress = 0;
return;
}
if (breedingTime < totalBreedingTime) {
breedingTime++;
if (beeProgress < totalBreedingTime) {
beeProgress++;
}
if (breedingTime < totalBreedingTime) {
if (beeProgress < totalBreedingTime) {
return;
}
// Breeding done, create new queen if slot available
if (!ForestryItem.beePrincessGE.isItemEqual(housing.getQueen())) {
return;
}
// Replace
IBee princess = BeeManager.beeRoot.getMember(housing.getQueen());
IBee drone = BeeManager.beeRoot.getMember(housing.getDrone());
// Mate and replace princess with queen
IBee princess = BeeManager.beeRoot.getMember(princessStack);
IBee drone = BeeManager.beeRoot.getMember(droneStack);
princess.mate(drone);
NBTTagCompound nbttagcompound = new NBTTagCompound();
princess.writeToNBT(nbttagcompound);
ItemStack queen = ForestryItem.beeQueenGE.getItemStack();
queen.setTagCompound(nbttagcompound);
queenStack = ForestryItem.beeQueenGE.getItemStack();
queenStack.setTagCompound(nbttagcompound);
housing.setQueen(queen);
housing.onQueenChange(housing.getQueen());
beeInventory.setQueen(queenStack);
// Register the new queen with the breeding tracker
BeeManager.beeRoot.getBreedingTracker(housing.getWorld(), housing.getOwnerName()).registerQueen(princess);
BeeManager.beeRoot.getBreedingTracker(housing.getWorld(), housing.getOwner()).registerQueen(princess);
// Remove drone
housing.getDrone().stackSize--;
if (housing.getDrone().stackSize <= 0) {
housing.setDrone(null);
beeInventory.getDrone().stackSize--;
if (beeInventory.getDrone().stackSize <= 0) {
beeInventory.setDrone(null);
}
// Reset breeding time
breedingTime = 0;
queen = princess;
beeProgress = princess.getHealth();
beeProgressMax = princess.getMaxHealth();
}
private boolean tryBreed() {
if (housing.getDrone() == null || housing.getQueen() == null) {
return false;
}
if (!ForestryItem.beeDroneGE.isItemEqual(housing.getDrone()) || !ForestryItem.beePrincessGE.isItemEqual(housing.getQueen())) {
return false;
}
return housing.canBreed();
}
private void killQueen() {
private static Collection<ItemStack> killQueen(IBee queen, IBeeHousing beeHousing, IBeeListener beeListener) {
if (queen == null) {
return;
return Collections.emptySet();
}
IBeeHousingInventory beeInventory = beeHousing.getBeeInventory();
Collection<ItemStack> spawn;
if (queen.canSpawn()) {
spawnOffspring(queen);
housing.getQueen().stackSize = 0;
housing.setQueen(null);
spawn = spawnOffspring(queen, beeHousing);
beeListener.onQueenDeath();
beeInventory.getQueen().stackSize = 0;
beeInventory.setQueen(null);
} else {
Proxies.log.warning("Tried to spawn offspring off an unmated queen. Devolving her to a princess.");
@@ -475,28 +364,29 @@ public class BeekeepingLogic implements IBeekeepingLogic {
queen.writeToNBT(nbttagcompound);
convert.setTagCompound(nbttagcompound);
spawn.add(convert);
housing.setQueen(null);
spawn = Collections.singleton(convert);
beeInventory.setQueen(null);
}
housing.onQueenChange(housing.getQueen());
return spawn;
}
/**
* Creates the succeeding princess and between one and three drones.
*/
private void spawnOffspring(IBee queen) {
private static Collection<ItemStack> spawnOffspring(IBee queen, IBeeHousing beeHousing) {
World world = beeHousing.getWorld();
Stack<ItemStack> offspring = new Stack<ItemStack>();
IApiaristTracker breedingTracker = BeeManager.beeRoot.getBreedingTracker(housing.getWorld(), housing.getOwnerName());
housing.onQueenDeath(getQueen());
IApiaristTracker breedingTracker = BeeManager.beeRoot.getBreedingTracker(world, beeHousing.getOwner());
// Princess
boolean secondPrincess = this.housing.getWorld().rand.nextInt(10000) < PluginApiculture.getSecondPrincessChance() * 100;
boolean secondPrincess = world.rand.nextInt(10000) < PluginApiculture.getSecondPrincessChance() * 100;
int count = secondPrincess ? 2 : 1;
while (count > 0) {
count--;
IBee heiress = queen.spawnPrincess(housing);
IBee heiress = queen.spawnPrincess(beeHousing);
if (heiress != null) {
ItemStack princess = BeeManager.beeRoot.getMemberStack(heiress, EnumBeeType.PRINCESS.ordinal());
breedingTracker.registerPrincess(heiress);
@@ -505,21 +395,93 @@ public class BeekeepingLogic implements IBeekeepingLogic {
}
// Drones
IBee[] larvae = queen.spawnDrones(housing);
for (IBee larva : larvae) {
ItemStack drone = BeeManager.beeRoot.getMemberStack(larva, EnumBeeType.DRONE.ordinal());
breedingTracker.registerDrone(larva);
offspring.push(drone);
IBee[] drones = queen.spawnDrones(beeHousing);
for (IBee drone : drones) {
ItemStack droneStack = BeeManager.beeRoot.getMemberStack(drone, EnumBeeType.DRONE.ordinal());
breedingTracker.registerDrone(drone);
offspring.push(droneStack);
}
IBeeHousingInventory beeInventory = beeHousing.getBeeInventory();
Collection<ItemStack> spawn = new ArrayList<ItemStack>();
while (!offspring.isEmpty()) {
ItemStack spawned = offspring.pop();
if (!housing.addProduct(spawned, true)) {
if (!beeInventory.addProduct(spawned, true)) {
spawn.add(spawned);
}
}
housing.onPostQueenDeath(getQueen());
return spawn;
}
/* CLIENT */
@Override
public int getBeeProgressPercent() {
if (beeProgressMax == 0) {
return 0;
}
return Math.round(beeProgress * 100f / beeProgressMax);
}
@Override
public boolean canDoBeeFX() {
return active;
}
@Override
public void doBeeFX() {
if (queen != null) {
queen.doFX(effectData, housing);
}
}
private static class QueenCanWorkCache {
private static final int ticksPerCheckQueenCanWork = 10;
private Set<IErrorState> queenCanWorkCached = Collections.emptySet();
private int queenCanWorkCooldown = 0;
public Set<IErrorState> queenCanWork(IBee queen, IBeeHousing beeHousing) {
if (queenCanWorkCooldown <= 0) {
queenCanWorkCached = queen.getCanWork(beeHousing);
queenCanWorkCooldown = ticksPerCheckQueenCanWork;
} else {
queenCanWorkCooldown--;
}
return queenCanWorkCached;
}
}
private static class PollenHandler {
private static final int MAX_POLLINATION_ATTEMPTS = 20;
private IIndividual pollen;
private int attemptedPollinations = 0;
public void doPollination(IBee queen, IBeeHousing beeHousing, IBeeListener beeListener) {
// Get pollen if none available yet
if (pollen == null) {
attemptedPollinations = 0;
pollen = queen.retrievePollen(beeHousing);
if (pollen != null) {
if (beeListener.onPollenRetrieved(pollen)) {
pollen = null;
}
}
}
if (pollen != null) {
attemptedPollinations++;
if (queen.pollinateRandom(beeHousing, pollen) || attemptedPollinations >= MAX_POLLINATION_ATTEMPTS) {
pollen = null;
}
}
}
}
}
@@ -0,0 +1,58 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture;
import net.minecraft.nbt.NBTTagCompound;
import forestry.api.apiculture.IBeekeepingLogic;
public class FakeBeekeepingLogic implements IBeekeepingLogic {
public static final FakeBeekeepingLogic instance = new FakeBeekeepingLogic();
private FakeBeekeepingLogic() {
}
@Override
public boolean canWork() {
return false;
}
@Override
public void doWork() {
}
@Override
public int getBeeProgressPercent() {
return 0;
}
@Override
public boolean canDoBeeFX() {
return false;
}
@Override
public void doBeeFX() {
}
@Override
public void readFromNBT(NBTTagCompound nbttagcompound) {
}
@Override
public void writeToNBT(NBTTagCompound nbttagcompound) {
}
}
@@ -15,10 +15,6 @@ import net.minecraft.item.ItemStack;
import net.minecraft.world.World;
import forestry.api.apiculture.BeeManager;
import forestry.apiculture.gadgets.TileAlvearyHygroregulator;
import forestry.apiculture.gadgets.TileAlvearyPlain;
import forestry.apiculture.gadgets.TileAlvearySieve;
import forestry.apiculture.gadgets.TileAlvearySwarmer;
import forestry.apiculture.gadgets.TileApiary;
import forestry.apiculture.gadgets.TileBeehouse;
import forestry.apiculture.genetics.BeeHelper;
@@ -26,20 +22,24 @@ import forestry.apiculture.gui.ContainerAlveary;
import forestry.apiculture.gui.ContainerAlvearyHygroregulator;
import forestry.apiculture.gui.ContainerAlvearySieve;
import forestry.apiculture.gui.ContainerAlvearySwarmer;
import forestry.apiculture.gui.ContainerApiary;
import forestry.apiculture.gui.ContainerBeeHousing;
import forestry.apiculture.gui.ContainerHabitatLocator;
import forestry.apiculture.gui.ContainerImprinter;
import forestry.apiculture.gui.GuiAlveary;
import forestry.apiculture.gui.GuiAlvearyHygroregulator;
import forestry.apiculture.gui.GuiAlvearySieve;
import forestry.apiculture.gui.GuiAlvearySwarmer;
import forestry.apiculture.gui.GuiApiary;
import forestry.apiculture.gui.GuiBeeHousing;
import forestry.apiculture.gui.GuiBeealyzer;
import forestry.apiculture.gui.GuiHabitatLocator;
import forestry.apiculture.gui.GuiImprinter;
import forestry.apiculture.items.ItemBeealyzer.BeealyzerInventory;
import forestry.apiculture.items.ItemHabitatLocator.HabitatLocatorInventory;
import forestry.apiculture.items.ItemImprinter.ImprinterInventory;
import forestry.apiculture.multiblock.TileAlvearyHygroregulator;
import forestry.apiculture.multiblock.TileAlvearyPlain;
import forestry.apiculture.multiblock.TileAlvearySieve;
import forestry.apiculture.multiblock.TileAlvearySwarmer;
import forestry.core.GuiHandlerBase;
import forestry.core.gui.ContainerAlyzer;
import forestry.core.network.GuiId;
@@ -59,19 +59,19 @@ public class GuiHandlerApiculture extends GuiHandlerBase {
switch (GuiId.values()[cleanId]) {
case AlvearyGUI:
return new GuiAlveary(player.inventory, getTileForestry(world, x, y, z, player, TileAlvearyPlain.class));
return new GuiAlveary(player.inventory, getTile(world, x, y, z, player, TileAlvearyPlain.class));
case AlvearySieveGUI:
return new GuiAlvearySieve(player.inventory, getTileForestry(world, x, y, z, player, TileAlvearySieve.class));
return new GuiAlvearySieve(player.inventory, getTile(world, x, y, z, player, TileAlvearySieve.class));
case AlvearySwarmerGUI:
return new GuiAlvearySwarmer(player.inventory, getTileForestry(world, x, y, z, player, TileAlvearySwarmer.class));
return new GuiAlvearySwarmer(player.inventory, getTile(world, x, y, z, player, TileAlvearySwarmer.class));
case ApiaristChestGUI:
return getNaturalistChestGui(BeeHelper.UID, player, world, x, y, z, guiData);
case ApiaryGUI:
return new GuiApiary(player.inventory, getTileForestry(world, x, y, z, player, TileApiary.class));
return new GuiBeeHousing(player.inventory, getTile(world, x, y, z, player, TileApiary.class));
case BeealyzerGUI:
equipped = player.getCurrentEquippedItem();
@@ -82,7 +82,7 @@ public class GuiHandlerApiculture extends GuiHandlerBase {
return new GuiBeealyzer(player, new BeealyzerInventory(player, equipped));
case BeehouseGUI:
return new GuiApiary(player.inventory, getTileForestry(world, x, y, z, player, TileBeehouse.class));
return new GuiBeeHousing(player.inventory, getTile(world, x, y, z, player, TileBeehouse.class));
case HabitatLocatorGUI:
equipped = player.getCurrentEquippedItem();
@@ -93,7 +93,7 @@ public class GuiHandlerApiculture extends GuiHandlerBase {
return new GuiHabitatLocator(player, new HabitatLocatorInventory(player, equipped));
case HygroregulatorGUI:
return new GuiAlvearyHygroregulator(player.inventory, getTileForestry(world, x, y, z, player, TileAlvearyHygroregulator.class));
return new GuiAlvearyHygroregulator(player.inventory, getTile(world, x, y, z, player, TileAlvearyHygroregulator.class));
case ImprinterGUI:
equipped = player.getCurrentEquippedItem();
@@ -122,20 +122,20 @@ public class GuiHandlerApiculture extends GuiHandlerBase {
case AlvearyGUI:
synchApiaristTracker(world, player);
return new ContainerAlveary(player.inventory, getTileForestry(world, x, y, z, player, TileAlvearyPlain.class));
return new ContainerAlveary(player.inventory, getTile(world, x, y, z, player, TileAlvearyPlain.class));
case AlvearySieveGUI:
return new ContainerAlvearySieve(player.inventory, getTileForestry(world, x, y, z, player, TileAlvearySieve.class));
return new ContainerAlvearySieve(player.inventory, getTile(world, x, y, z, player, TileAlvearySieve.class));
case AlvearySwarmerGUI:
return new ContainerAlvearySwarmer(player.inventory, getTileForestry(world, x, y, z, player, TileAlvearySwarmer.class));
return new ContainerAlvearySwarmer(player.inventory, getTile(world, x, y, z, player, TileAlvearySwarmer.class));
case ApiaristChestGUI:
return getNaturalistChestContainer(BeeHelper.UID, player, world, x, y, z, guiData);
case ApiaryGUI:
synchApiaristTracker(world, player);
return new ContainerApiary(player.inventory, getTileForestry(world, x, y, z, player, TileApiary.class), true);
return new ContainerBeeHousing(player.inventory, getTile(world, x, y, z, player, TileApiary.class), true);
case BeealyzerGUI:
equipped = player.getCurrentEquippedItem();
@@ -148,7 +148,7 @@ public class GuiHandlerApiculture extends GuiHandlerBase {
case BeehouseGUI:
synchApiaristTracker(world, player);
return new ContainerApiary(player.inventory, getTileForestry(world, x, y, z, player, TileBeehouse.class), false);
return new ContainerBeeHousing(player.inventory, getTile(world, x, y, z, player, TileBeehouse.class), false);
case HabitatLocatorGUI:
equipped = player.getCurrentEquippedItem();
@@ -159,7 +159,7 @@ public class GuiHandlerApiculture extends GuiHandlerBase {
return new ContainerHabitatLocator(player, new HabitatLocatorInventory(player, equipped));
case HygroregulatorGUI:
return new ContainerAlvearyHygroregulator(player.inventory, getTileForestry(world, x, y, z, player, TileAlvearyHygroregulator.class));
return new ContainerAlvearyHygroregulator(player.inventory, getTile(world, x, y, z, player, TileAlvearyHygroregulator.class));
case ImprinterGUI:
synchApiaristTracker(world, player);
@@ -0,0 +1,87 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.world.World;
import forestry.api.apiculture.FlowerManager;
import forestry.api.apiculture.IBee;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.core.INBTTagable;
import forestry.api.genetics.IFlowerProvider;
import forestry.plugins.PluginApiculture;
public class HasFlowersCache implements INBTTagable {
private static final String nbtKey = "hasFlowerCache";
private ChunkCoordinates flowerCoords = null;
private int cooldown = 0;
public boolean hasFlowers(IBee queen, IBeeHousing beeHousing) {
IFlowerProvider flowerProvider = queen.getGenome().getFlowerProvider();
String flowerType = flowerProvider.getFlowerType();
World world = beeHousing.getWorld();
if (flowerCoords != null) {
if (world.getTotalWorldTime() % 100 != 0) {
return true;
}
if (FlowerManager.flowerRegistry.isAcceptedFlower(flowerType, world, flowerCoords.posX, flowerCoords.posY, flowerCoords.posZ)) {
return true;
} else {
flowerCoords = null;
cooldown = 0;
}
}
if (cooldown <= 0) {
flowerCoords = FlowerManager.flowerRegistry.getAcceptedFlowerCoordinates(beeHousing, queen, flowerType);
cooldown = PluginApiculture.ticksPerBeeWorkCycle;
} else {
cooldown--;
}
return flowerCoords != null;
}
@Override
public void readFromNBT(NBTTagCompound nbttagcompound) {
if (!nbttagcompound.hasKey(nbtKey)) {
return;
}
NBTTagCompound hasFlowerCacheNBT = nbttagcompound.getCompoundTag(nbtKey);
if (hasFlowerCacheNBT.hasKey("flowerX")) {
int x = hasFlowerCacheNBT.getInteger("flowerX");
int y = hasFlowerCacheNBT.getInteger("flowerY");
int z = hasFlowerCacheNBT.getInteger("flowerZ");
flowerCoords = new ChunkCoordinates(x, y, z);
}
cooldown = hasFlowerCacheNBT.getInteger("cooldown");
}
@Override
public void writeToNBT(NBTTagCompound nbttagcompound) {
NBTTagCompound hasFlowerCacheNBT = new NBTTagCompound();
if (flowerCoords != null) {
hasFlowerCacheNBT.setInteger("flowerX", flowerCoords.posX);
hasFlowerCacheNBT.setInteger("flowerY", flowerCoords.posY);
hasFlowerCacheNBT.setInteger("flowerZ", flowerCoords.posZ);
}
hasFlowerCacheNBT.setInteger("cooldown", cooldown);
nbttagcompound.setTag(nbtKey, hasFlowerCacheNBT);
}
}
@@ -10,6 +10,8 @@
******************************************************************************/
package forestry.apiculture.flowers;
import java.util.Objects;
import net.minecraft.block.Block;
import net.minecraftforge.oredict.OreDictionary;
@@ -48,6 +50,11 @@ final class Flower implements IFlower {
return this.weight.compareTo(other.getWeight());
}
@Override
public int hashCode() {
return Objects.hash(block, meta);
}
@Override
public Block getBlock() {
return block;
@@ -11,7 +11,7 @@
package forestry.apiculture.flowers;
import java.util.EnumSet;
import java.util.List;
import java.util.Set;
import net.minecraft.item.ItemStack;
import net.minecraft.world.World;
@@ -36,8 +36,8 @@ public class FlowerProvider implements IFlowerProvider {
}
@Override
public boolean isAcceptedFlower(World world, IIndividual individual, int x, int y, int z) {
return FlowerManager.flowerRegistry.isAcceptedFlower(this.flowerType, world, individual, x, y, z);
public String getFlowerType() {
return flowerType;
}
@Override
@@ -70,7 +70,7 @@ public class FlowerProvider implements IFlowerProvider {
}
@Override
public List<IFlower> getFlowers() {
public Set<IFlower> getFlowers() {
return FlowerManager.flowerRegistry.getAcceptableFlowers(this.flowerType);
}
@@ -11,26 +11,27 @@
package forestry.apiculture.flowers;
import com.google.common.collect.ArrayListMultimap;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.TreeMap;
import net.minecraft.block.Block;
import net.minecraft.block.BlockFlowerPot;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.tileentity.TileEntityFlowerPot;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.world.World;
import net.minecraftforge.oredict.OreDictionary;
@@ -38,10 +39,17 @@ import net.minecraftforge.oredict.OreDictionary;
import cpw.mods.fml.common.registry.GameRegistry;
import forestry.api.apiculture.FlowerManager;
import forestry.api.apiculture.IBee;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.apiculture.IBeeModifier;
import forestry.api.genetics.IFlower;
import forestry.api.genetics.IFlowerGrowthRule;
import forestry.api.genetics.IFlowerRegistry;
import forestry.api.genetics.IIndividual;
import forestry.apiculture.BeeHousingModifier;
import forestry.core.vect.MutableVect;
import forestry.core.vect.Vect;
import forestry.plugins.PluginManager;
public final class FlowerRegistry implements IFlowerRegistry {
@@ -57,19 +65,19 @@ public final class FlowerRegistry implements IFlowerRegistry {
FlowerManager.FlowerTypeWheat,
FlowerManager.FlowerTypeGourd
);
private final ArrayListMultimap<String, IFlower> registeredFlowers;
private final HashMultimap<String, Block> registeredBlocks; // quick first check
private final HashMultimap<String, IFlower> registeredFlowers; // full check
private final ArrayListMultimap<String, IFlowerGrowthRule> growthRules;
private final Map<String, TreeMap<Double, IFlower>> chances;
private boolean hasDeprecatedFlowersImported;
public FlowerRegistry() {
this.registeredFlowers = ArrayListMultimap.create();
this.registeredBlocks = HashMultimap.create();
this.registeredFlowers = HashMultimap.create();
this.growthRules = ArrayListMultimap.create();
this.chances = new HashMap<String, TreeMap<Double, IFlower>>();
this.hasDeprecatedFlowersImported = false;
registerVanillaGrowthRules();
}
@@ -100,73 +108,107 @@ public final class FlowerRegistry implements IFlowerRegistry {
}
Flower newFlower = new Flower(block, meta, weight);
Integer index;
for (String flowerType : flowerTypes) {
List<IFlower> flowers = this.registeredFlowers.get(flowerType);
Set<IFlower> flowers = this.registeredFlowers.get(flowerType);
index = flowers.indexOf(newFlower);
if (index == -1) {
flowers.add(newFlower);
} else if (flowers.get(index).getMeta() != newFlower.getMeta()) {
flowers.add(newFlower);
} else if (flowers.get(index).getWeight() < newFlower.getWeight() && flowers.get(index).getMeta() == newFlower.getMeta()) {
flowers.get(index).setWeight(newFlower.getWeight());
if (flowers.contains(newFlower)) {
throw new IllegalArgumentException("Flower type already exists: " + flowerType + " for flower " + block);
}
flowers.add(newFlower);
Set<Block> blocks = this.registeredBlocks.get(flowerType);
blocks.add(block);
if (this.chances.containsKey(flowerType)) {
this.chances.remove(flowerType);
}
Collections.sort(this.registeredFlowers.get(flowerType));
}
}
private static Vect getArea(IBeeGenome genome, IBeeModifier beeModifier) {
int[] genomeTerritory = genome.getTerritory();
float housingModifier = beeModifier.getTerritoryModifier(genome, 1f);
return new Vect(genomeTerritory).multiply(housingModifier * 3.0f);
}
@Override
public boolean isAcceptedFlower(String flowerType, World world, IIndividual individual, int x, int y, int z) {
internalInitialize();
public ChunkCoordinates getAcceptedFlowerCoordinates(IBeeHousing beeHousing, IBee bee, String flowerType) {
if (!this.registeredFlowers.containsKey(flowerType)) {
return null;
}
Set<Block> acceptedBlocks = this.registeredBlocks.get(flowerType);
Set<IFlower> acceptedFlowers = this.registeredFlowers.get(flowerType);
World world = beeHousing.getWorld();
IBeeModifier beeModifier = new BeeHousingModifier(beeHousing);
Vect area = getArea(bee.getGenome(), beeModifier);
Vect housingPos = new Vect(beeHousing.getCoordinates()).add(-area.x / 2, -area.y / 2, -area.z / 2);
MutableVect posCurrent = new MutableVect(0, 0, 0);
while (posCurrent.advancePositionInArea(area)) {
Vect posBlock = Vect.add(housingPos, posCurrent);
if (isAcceptedFlower(flowerType, acceptedBlocks, acceptedFlowers, world, posBlock.x, posBlock.y, posBlock.z)) {
return new ChunkCoordinates(posBlock.x, posBlock.y, posBlock.z);
}
}
return null;
}
@Override
public boolean isAcceptedFlower(String flowerType, World world, int x, int y, int z) {
if (!this.registeredFlowers.containsKey(flowerType)) {
return false;
}
Set<Block> acceptedBlocks = this.registeredBlocks.get(flowerType);
Set<IFlower> acceptedFlowers = this.registeredFlowers.get(flowerType);
return isAcceptedFlower(flowerType, acceptedBlocks, acceptedFlowers, world, x, y, z);
}
private static boolean isAcceptedFlower(String flowerType, Set<Block> acceptedBlocks, Set<IFlower> acceptedFlowers, World world, int x, int y, int z) {
Block block = world.getBlock(x, y, z);
if (block.isAir(world, x, y, z) || block.equals(Blocks.bedrock) || block.equals(Blocks.dirt) || block.equals(Blocks.grass)) {
return false;
}
final int meta;
int meta;
TileEntity tile = world.getTileEntity(x, y, z);
if (tile instanceof TileEntityFlowerPot) {
if (block instanceof BlockFlowerPot) {
TileEntity tile = world.getTileEntity(x, y, z);
TileEntityFlowerPot tileFlowerPot = (TileEntityFlowerPot) tile;
Item item = tileFlowerPot.getFlowerPotItem();
block = Block.getBlockFromItem(item);
meta = tileFlowerPot.getFlowerPotData();
} else {
if (!acceptedBlocks.contains(block)) {
return false;
}
meta = world.getBlockMetadata(x, y, z);
}
if (PluginManager.Module.AGRICRAFT.isEnabled() && (flowerType == FlowerManager.FlowerTypeWheat || flowerType == FlowerManager.FlowerTypeNether)) {
if (PluginManager.Module.AGRICRAFT.isEnabled() && (flowerType.equals(FlowerManager.FlowerTypeWheat) || flowerType.equals(FlowerManager.FlowerTypeNether))) {
Block cropBlock = GameRegistry.findBlock("AgriCraft", "crops");
if(block == cropBlock) {
if (block == cropBlock) {
ArrayList<ItemStack> drops = block.getDrops(world, x, y, z, 7, 0);
if (drops.get(1).getItem() == Items.wheat_seeds && flowerType == FlowerManager.FlowerTypeWheat) {
if (drops.get(1).getItem() == Items.wheat_seeds && flowerType.equals(FlowerManager.FlowerTypeWheat)) {
return true;
}
if (drops.get(1).getItem() == Items.nether_wart && flowerType == FlowerManager.FlowerTypeNether) {
if (drops.get(1).getItem() == Items.nether_wart && flowerType.equals(FlowerManager.FlowerTypeNether)) {
return true;
}
}
}
Flower flower = new Flower(block, meta, 0);
List<IFlower> acceptedFlowers = this.registeredFlowers.get(flowerType);
return acceptedFlowers.contains(flower);
}
@Override
public boolean growFlower(String flowerType, World world, IIndividual individual, int x, int y, int z) {
internalInitialize();
if (!this.growthRules.containsKey(flowerType)) {
return false;
}
@@ -181,9 +223,7 @@ public final class FlowerRegistry implements IFlowerRegistry {
}
@Override
public List<IFlower> getAcceptableFlowers(String flowerType) {
internalInitialize();
public Set<IFlower> getAcceptableFlowers(String flowerType) {
return this.registeredFlowers.get(flowerType);
}
@@ -225,22 +265,6 @@ public final class FlowerRegistry implements IFlowerRegistry {
return this.chances.get(flowerType);
}
/*
* Method to support deprecated FlowerManager.plainFlowers
*/
@SuppressWarnings("deprecation")
private void internalInitialize() {
if (!hasDeprecatedFlowersImported) {
for (ItemStack plainFlower : FlowerManager.plainFlowers) {
Block flowerBlock = Block.getBlockFromItem(plainFlower.getItem());
int meta = plainFlower.getItemDamage();
registerPlantableFlower(flowerBlock, meta, 1.0, FlowerManager.FlowerTypeVanilla, FlowerManager.FlowerTypeSnow);
}
hasDeprecatedFlowersImported = true;
}
}
private void registerVanillaGrowthRules() {
registerGrowthRule(new VanillaDirtGrassGrowthRule(), FlowerManager.FlowerTypeVanilla, FlowerManager.FlowerTypeSnow);
registerGrowthRule(new VanillaSnowGrowthRule(), FlowerManager.FlowerTypeSnow);
@@ -28,7 +28,16 @@ import cpw.mods.fml.relauncher.SideOnly;
import forestry.api.core.Tabs;
import forestry.apiculture.MaterialBeehive;
import forestry.apiculture.multiblock.TileAlveary;
import forestry.apiculture.multiblock.TileAlvearyFan;
import forestry.apiculture.multiblock.TileAlvearyHeater;
import forestry.apiculture.multiblock.TileAlvearyHygroregulator;
import forestry.apiculture.multiblock.TileAlvearyPlain;
import forestry.apiculture.multiblock.TileAlvearySieve;
import forestry.apiculture.multiblock.TileAlvearyStabiliser;
import forestry.apiculture.multiblock.TileAlvearySwarmer;
import forestry.core.gadgets.BlockStructure;
import forestry.core.multiblock.MultiblockRegistry;
import forestry.core.render.TextureManager;
public class BlockAlveary extends BlockStructure {
@@ -78,17 +87,17 @@ public class BlockAlveary extends BlockStructure {
@Override
public TileEntity createTileEntity(World world, int metadata) {
switch (metadata) {
case TileAlvearySwarmer.BLOCK_META:
case TileAlveary.SWARMER_META:
return new TileAlvearySwarmer();
case TileAlvearyFan.BLOCK_META:
case TileAlveary.FAN_META:
return new TileAlvearyFan();
case TileAlvearyHeater.BLOCK_META:
case TileAlveary.HEATER_META:
return new TileAlvearyHeater();
case TileAlvearyHygroregulator.BLOCK_META:
case TileAlveary.HYGRO_META:
return new TileAlvearyHygroregulator();
case TileAlvearyStabiliser.BLOCK_META:
case TileAlveary.STABILIZER_META:
return new TileAlvearyStabiliser();
case TileAlvearySieve.BLOCK_META:
case TileAlveary.SIEVE_META:
return new TileAlvearySieve();
default:
return new TileAlvearyPlain();
@@ -143,27 +152,27 @@ public class BlockAlveary extends BlockStructure {
@Override
public IIcon getIcon(int side, int metadata) {
if ((metadata <= 1
|| metadata == TileAlvearySieve.BLOCK_META || metadata == TileAlvearySwarmer.BLOCK_META || metadata == TileAlvearyStabiliser.BLOCK_META)
|| metadata == TileAlveary.SIEVE_META || metadata == TileAlveary.SWARMER_META || metadata == TileAlveary.STABILIZER_META)
&& (side == 1 || side == 0)) {
return icons[BOTTOM];
}
switch (metadata) {
case TileAlvearyPlain.BLOCK_META:
case TileAlveary.PLAIN_META:
return icons[PLAIN];
case 1:
case TileAlveary.ENTRANCE_META:
return icons[ENTRANCE];
case TileAlvearySwarmer.BLOCK_META:
case TileAlveary.SWARMER_META:
return icons[ALVEARY_SWARMER_OFF];
case TileAlvearyFan.BLOCK_META:
case TileAlveary.FAN_META:
return icons[ALVEARY_FAN_OFF];
case TileAlvearyHeater.BLOCK_META:
case TileAlveary.HEATER_META:
return icons[ALVEARY_HEATER_OFF];
case TileAlvearyHygroregulator.BLOCK_META:
case TileAlveary.HYGRO_META:
return icons[ALVEARY_HYGRO];
case TileAlvearyStabiliser.BLOCK_META:
case TileAlveary.STABILIZER_META:
return icons[STABILISER];
case TileAlvearySieve.BLOCK_META:
case TileAlveary.SIEVE_META:
return icons[SIEVE];
default:
return null;
@@ -242,4 +251,17 @@ public class BlockAlveary extends BlockStructure {
}
}
@Override
public void onNeighborBlockChange(World world, int x, int y, int z, Block block) {
super.onNeighborBlockChange(world, x, y, z, block);
TileEntity tileEntity = world.getTileEntity(x, y, z);
if (tileEntity instanceof TileAlveary) {
TileAlveary tileAlveary = (TileAlveary) tileEntity;
// We must check that the slabs on top were not removed
MultiblockRegistry.addDirtyController(world, tileAlveary.getMultiblockController());
}
}
}
@@ -1,149 +0,0 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.gadgets;
import java.util.HashSet;
import java.util.Set;
import net.minecraft.block.Block;
import net.minecraft.init.Blocks;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.oredict.OreDictionary;
import forestry.api.apiculture.IAlvearyComponent;
import forestry.api.core.ITileStructure;
import forestry.core.gadgets.BlockStructure.EnumStructureState;
import forestry.core.gadgets.StructureLogic;
import forestry.core.utils.Schemata;
import forestry.core.utils.Schemata.EnumStructureBlock;
import forestry.core.vect.Vect;
public class StructureLogicAlveary extends StructureLogic {
/* CONSTANTS */
public static final String UID_ALVEARY = "alveary";
public static final Schemata SCHEMATA_ALVEARY = new Schemata("alveary3x3", 5, 6, 5,
"FFFFF", "FFFFF", "FFFFF", "FFFFF", "FFFFF", "FFFFF",
"FFFFF", "FAAAF", "FAAAF", "FABAF", "FCCCF", "FFFFF",
"FFFFF", "FAAAF", "FAAAF", "FBMBF", "FCCCF", "FFFFF",
"FFFFF", "FAAAF", "FAAAF", "FABAF", "FCCCF", "FFFFF",
"FFFFF", "FFFFF", "FFFFF", "FFFFF", "FFFFF", "FFFFF").setOffsets(-2, -3, -2);
private static final Set<Block> slabBlocks = new HashSet<Block>();
private static final Set<Integer> slabOreDictIds = new HashSet<Integer>();
static {
int slabWoodId = OreDictionary.getOreID("slabWood");
slabOreDictIds.add(slabWoodId);
}
public StructureLogicAlveary(ITileStructure structure) {
super(UID_ALVEARY, structure);
schematas = new Schemata[]{SCHEMATA_ALVEARY};
metaOnValid.put(EnumStructureBlock.BLOCK_B, 1);
}
@Override
protected EnumStructureState determineMasterState(Schemata schemata, boolean rotate) {
Vect dimensions = schemata.getDimensions(rotate);
int offsetX = schemata.getxOffset();
int offsetZ = schemata.getzOffset();
if (rotate) {
offsetX = schemata.getzOffset();
offsetZ = schemata.getxOffset();
}
for (int i = 0; i < dimensions.x; i++) {
for (int j = 0; j < schemata.getHeight(); j++) {
for (int k = 0; k < dimensions.z; k++) {
int x = structureTile.xCoord + i + offsetX;
int y = structureTile.yCoord + j + schemata.getyOffset();
int z = structureTile.zCoord + k + offsetZ;
if (!structureTile.getWorldObj().blockExists(x, y, z)) {
return EnumStructureState.INDETERMINATE;
}
EnumStructureBlock required = schemata.getAt(i, j, k, rotate);
if (required == EnumStructureBlock.ANY) {
continue;
}
TileEntity tile = structureTile.getWorldObj().getTileEntity(x, y, z);
Block block = structureTile.getWorldObj().getBlock(x, y, z);
switch (required) {
case AIR:
if (!block.isAir(structureTile.getWorldObj(), x, y, z)) {
return EnumStructureState.INVALID;
}
break;
case BLOCK_A:
if (tile == null || !(tile instanceof IAlvearyComponent)) {
return EnumStructureState.INVALID;
}
if (!((ITileStructure) tile).getTypeUID().equals(UID_ALVEARY)) {
return EnumStructureState.INVALID;
}
break;
case MASTER:
case BLOCK_B:
if (tile == null || !(tile instanceof TileAlvearyPlain)) {
return EnumStructureState.INVALID;
}
break;
case BLOCK_C:
if (!isWoodSlabBlock(block)) {
return EnumStructureState.INVALID;
}
if ((structureTile.getWorldObj().getBlockMetadata(x, y, z) & 8) != 0) {
return EnumStructureState.INVALID;
}
break;
case BLOCK_D:
if (block != Blocks.spruce_stairs) {
return EnumStructureState.INVALID;
}
break;
case FOREIGN:
if (tile instanceof ITileStructure) {
return EnumStructureState.INVALID;
}
break;
default:
return EnumStructureState.INDETERMINATE;
}
}
}
}
return EnumStructureState.VALID;
}
private static boolean isWoodSlabBlock(Block block) {
int[] oreIds = OreDictionary.getOreIDs(new ItemStack(block));
for (int oreId : oreIds) {
if (slabOreDictIds.contains(oreId)) {
return true;
}
}
return slabBlocks.contains(block);
}
public static void addSlabBlock(Block block) {
slabBlocks.add(block);
}
}
@@ -1,267 +0,0 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.gadgets;
import java.io.IOException;
import java.util.Collection;
import java.util.LinkedList;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;
import cpw.mods.fml.common.Optional;
import forestry.api.apiculture.IAlvearyComponent;
import forestry.api.apiculture.IBeeListener;
import forestry.api.apiculture.IBeeModifier;
import forestry.api.core.IStructureLogic;
import forestry.api.core.ITileStructure;
import forestry.apiculture.trigger.ApicultureTriggers;
import forestry.core.config.Defaults;
import forestry.core.config.ForestryBlock;
import forestry.core.gadgets.TileForestry;
import forestry.core.inventory.FakeInventoryAdapter;
import forestry.core.inventory.IInventoryAdapter;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
import forestry.core.proxy.Proxies;
import buildcraft.api.statements.ITriggerExternal;
public abstract class TileAlveary extends TileForestry implements IAlvearyComponent {
private final IStructureLogic structureLogic;
private boolean isMaster;
protected int masterX, masterZ;
protected int masterY = -99;
protected final int componentBlockMeta;
public TileAlveary(int componentBlockMeta) {
this.structureLogic = new StructureLogicAlveary(this);
this.componentBlockMeta = componentBlockMeta;
}
/* UPDATING */
@Override
public void initialize() {
if (!ForestryBlock.alveary.isBlockEqual(worldObj, xCoord, yCoord, zCoord)) {
Proxies.log.info("Updating alveary block at %s/%s/%s.", xCoord, yCoord, zCoord);
worldObj.setBlock(xCoord, yCoord, zCoord, ForestryBlock.alveary.block(), componentBlockMeta, Defaults.FLAG_BLOCK_SYNCH);
validate();
worldObj.setTileEntity(xCoord, yCoord, zCoord, this);
}
}
protected void updateServerSide() {
// Periodic validation if needed
if (updateOnInterval(200) && (!isIntegratedIntoStructure() || isMaster())) {
validateStructure();
}
}
/* TEXTURES */
public int getIcon(int side, int metadata) {
return BlockAlveary.PLAIN;
}
/* LOADING & SAVING */
@Override
public void readFromNBT(NBTTagCompound nbttagcompound) {
this.isMaster = nbttagcompound.getBoolean("IsMaster");
this.masterX = nbttagcompound.getInteger("MasterX");
this.masterY = nbttagcompound.getInteger("MasterY");
this.masterZ = nbttagcompound.getInteger("MasterZ");
// Init for master state
if (isMaster) {
makeMaster();
}
super.readFromNBT(nbttagcompound);
structureLogic.readFromNBT(nbttagcompound);
}
@Override
public void writeToNBT(NBTTagCompound nbttagcompound) {
super.writeToNBT(nbttagcompound);
nbttagcompound.setBoolean("IsMaster", isMaster);
nbttagcompound.setInteger("MasterX", masterX);
nbttagcompound.setInteger("MasterY", masterY);
nbttagcompound.setInteger("MasterZ", masterZ);
structureLogic.writeToNBT(nbttagcompound);
}
protected void createInventory() {
}
@Override
public void writeData(DataOutputStreamForestry data) throws IOException {
super.writeData(data);
data.writeBoolean(isMaster);
// so the client can know if it is part of an integrated structure
data.writeVarInt(masterY);
}
@Override
public void readData(DataInputStreamForestry data) throws IOException {
super.readData(data);
if (data.readBoolean()) {
makeMaster();
}
// so the client can know if it is part of an integrated structure
masterY = data.readVarInt();
}
/* ITILESTRUCTURE */
@Override
public String getTypeUID() {
return structureLogic.getTypeUID();
}
@Override
public void validateStructure() {
structureLogic.validateStructure();
}
@Override
public void makeMaster() {
setCentralTE(null);
isMaster = true;
if (getInternalInventory() instanceof FakeInventoryAdapter) {
createInventory();
}
if (worldObj != null && !worldObj.isRemote) {
setNeedsNetworkUpdate();
}
}
@Override
public void onStructureReset() {
setCentralTE(null);
if (worldObj.getBlockMetadata(xCoord, yCoord, zCoord) == 1) {
worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, 0, 0);
}
isMaster = false;
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
}
@Override
public ITileStructure getCentralTE() {
if (!isIntegratedIntoStructure()) {
return null;
}
if (!isMaster()) {
TileEntity tile = worldObj.getTileEntity(masterX, masterY, masterZ);
if (tile instanceof ITileStructure) {
ITileStructure master = (ITileStructure) worldObj.getTileEntity(masterX, masterY, masterZ);
if (master.isMaster()) {
return master;
} else {
return null;
}
} else {
return null;
}
} else {
return this;
}
}
private boolean isSameTile(TileEntity tile) {
return tile.xCoord == xCoord && tile.yCoord == yCoord && tile.zCoord == zCoord;
}
@Override
public void setCentralTE(TileEntity tile) {
if (tile == null || tile == this || isSameTile(tile)) {
this.masterX = this.masterZ = 0;
this.masterY = -99;
return;
}
this.isMaster = false;
this.masterX = tile.xCoord;
this.masterY = tile.yCoord;
this.masterZ = tile.zCoord;
}
@Override
public boolean isMaster() {
return isMaster;
}
protected boolean hasMaster() {
return masterY >= 0;
}
@Override
public boolean isIntegratedIntoStructure() {
return isMaster || masterY >= 0;
}
@Override
public IInventoryAdapter getStructureInventory() {
return getInternalInventory();
}
/* IALVEARY COMPONENT */
@Override
public boolean hasFunction() {
return false;
}
@Override
public void addTemperatureChange(float change, float boundaryDown, float boundaryUp) {
}
@Override
public void addHumidityChange(float change, float boundaryDown, float boundaryUp) {
}
@Override
public void registerBeeModifier(IBeeModifier modifier) {
}
@Override
public void removeBeeModifier(IBeeModifier modifier) {
}
@Override
public void registerBeeListener(IBeeListener event) {
}
@Override
public void removeBeeListener(IBeeListener event) {
}
/* ITRIGGERPROVIDER */
@Optional.Method(modid = "BuildCraftAPI|statements")
@Override
public Collection<ITriggerExternal> getExternalTriggers(ForgeDirection side, TileEntity tile) {
LinkedList<ITriggerExternal> res = new LinkedList<ITriggerExternal>();
res.add(ApicultureTriggers.missingQueen);
res.add(ApicultureTriggers.missingDrone);
return res;
}
}
@@ -1,716 +0,0 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.gadgets;
import java.io.IOException;
import java.util.LinkedHashSet;
import java.util.Set;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.ICrafting;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import com.mojang.authlib.GameProfile;
import forestry.api.apiculture.BeeManager;
import forestry.api.apiculture.IBee;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.apiculture.IBeeListener;
import forestry.api.apiculture.IBeeModifier;
import forestry.api.apiculture.IBeekeepingLogic;
import forestry.api.core.BiomeHelper;
import forestry.api.core.EnumHumidity;
import forestry.api.core.EnumTemperature;
import forestry.api.core.ForestryAPI;
import forestry.api.core.IErrorState;
import forestry.api.core.ITileStructure;
import forestry.api.genetics.IIndividual;
import forestry.apiculture.gui.ContainerAlveary;
import forestry.apiculture.network.PacketActiveUpdate;
import forestry.core.EnumErrorCode;
import forestry.core.config.Config;
import forestry.core.interfaces.IActivatable;
import forestry.core.interfaces.IClimatised;
import forestry.core.interfaces.IErrorSource;
import forestry.core.interfaces.IHintSource;
import forestry.core.inventory.IInventoryAdapter;
import forestry.core.inventory.InvTools;
import forestry.core.inventory.TileInventoryAdapter;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
import forestry.core.network.GuiId;
import forestry.core.proxy.Proxies;
public class TileAlvearyPlain extends TileAlveary implements ISidedInventory, IBeeHousing, IClimatised, IHintSource, IActivatable {
// / CONSTANTS
public static final int SLOT_QUEEN = 0;
public static final int SLOT_DRONE = 1;
public static final int SLOT_PRODUCT_1 = 2;
public static final int SLOT_PRODUCT_COUNT = 7;
public static final int BLOCK_META = 0;
// / MEMBERS
protected IBeekeepingLogic beekeepingLogic;
protected BiomeGenBase biome;
protected float tempChange = 0.0f;
protected float humidChange = 0.0f;
// CLIENT
private boolean active;
private int displayHealthMax = 0;
private int displayHealth = 0;
private IBee displayQueen;
public TileAlvearyPlain() {
super(0);
}
@Override
public void openGui(EntityPlayer player) {
if (isMaster()) {
player.openGui(ForestryAPI.instance, GuiId.AlvearyGUI.ordinal(), worldObj, xCoord, yCoord, zCoord);
} else if (this.hasMaster()) {
player.openGui(ForestryAPI.instance, GuiId.AlvearyGUI.ordinal(), worldObj, masterX, masterY, masterZ);
}
}
@Override
public void validate() {
super.validate();
setBiomeInformation();
}
private void setBiomeInformation() {
this.biome = worldObj.getBiomeGenForCoordsBody(xCoord, zCoord);
}
/* LOADING & SAVING */
@Override
public void readFromNBT(NBTTagCompound nbttagcompound) {
super.readFromNBT(nbttagcompound);
this.tempChange = nbttagcompound.getFloat("TempChange");
this.humidChange = nbttagcompound.getFloat("HumidChange");
if (beekeepingLogic != null) {
beekeepingLogic.readFromNBT(nbttagcompound);
}
}
@Override
public void writeToNBT(NBTTagCompound nbttagcompound) {
super.writeToNBT(nbttagcompound);
nbttagcompound.setFloat("TempChange", tempChange);
nbttagcompound.setFloat("HumidChange", humidChange);
if (beekeepingLogic != null) {
beekeepingLogic.writeToNBT(nbttagcompound);
}
}
@Override
public void writeData(DataOutputStreamForestry data) throws IOException {
super.writeData(data);
data.writeBoolean(active);
if (active) {
ItemStack queen = getStackInSlot(SLOT_QUEEN);
data.writeItemStack(queen);
}
}
@Override
public void readData(DataInputStreamForestry data) throws IOException {
super.readData(data);
active = data.readBoolean();
if (active) {
ItemStack queen = data.readItemStack();
setInventorySlotContents(SLOT_QUEEN, queen);
}
}
@Override
public boolean isActive() {
return active;
}
@Override
public void setActive(boolean active) {
if (this.active == active) {
return;
}
this.active = active;
if (!worldObj.isRemote) {
Proxies.net.sendNetworkPacket(new PacketActiveUpdate(this));
}
}
/* UPDATING */
@Override
public void initialize() {
super.initialize();
setBiomeInformation();
}
@Override
protected void updateServerSide() {
super.updateServerSide();
if (beekeepingLogic == null) {
return;
}
if (!isMaster()) {
return;
}
boolean canWork = beekeepingLogic.canWork();
setActive(canWork);
if (canWork) {
beekeepingLogic.doWork();
}
// Equalize humidity and temperature
equalizeTemperature();
equalizeHumidity();
}
@Override
protected void updateClientSide() {
if (isMaster() && active && (displayQueen != null) && updateOnInterval(2)) {
displayQueen.doFX(beekeepingLogic.getEffectData(), this);
if (updateOnInterval(50)) {
float fxX = xCoord + 0.5F;
float fxY = yCoord + 0.25F + (worldObj.rand.nextFloat() * 6F) / 16F;
float fxZ = zCoord + 0.5F;
float f3 = 1.6F;
float f4 = worldObj.rand.nextFloat() * f3 - 0.5F;
Proxies.common.addEntitySwarmFX(worldObj, (fxX - f3), fxY, (fxZ + f4), 0F, 0F, 0F);
Proxies.common.addEntitySwarmFX(worldObj, (fxX + f3), fxY, (fxZ + f4), 0F, 0F, 0F);
Proxies.common.addEntitySwarmFX(worldObj, (fxX + f4), fxY, (fxZ - f3), 0F, 0F, 0F);
Proxies.common.addEntitySwarmFX(worldObj, (fxX + f4), fxY, (fxZ + f3), 0F, 0F, 0F);
}
}
}
private void equalizeTemperature() {
if (tempChange == 0) {
return;
}
tempChange -= 0.05f * tempChange;
if (tempChange <= 0.001f && tempChange >= -0.001f) {
tempChange = 0;
}
}
private void equalizeHumidity() {
if (humidChange == 0) {
return;
}
humidChange -= 0.05f * humidChange;
if (humidChange <= 0.001f && humidChange >= 0.001f) {
humidChange = 0;
}
}
/* STATE INFORMATION */
private int getHealthDisplay() {
if (displayQueen == null) {
return 0;
}
if (displayQueen.getMate() != null) {
return displayQueen.getHealth();
} else {
return displayHealth;
}
}
private int getMaxHealthDisplay() {
if (displayQueen == null) {
return 0;
}
if (displayQueen.getMate() != null) {
return displayQueen.getMaxHealth();
} else {
return displayHealthMax;
}
}
public int getHealthScaled(int i) {
if (getMaxHealthDisplay() == 0) {
return 0;
}
return (getHealthDisplay() * i) / getMaxHealthDisplay();
}
/* STRUCTURE MANAGMENT */
@Override
protected void createInventory() {
setInternalInventory(new AlvearyInventoryAdapter(this));
}
@Override
public void makeMaster() {
super.makeMaster();
if (beekeepingLogic == null) {
this.beekeepingLogic = BeeManager.beeRoot.createBeekeepingLogic(this);
}
}
@Override
public void onStructureReset() {
super.onStructureReset();
modifiers.clear();
eventHandlers.clear();
setActive(false);
}
/* IALVEARYCOMPONENT */
private final Set<IBeeModifier> modifiers = new LinkedHashSet<IBeeModifier>();
private final Set<IBeeListener> eventHandlers = new LinkedHashSet<IBeeListener>();
@Override
public void registerBeeModifier(IBeeModifier modifier) {
modifiers.add(modifier);
}
@Override
public void removeBeeModifier(IBeeModifier modifier) {
modifiers.remove(modifier);
}
@Override
public void registerBeeListener(IBeeListener modifier) {
eventHandlers.add(modifier);
}
@Override
public void removeBeeListener(IBeeListener modifier) {
eventHandlers.remove(modifier);
}
@Override
public void addTemperatureChange(float change, float boundaryDown, float boundaryUp) {
float temperature = biome.getFloatTemperature(xCoord, yCoord, zCoord);
tempChange = Math.min(boundaryUp - temperature, Math.max(boundaryDown - temperature, tempChange + change));
}
@Override
public void addHumidityChange(float change, float boundaryDown, float boundaryUp) {
float humidity = biome.rainfall;
humidChange = Math.min(boundaryUp - humidity, Math.max(boundaryDown - humidity, humidChange + change));
}
/* IBEEHOUSING */
@Override
public int getXCoord() {
return xCoord;
}
@Override
public int getYCoord() {
return yCoord;
}
@Override
public int getZCoord() {
return zCoord;
}
@Override
public ItemStack getQueen() {
return getStackInSlot(SLOT_QUEEN);
}
@Override
public ItemStack getDrone() {
return getStackInSlot(SLOT_DRONE);
}
@Override
public void setQueen(ItemStack itemstack) {
setInventorySlotContents(SLOT_QUEEN, itemstack);
}
@Override
public ItemStack decrStackSize(int slotIndex, int amount) {
ItemStack itemStack = super.decrStackSize(slotIndex, amount);
if (slotIndex == SLOT_QUEEN) {
handleQueenChange();
}
return itemStack;
}
@Override
public void setInventorySlotContents(int slotIndex, ItemStack itemStack) {
super.setInventorySlotContents(slotIndex, itemStack);
if (slotIndex == SLOT_QUEEN) {
handleQueenChange();
}
}
private void handleQueenChange() {
if (!Proxies.common.isSimulating(worldObj)) {
TileAlvearyPlain master = (TileAlvearyPlain) getCentralTE();
if (master != null) {
ItemStack itemStack = getStackInSlot(SLOT_QUEEN);
master.displayQueen = BeeManager.beeRoot.getMember(itemStack);
}
}
}
@Override
public void setDrone(ItemStack itemstack) {
setInventorySlotContents(SLOT_DRONE, itemstack);
}
@Override
public BiomeGenBase getBiome() {
return biome;
}
@Override
public EnumTemperature getTemperature() {
if (isHellish() && tempChange >= 0) {
return EnumTemperature.HELLISH;
}
return EnumTemperature.getFromValue(getExactTemperature());
}
@Override
public EnumHumidity getHumidity() {
return EnumHumidity.getFromValue(getExactHumidity());
}
@Override
public float getTerritoryModifier(IBeeGenome genome, float currentModifier) {
float mod = 2.0f;
for (IBeeModifier modifier : modifiers) {
mod *= modifier.getTerritoryModifier(genome, mod);
}
return mod;
}
@Override
public float getProductionModifier(IBeeGenome genome, float currentModifier) {
float mod = 1.0f;
for (IBeeModifier modifier : modifiers) {
mod *= modifier.getProductionModifier(genome, mod);
}
return mod;
}
@Override
public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
float mod = 1.0f;
for (IBeeModifier modifier : modifiers) {
mod *= modifier.getMutationModifier(genome, mate, mod);
}
return mod;
}
@Override
public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
float mod = 1.0f;
for (IBeeModifier modifier : modifiers) {
mod *= modifier.getLifespanModifier(genome, mate, mod);
}
return mod;
}
@Override
public float getFloweringModifier(IBeeGenome genome, float currentModifier) {
float mod = 1.0f;
for (IBeeModifier modifier : modifiers) {
mod *= modifier.getFloweringModifier(genome, mod);
}
return mod;
}
@Override
public float getGeneticDecay(IBeeGenome genome, float currentModifier) {
float mod = 1.0f;
for (IBeeModifier modifier : modifiers) {
mod *= modifier.getGeneticDecay(genome, mod);
}
return mod;
}
@Override
public World getWorld() {
return worldObj;
}
@Override
public boolean canBreed() {
return true;
}
@Override
public boolean addProduct(ItemStack product, boolean all) {
IInventoryAdapter inventory = getStructureInventory();
if (inventory == null) {
return false;
}
return InvTools.tryAddStack(inventory, product, SLOT_PRODUCT_1, SLOT_PRODUCT_COUNT, all);
}
@Deprecated
@Override
public void setErrorState(IErrorState state) {
removeErrorStates();
if (state != EnumErrorCode.OK) {
addErrorState(state);
}
}
@Override
public void wearOutEquipment(int amount) {
for (IBeeListener eventHandler : eventHandlers) {
eventHandler.wearOutEquipment(amount);
}
}
@Override
public void onQueenChange(ItemStack queenStack) {
if (!Proxies.common.isSimulating(worldObj)) {
return;
}
for (IBeeListener eventHandler : eventHandlers) {
eventHandler.onQueenChange(queenStack);
}
}
@Override
public void onQueenDeath(IBee queen) {
for (IBeeListener eventHandler : eventHandlers) {
eventHandler.onQueenDeath(queen);
}
}
@Override
public void onPostQueenDeath(IBee queen) {
for (IBeeListener eventHandler : eventHandlers) {
eventHandler.onPostQueenDeath(queen);
}
}
@Override
public boolean onPollenRetrieved(IBee queen, IIndividual pollen, boolean isHandled) {
for (IBeeListener eventHandler : eventHandlers) {
if (eventHandler.onPollenRetrieved(queen, pollen, isHandled)) {
isHandled = true;
}
}
return isHandled;
}
@Override
public boolean onEggLaid(IBee queen) {
for (IBeeListener eventHandler : eventHandlers) {
if (eventHandler.onEggLaid(queen)) {
return true;
}
}
return false;
}
@Override
public boolean isSealed() {
for (IBeeModifier modifier : modifiers) {
if (modifier.isSealed()) {
return true;
}
}
return false;
}
@Override
public boolean isSelfLighted() {
for (IBeeModifier modifier : modifiers) {
if (modifier.isSelfLighted()) {
return true;
}
}
return false;
}
@Override
public boolean isSunlightSimulated() {
for (IBeeModifier modifier : modifiers) {
if (modifier.isSunlightSimulated()) {
return true;
}
}
return false;
}
@Override
public boolean isHellish() {
if (BiomeHelper.isBiomeHellish(biome)) {
return true;
}
for (IBeeModifier modifier : modifiers) {
if (modifier.isHellish()) {
return true;
}
}
return false;
}
/* IINVENTORY */
@Override
public IInventoryAdapter getInternalInventory() {
IInventoryAdapter inventory = super.getInternalInventory();
if (isMaster()) {
return inventory;
} else if (hasMaster()) {
ITileStructure central = getCentralTE();
if (central instanceof TileAlveary) {
return ((TileAlveary) central).getInternalInventory();
}
}
return inventory;
}
/* SMP GUI */
public void getGUINetworkData(int i, int j) {
switch (i) {
case 0:
displayHealth = j;
break;
case 1:
displayHealthMax = j;
break;
case 4:
this.tempChange = (float) j / 100;
break;
case 5:
this.humidChange = (float) j / 100;
break;
case 6: {
this.biome = BiomeGenBase.getBiome(j);
break;
}
}
}
public void sendGUINetworkData(ContainerAlveary container, ICrafting iCrafting) {
if (beekeepingLogic == null) {
return;
}
iCrafting.sendProgressBarUpdate(container, 0, beekeepingLogic.getBreedingTime());
iCrafting.sendProgressBarUpdate(container, 1, beekeepingLogic.getTotalBreedingTime());
iCrafting.sendProgressBarUpdate(container, 4, Math.round(tempChange * 100));
iCrafting.sendProgressBarUpdate(container, 5, Math.round(humidChange * 100));
iCrafting.sendProgressBarUpdate(container, 6, biome.biomeID);
}
/* IERRORSOURCE */
@Deprecated
@Override
public IErrorState getErrorState() {
Set<IErrorState> errorStates = null;
if (hasMaster()) {
ITileStructure tile = getCentralTE();
if (tile != null) {
errorStates = ((IErrorSource) tile).getErrorStates();
}
}
if (errorStates == null) {
errorStates = this.getErrorStates();
}
if (errorStates.size() == 0) {
return EnumErrorCode.OK;
} else {
return getErrorStates().iterator().next();
}
}
/* ICLIMATISED */
@Override
public boolean isClimatized() {
return true;
}
@Override
public float getExactTemperature() {
return biome.getFloatTemperature(xCoord, yCoord, zCoord) + this.tempChange;
}
@Override
public float getExactHumidity() {
return biome.rainfall + this.humidChange;
}
/* IHINTSOURCE */
@Override
public boolean hasHints() {
return Config.hints.get("alveary").length > 0;
}
@Override
public String[] getHints() {
return Config.hints.get("alveary");
}
/* IHousing */
@Override
public GameProfile getOwnerName() {
return this.getOwner();
}
private static class AlvearyInventoryAdapter extends TileInventoryAdapter<TileAlvearyPlain> {
public AlvearyInventoryAdapter(TileAlvearyPlain tileAlvearyPlain) {
super(tileAlvearyPlain, 9, "Items");
}
@Override
public boolean canSlotAccept(int slotIndex, ItemStack itemStack) {
if (slotIndex == SLOT_QUEEN) {
return BeeManager.beeRoot.isMember(itemStack) && !BeeManager.beeRoot.isDrone(itemStack);
} else if (slotIndex == SLOT_DRONE) {
return BeeManager.beeRoot.isDrone(itemStack);
}
return false;
}
@Override
public boolean canExtractItem(int slotIndex, ItemStack itemstack, int side) {
return slotIndex != SLOT_QUEEN && slotIndex != SLOT_DRONE;
}
}
}
@@ -1,196 +0,0 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.gadgets;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import forestry.api.apiculture.IAlvearyComponent;
import forestry.api.apiculture.IBee;
import forestry.api.apiculture.IBeeListener;
import forestry.api.arboriculture.EnumGermlingType;
import forestry.api.core.ForestryAPI;
import forestry.api.genetics.AlleleManager;
import forestry.api.genetics.IIndividual;
import forestry.core.config.ForestryItem;
import forestry.core.interfaces.ICrafter;
import forestry.core.inventory.IInventoryAdapter;
import forestry.core.inventory.TileInventoryAdapter;
import forestry.core.network.GuiId;
import forestry.core.proxy.Proxies;
import forestry.core.utils.StackUtils;
public class TileAlvearySieve extends TileAlveary implements ICrafter, IBeeListener {
/* CONSTANTS */
public static final int BLOCK_META = 7;
public static final int SLOT_POLLEN_1 = 0;
public static final int SLOTS_POLLEN_COUNT = 4;
public static final int SLOT_SIEVE = 4;
public TileAlvearySieve() {
super(BLOCK_META);
setInternalInventory(new AlvearySieveInventoryAdapter(this));
}
@Override
public void openGui(EntityPlayer player) {
player.openGui(ForestryAPI.instance, GuiId.AlvearySieveGUI.ordinal(), worldObj, xCoord, yCoord, zCoord);
}
@Override
public boolean hasFunction() {
return true;
}
/* UPDATING */
@Override
public void initialize() {
super.initialize();
if (!hasMaster() || !isIntegratedIntoStructure() || !Proxies.common.isSimulating(worldObj)) {
return;
}
((IAlvearyComponent) getCentralTE()).registerBeeListener(this);
}
@Override
protected void updateServerSide() {
super.updateServerSide();
if (!updateOnInterval(200)) {
return;
}
if (!hasMaster() || !isIntegratedIntoStructure()) {
return;
}
((IAlvearyComponent) getCentralTE()).registerBeeListener(this);
}
/* TEXTURES & INTERNAL */
@Override
public int getIcon(int side, int metadata) {
if (side == 0 || side == 1) {
return BlockAlveary.BOTTOM;
}
return BlockAlveary.SIEVE;
}
private void destroySieve() {
IInventoryAdapter inventory = getInternalInventory();
inventory.setInventorySlotContents(SLOT_SIEVE, null);
}
private void destroyPollen() {
IInventoryAdapter inventory = getInternalInventory();
for (int i = SLOT_POLLEN_1; i < SLOT_POLLEN_1 + SLOTS_POLLEN_COUNT; i++) {
inventory.setInventorySlotContents(i, null);
}
}
private boolean canStorePollen() {
IInventoryAdapter inventory = getInternalInventory();
if (inventory.getStackInSlot(SLOT_SIEVE) == null) {
return false;
}
for (int i = SLOT_POLLEN_1; i < SLOT_POLLEN_1 + SLOTS_POLLEN_COUNT; i++) {
if (inventory.getStackInSlot(i) == null) {
return true;
}
}
return false;
}
private void storePollenStack(ItemStack itemstack) {
IInventoryAdapter inventory = getInternalInventory();
for (int i = SLOT_POLLEN_1; i < SLOT_POLLEN_1 + SLOTS_POLLEN_COUNT; i++) {
if (inventory.getStackInSlot(i) == null) {
inventory.setInventorySlotContents(i, itemstack);
return;
}
}
}
/* ICRAFTER */
@Override
public boolean canTakeStack(int slotIndex) {
return true;
}
@Override
public ItemStack takenFromSlot(int slotIndex, EntityPlayer player) {
IInventoryAdapter inventory = getInternalInventory();
if (slotIndex == SLOT_SIEVE) {
destroyPollen();
return inventory.getStackInSlot(SLOT_SIEVE);
} else {
destroySieve();
return inventory.getStackInSlot(slotIndex);
}
}
@Override
public ItemStack getResult() {
return null;
}
/* IBEELISTENER */
@Override
public void onQueenChange(ItemStack queen) {
}
@Override
public void wearOutEquipment(int amount) {
}
@Override
public void onQueenDeath(IBee queen) {
}
@Override
public void onPostQueenDeath(IBee queen) {
}
@Override
public boolean onPollenRetrieved(IBee queen, IIndividual pollen, boolean isHandled) {
if (isHandled) {
return true;
}
if (!canStorePollen()) {
return false;
}
storePollenStack(AlleleManager.alleleRegistry.getSpeciesRoot(pollen.getClass()).getMemberStack(pollen, EnumGermlingType.POLLEN.ordinal()));
return true;
}
@Override
public boolean onEggLaid(IBee queen) {
return false;
}
private static class AlvearySieveInventoryAdapter extends TileInventoryAdapter<TileAlvearySieve> {
public AlvearySieveInventoryAdapter(TileAlvearySieve alvearySieve) {
super(alvearySieve, 5, "Items", 1);
}
@Override
public boolean canSlotAccept(int slotIndex, ItemStack itemStack) {
return StackUtils.isIdenticalItem(ForestryItem.craftingMaterial.getItemStack(1, 3), itemStack);
}
}
}
@@ -1,120 +0,0 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.gadgets;
import forestry.api.apiculture.IAlvearyComponent;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeModifier;
import forestry.core.proxy.Proxies;
public class TileAlvearyStabiliser extends TileAlveary implements IBeeModifier {
public static final int BLOCK_META = 6;
public TileAlvearyStabiliser() {
super(BLOCK_META);
}
/* UPDATING */
@Override
public void initialize() {
super.initialize();
if (!hasMaster() || !isIntegratedIntoStructure() || !Proxies.common.isSimulating(worldObj)) {
return;
}
((IAlvearyComponent) getCentralTE()).registerBeeModifier(this);
}
@Override
protected void updateServerSide() {
super.updateServerSide();
if (!updateOnInterval(200)) {
return;
}
if (!hasMaster() || !isIntegratedIntoStructure()) {
return;
}
((IAlvearyComponent) getCentralTE()).registerBeeModifier(this);
}
@Override
public boolean hasFunction() {
return true;
}
/* TEXTURES */
@Override
public int getIcon(int side, int metadata) {
if (side == 0 || side == 1) {
return BlockAlveary.BOTTOM;
}
return BlockAlveary.STABILISER;
}
/* IBEEMODIFIER */
@Override
public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
return 0.0f;
}
@Override
public float getTerritoryModifier(IBeeGenome genome, float currentModifier) {
return 1.0f;
}
@Override
public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
return 1.0f;
}
@Override
public float getProductionModifier(IBeeGenome genome, float currentModifier) {
return 1.0f;
}
@Override
public float getFloweringModifier(IBeeGenome genome, float currentModifier) {
return 1.0f;
}
@Override
public float getGeneticDecay(IBeeGenome genome, float currentModifier) {
return 1.0f;
}
@Override
public boolean isSealed() {
return false;
}
@Override
public boolean isSelfLighted() {
return false;
}
@Override
public boolean isSunlightSimulated() {
return false;
}
@Override
public boolean isHellish() {
return false;
}
}
@@ -10,10 +10,16 @@
******************************************************************************/
package forestry.apiculture.gadgets;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;
@@ -21,20 +27,41 @@ import net.minecraftforge.common.util.ForgeDirection;
import cpw.mods.fml.common.Optional;
import forestry.api.apiculture.BeeManager;
import forestry.api.apiculture.DefaultBeeListener;
import forestry.api.apiculture.DefaultBeeModifier;
import forestry.api.apiculture.IBee;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousingInventory;
import forestry.api.apiculture.IBeeListener;
import forestry.api.apiculture.IBeeModifier;
import forestry.api.apiculture.IBeekeepingMode;
import forestry.api.apiculture.IHiveFrame;
import forestry.api.core.ForestryAPI;
import forestry.apiculture.trigger.ApicultureTriggers;
import forestry.core.gadgets.TileBase;
import forestry.core.inventory.IInventoryAdapter;
import forestry.core.inventory.wrappers.InventoryMapper;
import forestry.core.network.GuiId;
import forestry.core.utils.GuiUtil;
import buildcraft.api.statements.ITriggerExternal;
public class TileApiary extends TileBeehouse {
public class TileApiary extends TileBeeHousing {
private static final IBeeModifier beeModifier = new ApiaryBeeModifier();
private final IBeeListener beeListener;
private final ApiaryInventory inventory;
public TileApiary() {
setInternalInventory(new BeehouseInventoryAdapter(this, 12, "Items"));
this.beeListener = new ApiaryBeeListener(this);
ApiaryInventory apiaryInventory = new ApiaryInventory(this, 12, "Items");
this.inventory = apiaryInventory;
setInternalInventory(apiaryInventory);
}
@Override
public IBeeHousingInventory getBeeInventory() {
return inventory;
}
@Override
@@ -42,209 +69,105 @@ public class TileApiary extends TileBeehouse {
player.openGui(ForestryAPI.instance, GuiId.ApiaryGUI.ordinal(), worldObj, xCoord, yCoord, zCoord);
}
/* IBEEHOUSING */
@Override
public float getTerritoryModifier(IBeeGenome genome, float currentModifier) {
IInventoryAdapter inventory = getInternalInventory();
float mod = 1.0f;
for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
if (inventory.getStackInSlot(i) == null) {
continue;
}
if (inventory.getStackInSlot(i).getItem() instanceof IHiveFrame) {
mod *= ((IHiveFrame) inventory.getStackInSlot(i).getItem()).getTerritoryModifier(genome, mod);
}
public Collection<IBeeModifier> getBeeModifiers() {
List<IBeeModifier> beeModifiers = new ArrayList<IBeeModifier>();
beeModifiers.add(beeModifier);
for (IHiveFrame frame : inventory.getFrames()) {
beeModifiers.add(frame.getBeeModifier());
}
return mod;
return beeModifiers;
}
@Override
public float getProductionModifier(IBeeGenome genome, float currentModifier) {
IInventoryAdapter inventory = getInternalInventory();
float mod = 0.1f;
for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
if (inventory.getStackInSlot(i) == null) {
continue;
}
if (inventory.getStackInSlot(i).getItem() instanceof IHiveFrame) {
mod *= ((IHiveFrame) inventory.getStackInSlot(i).getItem()).getProductionModifier(genome, mod);
}
}
return mod;
public Iterable<IBeeListener> getBeeListeners() {
return Collections.singleton(beeListener);
}
@Override
public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
IInventoryAdapter inventory = getInternalInventory();
float mod = 1.0f;
for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
if (inventory.getStackInSlot(i) == null) {
continue;
}
if (inventory.getStackInSlot(i).getItem() instanceof IHiveFrame) {
mod *= ((IHiveFrame) inventory.getStackInSlot(i).getItem()).getMutationModifier(genome, mate, mod);
}
}
return mod;
}
@Override
public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
IInventoryAdapter inventory = getInternalInventory();
float mod = 1.0f;
for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
if (inventory.getStackInSlot(i) == null) {
continue;
}
if (inventory.getStackInSlot(i).getItem() instanceof IHiveFrame) {
mod *= ((IHiveFrame) inventory.getStackInSlot(i).getItem()).getLifespanModifier(genome, mate, mod);
}
}
return mod;
}
@Override
public float getFloweringModifier(IBeeGenome genome, float currentModifier) {
IInventoryAdapter inventory = getInternalInventory();
float mod = 1f;
for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
if (inventory.getStackInSlot(i) == null) {
continue;
}
if (inventory.getStackInSlot(i).getItem() instanceof IHiveFrame) {
mod *= ((IHiveFrame) inventory.getStackInSlot(i).getItem()).getFloweringModifier(genome, mod);
}
}
return mod;
}
@Override
public float getGeneticDecay(IBeeGenome genome, float currentModifier) {
IInventoryAdapter inventory = getInternalInventory();
float mod = 1f;
for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
if (inventory.getStackInSlot(i) == null) {
continue;
}
if (inventory.getStackInSlot(i).getItem() instanceof IHiveFrame) {
mod *= ((IHiveFrame) inventory.getStackInSlot(i).getItem()).getGeneticDecay(genome, mod);
}
}
return mod;
}
@Override
public void wearOutEquipment(int amount) {
IInventoryAdapter inventory = getInternalInventory();
int wear = Math.round(amount * BeeManager.beeRoot.getBeekeepingMode(worldObj).getWearModifier());
for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
if (inventory.getStackInSlot(i) == null) {
continue;
}
if (!(inventory.getStackInSlot(i).getItem() instanceof IHiveFrame)) {
continue;
}
inventory.setInventorySlotContents(
i,
((IHiveFrame) inventory.getStackInSlot(i).getItem()).frameUsed(this, inventory.getStackInSlot(i),
BeeManager.beeRoot.getMember(inventory.getStackInSlot(SLOT_QUEEN)), wear));
private static class ApiaryBeeModifier extends DefaultBeeModifier {
@Override
public float getProductionModifier(IBeeGenome genome, float currentModifier) {
return 0.1f;
}
}
/* ISPECIALINVENTORY */
// @Override
// public ItemStack[] extractItem(boolean doRemove, ForgeDirection from, int maxItemCount) {
// ItemStack product = null;
//
// for (int i = SLOT_PRODUCT_1; i < SLOT_PRODUCT_1 + SLOT_PRODUCT_COUNT; i++) {
// if (inventory.getStackInSlot(i) == null)
// continue;
//
// // Princesses can only be extracted from top.
// if (ForestryItem.beePrincessGE.isItemEqual(inventory.getStackInSlot(i))) {
// if (PluginApiculture.apiarySideSensitive && from != ForgeDirection.UP)
// continue;
//
// product = inventory.getStackInSlot(i).copy();
// if (doRemove) {
// inventory.getStackInSlot(i).stackSize = 0;
// inventory.setInventorySlotContents(i, null);
// }
// break;
//
// // Drones can only be extracted from the bottom.
// } else if (ForestryItem.beeDroneGE.isItemEqual(inventory.getStackInSlot(i))) {
// if (PluginApiculture.apiarySideSensitive && from != ForgeDirection.DOWN)
// continue;
//
// product = StackUtils.createSplitStack(inventory.getStackInSlot(i), 1);
// product.stackSize = 1;
// if (doRemove) {
// inventory.getStackInSlot(i).stackSize--;
// if (inventory.getStackInSlot(i).stackSize <= 0)
// inventory.setInventorySlotContents(i, null);
// }
// break;
//
// // Everything else to be extracted from the sides
// } else {
// if (PluginApiculture.apiarySideSensitive && (from == ForgeDirection.UP || from == ForgeDirection.DOWN))
// continue;
//
// product = StackUtils.createSplitStack(inventory.getStackInSlot(i), 1);
// if (doRemove) {
// inventory.getStackInSlot(i).stackSize--;
// if (inventory.getStackInSlot(i).stackSize <= 0)
// inventory.setInventorySlotContents(i, null);
// }
// break;
// }
// }
//
// return new ItemStack[] { product };
// }
//
// @Override
// public int addItem(ItemStack stack, boolean doAdd, ForgeDirection from) {
// // Princesses && Queens
// if (ForestryItem.beePrincessGE.isItemEqual(stack) || ForestryItem.beeQueenGE.isItemEqual(stack))
// if (inventory.getStackInSlot(SLOT_QUEEN) == null) {
// if (doAdd) {
// inventory.setInventorySlotContents(SLOT_QUEEN, stack.copy());
// inventory.getStackInSlot(SLOT_QUEEN).stackSize = 1;
// }
//
// return 1;
// }
//
// // Drones
// if (ForestryItem.beeDroneGE.isItemEqual(stack)) {
//
// ItemStack droneStack = inventory.getStackInSlot(SLOT_DRONE);
// if (droneStack == null) {
// if (doAdd)
// inventory.setInventorySlotContents(SLOT_DRONE, stack.copy());
// return stack.stackSize;
// } else {
// if (!droneStack.isItemEqual(stack))
// return 0;
// if (!ItemStack.areItemStackTagsEqual(droneStack, stack))
// return 0;
// int space = droneStack.getMaxStackSize() - droneStack.stackSize;
// if (space <= 0)
// return 0;
//
// int added = space > stack.stackSize ? stack.stackSize : space;
// if (doAdd)
// droneStack.stackSize += added;
// return added;
// }
// }
//
// return 0;
// }
private static class ApiaryBeeListener extends DefaultBeeListener {
private final TileApiary apiary;
public ApiaryBeeListener(TileApiary apiary) {
this.apiary = apiary;
}
@Override
public void wearOutEquipment(int amount) {
IBeekeepingMode beekeepingMode = BeeManager.beeRoot.getBeekeepingMode(apiary.getWorldObj());
int wear = Math.round(amount * beekeepingMode.getWearModifier());
IInventory framesInventory = apiary.inventory.getFrameInventory();
for (int i = 0; i < framesInventory.getSizeInventory(); i++) {
ItemStack hiveFrameStack = framesInventory.getStackInSlot(i);
if (hiveFrameStack == null) {
continue;
}
Item hiveFrameItem = hiveFrameStack.getItem();
if (!(hiveFrameItem instanceof IHiveFrame)) {
continue;
}
IHiveFrame hiveFrame = (IHiveFrame) hiveFrameItem;
ItemStack queenStack = apiary.getBeeInventory().getQueen();
IBee queen = BeeManager.beeRoot.getMember(queenStack);
ItemStack usedFrame = hiveFrame.frameUsed(apiary, hiveFrameStack, queen, wear);
framesInventory.setInventorySlotContents(i, usedFrame);
}
}
}
public static class ApiaryInventory extends TileBeeHousingInventory {
public static final int SLOT_FRAMES_1 = 9;
public static final int SLOT_FRAMES_COUNT = 3;
public ApiaryInventory(TileApiary tile, int size, String name) {
super(tile, size, name);
}
@Override
public boolean canSlotAccept(int slotIndex, ItemStack itemStack) {
if (GuiUtil.isIndexInRange(slotIndex, SLOT_FRAMES_1, SLOT_FRAMES_COUNT)) {
return itemStack.getItem() instanceof IHiveFrame;
}
return super.canSlotAccept(slotIndex, itemStack);
}
public IInventory getFrameInventory() {
return new InventoryMapper(this, SLOT_FRAMES_1, SLOT_FRAMES_COUNT);
}
public Collection<IHiveFrame> getFrames() {
Collection<IHiveFrame> hiveFrames = new ArrayList<IHiveFrame>(SLOT_FRAMES_COUNT);
for (int i = SLOT_FRAMES_1; i < SLOT_FRAMES_1 + SLOT_FRAMES_COUNT; i++) {
ItemStack stackInSlot = getStackInSlot(i);
if (stackInSlot == null) {
continue;
}
Item itemInSlot = stackInSlot.getItem();
if (itemInSlot instanceof IHiveFrame) {
hiveFrames.add((IHiveFrame) itemInSlot);
}
}
return hiveFrames;
}
}
/* ITRIGGERPROVIDER */
@Optional.Method(modid = "BuildCraftAPI|statements")
@@ -0,0 +1,177 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.gadgets;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.ICrafting;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import com.mojang.authlib.GameProfile;
import forestry.api.apiculture.BeeManager;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.apiculture.IBeekeepingLogic;
import forestry.api.core.EnumHumidity;
import forestry.api.core.EnumTemperature;
import forestry.apiculture.BeeHousingInventory;
import forestry.core.config.Config;
import forestry.core.gadgets.TileBase;
import forestry.core.interfaces.IClimatised;
import forestry.core.proxy.Proxies;
public abstract class TileBeeHousing extends TileBase implements IBeeHousing, IClimatised {
private final IBeekeepingLogic beeLogic;
private BiomeGenBase cachedBiome;
// CLIENT
private int breedingProgressPercent = 0;
public TileBeeHousing() {
setHints(Config.hints.get("apiary"));
this.beeLogic = BeeManager.beeRoot.createBeekeepingLogic(this);
}
@Override
public IBeekeepingLogic getBeekeepingLogic() {
return beeLogic;
}
/* LOADING & SAVING */
@Override
public void writeToNBT(NBTTagCompound nbttagcompound) {
super.writeToNBT(nbttagcompound);
beeLogic.writeToNBT(nbttagcompound);
}
@Override
public void readFromNBT(NBTTagCompound nbttagcompound) {
super.readFromNBT(nbttagcompound);
beeLogic.readFromNBT(nbttagcompound);
}
/* ICLIMATISED */
@Override
public EnumTemperature getTemperature() {
return EnumTemperature.getFromBiome(getBiome(), xCoord, yCoord, zCoord);
}
@Override
public EnumHumidity getHumidity() {
return EnumHumidity.getFromValue(getExactHumidity());
}
@Override
public float getExactTemperature() {
return getBiome().getFloatTemperature(xCoord, yCoord, zCoord);
}
@Override
public float getExactHumidity() {
return getBiome().rainfall;
}
/* UPDATING */
@Override
public void updateClientSide() {
if (beeLogic.canDoBeeFX() && updateOnInterval(4)) {
beeLogic.doBeeFX();
if (updateOnInterval(50)) {
float fxX = xCoord + 0.5F;
float fxY = yCoord + 0.25F;
float fxZ = zCoord + 0.5F;
float distanceFromCenter = 0.6F;
float leftRightSpreadFromCenter = distanceFromCenter * (worldObj.rand.nextFloat() - 0.5F);
float upSpread = (worldObj.rand.nextFloat() * 6F) / 16F;
fxY += upSpread;
Proxies.common.addEntitySwarmFX(worldObj, (fxX - distanceFromCenter), fxY, (fxZ + leftRightSpreadFromCenter), 0F, 0F, 0F);
Proxies.common.addEntitySwarmFX(worldObj, (fxX + distanceFromCenter), fxY, (fxZ + leftRightSpreadFromCenter), 0F, 0F, 0F);
Proxies.common.addEntitySwarmFX(worldObj, (fxX + leftRightSpreadFromCenter), fxY, (fxZ - distanceFromCenter), 0F, 0F, 0F);
Proxies.common.addEntitySwarmFX(worldObj, (fxX + leftRightSpreadFromCenter), fxY, (fxZ + distanceFromCenter), 0F, 0F, 0F);
}
}
}
@Override
public void updateServerSide() {
if (beeLogic.canWork()) {
beeLogic.doWork();
}
}
/**
* Returns scaled queen health or breeding progress
*/
public int getHealthScaled(int i) {
return (breedingProgressPercent * i) / 100;
}
/* SMP */
public void getGUINetworkData(int i, int j) {
switch (i) {
case 0:
breedingProgressPercent = j;
break;
}
}
public void sendGUINetworkData(Container container, ICrafting iCrafting) {
iCrafting.sendProgressBarUpdate(container, 0, beeLogic.getBeeProgressPercent());
}
// / IBEEHOUSING
@Override
public BiomeGenBase getBiome() {
if (cachedBiome == null) {
cachedBiome = worldObj.getBiomeGenForCoordsBody(xCoord, zCoord);
}
return cachedBiome;
}
@Override
public int getBlockLightValue() {
return worldObj.getBlockLightValue(xCoord, yCoord + 1, zCoord);
}
@Override
public boolean canBlockSeeTheSky() {
return worldObj.canBlockSeeTheSky(xCoord, yCoord + 1, zCoord);
}
@Override
public GameProfile getOwner() {
return getAccessHandler().getOwner();
}
@Override
public World getWorld() {
return worldObj;
}
public static class TileBeeHousingInventory extends BeeHousingInventory {
private final TileBeeHousing tile;
public TileBeeHousingInventory(TileBeeHousing tile, int size, String name) {
super(size, name, tile.getAccessHandler());
this.tile = tile;
}
@Override
public void markDirty() {
super.markDirty();
tile.markDirty();
}
}
}
@@ -10,66 +10,39 @@
******************************************************************************/
package forestry.apiculture.gadgets;
import java.io.IOException;
import java.util.Set;
import java.util.Collections;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.ICrafting;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import com.mojang.authlib.GameProfile;
import forestry.api.apiculture.BeeManager;
import forestry.api.apiculture.IBee;
import forestry.api.apiculture.DefaultBeeListener;
import forestry.api.apiculture.DefaultBeeModifier;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.apiculture.IBeekeepingLogic;
import forestry.api.apiculture.IHiveFrame;
import forestry.api.core.EnumHumidity;
import forestry.api.core.EnumTemperature;
import forestry.api.apiculture.IBeeHousingInventory;
import forestry.api.apiculture.IBeeListener;
import forestry.api.apiculture.IBeeModifier;
import forestry.api.core.ForestryAPI;
import forestry.api.core.IErrorState;
import forestry.api.genetics.IIndividual;
import forestry.apiculture.network.PacketActiveUpdate;
import forestry.core.EnumErrorCode;
import forestry.core.config.Config;
import forestry.core.gadgets.TileBase;
import forestry.core.interfaces.IActivatable;
import forestry.core.interfaces.IClimatised;
import forestry.core.inventory.InvTools;
import forestry.core.inventory.TileInventoryAdapter;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
import forestry.core.network.GuiId;
import forestry.core.proxy.Proxies;
import forestry.core.utils.GuiUtil;
public class TileBeehouse extends TileBase implements IBeeHousing, IClimatised, IActivatable {
// CONSTANTS
public static final int SLOT_QUEEN = 0;
public static final int SLOT_DRONE = 1;
public static final int SLOT_PRODUCT_1 = 2;
public static final int SLOT_PRODUCT_COUNT = 7;
public static final int SLOT_FRAMES_1 = 9;
public static final int SLOT_FRAMES_COUNT = 3;
public class TileBeehouse extends TileBeeHousing {
private static final IBeeModifier beeModifier = new BeehouseBeeModifier();
private final IBeekeepingLogic logic;
private BiomeGenBase biome;
// CLIENT
private boolean active;
private int displayHealthMax = 0;
private int displayHealth = 0;
private IBee displayQueen;
private final IBeeListener beeListener;
private final IBeeHousingInventory beeInventory;
public TileBeehouse() {
setHints(Config.hints.get("apiary"));
logic = BeeManager.beeRoot.createBeekeepingLogic(this);
setInternalInventory(new BeehouseInventoryAdapter(this, 12, "Items").disableAutomation());
this.beeListener = new DefaultBeeListener();
TileBeeHousingInventory beeHousingInventory = new TileBeeHousingInventory(this, 12, "Items");
beeHousingInventory.disableAutomation();
this.beeInventory = beeHousingInventory;
setInternalInventory(beeHousingInventory);
}
@Override
public IBeeHousingInventory getBeeInventory() {
return beeInventory;
}
@Override
@@ -77,410 +50,45 @@ public class TileBeehouse extends TileBase implements IBeeHousing, IClimatised,
player.openGui(ForestryAPI.instance, GuiId.BeehouseGUI.ordinal(), worldObj, xCoord, yCoord, zCoord);
}
/* LOADING & SAVING */
@Override
public void writeToNBT(NBTTagCompound nbttagcompound) {
super.writeToNBT(nbttagcompound);
nbttagcompound.setInteger("BiomeId", biome.biomeID);
if (logic != null) {
logic.writeToNBT(nbttagcompound);
}
public Iterable<IBeeModifier> getBeeModifiers() {
return Collections.singleton(beeModifier);
}
@Override
public void readFromNBT(NBTTagCompound nbttagcompound) {
super.readFromNBT(nbttagcompound);
int biomeId = nbttagcompound.getInteger("BiomeId");
biome = BiomeGenBase.getBiome(biomeId);
logic.readFromNBT(nbttagcompound);
public Iterable<IBeeListener> getBeeListeners() {
return Collections.singleton(beeListener);
}
@Override
public void writeData(DataOutputStreamForestry data) throws IOException {
super.writeData(data);
data.writeBoolean(active);
if (active) {
ItemStack queen = getStackInSlot(SLOT_QUEEN);
data.writeItemStack(queen);
}
}
@Override
public void readData(DataInputStreamForestry data) throws IOException {
super.readData(data);
active = data.readBoolean();
if (active) {
ItemStack queen = data.readItemStack();
setInventorySlotContents(SLOT_QUEEN, queen);
}
}
@Override
public void initialize() {
super.initialize();
updateBiome();
}
@Override
public void validate() {
updateBiome();
}
/* ICLIMATISED */
@Override
public boolean isClimatized() {
return true;
}
@Override
public EnumTemperature getTemperature() {
return EnumTemperature.getFromBiome(biome, xCoord, yCoord, zCoord);
}
@Override
public EnumHumidity getHumidity() {
return EnumHumidity.getFromValue(getExactHumidity());
}
@Deprecated
@Override
public void setErrorState(IErrorState state) {
removeErrorStates();
if (state != EnumErrorCode.OK) {
addErrorState(state);
}
}
@Deprecated
@Override
public IErrorState getErrorState() {
Set<IErrorState> errorStates = getErrorStates();
if (errorStates.size() == 0) {
return EnumErrorCode.OK;
} else {
return getErrorStates().iterator().next();
}
}
@Override
public float getExactTemperature() {
return biome.getFloatTemperature(xCoord, yCoord, zCoord);
}
@Override
public float getExactHumidity() {
return biome.rainfall;
}
/* UPDATING */
@Override
public void updateClientSide() {
if (isActive() && (displayQueen != null) && updateOnInterval(4)) {
displayQueen.doFX(logic.getEffectData(), this);
if (updateOnInterval(50)) {
float fxX = xCoord + 0.5F;
float fxY = yCoord + 0.25F + (worldObj.rand.nextFloat() * 6F) / 16F;
float fxZ = zCoord + 0.5F;
float f3 = 0.6F;
float f4 = worldObj.rand.nextFloat() * f3 - 0.5F;
Proxies.common.addEntitySwarmFX(worldObj, (fxX - f3), fxY, (fxZ + f4), 0F, 0F, 0F);
Proxies.common.addEntitySwarmFX(worldObj, (fxX + f3), fxY, (fxZ + f4), 0F, 0F, 0F);
Proxies.common.addEntitySwarmFX(worldObj, (fxX + f4), fxY, (fxZ - f3), 0F, 0F, 0F);
Proxies.common.addEntitySwarmFX(worldObj, (fxX + f4), fxY, (fxZ + f3), 0F, 0F, 0F);
}
}
}
@Override
public void updateServerSide() {
boolean canWork = logic.canWork();
setActive(canWork);
if (canWork) {
logic.doWork();
}
}
// @Override
public boolean isWorking() {
return !hasErrorState();
}
@Override
public boolean addProduct(ItemStack product, boolean all) {
return InvTools.tryAddStack(getInternalInventory(), product, SLOT_PRODUCT_1, SLOT_PRODUCT_COUNT, all, true);
}
/* NETWORK SYNCH */
@Override
public void onQueenChange(ItemStack queenStack) {
}
/* STATE INFORMATION */
private int getHealthDisplay() {
if (displayQueen == null) {
return 0;
}
if (displayQueen.getMate() != null) {
return displayQueen.getHealth();
} else {
return displayHealth;
}
}
private int getMaxHealthDisplay() {
if (displayQueen == null) {
return 0;
}
if (displayQueen.getMate() != null) {
return displayQueen.getMaxHealth();
} else {
return displayHealthMax;
}
}
/**
* Returns scaled queen health or breeding progress
*/
public int getHealthScaled(int i) {
if (getMaxHealthDisplay() == 0) {
return 0;
}
return (getHealthDisplay() * i) / getMaxHealthDisplay();
}
public void updateBiome() {
if (worldObj != null) {
BiomeGenBase biome = worldObj.getBiomeGenForCoordsBody(xCoord, zCoord);
if (biome != null) {
this.biome = biome;
}
}
}
/* SMP */
// @Override
public void getGUINetworkData(int i, int j) {
if (logic == null) {
return;
}
switch (i) {
case 0:
displayHealth = j;
break;
case 1:
displayHealthMax = j;
break;
}
}
// @Override
public void sendGUINetworkData(Container container, ICrafting iCrafting) {
if (logic == null) {
return;
}
iCrafting.sendProgressBarUpdate(container, 0, logic.getBreedingTime());
iCrafting.sendProgressBarUpdate(container, 1, logic.getTotalBreedingTime());
}
// / IBEEHOUSING
@Override
public int getXCoord() {
return xCoord;
}
@Override
public int getYCoord() {
return yCoord;
}
@Override
public int getZCoord() {
return zCoord;
}
@Override
public BiomeGenBase getBiome() {
return biome;
}
@Override
public ItemStack getQueen() {
return getStackInSlot(SLOT_QUEEN);
}
@Override
public ItemStack getDrone() {
return getStackInSlot(SLOT_DRONE);
}
@Override
public void setQueen(ItemStack itemstack) {
setInventorySlotContents(SLOT_QUEEN, itemstack);
}
@Override
public ItemStack decrStackSize(int slotIndex, int amount) {
ItemStack itemStack = super.decrStackSize(slotIndex, amount);
if (slotIndex == SLOT_QUEEN) {
handleQueenChange();
}
return itemStack;
}
@Override
public void setInventorySlotContents(int slotIndex, ItemStack itemStack) {
super.setInventorySlotContents(slotIndex, itemStack);
if (slotIndex == SLOT_QUEEN) {
handleQueenChange();
}
}
private void handleQueenChange() {
if (!Proxies.common.isSimulating(worldObj)) {
ItemStack itemStack = getStackInSlot(SLOT_QUEEN);
displayQueen = BeeManager.beeRoot.getMember(itemStack);
}
}
@Override
public void setDrone(ItemStack itemstack) {
setInventorySlotContents(SLOT_DRONE, itemstack);
}
@Override
public World getWorld() {
return worldObj;
}
@Override
public boolean canBreed() {
return true;
}
@Override
public float getTerritoryModifier(IBeeGenome genome, float currentModifier) {
return 1.0f;
}
@Override
public float getProductionModifier(IBeeGenome genome, float currentModifier) {
return 0.25f;
}
@Override
public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
return 0.0f;
}
@Override
public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
return 3.0f;
}
@Override
public float getFloweringModifier(IBeeGenome genome, float currentModifier) {
return 3.0f;
}
@Override
public float getGeneticDecay(IBeeGenome genome, float currentModifier) {
return 0.0f;
}
@Override
public void wearOutEquipment(int amount) {
}
@Override
public boolean isSealed() {
return false;
}
@Override
public boolean isSelfLighted() {
return false;
}
@Override
public boolean isSunlightSimulated() {
return false;
}
@Override
public boolean isHellish() {
return false;
}
@Override
public void onQueenDeath(IBee queen) {
}
@Override
public void onPostQueenDeath(IBee queen) {
}
@Override
public boolean onPollenRetrieved(IBee queen, IIndividual pollen, boolean isHandled) {
return false;
}
@Override
public boolean onEggLaid(IBee queen) {
return false;
}
/* IHousing */
@Override
public GameProfile getOwnerName() {
return this.getOwner();
}
@Override
public boolean isActive() {
return active;
}
@Override
public void setActive(boolean active) {
if (this.active == active) {
return;
}
this.active = active;
if (!worldObj.isRemote) {
Proxies.net.sendNetworkPacket(new PacketActiveUpdate(this));
}
}
protected static class BeehouseInventoryAdapter extends TileInventoryAdapter<TileBeehouse> {
public BeehouseInventoryAdapter(TileBeehouse tile, int size, String name) {
super(tile, size, name);
public static class BeehouseBeeModifier extends DefaultBeeModifier {
@Override
public float getTerritoryModifier(IBeeGenome genome, float currentModifier) {
return 1.0f;
}
@Override
public boolean canSlotAccept(int slotIndex, ItemStack itemStack) {
if (slotIndex == SLOT_QUEEN) {
return BeeManager.beeRoot.isMember(itemStack) && !BeeManager.beeRoot.isDrone(itemStack);
} else if (GuiUtil.isIndexInRange(slotIndex, SLOT_FRAMES_1, SLOT_FRAMES_COUNT)) {
return itemStack.getItem() instanceof IHiveFrame;
} else if (slotIndex == SLOT_DRONE) {
return BeeManager.beeRoot.isDrone(itemStack);
}
return false;
public float getProductionModifier(IBeeGenome genome, float currentModifier) {
return 0.25f;
}
@Override
public boolean canExtractItem(int slotIndex, ItemStack itemstack, int side) {
return GuiUtil.isIndexInRange(slotIndex, SLOT_PRODUCT_1, SLOT_PRODUCT_COUNT);
public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
return 0.0f;
}
@Override
public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
return 3.0f;
}
@Override
public float getFloweringModifier(IBeeGenome genome, float currentModifier) {
return 3.0f;
}
@Override
public float getGeneticDecay(IBeeGenome genome, float currentModifier) {
return 0.0f;
}
}
}
@@ -45,12 +45,6 @@ import forestry.core.render.TextureManager;
import forestry.core.utils.StackUtils;
public class AlleleBeeSpecies extends AlleleSpecies implements IAlleleBeeSpeciesCustom {
@Deprecated
private final Map<ItemStack, Integer> products = new HashMap<ItemStack, Integer>();
@Deprecated
private final Map<ItemStack, Integer> specialty = new HashMap<ItemStack, Integer>();
private final Map<ItemStack, Float> productChances = new HashMap<ItemStack, Float>();
private final Map<ItemStack, Float> specialtyChances = new HashMap<ItemStack, Float>();
@@ -85,8 +79,6 @@ public class AlleleBeeSpecies extends AlleleSpecies implements IAlleleBeeSpecies
throw new IllegalArgumentException("chance must be in the range (0, 1]");
}
this.productChances.put(product, chance);
int intChance = Math.max(1, Math.round(chance * 100));
this.products.put(product, intChance);
return this;
}
@@ -99,8 +91,6 @@ public class AlleleBeeSpecies extends AlleleSpecies implements IAlleleBeeSpecies
throw new IllegalArgumentException("chance must be in the range (0, 1]");
}
this.specialtyChances.put(specialty, chance);
int intChance = Math.max(1, Math.round(chance * 100));
this.specialty.put(specialty, intChance);
return this;
}
@@ -194,21 +184,11 @@ public class AlleleBeeSpecies extends AlleleSpecies implements IAlleleBeeSpecies
return nocturnal;
}
@Override
public Map<ItemStack, Integer> getProducts() {
return products;
}
@Override
public Map<ItemStack, Float> getProductChances() {
return productChances;
}
@Override
public Map<ItemStack, Integer> getSpecialty() {
return specialty;
}
@Override
public Map<ItemStack, Float> getSpecialtyChances() {
return specialtyChances;
@@ -14,6 +14,7 @@ import java.util.List;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.world.World;
import forestry.api.apiculture.IBeeGenome;
@@ -26,8 +27,8 @@ public class AlleleEffectCreeper extends AlleleEffectThrottled {
private static final int explosionChance = 50;
private static final byte defaultForce = 12;
private final byte indexExplosionTimer = 1;
private final byte indexExplosionForce = 2;
private static final byte indexExplosionTimer = 1;
private static final byte indexExplosionForce = 2;
public AlleleEffectCreeper() {
super("creeper", true, 20, false, true);
@@ -50,6 +51,7 @@ public class AlleleEffectCreeper extends AlleleEffectThrottled {
public IEffectData doEffect(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
World world = housing.getWorld();
ChunkCoordinates housingCoords = housing.getCoordinates();
if (isHalted(storedData, housing)) {
return storedData;
@@ -57,7 +59,7 @@ public class AlleleEffectCreeper extends AlleleEffectThrottled {
// If we are already triggered, we continue the explosion sequence.
if (storedData.getInteger(indexExplosionTimer) > 0) {
progressExplosion(storedData, world, housing.getXCoord(), housing.getYCoord(), housing.getZCoord());
progressExplosion(storedData, world, housingCoords.posX, housingCoords.posY, housingCoords.posZ);
return storedData;
}
@@ -94,7 +96,7 @@ public class AlleleEffectCreeper extends AlleleEffectThrottled {
continue;
}
world.playSoundEffect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord(), "mob.creeper", 4F,
world.playSoundEffect(housingCoords.posX, housingCoords.posY, housingCoords.posZ, "mob.creeper", 4F,
(1.0F + (world.rand.nextFloat() - world.rand.nextFloat()) * 0.2F) * 0.7F);
storedData.setInteger(indexExplosionTimer, 2); // Set explosion
// timer
@@ -103,7 +105,7 @@ public class AlleleEffectCreeper extends AlleleEffectThrottled {
return storedData;
}
private void progressExplosion(IEffectData storedData, World world, int x, int y, int z) {
private static void progressExplosion(IEffectData storedData, World world, int x, int y, int z) {
int explosionTimer = storedData.getInteger(indexExplosionTimer);
explosionTimer--;
@@ -3,11 +3,13 @@ package forestry.apiculture.genetics;
import java.util.Random;
import net.minecraft.block.Block;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.world.World;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.genetics.IEffectData;
import forestry.core.vect.IVect;
public class AlleleEffectFertile extends AlleleEffectThrottled {
@@ -25,29 +27,30 @@ public class AlleleEffectFertile extends AlleleEffectThrottled {
}
World world = housing.getWorld();
int territorySize[] = getModifiedArea(genome, housing);
ChunkCoordinates housingCoordinates = housing.getCoordinates();
IVect area = getModifiedArea(genome, housing);
int blockX = getRandomOffset(world.rand, housing.getXCoord(), territorySize[0]);
int blockZ = getRandomOffset(world.rand, housing.getZCoord(), territorySize[2]);
int blockMaxY = housing.getYCoord() + territorySize[1] / 2 + 1;
int blockMinY = housing.getYCoord() - (territorySize[1] / 2) - 1;
int blockX = getRandomOffset(world.rand, housingCoordinates.posX, area.getX());
int blockZ = getRandomOffset(world.rand, housingCoordinates.posZ, area.getZ());
int blockMaxY = housingCoordinates.posY + (area.getY() / 2) + 1;
int blockMinY = housingCoordinates.posY - (area.getY() / 2) - 1;
for (int attempt = 0; attempt < MAX_BLOCK_FIND_TRIES; ++attempt) {
if (tryTickColumn(world, blockX, blockZ, blockMaxY, blockMinY)) {
break;
}
blockX = getRandomOffset(world.rand, housing.getXCoord(), territorySize[0]);
blockZ = getRandomOffset(world.rand, housing.getZCoord(), territorySize[2]);
blockX = getRandomOffset(world.rand, housingCoordinates.posX, area.getX());
blockZ = getRandomOffset(world.rand, housingCoordinates.posZ, area.getZ());
}
return storedData;
}
private int getRandomOffset(Random random, int centrePos, int offset) {
private static int getRandomOffset(Random random, int centrePos, int offset) {
return centrePos + random.nextInt(offset) - (offset / 2);
}
private boolean tryTickColumn(World world, int x, int z, int maxY, int minY) {
private static boolean tryTickColumn(World world, int x, int z, int maxY, int minY) {
for (int y = maxY; y >= minY; --y) {
if (!world.isAirBlock(x, y, z)) {
Block block = world.getBlock(x, y, z);
@@ -8,6 +8,7 @@ import net.minecraft.entity.passive.EntityCow;
import net.minecraft.entity.passive.EntityMooshroom;
import net.minecraft.init.Blocks;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.world.World;
import net.minecraft.world.gen.feature.WorldGenBigMushroom;
@@ -15,6 +16,7 @@ import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.genetics.IEffectData;
import forestry.core.genetics.EffectData;
import forestry.core.vect.IVect;
public class AlleleEffectFungification extends AlleleEffectThrottled {
@@ -56,11 +58,12 @@ public class AlleleEffectFungification extends AlleleEffectThrottled {
private void doBlockEffect(IBeeGenome genome, IBeeHousing housing) {
World world = housing.getWorld();
int territorySize[] = getModifiedArea(genome, housing);
ChunkCoordinates housingCoordinates = housing.getCoordinates();
IVect area = getModifiedArea(genome, housing);
int blockX = getRandomOffset(world.rand, housing.getXCoord(), territorySize[0]);
int blockY = getRandomOffset(world.rand, housing.getYCoord(), territorySize[1]);
int blockZ = getRandomOffset(world.rand, housing.getZCoord(), territorySize[2]);
int blockX = getRandomOffset(world.rand, housingCoordinates.posX, area.getX());
int blockY = getRandomOffset(world.rand, housingCoordinates.posY, area.getY());
int blockZ = getRandomOffset(world.rand, housingCoordinates.posZ, area.getZ());
for (int attempt = 0; attempt < MAX_BLOCK_FIND_TRIES; ++attempt) {
Block block = world.getBlock(blockX, blockY, blockZ);
@@ -71,9 +74,9 @@ public class AlleleEffectFungification extends AlleleEffectThrottled {
doMushroomGrowth(block, world, blockX, blockY, blockZ);
break;
}
blockX = getRandomOffset(world.rand, housing.getXCoord(), territorySize[0]);
blockY = getRandomOffset(world.rand, housing.getYCoord(), territorySize[1]);
blockZ = getRandomOffset(world.rand, housing.getZCoord(), territorySize[2]);
blockX = getRandomOffset(world.rand, housingCoordinates.posX, area.getX());
blockY = getRandomOffset(world.rand, housingCoordinates.posY, area.getY());
blockZ = getRandomOffset(world.rand, housingCoordinates.posZ, area.getZ());
}
}
@@ -91,15 +94,15 @@ public class AlleleEffectFungification extends AlleleEffectThrottled {
}
}
private int getRandomOffset(Random random, int centrePos, int offset) {
private static int getRandomOffset(Random random, int centrePos, int offset) {
return centrePos + random.nextInt(offset) - (offset / 2);
}
private boolean isSuitableForMycelium(World world, Block block, int blockX, int blockY, int blockZ) {
private static boolean isSuitableForMycelium(World world, Block block, int blockX, int blockY, int blockZ) {
return block == Blocks.grass || (block == Blocks.dirt && world.canBlockSeeTheSky(blockX, blockY, blockZ));
}
private boolean isSuitableForGrowth(Block block) {
private static boolean isSuitableForGrowth(Block block) {
return block == Blocks.red_mushroom || block == Blocks.brown_mushroom;
}
@@ -114,7 +117,7 @@ public class AlleleEffectFungification extends AlleleEffectThrottled {
worldObj.spawnParticle("largeexplode", cow.posX, cow.posY + (double) (cow.height / 2.0F), cow.posZ, 0.0D, 0.0D, 0.0D);
}
private void doMushroomGrowth(Block block, World world, int blockX, int blockY, int blockZ) {
private static void doMushroomGrowth(Block block, World world, int blockX, int blockY, int blockZ) {
WorldGenBigMushroom giantMushroomGenerator;
if (block == Blocks.brown_mushroom) {
@@ -13,7 +13,6 @@ package forestry.apiculture.genetics;
import net.minecraft.block.Block;
import net.minecraft.init.Blocks;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
@@ -50,13 +49,12 @@ public class AlleleEffectGlacial extends AlleleEffectThrottled {
int[] areaAr = genome.getTerritory();
Vect area = new Vect(areaAr[0], areaAr[1], areaAr[2]);
Vect offset = new Vect(-Math.round(area.x / 2), -Math.round(area.y / 2), -Math.round(area.z / 2));
Vect housingCoords = new Vect(housing.getCoordinates());
for (int i = 0; i < 10; i++) {
Vect randomPos = new Vect(world.rand.nextInt(area.x), world.rand.nextInt(area.y), world.rand.nextInt(area.z));
Vect posBlock = randomPos.add(new Vect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord()));
posBlock = posBlock.add(offset);
Vect randomPos = Vect.getRandomPositionInArea(world.rand, area);
Vect posBlock = Vect.add(randomPos, housingCoords, offset);
// Freeze water
Block block = world.getBlock(posBlock.x, posBlock.y, posBlock.z);
@@ -21,6 +21,7 @@ import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.genetics.IEffectData;
import forestry.apiculture.items.ItemArmorApiarist;
import forestry.core.vect.IVect;
import forestry.plugins.PluginApiculture;
public class AlleleEffectIgnition extends AlleleEffectThrottled {
@@ -83,14 +84,12 @@ public class AlleleEffectIgnition extends AlleleEffectThrottled {
@Override
public IEffectData doFX(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
int[] area = getModifiedArea(genome, housing);
IVect area = getModifiedArea(genome, housing);
if (housing.getWorld().rand.nextBoolean()) {
PluginApiculture.proxy.addBeeHiveFX("particles/swarm_bee", housing.getWorld(), housing.getXCoord(), housing.getYCoord(),
housing.getZCoord(), genome.getPrimary().getIconColour(0), area[0], area[1], area[2]);
PluginApiculture.proxy.addBeeHiveFX("particles/swarm_bee", housing.getWorld(), housing.getCoordinates(), genome.getPrimary().getIconColour(0), area);
} else {
PluginApiculture.proxy.addBeeHiveFX("particles/ember", housing.getWorld(), housing.getXCoord(), housing.getYCoord(),
housing.getZCoord(), 0xffffff, area[0], area[1], area[2]);
PluginApiculture.proxy.addBeeHiveFX("particles/ember", housing.getWorld(), housing.getCoordinates(), 0xffffff, area);
}
return storedData;
}
@@ -22,6 +22,7 @@ import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.genetics.IEffectData;
import forestry.apiculture.items.ItemArmorApiarist;
import forestry.core.vect.IVect;
import forestry.plugins.PluginApiculture;
public class AlleleEffectMiasmic extends AlleleEffectThrottled {
@@ -78,14 +79,12 @@ public class AlleleEffectMiasmic extends AlleleEffectThrottled {
@Override
public IEffectData doFX(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
int[] area = getModifiedArea(genome, housing);
IVect area = getModifiedArea(genome, housing);
if (housing.getWorld().rand.nextBoolean()) {
PluginApiculture.proxy.addBeeHiveFX("particles/swarm_bee", housing.getWorld(), housing.getXCoord(), housing.getYCoord(),
housing.getZCoord(), genome.getPrimary().getIconColour(0), area[0], area[1], area[2]);
PluginApiculture.proxy.addBeeHiveFX("particles/swarm_bee", housing.getWorld(), housing.getCoordinates(), genome.getPrimary().getIconColour(0), area);
} else {
PluginApiculture.proxy.addBeeHiveFX("particles/poison", housing.getWorld(), housing.getXCoord(), housing.getYCoord(),
housing.getZCoord(), 0xffffff, area[0], area[1], area[2]);
PluginApiculture.proxy.addBeeHiveFX("particles/poison", housing.getWorld(), housing.getCoordinates(), 0xffffff, area);
}
return storedData;
}
@@ -13,8 +13,11 @@ package forestry.apiculture.genetics;
import forestry.api.apiculture.IAlleleBeeEffect;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.apiculture.IBeeModifier;
import forestry.api.genetics.IEffectData;
import forestry.apiculture.BeeHousingModifier;
import forestry.core.genetics.alleles.AlleleCategorized;
import forestry.core.vect.MutableVect;
import forestry.plugins.PluginApiculture;
public class AlleleEffectNone extends AlleleCategorized implements IAlleleBeeEffect {
@@ -41,23 +44,23 @@ public class AlleleEffectNone extends AlleleCategorized implements IAlleleBeeEff
@Override
public IEffectData doFX(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
int[] area = genome.getTerritory();
area[0] *= housing.getTerritoryModifier(genome, 1f);
area[1] *= housing.getTerritoryModifier(genome, 1f);
area[2] *= housing.getTerritoryModifier(genome, 1f);
IBeeModifier beeModifier = new BeeHousingModifier(housing);
float territoryModifier = beeModifier.getTerritoryModifier(genome, 1f);
if (area[0] < 1) {
area[0] = 1;
MutableVect area = new MutableVect(genome.getTerritory());
area.multiply(territoryModifier);
if (area.x < 1) {
area.x = 1;
}
if (area[1] < 1) {
area[1] = 1;
if (area.y < 1) {
area.y = 1;
}
if (area[2] < 1) {
area[2] = 1;
if (area.z < 1) {
area.z = 1;
}
PluginApiculture.proxy.addBeeHiveFX("particles/swarm_bee", housing.getWorld(), housing.getXCoord(), housing.getYCoord(),
housing.getZCoord(), genome.getPrimary().getIconColour(0), area[0], area[1], area[2]);
PluginApiculture.proxy.addBeeHiveFX("particles/swarm_bee", housing.getWorld(), housing.getCoordinates(), genome.getPrimary().getIconColour(0), area);
return storedData;
}
@@ -25,8 +25,8 @@ import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.genetics.IEffectData;
import forestry.apiculture.gadgets.BlockAlveary;
import forestry.apiculture.gadgets.TileAlveary;
import forestry.apiculture.items.ItemArmorApiarist;
import forestry.apiculture.multiblock.TileAlveary;
import forestry.core.utils.DamageSourceForestry;
import forestry.core.vect.Vect;
@@ -52,8 +52,8 @@ public class AlleleEffectRadioactive extends AlleleEffectThrottled {
Vect offset = new Vect(-Math.round(area.x / 2), -Math.round(area.y / 2), -Math.round(area.z / 2));
// Radioactivity hurts players and mobs
Vect min = new Vect(housing.getXCoord() + offset.x, housing.getYCoord() + offset.y, housing.getZCoord() + offset.z);
Vect max = new Vect(housing.getXCoord() + offset.x + area.x, housing.getYCoord() + offset.y + area.y, housing.getZCoord() + offset.z + area.z);
Vect min = new Vect(housing.getCoordinates()).add(offset);
Vect max = min.add(area);
AxisAlignedBB hurtBox = AxisAlignedBB.getBoundingBox(min.x, min.y, min.z, max.x, max.y, max.z);
@@ -91,15 +91,16 @@ public class AlleleEffectRadioactive extends AlleleEffectThrottled {
Vect randomPos = new Vect(rand.nextInt(area.x), rand.nextInt(area.y), rand.nextInt(area.z));
Vect posBlock = randomPos.add(new Vect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord()));
Vect posHousing = new Vect(housing.getCoordinates());
Vect posBlock = randomPos.add(posHousing);
posBlock = posBlock.add(offset);
if (posBlock.y <= 1 || posBlock.y >= housing.getWorld().getActualHeight()) {
continue;
}
// Don't destroy ourself and blocks below us.
if (posBlock.x == housing.getXCoord() && posBlock.z == housing.getZCoord() && posBlock.y <= housing.getYCoord()) {
// Don't destroy ourselves or blocks below us.
if (posBlock.x == posHousing.x && posBlock.z == posHousing.z && posBlock.y <= posHousing.y) {
continue;
}
@@ -32,7 +32,7 @@ public class AlleleEffectRepulsion extends AlleleEffectThrottled {
return storedData;
}
if (housing.getOwnerName() == null) {
if (housing.getOwner() == null) {
return storedData;
}
@@ -11,8 +11,8 @@
package forestry.apiculture.genetics;
import net.minecraft.init.Blocks;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraftforge.common.util.ForgeDirection;
@@ -21,6 +21,7 @@ import forestry.api.apiculture.IBeeHousing;
import forestry.api.core.EnumTemperature;
import forestry.api.genetics.IEffectData;
import forestry.core.proxy.Proxies;
import forestry.core.vect.IVect;
import forestry.core.vect.Vect;
public class AlleleEffectSnowing extends AlleleEffectThrottled {
@@ -56,7 +57,7 @@ public class AlleleEffectSnowing extends AlleleEffectThrottled {
Vect randomPos = new Vect(world.rand.nextInt(area.x), world.rand.nextInt(area.y), world.rand.nextInt(area.z));
Vect posBlock = randomPos.add(new Vect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord()));
Vect posBlock = randomPos.add(new Vect(housing.getCoordinates()));
posBlock = posBlock.add(offset);
// Put snow on the ground
@@ -77,9 +78,18 @@ public class AlleleEffectSnowing extends AlleleEffectThrottled {
@Override
public IEffectData doFX(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
if (housing.getWorld().rand.nextInt(3) == 0) {
int[] area = getModifiedArea(genome, housing);
Proxies.render.addSnowFX(housing.getWorld(), housing.getXCoord(), housing.getYCoord(), housing.getZCoord(), genome.getPrimary().getIconColour(0), area[0], area[1], area[2]);
IVect area = getModifiedArea(genome, housing);
ChunkCoordinates coordinates = housing.getCoordinates();
World world = housing.getWorld();
double spawnX = coordinates.posX + world.rand.nextInt(area.getX() * 2) - area.getX();
double spawnY = coordinates.posY + world.rand.nextInt(area.getY());
double spawnZ = coordinates.posZ + world.rand.nextInt(area.getZ() * 2) - area.getZ();
Proxies.common.addEntitySnowFX(world, spawnX, spawnY, spawnZ, 0F, 0F, 0F);
}
return storedData;
}
}
@@ -15,10 +15,13 @@ import net.minecraft.util.AxisAlignedBB;
import forestry.api.apiculture.IAlleleBeeEffect;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.apiculture.IBeeModifier;
import forestry.api.genetics.IEffectData;
import forestry.core.EnumErrorCode;
import forestry.apiculture.BeeHousingModifier;
import forestry.core.genetics.EffectData;
import forestry.core.genetics.alleles.AlleleCategorized;
import forestry.core.vect.IVect;
import forestry.core.vect.MutableVect;
import forestry.core.vect.Vect;
import forestry.plugins.PluginApiculture;
@@ -55,7 +58,7 @@ public abstract class AlleleEffectThrottled extends AlleleCategorized implements
public boolean isHalted(IEffectData storedData, IBeeHousing housing) {
if (requiresWorkingQueen && housing.getErrorState() != EnumErrorCode.OK) {
if (requiresWorkingQueen && housing.getErrorLogic().hasErrors()) {
return true;
}
@@ -75,27 +78,27 @@ public abstract class AlleleEffectThrottled extends AlleleCategorized implements
@Override
public IEffectData doFX(IBeeGenome genome, IEffectData storedData, IBeeHousing housing) {
int[] area = getModifiedArea(genome, housing);
IVect area = getModifiedArea(genome, housing);
PluginApiculture.proxy.addBeeHiveFX("particles/swarm_bee", housing.getWorld(), housing.getXCoord(), housing.getYCoord(),
housing.getZCoord(), genome.getPrimary().getIconColour(0), area[0], area[1], area[2]);
PluginApiculture.proxy.addBeeHiveFX("particles/swarm_bee", housing.getWorld(), housing.getCoordinates(), genome.getPrimary().getIconColour(0), area);
return storedData;
}
protected int[] getModifiedArea(IBeeGenome genome, IBeeHousing housing) {
int[] area = genome.getTerritory();
area[0] *= housing.getTerritoryModifier(genome, 1f) * 3;
area[1] *= housing.getTerritoryModifier(genome, 1f) * 3;
area[2] *= housing.getTerritoryModifier(genome, 1f) * 3;
protected IVect getModifiedArea(IBeeGenome genome, IBeeHousing housing) {
IBeeModifier beeModifier = new BeeHousingModifier(housing);
float territoryModifier = beeModifier.getTerritoryModifier(genome, 1f);
if (area[0] < 1) {
area[0] = 1;
MutableVect area = new MutableVect(genome.getTerritory());
area.multiply(territoryModifier * 3);
if (area.x < 1) {
area.x = 1;
}
if (area[1] < 1) {
area[1] = 1;
if (area.y < 1) {
area.y = 1;
}
if (area[2] < 1) {
area[2] = 1;
if (area.z < 1) {
area.z = 1;
}
return area;
@@ -106,9 +109,8 @@ public abstract class AlleleEffectThrottled extends AlleleCategorized implements
Vect area = new Vect(areaAr[0], areaAr[1], areaAr[2]).multiply(modifier);
Vect offset = new Vect(-Math.round(area.x / 2), -Math.round(area.y / 2), -Math.round(area.z / 2));
// Radioactivity hurts players and mobs
Vect min = new Vect(housing.getXCoord() + offset.x, housing.getYCoord() + offset.y, housing.getZCoord() + offset.z);
Vect max = new Vect(housing.getXCoord() + offset.x + area.x, housing.getYCoord() + offset.y + area.y, housing.getZCoord() + offset.z + area.z);
Vect min = new Vect(housing.getCoordinates()).add(offset);
Vect max = min.add(area);
return AxisAlignedBB.getBoundingBox(min.x, min.y, min.z, max.x, max.y, max.z);
}
+76 -77
View File
@@ -10,6 +10,11 @@
******************************************************************************/
package forestry.apiculture.genetics;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import javax.annotation.Nonnull;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
@@ -21,6 +26,7 @@ import net.minecraft.item.EnumRarity;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.util.EnumChatFormatting;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
@@ -35,6 +41,7 @@ import forestry.api.apiculture.IApiaristTracker;
import forestry.api.apiculture.IBee;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.apiculture.IBeeModifier;
import forestry.api.apiculture.IBeeMutation;
import forestry.api.apiculture.IBeekeepingMode;
import forestry.api.core.BiomeHelper;
@@ -43,7 +50,6 @@ import forestry.api.core.EnumTemperature;
import forestry.api.core.IErrorState;
import forestry.api.genetics.AlleleManager;
import forestry.api.genetics.IAllele;
import forestry.api.genetics.IAlleleSpecies;
import forestry.api.genetics.IAlleleTolerance;
import forestry.api.genetics.IChromosome;
import forestry.api.genetics.IEffectData;
@@ -51,6 +57,7 @@ import forestry.api.genetics.IFlowerProvider;
import forestry.api.genetics.IIndividual;
import forestry.api.genetics.IMutation;
import forestry.api.genetics.IPollinatable;
import forestry.apiculture.BeeHousingModifier;
import forestry.arboriculture.genetics.FakePollinatable;
import forestry.arboriculture.genetics.ICheckPollinatable;
import forestry.core.EnumErrorCode;
@@ -62,7 +69,6 @@ import forestry.core.genetics.IndividualLiving;
import forestry.core.proxy.Proxies;
import forestry.core.utils.GeneticsUtil;
import forestry.core.utils.StringUtil;
import forestry.core.vect.MutableVect;
import forestry.core.vect.Vect;
public class Bee extends IndividualLiving implements IBee {
@@ -73,8 +79,24 @@ public class Bee extends IndividualLiving implements IBee {
public IBeeGenome genome;
public IBeeGenome mate;
private static final LoadingCache<NBTTagCompound, Bee> getBeeCache = CacheBuilder.newBuilder()
.maximumSize(128)
.build(new CacheLoader<NBTTagCompound, Bee>() {
@Override
public Bee load(@Nonnull NBTTagCompound tagCompound) {
return new Bee(tagCompound);
}
});
/* CONSTRUCTOR */
public Bee(NBTTagCompound nbttagcompound) {
public static Bee fromNBT(NBTTagCompound nbtTagCompound) {
if (nbtTagCompound == null) {
return null;
}
return getBeeCache.getUnchecked(nbtTagCompound);
}
private Bee(NBTTagCompound nbttagcompound) {
readFromNBT(nbttagcompound);
}
@@ -252,8 +274,10 @@ public class Bee extends IndividualLiving implements IBee {
Set<IErrorState> errorStates = new HashSet<IErrorState>();
IBeeModifier beeModifier = new BeeHousingModifier(housing);
// / Rain needs tolerant flyers
if (world.isRaining() && !genome.getTolerantFlyer() && BiomeHelper.canRainOrSnow(biome) && !housing.isSealed()) {
if (world.isRaining() && !genome.getTolerantFlyer() && BiomeHelper.canRainOrSnow(biome) && !beeModifier.isSealed()) {
errorStates.add(EnumErrorCode.ISRAINING);
}
@@ -262,21 +286,20 @@ public class Bee extends IndividualLiving implements IBee {
if (!canWorkDuringDay()) {
errorStates.add(EnumErrorCode.NOTNIGHT);
}
} else if (!canWorkAtNight() && !housing.isSelfLighted()) {
} else if (!canWorkAtNight() && !beeModifier.isSelfLighted()) {
errorStates.add(EnumErrorCode.NOTDAY);
}
if (world.getBlockLightValue(housing.getXCoord(), housing.getYCoord() + 2, housing.getZCoord()) > Defaults.APIARY_MIN_LEVEL_LIGHT) {
if (housing.getBlockLightValue() > Defaults.APIARY_MIN_LEVEL_LIGHT) {
if (!canWorkDuringDay()) {
errorStates.add(EnumErrorCode.NOTGLOOMY);
}
} else if (!canWorkAtNight() && !housing.isSelfLighted()) {
} else if (!canWorkAtNight() && !beeModifier.isSelfLighted()) {
errorStates.add(EnumErrorCode.NOTLUCID);
}
// / No sky, except if in hell
if (biome != null && !BiomeHelper.isBiomeHellish(biome) && !world.canBlockSeeTheSky(housing.getXCoord(), housing.getYCoord() + 3, housing.getZCoord())
&& !genome.getCaveDwelling() && !housing.isSunlightSimulated()) {
if (biome != null && !BiomeHelper.isBiomeHellish(biome) && !housing.canBlockSeeTheSky() && !genome.getCaveDwelling() && !beeModifier.isSunlightSimulated()) {
errorStates.add(EnumErrorCode.NOSKY);
}
@@ -288,16 +311,6 @@ public class Bee extends IndividualLiving implements IBee {
return errorStates;
}
@Override
public IErrorState canWork(IBeeHousing housing) {
Set<IErrorState> errorStates = getCanWork(housing);
if (errorStates.size() == 0) {
return EnumErrorCode.OK;
} else {
return errorStates.iterator().next();
}
}
private boolean canWorkAtNight() {
return genome.getPrimary().isNocturnal() || genome.getNocturnal();
}
@@ -322,32 +335,6 @@ public class Bee extends IndividualLiving implements IBee {
genome.getPrimary().getHumidity(), genome.getToleranceHumid());
}
@Override
public boolean hasFlower(IBeeHousing housing) {
IFlowerProvider provider = genome.getFlowerProvider();
Vect housingPos = new Vect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord());
Vect area = getArea(genome, housing);
Vect offset = new Vect(-area.x / 2, -area.y / 2, -area.z / 2);
boolean hasFlower = false;
MutableVect posCurrent = new MutableVect(0, 0, 0);
while (posCurrent.advancePositionInArea(area)) {
Vect posBlock = Vect.add(housingPos, posCurrent, offset);
if (provider.isAcceptedFlower(housing.getWorld(), this, posBlock.x, posBlock.y, posBlock.z)) {
hasFlower = true;
break;
}
}
return hasFlower;
}
@Override
public ArrayList<BiomeGenBase> getSuitableBiomes() {
ArrayList<BiomeGenBase> suitableBiomes = new ArrayList<BiomeGenBase>();
@@ -427,7 +414,8 @@ public class Bee extends IndividualLiving implements IBee {
@Override
public void age(World world, float housingLifespanModifier) {
IBeekeepingMode mode = BeeManager.beeRoot.getBeekeepingMode(world);
float finalModifier = housingLifespanModifier * mode.getLifespanModifier(genome, mate, housingLifespanModifier);
IBeeModifier beeModifier = mode.getBeeModifier();
float finalModifier = housingLifespanModifier * beeModifier.getLifespanModifier(genome, mate, housingLifespanModifier);
super.age(world, finalModifier);
}
@@ -440,9 +428,9 @@ public class Bee extends IndividualLiving implements IBee {
IAlleleBeeSpecies primary = genome.getPrimary();
IAlleleBeeSpecies secondary = genome.getSecondary();
products.addAll(primary.getProducts().keySet());
products.addAll(primary.getProductChances().keySet());
Set<ItemStack> secondaryProducts = secondary.getProducts().keySet();
Set<ItemStack> secondaryProducts = secondary.getProductChances().keySet();
// Remove duplicates
for (ItemStack second : secondaryProducts) {
boolean skip = false;
@@ -465,7 +453,7 @@ public class Bee extends IndividualLiving implements IBee {
@Override
public ItemStack[] getSpecialtyList() {
Set<ItemStack> specialties = genome.getPrimary().getSpecialty().keySet();
Set<ItemStack> specialties = genome.getPrimary().getSpecialtyChances().keySet();
return specialties.toArray(new ItemStack[specialties.size()]);
}
@@ -491,33 +479,37 @@ public class Bee extends IndividualLiving implements IBee {
setIsNatural(false);
}
IBeeModifier beeHousingModifier = new BeeHousingModifier(housing);
IBeeModifier beeModeModifier = mode.getBeeModifier();
// Bee genetic speed * beehousing * beekeeping mode
float speed = genome.getSpeed() * housing.getProductionModifier(genome, 1f) * mode.getProductionModifier(genome, 1f);
float speed = genome.getSpeed() * beeHousingModifier.getProductionModifier(genome, 1f) * beeModeModifier.getProductionModifier(genome, 1f);
// / Primary Products
for (Map.Entry<ItemStack, Integer> entry : primary.getProducts().entrySet()) {
if (housing.getWorld().rand.nextInt(100) < entry.getValue() * speed) {
for (Map.Entry<ItemStack, Float> entry : primary.getProductChances().entrySet()) {
if (housing.getWorld().rand.nextFloat() < entry.getValue() * speed) {
products.add(entry.getKey().copy());
}
}
// / Secondary Products
for (Map.Entry<ItemStack, Integer> entry : secondary.getProducts().entrySet()) {
if (housing.getWorld().rand.nextInt(100) < Math.round(entry.getValue() / 2) * speed) {
for (Map.Entry<ItemStack, Float> entry : secondary.getProductChances().entrySet()) {
if (housing.getWorld().rand.nextFloat() < Math.round(entry.getValue() / 2) * speed) {
products.add(entry.getKey().copy());
}
}
// / Specialty products
if (primary.isJubilant(genome, housing) && secondary.isJubilant(genome, housing)) {
for (Map.Entry<ItemStack, Integer> entry : primary.getSpecialty().entrySet()) {
if (housing.getWorld().rand.nextInt(100) < entry.getValue() * speed) {
for (Map.Entry<ItemStack, Float> entry : primary.getSpecialtyChances().entrySet()) {
if (housing.getWorld().rand.nextFloat() < entry.getValue() * speed) {
products.add(entry.getKey().copy());
}
}
}
ItemStack[] productsArray = products.toArray(new ItemStack[products.size()]);
return genome.getFlowerProvider().affectProducts(housing.getWorld(), this, housing.getXCoord(), housing.getYCoord(), housing.getZCoord(), productsArray);
ChunkCoordinates housingCoordinates = housing.getCoordinates();
return genome.getFlowerProvider().affectProducts(housing.getWorld(), this, housingCoordinates.posX, housingCoordinates.posY, housingCoordinates.posZ, productsArray);
}
/* REPRODUCTION */
@@ -547,10 +539,10 @@ public class Bee extends IndividualLiving implements IBee {
return null;
}
ArrayList<IBee> bees = new ArrayList<IBee>();
List<IBee> bees = new ArrayList<IBee>();
int toCreate = BeeManager.beeRoot.getBeekeepingMode(world).getFinalFertility(this, world, housing.getXCoord(), housing.getYCoord(),
housing.getZCoord());
ChunkCoordinates housingCoordinates = housing.getCoordinates();
int toCreate = BeeManager.beeRoot.getBeekeepingMode(world).getFinalFertility(this, world, housingCoordinates.posX, housingCoordinates.posY, housingCoordinates.posZ);
if (toCreate <= 0) {
toCreate = 1;
@@ -609,8 +601,9 @@ public class Bee extends IndividualLiving implements IBee {
IBeeGenome genome0;
IBeeGenome genome1;
IAlleleSpecies allele0;
IAlleleSpecies allele1;
IAlleleBeeSpecies allele0;
IAlleleBeeSpecies allele1;
if (world.rand.nextBoolean()) {
allele0 = (IAlleleBeeSpecies) parent1[EnumBeeChromosome.SPECIES.ordinal()].getPrimaryAllele();
@@ -626,7 +619,7 @@ public class Bee extends IndividualLiving implements IBee {
genome1 = genomeOne;
}
GameProfile playerProfile = housing.getOwnerName();
GameProfile playerProfile = housing.getOwner();
IApiaristTracker breedingTracker = BeeManager.beeRoot.getBreedingTracker(world, playerProfile);
List<IMutation> combinations = BeeManager.beeRoot.getCombinations(allele0, allele1, true);
@@ -646,8 +639,8 @@ public class Bee extends IndividualLiving implements IBee {
}
if (chance > world.rand.nextFloat() * 100) {
breedingTracker.registerMutation(beeMutation);
return BeeManager.beeRoot.templateAsChromosomes(beeMutation.getTemplate());
breedingTracker.registerMutation(mutation);
return BeeManager.beeRoot.templateAsChromosomes(mutation.getTemplate());
}
}
@@ -658,7 +651,9 @@ public class Bee extends IndividualLiving implements IBee {
@Override
public IIndividual retrievePollen(IBeeHousing housing) {
int chance = Math.round(genome.getFlowering() * housing.getFloweringModifier(getGenome(), 1f));
IBeeModifier beeModifier = new BeeHousingModifier(housing);
int chance = Math.round(genome.getFlowering() * beeModifier.getFloweringModifier(getGenome(), 1f));
World world = housing.getWorld();
Random random = world.rand;
@@ -668,9 +663,9 @@ public class Bee extends IndividualLiving implements IBee {
return null;
}
Vect area = getArea(genome, housing);
Vect area = getArea(genome, beeModifier);
Vect offset = new Vect(-area.x / 2, -area.y / 4, -area.z / 2);
Vect housingPos = new Vect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord());
Vect housingPos = new Vect(housing.getCoordinates());
IIndividual pollen = null;
@@ -699,7 +694,9 @@ public class Bee extends IndividualLiving implements IBee {
@Override
public boolean pollinateRandom(IBeeHousing housing, IIndividual pollen) {
int chance = (int) (genome.getFlowering() * housing.getFloweringModifier(getGenome(), 1f));
IBeeModifier beeModifier = new BeeHousingModifier(housing);
int chance = (int) (genome.getFlowering() * beeModifier.getFloweringModifier(getGenome(), 1f));
World world = housing.getWorld();
Random random = world.rand;
@@ -709,9 +706,9 @@ public class Bee extends IndividualLiving implements IBee {
return false;
}
Vect area = getArea(genome, housing);
Vect area = getArea(genome, beeModifier);
Vect offset = new Vect(-area.x / 2, -area.y / 4, -area.z / 2);
Vect housingPos = new Vect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord());
Vect housingPos = new Vect(housing.getCoordinates());
for (int i = 0; i < 30; i++) {
@@ -730,7 +727,7 @@ public class Bee extends IndividualLiving implements IBee {
continue;
}
IPollinatable realPollinatable = GeneticsUtil.getOrCreatePollinatable(housing.getOwnerName(), world, posBlock.x, posBlock.y, posBlock.z);
IPollinatable realPollinatable = GeneticsUtil.getOrCreatePollinatable(housing.getOwner(), world, posBlock.x, posBlock.y, posBlock.z);
if (realPollinatable != null) {
realPollinatable.mateWith(pollen);
@@ -744,7 +741,9 @@ public class Bee extends IndividualLiving implements IBee {
@Override
public void plantFlowerRandom(IBeeHousing housing) {
int chance = Math.round(genome.getFlowering() * housing.getFloweringModifier(getGenome(), 1f));
IBeeModifier beeModifier = new BeeHousingModifier(housing);
int chance = Math.round(genome.getFlowering() * beeModifier.getFloweringModifier(getGenome(), 1f));
World world = housing.getWorld();
Random random = world.rand;
@@ -756,9 +755,9 @@ public class Bee extends IndividualLiving implements IBee {
// Gather required info
IFlowerProvider provider = genome.getFlowerProvider();
Vect area = getArea(genome, housing);
Vect area = getArea(genome, beeModifier);
Vect offset = new Vect(-area.x / 2, -area.y / 4, -area.z / 2);
Vect housingPos = new Vect(housing.getXCoord(), housing.getYCoord(), housing.getZCoord());
Vect housingPos = new Vect(housing.getCoordinates());
for (int i = 0; i < 10; i++) {
Vect randomPos = Vect.getRandomPositionInArea(random, area);
@@ -770,9 +769,9 @@ public class Bee extends IndividualLiving implements IBee {
}
}
private static Vect getArea(IBeeGenome genome, IBeeHousing housing) {
private static Vect getArea(IBeeGenome genome, IBeeModifier beeModifier) {
int[] genomeTerritory = genome.getTerritory();
float housingModifier = housing.getTerritoryModifier(genome, 1f);
float housingModifier = beeModifier.getTerritoryModifier(genome, 1f);
return new Vect(genomeTerritory).multiply(housingModifier * 3.0f);
}
}
@@ -108,8 +108,7 @@ public enum BeeBranchDefinition {
Allele.helper.set(alleles, EnumBeeChromosome.CAVE_DWELLING, true);
Allele.helper.set(alleles, EnumBeeChromosome.FLOWER_PROVIDER, EnumAllele.Flowers.WHEAT);
}
}
;
};
private final IClassification branch;
@@ -505,7 +505,6 @@ public enum BeeDefinition implements IBeeDefinition {
}
},
SPECTRAL(BeeBranchDefinition.END, "idolum", true, new Color(0xa98bed), new Color(0xd9de9e)) {
@Override
protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 8), 0.50f)
@@ -523,7 +522,6 @@ public enum BeeDefinition implements IBeeDefinition {
}
},
PHANTASMAL(BeeBranchDefinition.END, "lemur", false, new Color(0xcc00fa), new Color(0xd9de9e)) {
@Override
protected void setSpeciesProperties(IAlleleBeeSpeciesCustom beeSpecies) {
beeSpecies.addProduct(ForestryItem.beeComb.getItemStack(1, 8), 0.40f)
@@ -12,16 +12,13 @@ package forestry.apiculture.genetics;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import forestry.api.apiculture.BeeManager;
import forestry.api.apiculture.EnumBeeChromosome;
import forestry.api.apiculture.IAlleleBeeEffect;
import forestry.api.apiculture.IAlleleBeeSpecies;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.genetics.AlleleManager;
import forestry.api.genetics.EnumTolerance;
import forestry.api.genetics.IAllele;
import forestry.api.genetics.IAlleleFloat;
import forestry.api.genetics.IAlleleFlowers;
import forestry.api.genetics.IAlleleInteger;
@@ -29,7 +26,6 @@ import forestry.api.genetics.IAlleleSpecies;
import forestry.api.genetics.IChromosome;
import forestry.api.genetics.IFlowerProvider;
import forestry.api.genetics.ISpeciesRoot;
import forestry.core.genetics.Chromosome;
import forestry.core.genetics.Genome;
import forestry.core.genetics.alleles.AlleleArea;
import forestry.core.genetics.alleles.AlleleBoolean;
@@ -29,7 +29,6 @@ import forestry.api.apiculture.BeeManager;
import forestry.api.apiculture.EnumBeeChromosome;
import forestry.api.apiculture.EnumBeeType;
import forestry.api.apiculture.IAlleleBeeSpecies;
import forestry.api.apiculture.IAlvearyComponent;
import forestry.api.apiculture.IApiaristTracker;
import forestry.api.apiculture.IBee;
import forestry.api.apiculture.IBeeGenome;
@@ -38,14 +37,12 @@ import forestry.api.apiculture.IBeeMutation;
import forestry.api.apiculture.IBeeRoot;
import forestry.api.apiculture.IBeekeepingLogic;
import forestry.api.apiculture.IBeekeepingMode;
import forestry.api.core.IStructureLogic;
import forestry.api.genetics.AlleleManager;
import forestry.api.genetics.IAllele;
import forestry.api.genetics.IChromosomeType;
import forestry.api.genetics.IIndividual;
import forestry.api.genetics.IMutation;
import forestry.apiculture.BeekeepingLogic;
import forestry.apiculture.gadgets.StructureLogicAlveary;
import forestry.core.config.ForestryItem;
import forestry.core.genetics.SpeciesRoot;
import forestry.plugins.PluginApiculture;
@@ -167,12 +164,12 @@ public class BeeHelper extends SpeciesRoot implements IBeeRoot {
return null;
}
return new Bee(stack.getTagCompound());
return Bee.fromNBT(stack.getTagCompound());
}
@Override
public IBee getMember(NBTTagCompound compound) {
return new Bee(compound);
return Bee.fromNBT(compound);
}
@Override
@@ -255,8 +252,8 @@ public class BeeHelper extends SpeciesRoot implements IBeeRoot {
}
/* BREEDING MODES */
final ArrayList<IBeekeepingMode> beekeepingModes = new ArrayList<IBeekeepingMode>();
public static IBeekeepingMode activeBeekeepingMode;
private final ArrayList<IBeekeepingMode> beekeepingModes = new ArrayList<IBeekeepingMode>();
private static IBeekeepingMode activeBeekeepingMode;
@Override
public void resetBeekeepingMode() {
@@ -329,11 +326,6 @@ public class BeeHelper extends SpeciesRoot implements IBeeRoot {
return new BeekeepingLogic(housing);
}
@Override
public IStructureLogic createAlvearyStructureLogic(IAlvearyComponent structure) {
return new StructureLogicAlveary(structure);
}
@Override
public IChromosomeType[] getKaryotype() {
return EnumBeeChromosome.values();
+12 -11
View File
@@ -10,16 +10,18 @@
******************************************************************************/
package forestry.apiculture.genetics;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.world.World;
import forestry.api.apiculture.BeeManager;
import forestry.api.apiculture.IAlleleBeeSpecies;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.apiculture.IBeeModifier;
import forestry.api.apiculture.IBeeMutationCustom;
import forestry.api.apiculture.IBeeRoot;
import forestry.api.genetics.IAllele;
import forestry.api.genetics.IGenome;
import forestry.apiculture.BeeHousingModifier;
import forestry.core.genetics.Mutation;
public class BeeMutation extends Mutation implements IBeeMutationCustom {
@@ -33,25 +35,24 @@ public class BeeMutation extends Mutation implements IBeeMutationCustom {
return BeeManager.beeRoot;
}
@Override
public float getChance(IBeeHousing housing, IAllele allele0, IAllele allele1, IGenome genome0, IGenome genome1) {
return getChance(housing, (IAlleleBeeSpecies) allele0, (IAlleleBeeSpecies) allele1, (IBeeGenome) genome0, (IBeeGenome) genome1);
}
@Override
public float getChance(IBeeHousing housing, IAlleleBeeSpecies allele0, IAlleleBeeSpecies allele1, IBeeGenome genome0, IBeeGenome genome1) {
World world = housing.getWorld();
int x = housing.getXCoord();
int y = housing.getYCoord();
int z = housing.getZCoord();
ChunkCoordinates housingCoordinates = housing.getCoordinates();
int x = housingCoordinates.posX;
int y = housingCoordinates.posY;
int z = housingCoordinates.posZ;
float processedChance = super.getChance(world, x, y, z, allele0, allele1, genome0, genome1);
if (processedChance <= 0) {
return 0;
}
processedChance *= housing.getMutationModifier(genome0, genome1, 1f);
processedChance *= BeeManager.beeRoot.getBeekeepingMode(world).getMutationModifier(genome0, genome1, 1f);
IBeeModifier beeHousingModifier = new BeeHousingModifier(housing);
IBeeModifier beeModeModifier = BeeManager.beeRoot.getBeekeepingMode(world).getBeeModifier();
processedChance *= beeHousingModifier.getMutationModifier(genome0, genome1, processedChance);
processedChance *= beeModeModifier.getMutationModifier(genome0, genome1, processedChance);
return processedChance;
}
@@ -16,10 +16,13 @@ import java.util.Random;
import net.minecraft.world.World;
import forestry.api.apiculture.DefaultBeeModifier;
import forestry.api.apiculture.IBee;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.apiculture.IBeeModifier;
import forestry.api.apiculture.IBeekeepingMode;
import forestry.apiculture.BeeHousingModifier;
public class BeekeepingMode implements IBeekeepingMode {
@@ -29,22 +32,18 @@ public class BeekeepingMode implements IBeekeepingMode {
public static final IBeekeepingMode hardcore = new BeekeepingMode("HARDCORE", 0.5f, 5.0f, 0.8f, true, true);
public static final IBeekeepingMode insane = new BeekeepingMode("INSANE", 0.2f, 10.0f, 0.6f, true, true);
final Random rand;
final String name;
final float mutationModifier;
final float lifespanModifier;
final float speedModifier;
final boolean reducesFertility;
final boolean canFatigue;
private final Random rand;
private final String name;
private final boolean reducesFertility;
private final boolean canFatigue;
private final IBeeModifier beeModifier;
public BeekeepingMode(String name, float mutationModifier, float lifespanModifier, float speedModifier, boolean reducesFertility, boolean canFatigue) {
this.rand = new Random();
this.name = name;
this.mutationModifier = mutationModifier;
this.lifespanModifier = lifespanModifier;
this.speedModifier = speedModifier;
this.reducesFertility = reducesFertility;
this.canFatigue = canFatigue;
this.beeModifier = new BeekeepingModeBeeModifier(mutationModifier, lifespanModifier, speedModifier);
}
@Override
@@ -64,36 +63,6 @@ public class BeekeepingMode implements IBeekeepingMode {
return 1.0f;
}
@Override
public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
return this.mutationModifier;
}
@Override
public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
return this.lifespanModifier;
}
@Override
public float getProductionModifier(IBeeGenome genome, float currentModifier) {
return this.speedModifier;
}
@Override
public float getTerritoryModifier(IBeeGenome genome, float currentModifier) {
return 1.0f;
}
@Override
public float getFloweringModifier(IBeeGenome genome, float currentModifier) {
return 1.0f;
}
@Override
public float getGeneticDecay(IBeeGenome genome, float currentModifier) {
return 1.0f;
}
@Override
public int getFinalFertility(IBee queen, World world, int x, int y, int z) {
int toCreate = queen.getGenome().getFertility();
@@ -115,17 +84,17 @@ public class BeekeepingMode implements IBeekeepingMode {
return false;
}
if (queen.getGeneration() > 96 + rand.nextInt(6) + rand.nextInt(6) &&
rand.nextFloat() < 0.02f * housing.getGeneticDecay(queen.getGenome(), 1f)) {
return true;
}
IBeeModifier beeModifier = new BeeHousingModifier(housing);
return false;
return queen.getGeneration() > 96 + rand.nextInt(6) + rand.nextInt(6) &&
rand.nextFloat() < 0.02f * beeModifier.getGeneticDecay(queen.getGenome(), 1f);
}
@Override
public boolean isOverworked(IBee queen, IBeeHousing housing) {
float productionModifier = housing.getProductionModifier(queen.getGenome(), 1f);
IBeeModifier beeModifier = new BeeHousingModifier(housing);
float productionModifier = beeModifier.getProductionModifier(queen.getGenome(), 1f);
if (productionModifier > 16) {
if (housing.getWorld().rand.nextFloat() * 100 < 0.01 * ((productionModifier * productionModifier) - 100)) {
return true;
@@ -137,7 +106,9 @@ public class BeekeepingMode implements IBeekeepingMode {
@Override
public boolean isDegenerating(IBee queen, IBee offspring, IBeeHousing housing) {
float mutationModifier = housing.getMutationModifier(queen.getGenome(), queen.getMate(), 1.0f);
IBeeModifier beeModifier = new BeeHousingModifier(housing);
float mutationModifier = beeModifier.getMutationModifier(queen.getGenome(), queen.getMate(), 1.0f);
if (mutationModifier > 10) {
if (housing.getWorld().rand.nextFloat() * 100 < 0.4 * ((mutationModifier * mutationModifier) - 100)) {
return true;
@@ -158,23 +129,34 @@ public class BeekeepingMode implements IBeekeepingMode {
}
@Override
public boolean isSealed() {
return false;
public IBeeModifier getBeeModifier() {
return beeModifier;
}
@Override
public boolean isSelfLighted() {
return false;
}
private static class BeekeepingModeBeeModifier extends DefaultBeeModifier {
private final float mutationModifier;
private final float lifespanModifier;
private final float speedModifier;
@Override
public boolean isSunlightSimulated() {
return false;
}
public BeekeepingModeBeeModifier(float mutationModifier, float lifespanModifier, float speedModifier) {
this.mutationModifier = mutationModifier;
this.lifespanModifier = lifespanModifier;
this.speedModifier = speedModifier;
}
@Override
public boolean isHellish() {
return false;
}
@Override
public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
return this.mutationModifier;
}
@Override
public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
return this.lifespanModifier;
}
@Override
public float getProductionModifier(IBeeGenome genome, float currentModifier) {
return this.speedModifier;
}
}
}
@@ -14,6 +14,7 @@ import java.util.List;
import net.minecraft.entity.EntityLiving;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.ChunkCoordinates;
import forestry.api.apiculture.IAlleleBeeSpecies;
import forestry.api.apiculture.IBeeGenome;
@@ -38,9 +39,11 @@ public class JubilanceProviderHermit extends JubilanceDefault {
int[] areaAr = genome.getTerritory();
Vect area = new Vect(areaAr[0], areaAr[1], areaAr[2]).multiply(modifier);
Vect offset = new Vect(-Math.round(area.x / 2), -Math.round(area.y / 2), -Math.round(area.z / 2));
Vect min = new Vect(housing.getXCoord() + offset.x, housing.getYCoord() + offset.y, housing.getZCoord() + offset.z);
Vect max = new Vect(housing.getXCoord() + offset.x + area.x, housing.getYCoord() + offset.y + area.y, housing.getZCoord() + offset.z + area.z);
ChunkCoordinates housingCoordinates = housing.getCoordinates();
Vect min = new Vect(housingCoordinates).add(offset);
Vect max = min.add(area);
return AxisAlignedBB.getBoundingBox(min.x, min.y, min.z, max.x, max.y, max.z);
}
@@ -12,6 +12,7 @@ package forestry.apiculture.genetics;
import net.minecraft.block.Block;
import net.minecraft.item.ItemStack;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.world.World;
import forestry.api.apiculture.IAlleleBeeSpecies;
@@ -31,9 +32,10 @@ public class JubilanceRequiresResource implements IJubilanceProvider {
@Override
public boolean isJubilant(IAlleleBeeSpecies species, IBeeGenome genome, IBeeHousing housing) {
World world = housing.getWorld();
ChunkCoordinates housingCoords = housing.getCoordinates();
Block block = world.getBlock(housing.getXCoord(), housing.getYCoord() - 1, housing.getZCoord());
int meta = world.getBlockMetadata(housing.getXCoord(), housing.getYCoord() - 1, housing.getZCoord());
Block block = world.getBlock(housingCoords.posX, housingCoords.posY - 1, housingCoords.posZ);
int meta = world.getBlockMetadata(housingCoords.posX, housingCoords.posY - 1, housingCoords.posZ);
return StackUtils.equals(block, meta, blockRequired);
}
@@ -11,12 +11,13 @@
package forestry.apiculture.gui;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.ICrafting;
import forestry.apiculture.gadgets.TileAlvearyPlain;
import forestry.apiculture.BeeHousingInventory;
import forestry.apiculture.multiblock.TileAlvearyPlain;
import forestry.core.gui.ContainerTile;
import forestry.core.gui.slots.SlotFiltered;
import forestry.core.gui.slots.SlotOutput;
import forestry.core.network.PacketGuiUpdate;
public class ContainerAlveary extends ContainerTile<TileAlvearyPlain> {
@@ -24,10 +25,10 @@ public class ContainerAlveary extends ContainerTile<TileAlvearyPlain> {
super(tile, player, 8, 108);
// Queen/Princess
this.addSlotToContainer(new SlotFiltered(tile, TileAlvearyPlain.SLOT_QUEEN, 29, 39));
this.addSlotToContainer(new SlotFiltered(tile, BeeHousingInventory.SLOT_QUEEN, 29, 39));
// Drone
this.addSlotToContainer(new SlotFiltered(tile, TileAlvearyPlain.SLOT_DRONE, 29, 65));
this.addSlotToContainer(new SlotFiltered(tile, BeeHousingInventory.SLOT_DRONE, 29, 65));
// Product Inventory
this.addSlotToContainer(new SlotOutput(tile, 2, 116, 52));
@@ -39,16 +40,10 @@ public class ContainerAlveary extends ContainerTile<TileAlvearyPlain> {
this.addSlotToContainer(new SlotOutput(tile, 8, 116, 26));
}
@Override
public void updateProgressBar(int i, int j) {
tile.getGUINetworkData(i, j);
}
@Override
public void detectAndSendChanges() {
super.detectAndSendChanges();
for (Object crafter : crafters) {
tile.sendGUINetworkData(this, (ICrafting) crafter);
}
PacketGuiUpdate packet = new PacketGuiUpdate(tile);
sendPacketToCrafters(packet);
}
}
@@ -12,7 +12,7 @@ package forestry.apiculture.gui;
import net.minecraft.entity.player.InventoryPlayer;
import forestry.apiculture.gadgets.TileAlvearyHygroregulator;
import forestry.apiculture.multiblock.TileAlvearyHygroregulator;
import forestry.core.gui.ContainerLiquidTanks;
import forestry.core.gui.slots.SlotFiltered;
@@ -21,7 +21,7 @@ public class ContainerAlvearyHygroregulator extends ContainerLiquidTanks<TileAlv
public ContainerAlvearyHygroregulator(InventoryPlayer playerInventory, TileAlvearyHygroregulator tile) {
super(tile, playerInventory, 8, 84);
this.addSlotToContainer(new SlotFiltered(tile, TileAlvearyHygroregulator.SLOT_INPUT, 56, 38));
this.addSlotToContainer(new SlotFiltered(tile, TileAlvearyHygroregulator.HygroInventory.SLOT_INPUT, 56, 38));
}
}
@@ -12,7 +12,7 @@ package forestry.apiculture.gui;
import net.minecraft.entity.player.InventoryPlayer;
import forestry.apiculture.gadgets.TileAlvearySieve;
import forestry.apiculture.multiblock.TileAlvearySieve;
import forestry.core.gui.ContainerTile;
import forestry.core.gui.slots.SlotFiltered;
import forestry.core.gui.slots.SlotOutput;
@@ -27,6 +27,6 @@ public class ContainerAlvearySieve extends ContainerTile<TileAlvearySieve> {
addSlotToContainer(new SlotOutput(tile, 2, 73, 39).setCrafter(tile));
addSlotToContainer(new SlotOutput(tile, 3, 94, 26).setCrafter(tile));
addSlotToContainer(new SlotFiltered(tile, TileAlvearySieve.SLOT_SIEVE, 43, 39).setCrafter(tile));
addSlotToContainer(new SlotFiltered(tile, TileAlvearySieve.AlvearySieveInventory.SLOT_SIEVE, 43, 39).setCrafter(tile));
}
}
@@ -12,7 +12,7 @@ package forestry.apiculture.gui;
import net.minecraft.entity.player.InventoryPlayer;
import forestry.apiculture.gadgets.TileAlvearySwarmer;
import forestry.apiculture.multiblock.TileAlvearySwarmer;
import forestry.core.gui.ContainerTile;
import forestry.core.gui.slots.SlotFiltered;
@@ -13,27 +13,30 @@ package forestry.apiculture.gui;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.ICrafting;
import forestry.apiculture.gadgets.TileBeehouse;
import forestry.apiculture.BeeHousingInventory;
import forestry.apiculture.gadgets.TileApiary;
import forestry.apiculture.gadgets.TileBeeHousing;
import forestry.core.gui.ContainerTile;
import forestry.core.gui.slots.SlotFiltered;
import forestry.core.gui.slots.SlotOutput;
public class ContainerApiary extends ContainerTile<TileBeehouse> {
public class ContainerBeeHousing extends ContainerTile<TileBeeHousing> {
public ContainerApiary(InventoryPlayer player, TileBeehouse tile, boolean hasFrames) {
public ContainerBeeHousing(InventoryPlayer player, TileBeeHousing tile, boolean hasFrames) {
super(tile, player, 8, 108);
// Queen/Princess
this.addSlotToContainer(new SlotFiltered(tile, TileBeehouse.SLOT_QUEEN, 29, 39));
this.addSlotToContainer(new SlotFiltered(tile, BeeHousingInventory.SLOT_QUEEN, 29, 39));
// Drone
this.addSlotToContainer(new SlotFiltered(tile, TileBeehouse.SLOT_DRONE, 29, 65));
this.addSlotToContainer(new SlotFiltered(tile, BeeHousingInventory.SLOT_DRONE, 29, 65));
// Frames
if (hasFrames) {
this.addSlotToContainer(new SlotFiltered(tile, TileBeehouse.SLOT_FRAMES_1, 66, 23));
this.addSlotToContainer(new SlotFiltered(tile, TileBeehouse.SLOT_FRAMES_1 + 1, 66, 52));
this.addSlotToContainer(new SlotFiltered(tile, TileBeehouse.SLOT_FRAMES_1 + 2, 66, 81));
final int slotFrames1 = TileApiary.ApiaryInventory.SLOT_FRAMES_1;
this.addSlotToContainer(new SlotFiltered(tile, slotFrames1, 66, 23));
this.addSlotToContainer(new SlotFiltered(tile, slotFrames1 + 1, 66, 52));
this.addSlotToContainer(new SlotFiltered(tile, slotFrames1 + 2, 66, 81));
}
// Product Inventory
@@ -12,9 +12,11 @@ package forestry.apiculture.gui;
import net.minecraft.entity.player.InventoryPlayer;
import forestry.apiculture.gadgets.TileAlvearyPlain;
import forestry.apiculture.multiblock.IAlvearyController;
import forestry.apiculture.multiblock.TileAlvearyPlain;
import forestry.core.config.Defaults;
import forestry.core.gui.GuiForestryTitled;
import forestry.core.gui.OwnerLedger;
import forestry.core.utils.EnumTankLevel;
import forestry.core.utils.Utils;
@@ -30,8 +32,8 @@ public class GuiAlveary extends GuiForestryTitled<ContainerAlveary, TileAlvearyP
protected void drawGuiContainerBackgroundLayer(float var1, int mouseX, int mouseY) {
super.drawGuiContainerBackgroundLayer(var1, mouseX, mouseY);
TileAlvearyPlain machine = inventory;
drawHealthMeter(guiLeft + 20, guiTop + 37, machine.getHealthScaled(46), Utils.rateTankLevel(machine.getHealthScaled(100)));
IAlvearyController alvearyController = inventory.getAlvearyController();
drawHealthMeter(guiLeft + 20, guiTop + 37, alvearyController.getHealthScaled(46), Utils.rateTankLevel(alvearyController.getHealthScaled(100)));
}
private void drawHealthMeter(int x, int y, int height, EnumTankLevel rated) {
@@ -57,4 +59,12 @@ public class GuiAlveary extends GuiForestryTitled<ContainerAlveary, TileAlvearyP
this.drawTexturedModalRect(x, y + 46 - height, i, k + 46 - height, 4, height);
}
/* LEDGERS */
protected void initLedgers() {
super.initLedgers();
IAlvearyController alvearyController = inventory.getAlvearyController();
ledgerManager.add(new OwnerLedger(ledgerManager, alvearyController));
}
}
@@ -12,7 +12,7 @@ package forestry.apiculture.gui;
import net.minecraft.entity.player.InventoryPlayer;
import forestry.apiculture.gadgets.TileAlvearyHygroregulator;
import forestry.apiculture.multiblock.TileAlvearyHygroregulator;
import forestry.core.config.Defaults;
import forestry.core.gui.GuiForestryTitled;
import forestry.core.gui.widgets.TankWidget;
@@ -12,11 +12,11 @@ package forestry.apiculture.gui;
import net.minecraft.entity.player.InventoryPlayer;
import forestry.apiculture.gadgets.TileAlvearySieve;
import forestry.apiculture.multiblock.TileAlvearySieve;
import forestry.core.config.Defaults;
import forestry.core.gui.GuiForestry;
import forestry.core.gui.GuiForestryTitled;
public class GuiAlvearySieve extends GuiForestry<ContainerAlvearySieve, TileAlvearySieve> {
public class GuiAlvearySieve extends GuiForestryTitled<ContainerAlvearySieve, TileAlvearySieve> {
public GuiAlvearySieve(InventoryPlayer inventory, TileAlvearySieve tile) {
super(Defaults.TEXTURE_PATH_GUI + "/sieve.png", new ContainerAlvearySieve(inventory, tile), tile);
@@ -12,11 +12,11 @@ package forestry.apiculture.gui;
import net.minecraft.entity.player.InventoryPlayer;
import forestry.apiculture.gadgets.TileAlvearySwarmer;
import forestry.apiculture.multiblock.TileAlvearySwarmer;
import forestry.core.config.Defaults;
import forestry.core.gui.GuiForestry;
import forestry.core.gui.GuiForestryTitled;
public class GuiAlvearySwarmer extends GuiForestry<ContainerAlvearySwarmer, TileAlvearySwarmer> {
public class GuiAlvearySwarmer extends GuiForestryTitled<ContainerAlvearySwarmer, TileAlvearySwarmer> {
public GuiAlvearySwarmer(InventoryPlayer inventory, TileAlvearySwarmer tile) {
super(Defaults.TEXTURE_PATH_GUI + "/swarmer.png", new ContainerAlvearySwarmer(inventory, tile), tile);
@@ -13,22 +13,23 @@ package forestry.apiculture.gui;
import net.minecraft.entity.player.InventoryPlayer;
import forestry.apiculture.gadgets.TileApiary;
import forestry.apiculture.gadgets.TileBeeHousing;
import forestry.apiculture.gadgets.TileBeehouse;
import forestry.core.config.Defaults;
import forestry.core.gui.GuiForestryTitled;
import forestry.core.utils.EnumTankLevel;
import forestry.core.utils.Utils;
public class GuiApiary extends GuiForestryTitled<ContainerApiary, TileBeehouse> {
public class GuiBeeHousing extends GuiForestryTitled<ContainerBeeHousing, TileBeeHousing> {
public GuiApiary(InventoryPlayer inventory, TileApiary tile) {
super(Defaults.TEXTURE_PATH_GUI + "/apiary.png", new ContainerApiary(inventory, tile, true), tile);
public GuiBeeHousing(InventoryPlayer inventory, TileApiary tile) {
super(Defaults.TEXTURE_PATH_GUI + "/apiary.png", new ContainerBeeHousing(inventory, tile, true), tile);
ySize = 190;
}
public GuiApiary(InventoryPlayer inventory, TileBeehouse tile) {
super(Defaults.TEXTURE_PATH_GUI + "/alveary.png", new ContainerApiary(inventory, tile, false), tile);
public GuiBeeHousing(InventoryPlayer inventory, TileBeehouse tile) {
super(Defaults.TEXTURE_PATH_GUI + "/alveary.png", new ContainerBeeHousing(inventory, tile, false), tile);
ySize = 190;
}
@@ -37,8 +38,7 @@ public class GuiApiary extends GuiForestryTitled<ContainerApiary, TileBeehouse>
protected void drawGuiContainerBackgroundLayer(float var1, int mouseX, int mouseY) {
super.drawGuiContainerBackgroundLayer(var1, mouseX, mouseY);
TileBeehouse machine = inventory;
drawHealthMeter(guiLeft + 20, guiTop + 37, machine.getHealthScaled(46), Utils.rateTankLevel(machine.getHealthScaled(100)));
drawHealthMeter(guiLeft + 20, guiTop + 37, inventory.getHealthScaled(46), Utils.rateTankLevel(inventory.getHealthScaled(100)));
}
private void drawHealthMeter(int x, int y, int height, EnumTankLevel rated) {
@@ -34,7 +34,6 @@ import forestry.api.genetics.AlleleManager;
import forestry.api.genetics.IAllele;
import forestry.api.genetics.IAlleleSpecies;
import forestry.api.genetics.IIndividual;
import forestry.apiculture.genetics.Bee;
import forestry.apiculture.genetics.BeeGenome;
import forestry.core.config.Config;
import forestry.core.genetics.ItemGE;
@@ -55,7 +54,7 @@ public class ItemBeeGE extends ItemGE {
@Override
public IBee getIndividual(ItemStack itemstack) {
return new Bee(itemstack.getTagCompound());
return BeeManager.beeRoot.getMember(itemstack);
}
@Override
@@ -80,7 +79,7 @@ public class ItemBeeGE extends ItemGE {
return super.getItemStackDisplayName(itemstack);
}
IBee individual = new Bee(itemstack.getTagCompound());
IBee individual = BeeManager.beeRoot.getMember(itemstack);
String customBeeKey = "bees.custom." + type.getName() + "." + individual.getGenome().getPrimary().getUnlocalizedName().replace("bees.species.", "");
if (StringUtil.canTranslate(customBeeKey)) {
return StringUtil.localize(customBeeKey);
@@ -99,7 +98,7 @@ public class ItemBeeGE extends ItemGE {
}
if (type != EnumBeeType.DRONE) {
IBee individual = new Bee(itemstack.getTagCompound());
IBee individual = BeeManager.beeRoot.getMember(itemstack);
if (individual.isNatural()) {
list.add(EnumChatFormatting.YELLOW + EnumChatFormatting.ITALIC.toString() + StringUtil.localize("bees.stock.pristine"));
} else {
@@ -39,6 +39,7 @@ import forestry.api.apiculture.IBee;
import forestry.api.core.EnumHumidity;
import forestry.api.core.EnumTemperature;
import forestry.api.core.ForestryAPI;
import forestry.api.core.IErrorSource;
import forestry.api.core.IErrorState;
import forestry.api.core.Tabs;
import forestry.api.genetics.AlleleManager;
@@ -46,7 +47,6 @@ import forestry.apiculture.render.TextureHabitatLocator;
import forestry.core.EnumErrorCode;
import forestry.core.config.Config;
import forestry.core.config.ForestryItem;
import forestry.core.interfaces.IErrorSource;
import forestry.core.interfaces.IHintSource;
import forestry.core.inventory.ItemInventory;
import forestry.core.items.ItemInventoried;
@@ -12,23 +12,25 @@ package forestry.apiculture.items;
import net.minecraft.item.ItemStack;
import forestry.api.apiculture.DefaultBeeModifier;
import forestry.api.apiculture.IBee;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.apiculture.IBeeModifier;
import forestry.api.apiculture.IHiveFrame;
import forestry.api.core.Tabs;
import forestry.core.items.ItemForestry;
public class ItemHiveFrame extends ItemForestry implements IHiveFrame {
private final float geneticDecay;
private final IBeeModifier beeModifier;
public ItemHiveFrame(int maxDamage, float geneticDecay) {
super();
setMaxStackSize(1);
setMaxDamage(maxDamage);
this.geneticDecay = geneticDecay;
setCreativeTab(Tabs.tabApiculture);
this.beeModifier = new HiveFrameBeeModifier(geneticDecay);
}
@Override
@@ -42,58 +44,25 @@ public class ItemHiveFrame extends ItemForestry implements IHiveFrame {
}
@Override
public float getTerritoryModifier(IBeeGenome genome, float currentModifier) {
return 1.0f;
public IBeeModifier getBeeModifier() {
return beeModifier;
}
@Override
public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
return 1.0f;
}
private static class HiveFrameBeeModifier extends DefaultBeeModifier {
private final float geneticDecay;
@Override
public float getLifespanModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
return 1.0f;
}
public HiveFrameBeeModifier(float geneticDecay) {
this.geneticDecay = geneticDecay;
}
@Override
public float getProductionModifier(IBeeGenome genome, float currentModifier) {
return currentModifier < 10f ? 2.0f : 1f;
}
@Override
public float getProductionModifier(IBeeGenome genome, float currentModifier) {
return (currentModifier < 10f) ? 2f : 1f;
}
@Override
public float getFloweringModifier(IBeeGenome genome, float currentModifier) {
return 1.0f;
@Override
public float getGeneticDecay(IBeeGenome genome, float currentModifier) {
return this.geneticDecay;
}
}
@Override
public float getGeneticDecay(IBeeGenome genome, float currentModifier) {
return this.geneticDecay;
}
@Override
public boolean isSealed() {
return false;
}
@Override
public boolean isSelfLighted() {
return false;
}
@Override
public boolean isSunlightSimulated() {
return false;
}
@Override
public boolean isHellish() {
return false;
}
@Override
public boolean isBookEnchantable(ItemStack itemstack1, ItemStack itemstack2) {
return false;
}
}
@@ -0,0 +1,466 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.multiblock;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
import net.minecraft.block.Block;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.util.StatCollector;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import com.mojang.authlib.GameProfile;
import forestry.api.apiculture.BeeManager;
import forestry.api.apiculture.DefaultBeeModifier;
import forestry.api.apiculture.IAlvearyComponent;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeHousingInventory;
import forestry.api.apiculture.IBeeListener;
import forestry.api.apiculture.IBeeModifier;
import forestry.api.apiculture.IBeekeepingLogic;
import forestry.api.core.EnumHumidity;
import forestry.api.core.EnumTemperature;
import forestry.api.core.IClimateControlled;
import forestry.apiculture.BeeHousingInventory;
import forestry.apiculture.BeeHousingModifier;
import forestry.core.inventory.IInventoryAdapter;
import forestry.core.multiblock.CoordTriplet;
import forestry.core.multiblock.IMultiblockPart;
import forestry.core.multiblock.MultiblockControllerBase;
import forestry.core.multiblock.MultiblockTileEntityBase;
import forestry.core.multiblock.MultiblockValidationException;
import forestry.core.multiblock.rectangular.RectangularMultiblockControllerBase;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
import forestry.core.network.PacketGuiUpdate;
import forestry.core.proxy.Proxies;
import forestry.core.utils.EnumAccess;
import forestry.core.utils.Utils;
public class AlvearyController extends RectangularMultiblockControllerBase implements IAlvearyController, IClimateControlled {
private final BeeHousingInventory inventory;
private final IBeekeepingLogic beekeepingLogic;
private BiomeGenBase cachedBiome;
private float tempChange = 0.0f;
private float humidChange = 0.0f;
// PARTS
private final Set<IBeeModifier> beeModifiers = new HashSet<IBeeModifier>();
private final Set<IBeeListener> beeListeners = new HashSet<IBeeListener>();
private final Set<IAlvearyComponent.Climatiser> climatisers = new HashSet<IAlvearyComponent.Climatiser>();
private final Set<IAlvearyComponent.Active> activeComponents = new HashSet<IAlvearyComponent.Active>();
// CLIENT
private int breedingProgressPercent = 0;
public AlvearyController(World world) {
super(world);
this.inventory = new BeeHousingInventory(9, "Items", getAccessHandler());
this.beekeepingLogic = BeeManager.beeRoot.createBeekeepingLogic(this);
this.beeModifiers.add(new AlvearyBeeModifier());
}
@Override
public IBeeHousingInventory getBeeInventory() {
return inventory;
}
@Override
public IBeekeepingLogic getBeekeepingLogic() {
return beekeepingLogic;
}
@Override
public IInventoryAdapter getInternalInventory() {
return inventory;
}
@Override
public Iterable<IBeeListener> getBeeListeners() {
return beeListeners;
}
@Override
public Iterable<IBeeModifier> getBeeModifiers() {
return beeModifiers;
}
@Override
public void onAttachedPartWithMultiblockData(IMultiblockPart part, NBTTagCompound data) {
this.readFromNBT(data);
}
@Override
protected void onBlockAdded(IMultiblockPart newPart) {
if (newPart instanceof IAlvearyComponent.BeeModifier) {
IAlvearyComponent.BeeModifier alvearyBeeModifier = (IAlvearyComponent.BeeModifier) newPart;
IBeeModifier beeModifier = alvearyBeeModifier.getBeeModifier();
beeModifiers.add(beeModifier);
}
if (newPart instanceof IAlvearyComponent.BeeListener) {
IAlvearyComponent.BeeListener beeListenerSource = (IAlvearyComponent.BeeListener) newPart;
IBeeListener beeListener = beeListenerSource.getBeeListener();
beeListeners.add(beeListener);
}
if (newPart instanceof IAlvearyComponent.Climatiser) {
climatisers.add((IAlvearyComponent.Climatiser) newPart);
}
if (newPart instanceof IAlvearyComponent.Active) {
activeComponents.add((IAlvearyComponent.Active) newPart);
}
}
@Override
protected void onBlockRemoved(IMultiblockPart oldPart) {
if (oldPart instanceof IAlvearyComponent.BeeModifier) {
IAlvearyComponent.BeeModifier alvearyBeeModifier = (IAlvearyComponent.BeeModifier) oldPart;
IBeeModifier beeModifier = alvearyBeeModifier.getBeeModifier();
beeModifiers.remove(beeModifier);
}
if (oldPart instanceof IAlvearyComponent.BeeListener) {
IAlvearyComponent.BeeListener beeListenerSource = (IAlvearyComponent.BeeListener) oldPart;
IBeeListener beeListener = beeListenerSource.getBeeListener();
beeListeners.remove(beeListener);
}
if (oldPart instanceof IAlvearyComponent.Climatiser) {
climatisers.remove(oldPart);
}
if (oldPart instanceof IAlvearyComponent.Active) {
activeComponents.remove(oldPart);
}
}
@Override
protected void isMachineWhole() throws MultiblockValidationException {
super.isMachineWhole();
final CoordTriplet maximumCoord = getMaximumCoord();
final CoordTriplet minimumCoord = getMinimumCoord();
// check that the top is covered in wood slabs
final int slabY = maximumCoord.y + 1;
for (int slabX = minimumCoord.x; slabX <= maximumCoord.x; slabX++) {
for (int slabZ = minimumCoord.z; slabZ <= maximumCoord.z; slabZ++) {
Block block = worldObj.getBlock(slabX, slabY, slabZ);
if (!Utils.isWoodSlabBlock(block)) {
throw new MultiblockValidationException(StatCollector.translateToLocal("for.multiblock.alveary.error.needSlabs"));
}
int meta = worldObj.getBlockMetadata(slabX, slabY, slabZ);
if ((meta & 8) != 0) {
throw new MultiblockValidationException(StatCollector.translateToLocal("for.multiblock.alveary.error.needSlabs"));
}
}
}
// check that there is space all around the alveary entrances
int airY = maximumCoord.y;
for (int airX = minimumCoord.x - 1; airX <= maximumCoord.x + 1; airX++) {
for (int airZ = minimumCoord.z - 1; airZ <= maximumCoord.z + 1; airZ++) {
if (isCoordInMultiblock(airX, airY, airZ)) {
continue;
}
Block block = worldObj.getBlock(airX, airY, airZ);
if (block.isOpaqueCube()) {
throw new MultiblockValidationException(StatCollector.translateToLocal("for.multiblock.alveary.error.needSpace"));
}
}
}
}
@Override
protected int getMinimumNumberOfBlocksForAssembledMachine() {
return 27;
}
@Override
protected int getMaximumXSize() {
return 3;
}
@Override
protected int getMaximumZSize() {
return 3;
}
@Override
protected int getMaximumYSize() {
return 3;
}
@Override
protected int getMinimumXSize() {
return 3;
}
@Override
protected int getMinimumYSize() {
return 3;
}
@Override
protected int getMinimumZSize() {
return 3;
}
@Override
protected void onAssimilate(MultiblockControllerBase assimilated) {
}
@Override
protected void onAssimilated(MultiblockControllerBase assimilator) {
}
@Override
protected boolean updateServer(int tickCount) {
for (IAlvearyComponent.Active activeComponent : activeComponents) {
activeComponent.updateServer(tickCount);
}
final boolean canWork = beekeepingLogic.canWork();
if (canWork) {
beekeepingLogic.doWork();
}
for (IAlvearyComponent.Climatiser climatiser : climatisers) {
climatiser.changeClimate(tickCount, this);
}
tempChange = equalizeChange(tempChange);
humidChange = equalizeChange(humidChange);
return canWork;
}
private static float equalizeChange(float change) {
if (change == 0) {
return 0;
}
change *= 0.95f;
if (change <= 0.001f && change >= -0.001f) {
change = 0;
}
return change;
}
@Override
protected void updateClient(int tickCount) {
for (IAlvearyComponent.Active activeComponent : activeComponents) {
activeComponent.updateClient(tickCount);
}
if (beekeepingLogic.canDoBeeFX() && updateOnInterval(2)) {
beekeepingLogic.doBeeFX();
if (updateOnInterval(50)) {
CoordTriplet center = getCenterCoord();
float fxX = center.x + 0.5F;
float fxY = center.y + 1.0F;
float fxZ = center.z + 0.5F;
float distanceFromCenter = 1.6F;
float leftRightSpreadFromCenter = distanceFromCenter * (worldObj.rand.nextFloat() - 0.5F);
float upSpread = worldObj.rand.nextFloat() * 0.8F;
fxY += upSpread;
// display fx on all 4 sides
Proxies.common.addEntitySwarmFX(worldObj, (fxX - distanceFromCenter), fxY, (fxZ + leftRightSpreadFromCenter), 0F, 0F, 0F);
Proxies.common.addEntitySwarmFX(worldObj, (fxX + distanceFromCenter), fxY, (fxZ + leftRightSpreadFromCenter), 0F, 0F, 0F);
Proxies.common.addEntitySwarmFX(worldObj, (fxX + leftRightSpreadFromCenter), fxY, (fxZ - distanceFromCenter), 0F, 0F, 0F);
Proxies.common.addEntitySwarmFX(worldObj, (fxX + leftRightSpreadFromCenter), fxY, (fxZ + distanceFromCenter), 0F, 0F, 0F);
}
}
}
@Override
public void writeToNBT(NBTTagCompound data) {
super.writeToNBT(data);
data.setFloat("TempChange", tempChange);
data.setFloat("HumidChange", humidChange);
beekeepingLogic.writeToNBT(data);
inventory.writeToNBT(data);
}
@Override
public void readFromNBT(NBTTagCompound data) {
super.readFromNBT(data);
tempChange = data.getFloat("TempChange");
humidChange = data.getFloat("HumidChange");
beekeepingLogic.readFromNBT(data);
inventory.readFromNBT(data);
}
@Override
public void formatDescriptionPacket(NBTTagCompound data) {
writeToNBT(data);
}
@Override
public void decodeDescriptionPacket(NBTTagCompound data) {
readFromNBT(data);
}
/* IActivatable */
@Override
public ChunkCoordinates getCoordinates() {
CoordTriplet coord = getCenterCoord();
return new ChunkCoordinates(coord.x, coord.y + 1, coord.z);
}
@Override
public void onSwitchAccess(EnumAccess oldAccess, EnumAccess newAccess) {
PacketGuiUpdate packet = new PacketGuiUpdate(this);
Proxies.net.sendNetworkPacket(packet);
if (oldAccess == EnumAccess.SHARED || newAccess == EnumAccess.SHARED) {
// pipes connected to this need to update
for (IMultiblockPart part : connectedParts) {
if (part instanceof MultiblockTileEntityBase) {
MultiblockTileEntityBase tile = (MultiblockTileEntityBase) part;
tile.notifyNeighborsOfBlockChange();
}
}
markDirty();
}
}
@Override
public float getExactTemperature() {
CoordTriplet coords = getReferenceCoord();
return getBiome().getFloatTemperature(coords.x, coords.y, coords.z) + tempChange;
}
@Override
public float getExactHumidity() {
return getBiome().rainfall + humidChange;
}
@Override
public GameProfile getOwner() {
return getAccessHandler().getOwner();
}
@Override
public World getWorld() {
return worldObj;
}
@Override
public BiomeGenBase getBiome() {
if (cachedBiome == null) {
CoordTriplet coords = getReferenceCoord();
cachedBiome = worldObj.getBiomeGenForCoords(coords.x, coords.z);
}
return cachedBiome;
}
@Override
public EnumTemperature getTemperature() {
IBeeModifier beeModifier = new BeeHousingModifier(this);
if (beeModifier.isHellish() && tempChange >= 0) {
return EnumTemperature.HELLISH;
}
CoordTriplet coords = getReferenceCoord();
return EnumTemperature.getFromBiome(getBiome(), coords.x, coords.y, coords.z);
}
@Override
public EnumHumidity getHumidity() {
return EnumHumidity.getFromValue(getExactHumidity());
}
@Override
public int getBlockLightValue() {
CoordTriplet topCenter = getTopCenterCoord();
return worldObj.getBlockLightValue(topCenter.x, topCenter.y + 1, topCenter.z);
}
@Override
public boolean canBlockSeeTheSky() {
CoordTriplet topCenter = getTopCenterCoord();
return worldObj.canBlockSeeTheSky(topCenter.x, topCenter.y + 2, topCenter.z);
}
@Override
public void addTemperatureChange(float change, float boundaryDown, float boundaryUp) {
ChunkCoordinates coordinates = getCoordinates();
float temperature = getBiome().getFloatTemperature(coordinates.posX, coordinates.posY, coordinates.posZ);
tempChange += change;
tempChange = Math.max(boundaryDown - temperature, tempChange);
tempChange = Math.min(boundaryUp - temperature, tempChange);
}
@Override
public void addHumidityChange(float change, float boundaryDown, float boundaryUp) {
float humidity = getBiome().rainfall;
humidChange += change;
humidChange = Math.max(boundaryDown - humidity, humidChange);
humidChange = Math.min(boundaryUp - humidity, humidChange);
}
/* GUI */
@Override
public int getHealthScaled(int i) {
return (breedingProgressPercent * i) / 100;
}
@Override
public void writeGuiData(DataOutputStreamForestry data) throws IOException {
super.writeGuiData(data);
data.writeVarInt(beekeepingLogic.getBeeProgressPercent());
data.writeVarInt(Math.round(tempChange * 100));
data.writeVarInt(Math.round(humidChange * 100));
}
@Override
public void readGuiData(DataInputStreamForestry data) throws IOException {
super.readGuiData(data);
breedingProgressPercent = data.readVarInt();
tempChange = data.readVarInt() / 100.0F;
humidChange = data.readVarInt() / 100.0F;
}
private static class AlvearyBeeModifier extends DefaultBeeModifier {
@Override
public float getTerritoryModifier(IBeeGenome genome, float currentModifier) {
return 2.0f;
}
}
}
@@ -0,0 +1,184 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.multiblock;
import java.io.IOException;
import java.util.Collections;
import net.minecraft.item.ItemStack;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import com.mojang.authlib.GameProfile;
import forestry.api.apiculture.IBeeHousingInventory;
import forestry.api.apiculture.IBeeListener;
import forestry.api.apiculture.IBeeModifier;
import forestry.api.apiculture.IBeekeepingLogic;
import forestry.api.core.EnumHumidity;
import forestry.api.core.EnumTemperature;
import forestry.api.core.IErrorLogic;
import forestry.apiculture.FakeBeekeepingLogic;
import forestry.core.delegates.FakeAccessHandler;
import forestry.core.delegates.FakeErrorLogic;
import forestry.core.interfaces.IAccessHandler;
import forestry.core.inventory.FakeInventoryAdapter;
import forestry.core.inventory.IInventoryAdapter;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
import forestry.core.utils.EnumAccess;
public class FakeAlvearyController implements IAlvearyController {
public static final FakeAlvearyController instance = new FakeAlvearyController();
private FakeAlvearyController() {
}
@Override
public Iterable<IBeeModifier> getBeeModifiers() {
return Collections.emptyList();
}
@Override
public Iterable<IBeeListener> getBeeListeners() {
return Collections.emptyList();
}
@Override
public IBeeHousingInventory getBeeInventory() {
return FakeBeeHousingInventory.instance;
}
@Override
public IBeekeepingLogic getBeekeepingLogic() {
return FakeBeekeepingLogic.instance;
}
@Override
public EnumTemperature getTemperature() {
return EnumTemperature.NORMAL;
}
@Override
public EnumHumidity getHumidity() {
return EnumHumidity.NORMAL;
}
@Override
public int getBlockLightValue() {
return 0;
}
@Override
public boolean canBlockSeeTheSky() {
return false;
}
@Override
public float getExactTemperature() {
return 0.5f;
}
@Override
public float getExactHumidity() {
return 0.5f;
}
@Override
public GameProfile getOwner() {
return null;
}
@Override
public IErrorLogic getErrorLogic() {
return FakeErrorLogic.instance;
}
@Override
public World getWorld() {
return null;
}
@Override
public ChunkCoordinates getCoordinates() {
return null;
}
@Override
public void onSwitchAccess(EnumAccess oldAccess, EnumAccess newAccess) {
}
@Override
public void writeGuiData(DataOutputStreamForestry data) throws IOException {
}
@Override
public void readGuiData(DataInputStreamForestry data) throws IOException {
}
@Override
public BiomeGenBase getBiome() {
return null;
}
@Override
public IAccessHandler getAccessHandler() {
return FakeAccessHandler.getInstance();
}
@Override
public IInventoryAdapter getInternalInventory() {
return FakeInventoryAdapter.instance();
}
@Override
public int getHealthScaled(int i) {
return 0;
}
private static class FakeBeeHousingInventory implements IBeeHousingInventory {
public static final FakeBeeHousingInventory instance = new FakeBeeHousingInventory();
private FakeBeeHousingInventory() {
}
@Override
public ItemStack getQueen() {
return null;
}
@Override
public ItemStack getDrone() {
return null;
}
@Override
public void setQueen(ItemStack itemstack) {
}
@Override
public void setDrone(ItemStack itemstack) {
}
@Override
public boolean addProduct(ItemStack product, boolean all) {
return false;
}
}
}
@@ -0,0 +1,24 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.multiblock;
import forestry.api.apiculture.IBeeHousing;
import forestry.core.interfaces.IClimatised;
import forestry.core.interfaces.IRestrictedAccessTile;
import forestry.core.inventory.IInventoryAdapter;
import forestry.core.network.IStreamableGui;
public interface IAlvearyController extends IBeeHousing, IClimatised, IRestrictedAccessTile, IStreamableGui {
IInventoryAdapter getInternalInventory();
int getHealthScaled(int i);
}
@@ -0,0 +1,98 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.multiblock;
import net.minecraft.util.StatCollector;
import forestry.apiculture.gadgets.BlockAlveary;
import forestry.core.multiblock.MultiblockControllerBase;
import forestry.core.multiblock.MultiblockValidationException;
import forestry.core.multiblock.rectangular.RectangularMultiblockTileEntityBase;
public abstract class TileAlveary extends RectangularMultiblockTileEntityBase {
public static final int PLAIN_META = 0;
public static final int ENTRANCE_META = 1;
public static final int SWARMER_META = 2;
public static final int FAN_META = 3;
public static final int HEATER_META = 4;
public static final int HYGRO_META = 5;
public static final int STABILIZER_META = 6;
public static final int SIEVE_META = 7;
/* TEXTURES */
public int getIcon(int side, int metadata) {
return BlockAlveary.PLAIN;
}
@Override
public void isGoodForExteriorLevel(int level) throws MultiblockValidationException {
if (level == 2 && !(this instanceof TileAlvearyPlain)) {
throw new MultiblockValidationException(StatCollector.translateToLocal("for.multiblock.alveary.error.needPlainOnTop"));
}
}
@Override
public void isGoodForInterior() throws MultiblockValidationException {
if (!(this instanceof TileAlvearyPlain)) {
throw new MultiblockValidationException(StatCollector.translateToLocal("for.multiblock.alveary.error.needPlainInterior"));
}
}
@Override
public void onMachineActivated() {
}
@Override
public void onMachineDeactivated() {
}
@Override
public MultiblockControllerBase createNewMultiblock() {
return new AlvearyController(worldObj);
}
@Override
public Class<? extends MultiblockControllerBase> getMultiblockControllerType() {
return AlvearyController.class;
}
public IAlvearyController getAlvearyController() {
if (isConnected()) {
return (IAlvearyController) getMultiblockController();
} else {
return FakeAlvearyController.instance;
}
}
@Override
public void onMachineAssembled(MultiblockControllerBase controller) {
super.onMachineAssembled(controller);
// Re-render this block on the client
if (worldObj.isRemote) {
this.worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
}
}
@Override
public void onMachineBroken() {
super.onMachineBroken();
// Re-render this block on the client
if (worldObj.isRemote) {
this.worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
}
}
}
@@ -8,66 +8,54 @@
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.gadgets;
import java.io.IOException;
package forestry.apiculture.multiblock;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.ChunkCoordinates;
import net.minecraftforge.common.util.ForgeDirection;
import forestry.api.apiculture.IAlvearyComponent;
import forestry.api.core.IClimateControlled;
import forestry.apiculture.network.PacketActiveUpdate;
import forestry.core.interfaces.IActivatable;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
import forestry.core.proxy.Proxies;
import forestry.energy.EnergyManager;
import cofh.api.energy.IEnergyHandler;
public abstract class TileAlvearyClimatiser extends TileAlveary implements IEnergyHandler, IActivatable {
public abstract class TileAlvearyClimatiser extends TileAlveary implements IEnergyHandler, IActivatable, IAlvearyComponent.Climatiser {
public static class ClimateControl {
protected interface IClimitiserDefinition {
float getChangePerTransfer();
final float changePerTransfer;
final float boundaryUp;
final float boundaryDown;
float getBoundaryUp();
public ClimateControl(float changePerTransfer, float boundaryDown, float boundaryUp) {
this.changePerTransfer = changePerTransfer;
this.boundaryDown = boundaryDown;
this.boundaryUp = boundaryUp;
}
float getBoundaryDown();
int getIconOff();
int getIconOn();
}
protected final EnergyManager energyManager;
private final ClimateControl climateControl;
private final EnergyManager energyManager;
private final IClimitiserDefinition definition;
private int workingTime = 0;
private final int textureOff;
private final int textureOn;
// CLIENT
private boolean active;
public TileAlvearyClimatiser(ClimateControl control, int textureOff, int textureOn, int componentBlockMeta) {
super(componentBlockMeta);
this.climateControl = control;
energyManager = new EnergyManager(1000, 50, 2000);
energyManager.setReceiveOnly();
this.textureOff = textureOff;
this.textureOn = textureOn;
public TileAlvearyClimatiser(IClimitiserDefinition definition) {
this.definition = definition;
this.energyManager = new EnergyManager(1000, 50, 2000);
this.energyManager.setReceiveOnly();
}
/* UPDATING */
@Override
protected void updateServerSide() {
super.updateServerSide();
if (!this.hasMaster()) {
return;
}
public void changeClimate(int tick, IClimateControlled climateControlled) {
if (workingTime < 20 && energyManager.consumeEnergyToDoWork()) {
// consume 10 RF per tick of work
workingTime += energyManager.getEnergyPerWork() / 10;
@@ -75,27 +63,19 @@ public abstract class TileAlvearyClimatiser extends TileAlveary implements IEner
if (workingTime > 0) {
workingTime--;
IAlvearyComponent component = (IAlvearyComponent) this.getCentralTE();
if (component != null) {
component.addTemperatureChange(climateControl.changePerTransfer, climateControl.boundaryDown, climateControl.boundaryUp);
}
climateControlled.addTemperatureChange(definition.getChangePerTransfer(), definition.getBoundaryDown(), definition.getBoundaryUp());
}
setActive(workingTime > 0);
}
@Override
public boolean hasFunction() {
return true;
}
/* TEXTURES */
@Override
public int getIcon(int side, int metadata) {
if (active) {
return textureOn;
return definition.getIconOn();
} else {
return textureOff;
return definition.getIconOff();
}
}
@@ -115,19 +95,20 @@ public abstract class TileAlvearyClimatiser extends TileAlveary implements IEner
nbttagcompound.setInteger("Heating", workingTime);
}
/* NETWORK */
/* Network */
@Override
public void writeData(DataOutputStreamForestry data) throws IOException {
super.writeData(data);
data.writeBoolean(active);
protected void encodeDescriptionPacket(NBTTagCompound packetData) {
super.encodeDescriptionPacket(packetData);
packetData.setBoolean("Active", active);
}
@Override
public void readData(DataInputStreamForestry data) throws IOException {
super.readData(data);
setActive(data.readBoolean());
protected void decodeDescriptionPacket(NBTTagCompound packetData) {
super.decodeDescriptionPacket(packetData);
setActive(packetData.getBoolean("Active"));
}
/* IActivatable */
@Override
public boolean isActive() {
return active;
@@ -148,6 +129,11 @@ public abstract class TileAlvearyClimatiser extends TileAlveary implements IEner
}
}
@Override
public ChunkCoordinates getCoordinates() {
return new ChunkCoordinates(xCoord, yCoord, zCoord);
}
/* IEnergyHandler */
@Override
public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) {
@@ -173,4 +159,5 @@ public abstract class TileAlvearyClimatiser extends TileAlveary implements IEner
public boolean canConnectEnergy(ForgeDirection from) {
return energyManager.canConnectEnergy(from);
}
}
@@ -0,0 +1,50 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.multiblock;
import forestry.apiculture.gadgets.BlockAlveary;
public class TileAlvearyFan extends TileAlvearyClimatiser {
private static final FanDefinition definition = new FanDefinition();
public TileAlvearyFan() {
super(definition);
}
private static class FanDefinition implements IClimitiserDefinition {
@Override
public float getChangePerTransfer() {
return -0.01f;
}
@Override
public float getBoundaryUp() {
return 2.5f;
}
@Override
public float getBoundaryDown() {
return 0.05f;
}
@Override
public int getIconOff() {
return BlockAlveary.ALVEARY_FAN_OFF;
}
@Override
public int getIconOn() {
return BlockAlveary.ALVEARY_FAN_ON;
}
}
}
@@ -0,0 +1,50 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.multiblock;
import forestry.apiculture.gadgets.BlockAlveary;
public class TileAlvearyHeater extends TileAlvearyClimatiser {
private static final HeaterDefinition definition = new HeaterDefinition();
public TileAlvearyHeater() {
super(definition);
}
private static class HeaterDefinition implements IClimitiserDefinition {
@Override
public float getChangePerTransfer() {
return 0.01f;
}
@Override
public float getBoundaryUp() {
return 2.5f;
}
@Override
public float getBoundaryDown() {
return 0.0f;
}
@Override
public int getIconOff() {
return BlockAlveary.ALVEARY_HEATER_OFF;
}
@Override
public int getIconOn() {
return BlockAlveary.ALVEARY_HEATER_ON;
}
}
}
@@ -8,9 +8,8 @@
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.gadgets;
package forestry.apiculture.multiblock;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.ICrafting;
import net.minecraft.inventory.IInventory;
@@ -23,7 +22,8 @@ import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTankInfo;
import forestry.api.apiculture.IAlvearyComponent;
import forestry.api.core.ForestryAPI;
import forestry.api.core.IClimateControlled;
import forestry.apiculture.gadgets.BlockAlveary;
import forestry.core.config.Defaults;
import forestry.core.fluids.FluidHelper;
import forestry.core.fluids.Fluids;
@@ -34,58 +34,43 @@ import forestry.core.inventory.IInventoryAdapter;
import forestry.core.inventory.TileInventoryAdapter;
import forestry.core.network.GuiId;
public class TileAlvearyHygroregulator extends TileAlveary implements IInventory, ILiquidTankContainer {
/* CONSTANTS */
public static final int BLOCK_META = 5;
/* RECIPE MANAGMENT */
private static class HygroregulatorRecipe {
public final FluidStack liquid;
public final int transferTime;
public final float humidChange;
public final float tempChange;
public HygroregulatorRecipe(FluidStack liquid, int transferTime, float humidChange, float tempChange) {
this.liquid = liquid;
this.transferTime = transferTime;
this.humidChange = humidChange;
this.tempChange = tempChange;
}
}
public static final short SLOT_INPUT = 0;
public class TileAlvearyHygroregulator extends TileAlvearyWithGui implements IInventory, ILiquidTankContainer, IAlvearyComponent.Climatiser {
private final HygroregulatorRecipe[] recipes;
/* MEMBERS */
private final TankManager tankManager;
private final FilteredTank liquidTank;
private final IInventoryAdapter inventory;
private HygroregulatorRecipe currentRecipe;
private int transferTime;
public TileAlvearyHygroregulator() {
super(BLOCK_META);
super(TileAlveary.HYGRO_META, GuiId.HygroregulatorGUI);
setInternalInventory(new HygroInventoryAdapter(this));
this.inventory = new HygroInventory(this);
Fluid water = Fluids.WATER.getFluid();
Fluid lava = Fluids.LAVA.getFluid();
Fluid liquidIce = Fluids.ICE.getFluid();
liquidTank = new FilteredTank(Defaults.PROCESSOR_TANK_CAPACITY, water, lava, liquidIce);
tankManager = new TankManager(liquidTank);
this.liquidTank = new FilteredTank(Defaults.PROCESSOR_TANK_CAPACITY, water, lava, liquidIce);
this.tankManager = new TankManager(liquidTank);
recipes = new HygroregulatorRecipe[]{new HygroregulatorRecipe(new FluidStack(water, 1), 1, 0.01f, -0.005f),
this.recipes = new HygroregulatorRecipe[]{new HygroregulatorRecipe(new FluidStack(water, 1), 1, 0.01f, -0.005f),
new HygroregulatorRecipe(new FluidStack(lava, 1), 10, -0.01f, +0.005f),
new HygroregulatorRecipe(new FluidStack(liquidIce, 1), 10, 0.02f, -0.01f)};
}
@Override
public void openGui(EntityPlayer player) {
player.openGui(ForestryAPI.instance, GuiId.HygroregulatorGUI.ordinal(), worldObj, xCoord, yCoord, zCoord);
public IInventoryAdapter getInternalInventory() {
return inventory;
}
@Override
public boolean allowsAutomation() {
return true;
}
/* UPDATING */
@@ -101,9 +86,7 @@ public class TileAlvearyHygroregulator extends TileAlveary implements IInventory
}
@Override
protected void updateServerSide() {
super.updateServerSide();
public void changeClimate(int tickCount, IClimateControlled climateControlled) {
if (transferTime <= 0 && liquidTank.getFluidAmount() > 0) {
currentRecipe = getRecipe(liquidTank.getFluid());
@@ -117,17 +100,14 @@ public class TileAlvearyHygroregulator extends TileAlveary implements IInventory
transferTime--;
if (currentRecipe != null) {
IAlvearyComponent component = (IAlvearyComponent) this.getCentralTE();
if (component != null) {
component.addHumidityChange(currentRecipe.humidChange, 0.0f, 1.0f);
component.addTemperatureChange(currentRecipe.tempChange, 0.0f, 2.0f);
}
climateControlled.addHumidityChange(currentRecipe.humidChange, 0.0f, 1.0f);
climateControlled.addTemperatureChange(currentRecipe.tempChange, 0.0f, 2.0f);
} else {
transferTime = 0;
}
}
if (updateOnInterval(20)) {
if (tickCount % 20 == 0) {
IInventoryAdapter canInventory = getInternalInventory();
// Check if we have suitable items waiting in the item slot
@@ -137,11 +117,6 @@ public class TileAlvearyHygroregulator extends TileAlveary implements IInventory
}
}
@Override
public boolean hasFunction() {
return true;
}
/* SAVING & LOADING */
@Override
public void readFromNBT(NBTTagCompound nbttagcompound) {
@@ -167,7 +142,6 @@ public class TileAlvearyHygroregulator extends TileAlveary implements IInventory
currentRecipe.liquid.writeToNBT(subcompound);
nbttagcompound.setTag("CurrentLiquid", subcompound);
}
}
/* TEXTURES */
@@ -220,8 +194,26 @@ public class TileAlvearyHygroregulator extends TileAlveary implements IInventory
public void sendGUINetworkData(Container container, ICrafting iCrafting) {
}
private static class HygroInventoryAdapter extends TileInventoryAdapter<TileAlvearyHygroregulator> {
public HygroInventoryAdapter(TileAlvearyHygroregulator alvearyHygroregulator) {
/* RECIPE MANAGMENT */
private static class HygroregulatorRecipe {
public final FluidStack liquid;
public final int transferTime;
public final float humidChange;
public final float tempChange;
public HygroregulatorRecipe(FluidStack liquid, int transferTime, float humidChange, float tempChange) {
this.liquid = liquid;
this.transferTime = transferTime;
this.humidChange = humidChange;
this.tempChange = tempChange;
}
}
public static class HygroInventory extends TileInventoryAdapter<TileAlvearyHygroregulator> {
public static final short SLOT_INPUT = 0;
public HygroInventory(TileAlvearyHygroregulator alvearyHygroregulator) {
super(alvearyHygroregulator, 1, "CanInv");
}
@@ -0,0 +1,210 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.multiblock;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import net.minecraftforge.common.util.ForgeDirection;
import cpw.mods.fml.common.Optional;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.apiculture.IBeeHousingInventory;
import forestry.api.apiculture.IBeeListener;
import forestry.api.apiculture.IBeeModifier;
import forestry.api.apiculture.IBeekeepingLogic;
import forestry.api.core.EnumHumidity;
import forestry.api.core.EnumTemperature;
import forestry.api.core.ForestryAPI;
import forestry.api.core.IErrorLogic;
import forestry.apiculture.trigger.ApicultureTriggers;
import forestry.core.config.Config;
import forestry.core.interfaces.IClimatised;
import forestry.core.interfaces.IHintSource;
import forestry.core.interfaces.ITitled;
import forestry.core.inventory.IInventoryAdapter;
import forestry.core.multiblock.MultiblockControllerBase;
import forestry.core.multiblock.rectangular.PartPosition;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
import forestry.core.network.GuiId;
import forestry.core.network.IStreamableGui;
import buildcraft.api.statements.IStatementContainer;
import buildcraft.api.statements.ITriggerExternal;
import buildcraft.api.statements.ITriggerInternal;
import buildcraft.api.statements.ITriggerProvider;
@Optional.Interface(iface = "buildcraft.api.statements.ITriggerProvider", modid = "BuildCraftAPI|statements")
public class TileAlvearyPlain extends TileAlveary implements IBeeHousing, IClimatised, IHintSource, IStreamableGui, ITitled, ITriggerProvider {
@Override
public void onMachineAssembled(MultiblockControllerBase controller) {
super.onMachineAssembled(controller);
// set alveary entrance block meta
if (getPartPosition() == PartPosition.Frame) {
if (worldObj.getTileEntity(xCoord, yCoord + 1, zCoord) == null) {
this.worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, TileAlveary.ENTRANCE_META, 2);
}
}
}
@Override
public void onMachineBroken() {
super.onMachineBroken();
// set alveary entrance block meta back to normal
this.worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, TileAlveary.PLAIN_META, 2);
}
@Override
public IInventoryAdapter getInternalInventory() {
return getAlvearyController().getInternalInventory();
}
@Override
public boolean allowsAutomation() {
return true;
}
/* GUI */
@Override
public void openGui(EntityPlayer player) {
if (isConnected()) {
player.openGui(ForestryAPI.instance, GuiId.AlvearyGUI.ordinal(), worldObj, xCoord, yCoord, zCoord);
}
}
@Override
public void writeGuiData(DataOutputStreamForestry data) throws IOException {
getAlvearyController().writeGuiData(data);
}
@Override
public void readGuiData(DataInputStreamForestry data) throws IOException {
getAlvearyController().readGuiData(data);
}
@Override
public String getUnlocalizedTitle() {
return "alveary.0.name";
}
/* IHintSource */
@Override
public boolean hasHints() {
return Config.hints.get("apiary").length > 0;
}
@Override
public String[] getHints() {
return Config.hints.get("apiary");
}
/* ITRIGGERPROVIDER */
@Optional.Method(modid = "BuildCraftAPI|statements")
@Override
public Collection<ITriggerInternal> getInternalTriggers(IStatementContainer container) {
return null;
}
@Optional.Method(modid = "BuildCraftAPI|statements")
@Override
public Collection<ITriggerExternal> getExternalTriggers(ForgeDirection side, TileEntity tile) {
Collection<ITriggerExternal> res = new ArrayList<ITriggerExternal>();
res.add(ApicultureTriggers.missingQueen);
res.add(ApicultureTriggers.missingDrone);
return res;
}
/* IHousing */
@Override
public World getWorld() {
return getAlvearyController().getWorld();
}
@Override
public ChunkCoordinates getCoordinates() {
return getAlvearyController().getCoordinates();
}
@Override
public BiomeGenBase getBiome() {
return getAlvearyController().getBiome();
}
/* IBeeHousing */
@Override
public Iterable<IBeeModifier> getBeeModifiers() {
return getAlvearyController().getBeeModifiers();
}
@Override
public Iterable<IBeeListener> getBeeListeners() {
return getAlvearyController().getBeeListeners();
}
@Override
public IBeeHousingInventory getBeeInventory() {
return getAlvearyController().getBeeInventory();
}
@Override
public IBeekeepingLogic getBeekeepingLogic() {
return getAlvearyController().getBeekeepingLogic();
}
/* IClimatised */
@Override
public EnumTemperature getTemperature() {
return getAlvearyController().getTemperature();
}
@Override
public EnumHumidity getHumidity() {
return getAlvearyController().getHumidity();
}
@Override
public int getBlockLightValue() {
return getAlvearyController().getBlockLightValue();
}
@Override
public boolean canBlockSeeTheSky() {
return getAlvearyController().canBlockSeeTheSky();
}
@Override
public float getExactTemperature() {
return getAlvearyController().getExactTemperature();
}
@Override
public float getExactHumidity() {
return getAlvearyController().getExactHumidity();
}
@Override
public IErrorLogic getErrorLogic() {
return getAlvearyController().getErrorLogic();
}
}
@@ -0,0 +1,151 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.multiblock;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import forestry.api.apiculture.DefaultBeeListener;
import forestry.api.apiculture.IAlvearyComponent;
import forestry.api.apiculture.IBeeListener;
import forestry.api.arboriculture.EnumGermlingType;
import forestry.api.genetics.AlleleManager;
import forestry.api.genetics.IIndividual;
import forestry.api.genetics.ISpeciesRoot;
import forestry.apiculture.gadgets.BlockAlveary;
import forestry.core.config.ForestryItem;
import forestry.core.interfaces.ICrafter;
import forestry.core.inventory.IInventoryAdapter;
import forestry.core.inventory.TileInventoryAdapter;
import forestry.core.network.GuiId;
import forestry.core.utils.StackUtils;
public class TileAlvearySieve extends TileAlvearyWithGui implements ICrafter, IAlvearyComponent.BeeListener {
private final IBeeListener beeListener;
private final AlvearySieveInventory inventory;
public TileAlvearySieve() {
super(TileAlveary.SIEVE_META, GuiId.AlvearySieveGUI);
this.inventory = new AlvearySieveInventory(this);
this.beeListener = new AlvearySieveBeeListener(this);
}
@Override
public IInventoryAdapter getInternalInventory() {
return inventory;
}
@Override
public IBeeListener getBeeListener() {
return beeListener;
}
/* TEXTURES & INTERNAL */
@Override
public int getIcon(int side, int metadata) {
if (side == 0 || side == 1) {
return BlockAlveary.BOTTOM;
}
return BlockAlveary.SIEVE;
}
/* ICRAFTER */
@Override
public boolean canTakeStack(int slotIndex) {
return true;
}
@Override
public ItemStack takenFromSlot(int slotIndex, EntityPlayer player) {
return inventory.takenFromSlot(slotIndex);
}
@Override
public ItemStack getResult() {
return null;
}
private static class AlvearySieveBeeListener extends DefaultBeeListener {
private final TileAlvearySieve tile;
public AlvearySieveBeeListener(TileAlvearySieve tile) {
this.tile = tile;
}
@Override
public boolean onPollenRetrieved(IIndividual pollen) {
if (!tile.inventory.canStorePollen()) {
return false;
}
ISpeciesRoot speciesRoot = AlleleManager.alleleRegistry.getSpeciesRoot(pollen.getClass());
ItemStack pollenStack = speciesRoot.getMemberStack(pollen, EnumGermlingType.POLLEN.ordinal());
if (pollenStack != null) {
tile.inventory.storePollenStack(pollenStack);
return true;
}
return false;
}
}
public static class AlvearySieveInventory extends TileInventoryAdapter<TileAlvearySieve> {
public static final int SLOT_POLLEN_1 = 0;
public static final int SLOTS_POLLEN_COUNT = 4;
public static final int SLOT_SIEVE = 4;
public AlvearySieveInventory(TileAlvearySieve alvearySieve) {
super(alvearySieve, 5, "Items", 1);
}
@Override
public boolean canSlotAccept(int slotIndex, ItemStack itemStack) {
return StackUtils.isIdenticalItem(ForestryItem.craftingMaterial.getItemStack(1, 3), itemStack);
}
private boolean canStorePollen() {
if (getStackInSlot(SLOT_SIEVE) == null) {
return false;
}
for (int i = SLOT_POLLEN_1; i < SLOT_POLLEN_1 + SLOTS_POLLEN_COUNT; i++) {
if (getStackInSlot(i) == null) {
return true;
}
}
return false;
}
private void storePollenStack(ItemStack itemstack) {
for (int i = SLOT_POLLEN_1; i < SLOT_POLLEN_1 + SLOTS_POLLEN_COUNT; i++) {
if (getStackInSlot(i) == null) {
setInventorySlotContents(i, itemstack);
return;
}
}
}
public ItemStack takenFromSlot(int slotIndex) {
if (slotIndex == SLOT_SIEVE) {
for (int i = SLOT_POLLEN_1; i < SLOT_POLLEN_1 + SLOTS_POLLEN_COUNT; i++) {
setInventorySlotContents(i, null);
}
return getStackInSlot(SLOT_SIEVE);
} else {
setInventorySlotContents(SLOT_SIEVE, null);
return getStackInSlot(slotIndex);
}
}
}
}
@@ -0,0 +1,44 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.multiblock;
import forestry.api.apiculture.DefaultBeeModifier;
import forestry.api.apiculture.IAlvearyComponent;
import forestry.api.apiculture.IBeeGenome;
import forestry.api.apiculture.IBeeModifier;
import forestry.apiculture.gadgets.BlockAlveary;
public class TileAlvearyStabiliser extends TileAlveary implements IAlvearyComponent.BeeModifier {
private static final IBeeModifier beeModifier = new AlvearyStabiliserBeeModifier();
/* TEXTURES */
@Override
public int getIcon(int side, int metadata) {
if (side == 0 || side == 1) {
return BlockAlveary.BOTTOM;
}
return BlockAlveary.STABILISER;
}
@Override
public IBeeModifier getBeeModifier() {
return beeModifier;
}
private static class AlvearyStabiliserBeeModifier extends DefaultBeeModifier {
@Override
public float getMutationModifier(IBeeGenome genome, IBeeGenome mate, float currentModifier) {
return 0.0f;
}
}
}
@@ -8,13 +8,11 @@
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.gadgets;
package forestry.apiculture.multiblock;
import java.io.IOException;
import java.util.Map.Entry;
import java.util.Stack;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
@@ -24,55 +22,55 @@ import forestry.api.apiculture.BeeManager;
import forestry.api.apiculture.EnumBeeType;
import forestry.api.apiculture.IAlvearyComponent;
import forestry.api.apiculture.IBee;
import forestry.api.apiculture.IBeeHousing;
import forestry.api.core.ForestryAPI;
import forestry.apiculture.gadgets.BlockAlveary;
import forestry.apiculture.network.PacketActiveUpdate;
import forestry.apiculture.worldgen.Hive;
import forestry.apiculture.worldgen.HiveDecorator;
import forestry.apiculture.worldgen.HiveDescriptionSwarmer;
import forestry.core.interfaces.IActivatable;
import forestry.core.inventory.IInventoryAdapter;
import forestry.core.inventory.TileInventoryAdapter;
import forestry.core.inventory.wrappers.IInvSlot;
import forestry.core.inventory.wrappers.InventoryIterator;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
import forestry.core.network.GuiId;
import forestry.core.proxy.Proxies;
import forestry.core.utils.EnumAccess;
import forestry.core.utils.StackUtils;
public class TileAlvearySwarmer extends TileAlveary implements ISidedInventory, IActivatable {
/* CONSTANTS */
public static final int BLOCK_META = 2;
public class TileAlvearySwarmer extends TileAlvearyWithGui implements ISidedInventory, IActivatable, IAlvearyComponent.Active {
private final SwarmerInventory inventory;
private final Stack<ItemStack> pendingSpawns = new Stack<ItemStack>();
private boolean active;
public TileAlvearySwarmer() {
super(BLOCK_META);
setInternalInventory(new SwarmerInventoryAdapter(this));
super(TileAlveary.SWARMER_META, GuiId.AlvearySwarmerGUI);
this.inventory = new SwarmerInventory(this);
}
@Override
public void openGui(EntityPlayer player) {
player.openGui(ForestryAPI.instance, GuiId.AlvearySwarmerGUI.ordinal(), worldObj, xCoord, yCoord, zCoord);
public IInventoryAdapter getInternalInventory() {
return inventory;
}
@Override
public boolean allowsAutomation() {
return true;
}
/* UPDATING */
@Override
protected void updateServerSide() {
super.updateServerSide();
public void updateServer(int tickCount) {
if (pendingSpawns.size() > 0) {
setActive(true);
if (updateOnInterval(1000)) {
if (tickCount % 1000 == 0) {
trySpawnSwarm();
}
} else {
setActive(false);
}
if (!updateOnInterval(500)) {
if (tickCount % 500 != 0) {
return;
}
@@ -97,23 +95,19 @@ public class TileAlvearySwarmer extends TileAlveary implements ISidedInventory,
pendingSpawns.push(BeeManager.beeRoot.getMemberStack(princess, EnumBeeType.PRINCESS.ordinal()));
}
@Override
public void updateClient(int tickCount) {
}
private ItemStack getPrincessStack() {
if (!this.hasMaster()) {
return null;
ItemStack princessStack = getAlvearyController().getBeeInventory().getQueen();
if (BeeManager.beeRoot.isMated(princessStack)) {
return princessStack;
}
IAlvearyComponent master = (IAlvearyComponent) this.getCentralTE();
if (!(master instanceof IBeeHousing)) {
return null;
}
IBeeHousing housing = (IBeeHousing) master;
ItemStack princessStack = housing.getQueen();
if (princessStack == null || !BeeManager.beeRoot.isMated(princessStack)) {
return null;
}
return princessStack;
return null;
}
private int consumeInducerAndGetChance() {
@@ -151,24 +145,15 @@ public class TileAlvearySwarmer extends TileAlveary implements ISidedInventory,
/* NETWORK */
@Override
public void writeData(DataOutputStreamForestry data) throws IOException {
super.writeData(data);
data.writeBoolean(active);
protected void encodeDescriptionPacket(NBTTagCompound packetData) {
super.encodeDescriptionPacket(packetData);
packetData.setBoolean("Active", active);
}
@Override
public void readData(DataInputStreamForestry data) throws IOException {
super.readData(data);
boolean active = data.readBoolean();
if (this.active != active) {
this.active = active;
worldObj.func_147479_m(xCoord, yCoord, zCoord);
}
}
@Override
public boolean hasFunction() {
return true;
protected void decodeDescriptionPacket(NBTTagCompound packetData) {
super.decodeDescriptionPacket(packetData);
setActive(packetData.getBoolean("Active"));
}
/* TEXTURES */
@@ -189,18 +174,19 @@ public class TileAlvearySwarmer extends TileAlveary implements ISidedInventory,
@Override
public void readFromNBT(NBTTagCompound nbttagcompound) {
super.readFromNBT(nbttagcompound);
setActive(nbttagcompound.getBoolean("Active"));
NBTTagList nbttaglist = nbttagcompound.getTagList("PendingSpawns", 10);
for (int i = 0; i < nbttaglist.tagCount(); i++) {
NBTTagCompound nbttagcompound1 = nbttaglist.getCompoundTagAt(i);
pendingSpawns.add(ItemStack.loadItemStackFromNBT(nbttagcompound1));
}
}
@Override
public void writeToNBT(NBTTagCompound nbttagcompound) {
super.writeToNBT(nbttagcompound);
nbttagcompound.setBoolean("Active", active);
NBTTagList nbttaglist = new NBTTagList();
ItemStack[] offspring = pendingSpawns.toArray(new ItemStack[pendingSpawns.size()]);
@@ -213,7 +199,15 @@ public class TileAlvearySwarmer extends TileAlveary implements ISidedInventory,
}
}
nbttagcompound.setTag("PendingSpawns", nbttaglist);
}
@Override
public void onSwitchAccess(EnumAccess oldAccess, EnumAccess newAccess) {
if (oldAccess == EnumAccess.SHARED || newAccess == EnumAccess.SHARED) {
// pipes connected to this need to update
worldObj.notifyBlocksOfNeighborChange(xCoord, yCoord, zCoord, blockType);
markDirty();
}
}
@Override
@@ -234,8 +228,8 @@ public class TileAlvearySwarmer extends TileAlveary implements ISidedInventory,
}
}
private static class SwarmerInventoryAdapter extends TileInventoryAdapter<TileAlvearySwarmer> {
public SwarmerInventoryAdapter(TileAlvearySwarmer alvearySwarmer) {
private static class SwarmerInventory extends TileInventoryAdapter<TileAlvearySwarmer> {
public SwarmerInventory(TileAlvearySwarmer alvearySwarmer) {
super(alvearySwarmer, 4, "SwarmInv");
}
@@ -0,0 +1,92 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.multiblock;
import java.io.IOException;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.ChunkCoordinates;
import forestry.api.core.ForestryAPI;
import forestry.core.delegates.AccessHandler;
import forestry.core.interfaces.IAccessHandler;
import forestry.core.interfaces.IRestrictedAccessTile;
import forestry.core.interfaces.ITitled;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
import forestry.core.network.GuiId;
import forestry.core.network.IStreamableGui;
import forestry.core.utils.EnumAccess;
public abstract class TileAlvearyWithGui extends TileAlveary implements IStreamableGui, ITitled, IRestrictedAccessTile {
private final AccessHandler accessHandler;
private final String unlocalizedTitle;
private final GuiId guiId;
public TileAlvearyWithGui(int meta, GuiId guiId) {
this.accessHandler = new AccessHandler(this);
this.unlocalizedTitle = "alveary." + meta + ".name";
this.guiId = guiId;
}
@Override
public final IAccessHandler getAccessHandler() {
return accessHandler;
}
@Override
public final ChunkCoordinates getCoordinates() {
return new ChunkCoordinates(xCoord, yCoord, zCoord);
}
@Override
public void onSwitchAccess(EnumAccess oldAccess, EnumAccess newAccess) {
if (oldAccess == EnumAccess.SHARED || newAccess == EnumAccess.SHARED) {
// pipes connected to this need to update
worldObj.notifyBlocksOfNeighborChange(xCoord, yCoord, zCoord, blockType);
markDirty();
}
}
@Override
public void writeToNBT(NBTTagCompound data) {
super.writeToNBT(data);
accessHandler.writeToNBT(data);
}
@Override
public void readFromNBT(NBTTagCompound data) {
super.readFromNBT(data);
accessHandler.readFromNBT(data);
}
@Override
public void writeGuiData(DataOutputStreamForestry data) throws IOException {
accessHandler.writeData(data);
}
@Override
public void readGuiData(DataInputStreamForestry data) throws IOException {
accessHandler.readData(data);
}
@Override
public final String getUnlocalizedTitle() {
return unlocalizedTitle;
}
@Override
public final void openGui(EntityPlayer player) {
player.openGui(ForestryAPI.instance, guiId.ordinal(), worldObj, xCoord, yCoord, zCoord);
}
}
@@ -14,7 +14,6 @@ import java.io.IOException;
import net.minecraft.tileentity.TileEntity;
import forestry.core.gadgets.TileForestry;
import forestry.core.interfaces.IActivatable;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
@@ -24,7 +23,7 @@ import forestry.core.proxy.Proxies;
public class PacketActiveUpdate extends PacketCoordinates {
private IActivatable activatable;
private boolean active;
public static void onPacketData(DataInputStreamForestry data) throws IOException {
new PacketActiveUpdate(data);
@@ -34,22 +33,22 @@ public class PacketActiveUpdate extends PacketCoordinates {
super(data);
}
public <T extends TileForestry & IActivatable> PacketActiveUpdate(T tile) {
super(PacketId.TILE_FORESTRY_ACTIVE, tile);
this.activatable = tile;
public PacketActiveUpdate(IActivatable tile) {
super(PacketId.TILE_FORESTRY_ACTIVE, tile.getCoordinates());
this.active = tile.isActive();
}
@Override
protected void writeData(DataOutputStreamForestry data) throws IOException {
super.writeData(data);
data.writeBoolean(activatable.isActive());
data.writeBoolean(active);
}
@Override
protected void readData(DataInputStreamForestry data) throws IOException {
super.readData(data);
boolean active = data.readBoolean();
active = data.readBoolean();
TileEntity tile = getTarget(Proxies.common.getRenderWorld());
if (tile instanceof IActivatable) {
@@ -0,0 +1,58 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.apiculture.network;
import java.io.IOException;
import net.minecraft.tileentity.TileEntity;
import forestry.api.apiculture.IBeeHousing;
import forestry.apiculture.BeekeepingLogic;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
import forestry.core.network.PacketCoordinates;
import forestry.core.network.PacketId;
import forestry.core.proxy.Proxies;
public class PacketBeekeepingLogicActive extends PacketCoordinates {
private BeekeepingLogic beekeepingLogic;
public static void onPacketData(DataInputStreamForestry data) throws IOException {
new PacketBeekeepingLogicActive(data);
}
private PacketBeekeepingLogicActive(DataInputStreamForestry data) throws IOException {
super(data);
}
public PacketBeekeepingLogicActive(IBeeHousing tile) {
super(PacketId.BEE_LOGIC_ACTIVE, tile.getCoordinates());
this.beekeepingLogic = (BeekeepingLogic) tile.getBeekeepingLogic();
}
@Override
protected void writeData(DataOutputStreamForestry data) throws IOException {
super.writeData(data);
beekeepingLogic.writeData(data);
}
@Override
protected void readData(DataInputStreamForestry data) throws IOException {
super.readData(data);
TileEntity tile = getTarget(Proxies.common.getRenderWorld());
if (tile instanceof IBeeHousing) {
IBeeHousing beeHousing = (IBeeHousing) tile;
BeekeepingLogic beekeepingLogic = (BeekeepingLogic) beeHousing.getBeekeepingLogic();
beekeepingLogic.readData(data);
}
}
}
@@ -43,6 +43,10 @@ public class PacketHandlerApiculture implements IPacketHandler {
onCandleUpdate(updateCandle);
return true;
}
case BEE_LOGIC_ACTIVE: {
PacketBeekeepingLogicActive.onPacketData(data);
return true;
}
}
return false;
@@ -11,6 +11,7 @@
package forestry.apiculture.proxy;
import net.minecraft.client.particle.EntityFX;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.world.World;
import net.minecraftforge.client.MinecraftForgeClient;
@@ -27,6 +28,7 @@ import forestry.core.interfaces.IBlockRenderer;
import forestry.core.proxy.ClientProxyRender;
import forestry.core.render.RenderAnalyzer;
import forestry.core.render.TextureManager;
import forestry.core.vect.IVect;
import forestry.plugins.PluginApiculture;
public class ClientProxyApiculture extends ProxyApiculture {
@@ -43,7 +45,7 @@ public class ClientProxyApiculture extends ProxyApiculture {
}
@Override
public void addBeeHiveFX(String icon, World world, double xCoord, double yCoord, double zCoord, int color, int areaX, int areaY, int areaZ) {
public void addBeeHiveFX(String icon, World world, ChunkCoordinates coordinates, int color, IVect area) {
if (!ClientProxyRender.shouldSpawnParticle(world)) {
return;
}
@@ -51,11 +53,11 @@ public class ClientProxyApiculture extends ProxyApiculture {
EntityFX fx;
if (world.rand.nextBoolean()) {
fx = new EntityBeeFX(world, xCoord + 0.5D, yCoord + 0.75D, zCoord + 0.5D, 0.0f, 0.0f, 0.0f, color);
fx = new EntityBeeFX(world, coordinates.posX + 0.5D, coordinates.posY + 0.75D, coordinates.posZ + 0.5D, 0.0f, 0.0f, 0.0f, color);
} else {
double spawnX = xCoord + world.rand.nextInt(areaX * 2) - areaX;
double spawnY = yCoord + world.rand.nextInt(areaY);
double spawnZ = zCoord + world.rand.nextInt(areaZ * 2) - areaZ;
double spawnX = coordinates.posX + world.rand.nextInt(area.getX() * 2) - area.getX();
double spawnY = coordinates.posY + world.rand.nextInt(area.getY());
double spawnZ = coordinates.posZ + world.rand.nextInt(area.getZ() * 2) - area.getZ();
fx = new EntityBeeFX(world, spawnX, spawnY, spawnZ, 0.0f, 0.0f, 0.0f, color);
}
@@ -10,12 +10,14 @@
******************************************************************************/
package forestry.apiculture.proxy;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.world.World;
import forestry.core.interfaces.IBlockRenderer;
import forestry.core.vect.IVect;
public class ProxyApiculture {
public void addBeeHiveFX(String texture, World world, double xCoord, double yCoord, double zCoord, int color, int areaX, int areaY, int areaZ) {
public void addBeeHiveFX(String texture, World world, ChunkCoordinates coordinates, int color, IVect area) {
}
public void addBeeSwarmFX(String texture, World world, double xCoord, double yCoord, double zCoord, int color) {
@@ -14,9 +14,8 @@ import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;
import forestry.apiculture.gadgets.TileAlveary;
import forestry.api.core.IErrorLogicSource;
import forestry.core.EnumErrorCode;
import forestry.core.interfaces.IErrorSource;
import forestry.core.triggers.Trigger;
import buildcraft.api.statements.IStatementContainer;
@@ -34,14 +33,12 @@ public class TriggerMissingDrone extends Trigger {
@Override
public boolean isTriggerActive(TileEntity tile, ForgeDirection side, IStatementContainer source, IStatementParameter[] parameters) {
if (!(tile instanceof IErrorSource)) {
if (!(tile instanceof IErrorLogicSource)) {
return false;
}
if (tile instanceof TileAlveary) {
tile = (TileAlveary) ((TileAlveary) tile).getCentralTE();
}
return ((IErrorSource) tile).getErrorStates().contains(EnumErrorCode.NODRONE);
IErrorLogicSource apiary = (IErrorLogicSource) tile;
return apiary.getErrorLogic().contains(EnumErrorCode.NODRONE);
}
}
@@ -14,9 +14,8 @@ import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;
import forestry.apiculture.gadgets.TileAlveary;
import forestry.api.core.IErrorLogicSource;
import forestry.core.EnumErrorCode;
import forestry.core.interfaces.IErrorSource;
import forestry.core.triggers.Trigger;
import buildcraft.api.statements.IStatementContainer;
@@ -34,13 +33,11 @@ public class TriggerMissingQueen extends Trigger {
@Override
public boolean isTriggerActive(TileEntity tile, ForgeDirection side, IStatementContainer source, IStatementParameter[] parameters) {
if (!(tile instanceof IErrorSource)) {
if (!(tile instanceof IErrorLogicSource)) {
return false;
}
if (tile instanceof TileAlveary) {
tile = (TileAlveary) ((TileAlveary) tile).getCentralTE();
}
return ((IErrorSource) tile).getErrorStates().contains(EnumErrorCode.NOQUEEN);
IErrorLogicSource apiary = (IErrorLogicSource) tile;
return apiary.getErrorLogic().contains(EnumErrorCode.NOQUEEN);
}
}
@@ -36,14 +36,11 @@ public class TriggerNoFrames extends Trigger {
return false;
}
for (int i = TileApiary.SLOT_FRAMES_1; i < TileApiary.SLOT_FRAMES_1 + TileApiary.SLOT_FRAMES_COUNT; i++) {
if (((TileApiary) tile).getStackInSlot(i) != null) {
return false;
}
}
TileApiary apiary = (TileApiary) tile;
return true;
TileApiary.ApiaryInventory inventory = (TileApiary.ApiaryInventory) apiary.getInternalInventory();
return inventory.getFrames().size() == 0;
}
}
@@ -11,7 +11,6 @@
package forestry.apiculture.worldgen;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Random;
@@ -36,9 +35,8 @@ import forestry.api.apiculture.IBeeGenome;
import forestry.api.core.EnumHumidity;
import forestry.api.core.EnumTemperature;
import forestry.api.genetics.AlleleManager;
import forestry.api.genetics.EnumTolerance;
import forestry.api.genetics.IFlower;
import forestry.apiculture.gadgets.TileBeehouse;
import forestry.apiculture.gadgets.TileApiary;
import forestry.arboriculture.gadgets.BlockFireproofLog;
import forestry.arboriculture.gadgets.BlockFireproofPlanks;
import forestry.arboriculture.gadgets.BlockLog;
@@ -298,38 +296,52 @@ public class ComponentVillageBeeHouse extends StructureVillagePieces.House1 {
int yCoord = this.getYWithOffset(y);
int zCoord = this.getZWithOffset(x, z);
if (box.isVecInside(xCoord, yCoord, zCoord) && !ForestryBlock.apiculture.isBlockEqual(world, xCoord, yCoord, zCoord)
&& world.blockExists(xCoord, yCoord - 1, zCoord)) {
if (!box.isVecInside(xCoord, yCoord, zCoord) || ForestryBlock.apiculture.isBlockEqual(world, xCoord, yCoord, zCoord)
|| !world.blockExists(xCoord, yCoord - 1, zCoord)) {
return;
}
world.setBlock(xCoord, yCoord, zCoord, ForestryBlock.apiculture.block(), Defaults.DEFINITION_APIARY_META,
Defaults.FLAG_BLOCK_SYNCH);
ForestryBlock.apiculture.block().onBlockAdded(world, xCoord, yCoord, zCoord);
world.setBlock(xCoord, yCoord, zCoord, ForestryBlock.apiculture.block(), Defaults.DEFINITION_APIARY_META, Defaults.FLAG_BLOCK_SYNCH);
ForestryBlock.apiculture.block().onBlockAdded(world, xCoord, yCoord, zCoord);
TileEntity tile = world.getTileEntity(xCoord, yCoord, zCoord);
if (tile instanceof TileBeehouse) {
TileBeehouse apiary = ((TileBeehouse) tile);
apiary.initialize();
apiary.setInventorySlotContents(TileBeehouse.SLOT_QUEEN,
BeeManager.beeRoot.getMemberStack(getVillageBee(world, xCoord, yCoord, zCoord), EnumBeeType.PRINCESS.ordinal()));
apiary.setInventorySlotContents(TileBeehouse.SLOT_DRONE,
BeeManager.beeRoot.getMemberStack(getVillageBee(world, xCoord, yCoord, zCoord), EnumBeeType.DRONE.ordinal()));
TileEntity tile = world.getTileEntity(xCoord, yCoord, zCoord);
if (!(tile instanceof TileApiary)) {
return;
}
for (int i = TileBeehouse.SLOT_FRAMES_1; i < TileBeehouse.SLOT_FRAMES_1 + TileBeehouse.SLOT_FRAMES_COUNT; i++) {
float roll = world.rand.nextFloat();
if (roll < 0.2f) {
apiary.setInventorySlotContents(i, ForestryItem.frameUntreated.getItemStack());
} else if (roll < 0.4f) {
apiary.setInventorySlotContents(i, ForestryItem.frameImpregnated.getItemStack());
} else if (roll < 0.6) {
apiary.setInventorySlotContents(i, ForestryItem.frameProven.getItemStack());
}
}
TileApiary apiary = (TileApiary) tile;
}
ItemStack randomVillagePrincess = getRandomVillageBeeStack(world, xCoord, yCoord, zCoord, EnumBeeType.PRINCESS);
apiary.getBeeInventory().setQueen(randomVillagePrincess);
ItemStack randomVillageDrone = getRandomVillageBeeStack(world, xCoord, yCoord, zCoord, EnumBeeType.DRONE);
apiary.getBeeInventory().setDrone(randomVillageDrone);
for (int i = TileApiary.ApiaryInventory.SLOT_FRAMES_1; i < TileApiary.ApiaryInventory.SLOT_FRAMES_1 + TileApiary.ApiaryInventory.SLOT_FRAMES_COUNT; i++) {
ItemStack randomFrame = getRandomFrame(world.rand);
apiary.setInventorySlotContents(i, randomFrame);
}
}
private static IBee getVillageBee(World world, int xCoord, int yCoord, int zCoord) {
private static ItemStack getRandomFrame(Random random) {
float roll = random.nextFloat();
if (roll < 0.2f) {
return ForestryItem.frameUntreated.getItemStack();
} else if (roll < 0.4f) {
return ForestryItem.frameImpregnated.getItemStack();
} else if (roll < 0.6) {
return ForestryItem.frameProven.getItemStack();
} else {
return null;
}
}
private static ItemStack getRandomVillageBeeStack(World world, int xCoord, int yCoord, int zCoord, EnumBeeType beeType) {
IBee randomVillageBee = getRandomVillageBee(world, xCoord, yCoord, zCoord);
return BeeManager.beeRoot.getMemberStack(randomVillageBee, beeType.ordinal());
}
private static IBee getRandomVillageBee(World world, int xCoord, int yCoord, int zCoord) {
// Get current biome
BiomeGenBase biome = world.getBiomeGenForCoords(xCoord, zCoord);
@@ -154,13 +154,7 @@ public class ForestryBlockLeaves extends BlockNewLeaf implements ITileEntityProv
}
// Add saplings
ITree[] saplings;
try {
saplings = tile.getTree().getSaplings(world, playerProfile, x, y, z, saplingModifier);
} catch (Throwable ignored) {
// legacy
saplings = tile.getTree().getSaplings(world, x, y, z, saplingModifier);
}
ITree[] saplings = tile.getTree().getSaplings(world, playerProfile, x, y, z, saplingModifier);
for (ITree sapling : saplings) {
if (sapling != null) {
@@ -10,8 +10,6 @@
******************************************************************************/
package forestry.arboriculture.gadgets;
import com.google.common.collect.ImmutableSet;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collection;
@@ -23,11 +21,9 @@ import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.Packet;
import net.minecraft.util.ChunkCoordinates;
import net.minecraft.util.IIcon;
import net.minecraft.world.World;
import net.minecraft.world.biome.BiomeGenBase;
import com.mojang.authlib.GameProfile;
import net.minecraftforge.common.EnumPlantType;
@@ -41,9 +37,6 @@ import forestry.api.arboriculture.ILeafTickHandler;
import forestry.api.arboriculture.ITree;
import forestry.api.arboriculture.ITreeGenome;
import forestry.api.arboriculture.ITreekeepingMode;
import forestry.api.core.EnumHumidity;
import forestry.api.core.EnumTemperature;
import forestry.api.core.IErrorState;
import forestry.api.genetics.AlleleManager;
import forestry.api.genetics.IAllele;
import forestry.api.genetics.IEffectData;
@@ -56,7 +49,6 @@ import forestry.api.lepidopterology.IButterflyGenome;
import forestry.api.lepidopterology.IButterflyNursery;
import forestry.api.lepidopterology.IButterflyRoot;
import forestry.arboriculture.network.PacketRipeningUpdate;
import forestry.core.EnumErrorCode;
import forestry.core.genetics.alleles.Allele;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
@@ -87,17 +79,8 @@ public class TileLeaves extends TileTreeContainer implements IPollinatable, IFru
private int maturationTime;
private int damage;
private BiomeGenBase biome;
private IEffectData effectData[] = new IEffectData[2];
private void updateBiome() {
if (worldObj == null) {
return;
}
biome = worldObj.getBiomeGenForCoordsBody(xCoord, zCoord);
}
/* SAVING & LOADING */
@Override
public void readFromNBT(NBTTagCompound nbttagcompound) {
@@ -142,10 +125,6 @@ public class TileLeaves extends TileTreeContainer implements IPollinatable, IFru
@Override
public void onBlockTick() {
if (biome == null) {
updateBiome();
}
ITree tree = getTree();
if (isDecorative || tree == null) {
return;
@@ -155,7 +134,7 @@ public class TileLeaves extends TileTreeContainer implements IPollinatable, IFru
boolean isDestroyed = isDestroyed(tree, damage);
for (ILeafTickHandler tickHandler : genome.getPrimary().getRoot().getLeafTickHandlers()) {
if (tickHandler.onRandomLeafTick(tree, worldObj, biome.biomeID, xCoord, yCoord, zCoord, isDestroyed)) {
if (tickHandler.onRandomLeafTick(tree, worldObj, xCoord, yCoord, zCoord, isDestroyed)) {
return;
}
}
@@ -183,7 +162,7 @@ public class TileLeaves extends TileTreeContainer implements IPollinatable, IFru
matureCaterpillar();
}
effectData = tree.doEffect(effectData, worldObj, biome.biomeID, xCoord, yCoord, zCoord);
effectData = tree.doEffect(effectData, worldObj, xCoord, yCoord, zCoord);
}
@Override
@@ -523,62 +502,8 @@ public class TileLeaves extends TileTreeContainer implements IPollinatable, IFru
}
@Override
public World getWorld() {
return worldObj;
}
@Override
public int getXCoord() {
return xCoord;
}
@Override
public int getYCoord() {
return yCoord;
}
@Override
public int getZCoord() {
return zCoord;
}
@Override
public BiomeGenBase getBiome() {
return biome;
}
@Override
public EnumTemperature getTemperature() {
return null;
}
@Override
public EnumHumidity getHumidity() {
return null;
}
@Override
public boolean setErrorCondition(boolean condition, IErrorState errorState) {
return condition;
}
@Override
public ImmutableSet<IErrorState> getErrorStates() {
return ImmutableSet.of();
}
@Override
public void setErrorState(IErrorState state) {
}
@Override
public EnumErrorCode getErrorState() {
return null;
}
@Override
public boolean addProduct(ItemStack product, boolean all) {
return false;
public ChunkCoordinates getCoordinates() {
return new ChunkCoordinates(xCoord, yCoord, zCoord);
}
@Override
@@ -607,9 +532,4 @@ public class TileLeaves extends TileTreeContainer implements IPollinatable, IFru
return !isDecorative && !isDestroyed(tree, damage) && caterpillar == null;
}
/* IHousing */
@Override
public GameProfile getOwnerName() {
return this.getOwner();
}
}
@@ -12,7 +12,6 @@ package forestry.arboriculture.gadgets;
import java.io.IOException;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTUtil;
import net.minecraft.network.Packet;
@@ -23,11 +22,9 @@ import com.mojang.authlib.GameProfile;
import forestry.api.arboriculture.ITree;
import forestry.api.genetics.IAllele;
import forestry.arboriculture.genetics.Tree;
import forestry.core.interfaces.IOwnable;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
import forestry.core.network.IStreamable;
import forestry.core.utils.PlayerUtil;
import forestry.plugins.PluginArboriculture;
/**
@@ -35,9 +32,10 @@ import forestry.plugins.PluginArboriculture;
*
* @author SirSengir
*/
public abstract class TileTreeContainer extends TileEntity implements IStreamable, IOwnable {
public abstract class TileTreeContainer extends TileEntity implements IStreamable {
private ITree containedTree;
private GameProfile owner;
/* SAVING & LOADING */
@Override
@@ -104,6 +102,15 @@ public abstract class TileTreeContainer extends TileEntity implements IStreamabl
return this.containedTree;
}
/* Owner */
public GameProfile getOwner() {
return owner;
}
public void setOwner(GameProfile owner) {
this.owner = owner;
}
/* UPDATING */
/**
@@ -123,36 +130,4 @@ public abstract class TileTreeContainer extends TileEntity implements IStreamabl
@Override
public abstract Packet getDescriptionPacket();
/* IOWNABLE */
public GameProfile owner = null;
@Override
public boolean allowsRemoval(EntityPlayer player) {
return true;
}
@Override
public boolean isOwned() {
return owner != null;
}
@Override
public GameProfile getOwner() {
return owner;
}
@Override
public void setOwner(EntityPlayer player) {
this.owner = player.getGameProfile();
}
public void setOwner(GameProfile playername) {
this.owner = playername;
}
@Override
public boolean isOwner(EntityPlayer player) {
return PlayerUtil.isSameGameProfile(owner, player.getGameProfile());
}
}
@@ -93,7 +93,7 @@ public class AlleleTreeSpecies extends AlleleSpecies implements IAlleleTreeSpeci
public AlleleTreeSpecies(String uid, boolean isDominant, String speciesName, IClassification branch, String binomial, int primaryColor, int secondaryColor,
Class<? extends WorldGenArboriculture> generator, ItemStack wood) {
super("forestry." + uid, "for.trees.species." + speciesName, "Sengir", "for.description." + uid, isDominant, branch, binomial, true);
super("forestry." + uid, "for.trees.species." + speciesName, "Sengir", "for.description." + uid, isDominant, branch, binomial, true);
this.root = (ITreeRoot) AlleleManager.alleleRegistry.getSpeciesRoot("rootTrees");
this.generatorClass = generator;
@@ -42,11 +42,9 @@ import forestry.api.arboriculture.ITreeGenome;
import forestry.api.arboriculture.ITreeMutation;
import forestry.api.genetics.IAllele;
import forestry.api.genetics.IAlleleBoolean;
import forestry.api.genetics.IAlleleSpecies;
import forestry.api.genetics.IChromosome;
import forestry.api.genetics.IEffectData;
import forestry.api.genetics.IFruitFamily;
import forestry.api.genetics.IGenome;
import forestry.api.genetics.IMutation;
import forestry.arboriculture.gadgets.ForestryBlockLeaves;
import forestry.arboriculture.gadgets.TileLeaves;
@@ -120,14 +118,14 @@ public class Tree extends Individual implements ITree, IPlantable {
/* EFFECTS */
@Override
public IEffectData[] doEffect(IEffectData[] storedData, World world, int biomeid, int x, int y, int z) {
public IEffectData[] doEffect(IEffectData[] storedData, World world, int x, int y, int z) {
IAlleleLeafEffect effect = (IAlleleLeafEffect) getGenome().getActiveAllele(EnumTreeChromosome.EFFECT);
if (effect == null) {
return null;
}
storedData[0] = doEffect(effect, storedData[0], world, biomeid, x, y, z);
storedData[0] = doEffect(effect, storedData[0], world, x, y, z);
// Return here if the primary can already not be combined
if (!effect.isCombinable()) {
@@ -139,18 +137,18 @@ public class Tree extends Individual implements ITree, IPlantable {
return storedData;
}
storedData[1] = doEffect(secondary, storedData[1], world, biomeid, x, y, z);
storedData[1] = doEffect(secondary, storedData[1], world, x, y, z);
return storedData;
}
private IEffectData doEffect(IAlleleLeafEffect effect, IEffectData storedData, World world, int biomeid, int x, int y, int z) {
private IEffectData doEffect(IAlleleLeafEffect effect, IEffectData storedData, World world, int x, int y, int z) {
storedData = effect.validateStorage(storedData);
return effect.doEffect(getGenome(), storedData, world, x, y, z);
}
@Override
public IEffectData[] doFX(IEffectData[] storedData, World world, int biomeid, int x, int y, int z) {
public IEffectData[] doFX(IEffectData[] storedData, World world, int x, int y, int z) {
return null;
}
@@ -358,11 +356,6 @@ public class Tree extends Individual implements ITree, IPlantable {
}
/* REPRODUCTION */
@Override
public ITree[] getSaplings(World world, int x, int y, int z, float modifier) {
return getSaplings(world, null, x, y, z, modifier);
}
@Override
public ITree[] getSaplings(World world, GameProfile playerProfile, int x, int y, int z, float modifier) {
ArrayList<ITree> prod = new ArrayList<ITree>();
@@ -406,15 +399,15 @@ public class Tree extends Individual implements ITree, IPlantable {
return new Tree(new TreeGenome(chromosomes));
}
private static IChromosome[] mutateSpecies(World world, @Nullable GameProfile playerProfile, int x, int y, int z, IGenome genomeOne, IGenome genomeTwo) {
private static IChromosome[] mutateSpecies(World world, @Nullable GameProfile playerProfile, int x, int y, int z, ITreeGenome genomeOne, ITreeGenome genomeTwo) {
IChromosome[] parent1 = genomeOne.getChromosomes();
IChromosome[] parent2 = genomeTwo.getChromosomes();
IGenome genome0;
IGenome genome1;
IAlleleSpecies allele0;
IAlleleSpecies allele1;
ITreeGenome genome0;
ITreeGenome genome1;
IAlleleTreeSpecies allele0;
IAlleleTreeSpecies allele1;
if (world.rand.nextBoolean()) {
allele0 = (IAlleleTreeSpecies) parent1[EnumTreeChromosome.SPECIES.ordinal()].getPrimaryAllele();
@@ -45,9 +45,7 @@ import forestry.api.genetics.IChromosomeType;
import forestry.api.genetics.IIndividual;
import forestry.api.genetics.IMutation;
import forestry.arboriculture.gadgets.BlockFruitPod;
import forestry.arboriculture.gadgets.ForestryBlockLeaves;
import forestry.arboriculture.gadgets.TileFruitPod;
import forestry.arboriculture.gadgets.TileLeaves;
import forestry.arboriculture.gadgets.TileSapling;
import forestry.core.config.Defaults;
import forestry.core.config.ForestryBlock;
@@ -160,6 +158,9 @@ public class TreeHelper extends SpeciesRoot implements ITreeRoot {
@Override
public ItemStack getMemberStack(IIndividual tree, int type) {
if (!isMember(tree)) {
return null;
}
Item germlingItem;
switch (EnumGermlingType.VALUES[type]) {
@@ -209,33 +210,6 @@ public class TreeHelper extends SpeciesRoot implements ITreeRoot {
return true;
}
@Override
public boolean setLeaves(World world, IIndividual tree, GameProfile owner, int x, int y, int z) {
return setLeaves(world, tree, owner, x, y, z, false);
}
@Override
public boolean setLeaves(World world, IIndividual tree, GameProfile owner, int x, int y, int z, boolean decorative) {
if (decorative) {
((ITree) tree).setLeavesDecorative(world, owner, x, y, z);
} else {
((ITree) tree).setLeaves(world, owner, x, y, z);
}
if (!ForestryBlock.leaves.isBlockEqual(world, x, y, z)) {
return false;
}
TileLeaves tileLeaves = ForestryBlockLeaves.getLeafTile(world, x, y, z);
if (tileLeaves == null) {
world.setBlockToAir(x, y, z);
return false;
}
return true;
}
@Override
public boolean setFruitBlock(World world, IAlleleFruit allele, float sappiness, short[] indices, int x, int y, int z) {
@@ -19,7 +19,6 @@ import forestry.api.arboriculture.ITreeRoot;
import forestry.api.genetics.AlleleManager;
import forestry.api.genetics.IAllele;
import forestry.api.genetics.IAlleleSpecies;
import forestry.api.genetics.IGenome;
import forestry.core.genetics.Mutation;
import forestry.plugins.PluginArboriculture;
@@ -38,11 +37,6 @@ public class TreeMutation extends Mutation implements ITreeMutation {
public ITreeRoot getRoot() {
return root;
}
@Override
public float getChance(World world, int x, int y, int z, IAllele allele0, IAllele allele1, IGenome genome0, IGenome genome1) {
return getChance(world, x, y, z, (IAlleleTreeSpecies) allele0, (IAlleleTreeSpecies) allele1, (ITreeGenome) genome0, (ITreeGenome) genome1);
}
@Override
public float getChance(World world, int x, int y, int z, IAlleleTreeSpecies allele0, IAlleleTreeSpecies allele1, ITreeGenome genome0, ITreeGenome genome1) {
@@ -11,15 +11,13 @@ import net.minecraft.util.IIcon;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import forestry.api.core.ErrorStateRegistry;
import forestry.api.core.ForestryAPI;
import forestry.api.core.IErrorState;
import forestry.core.config.Defaults;
public enum EnumErrorCode implements IErrorState {
UNKNOWN("unknown"),
@Deprecated // use no error code
OK("ok"),
INVALIDBIOME("invalidBiome"),
ISRAINING("isRaining"),
NOTRAINING("notRaining"),
@@ -49,15 +47,12 @@ public enum EnumErrorCode implements IErrorState {
NOSTAMPS("noStamps"),
NOCIRCUITBOARD("noCircuitBoard"),
NOCIRCUITLAYOUT("noCircuitLayout"),
@Deprecated // wrong stack size is prevented in code
WRONGSTACKSIZE("wrongStacksize"),
NOFERTILIZER("noFertilizer"),
NOFARMLAND("noFarmland"),
CIRCUITMISMATCH("circuitMismatch"),
NOLIQUID("noLiquid"),
NOPAPER("noPaper"),
@Deprecated // use two error codes instead: NOSTAMPS and NOPAPER
NOSTAMPSNOPAPER("noStampsNoPaper", "noStamps"),
NOSUPPLIES("noSupplies", "noResource"),
NOTRADE("noTrade", "noResource"),
NOPOWER("noPower"),
@@ -113,7 +108,7 @@ public enum EnumErrorCode implements IErrorState {
public static void init() {
for (IErrorState code : values()) {
ErrorStateRegistry.registerErrorState(code);
ForestryAPI.errorStateRegistry.registerErrorState(code);
}
}
}
@@ -0,0 +1,98 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.core;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import net.minecraft.client.renderer.texture.IIconRegister;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import forestry.api.core.IErrorLogic;
import forestry.api.core.IErrorState;
import forestry.api.core.IErrorStateRegistry;
import forestry.core.delegates.ErrorLogic;
/**
*
* @author CovertJaguar <http://www.railcraft.info/>
*/
public class ErrorStateRegistry implements IErrorStateRegistry {
private static final BiMap<Short, IErrorState> states = HashBiMap.create();
private static final Map<String, IErrorState> stateNames = new HashMap<String, IErrorState>();
private static final Set<IErrorState> stateView = Collections.unmodifiableSet(states.inverse().keySet());
@Override
public void registerErrorState(IErrorState state) {
if (states.containsKey(state.getID())) {
throw new RuntimeException("Forestry Error State does not possess a unique id.");
}
states.put(state.getID(), state);
addStateName(state, state.getUniqueName());
}
@Override
public void addAlias(IErrorState state, String name) {
if (!states.values().contains(state)) {
throw new RuntimeException("Forestry Error State did not exist while trying to register alias.");
}
addStateName(state, name);
}
private static void addStateName(IErrorState state, String name) {
if (!name.contains(":")) {
throw new RuntimeException("Forestry Error State name must be in the format <modid>:<name>.");
}
if (stateNames.containsKey(name)) {
throw new RuntimeException("Forestry Error State does not possess a unique name.");
}
stateNames.put(name, state);
}
@Override
public IErrorState getErrorState(short id) {
return states.get(id);
}
@Override
public IErrorState getErrorState(String name) {
return stateNames.get(name);
}
@Override
public Set<IErrorState> getErrorStates() {
return stateView;
}
@Override
public IErrorLogic createErrorLogic() {
return new ErrorLogic();
}
@SideOnly(Side.CLIENT)
public static void initIcons(IIconRegister register) {
for (IErrorState code : states.values()) {
code.registerIcons(register);
}
}
}
@@ -19,7 +19,6 @@ import cpw.mods.fml.common.eventhandler.SubscribeEvent;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import forestry.api.core.ErrorStateRegistry;
import forestry.core.interfaces.IPickupHandler;
import forestry.core.interfaces.ISaveEventHandler;
import forestry.core.render.TextureManager;
@@ -65,7 +64,7 @@ public class EventHandlerCore {
handler.onWorldUnload(event.world);
}
}
@SubscribeEvent
@SideOnly(Side.CLIENT)
public void handleTextureRemap(TextureStitchEvent.Pre event) {
@@ -35,8 +35,8 @@ import forestry.api.fuels.RainSubstrate;
import forestry.core.config.Config;
import forestry.core.config.Defaults;
import forestry.core.config.ForestryItem;
import forestry.core.config.Version;
import forestry.core.fluids.Fluids;
import forestry.core.multiblock.MultiblockEventHandler;
import forestry.core.proxy.Proxies;
import forestry.plugins.PluginManager;
@@ -45,12 +45,14 @@ public class ForestryCore {
public void preInit(File modLocation, Object basemod) {
ForestryAPI.instance = basemod;
ForestryAPI.forestryConstants = new ForestryConstants();
ForestryAPI.errorStateRegistry = new ErrorStateRegistry();
// Register event handler
MinecraftForge.EVENT_BUS.register(new EventHandlerCore());
MinecraftForge.EVENT_BUS.register(new MultiblockEventHandler());
Config.load();
EnumErrorCode.init();
PluginManager.runSetup();
+4 -4
View File
@@ -38,10 +38,10 @@ public class GuiHandler extends GuiHandlerBase {
switch (GuiId.values()[cleanId]) {
case AnalyzerGUI:
return new GuiAnalyzer(player.inventory, getTileForestry(world, x, y, z, player, TileAnalyzer.class));
return new GuiAnalyzer(player.inventory, getTile(world, x, y, z, player, TileAnalyzer.class));
case NaturalistBenchGUI:
return new GuiEscritoire(player, getTileForestry(world, x, y, z, player, TileEscritoire.class));
return new GuiEscritoire(player, getTile(world, x, y, z, player, TileEscritoire.class));
case SolderingIronGUI:
ItemStack equipped = player.getCurrentEquippedItem();
@@ -73,10 +73,10 @@ public class GuiHandler extends GuiHandlerBase {
switch (GuiId.values()[cleanId]) {
case AnalyzerGUI:
return new ContainerAnalyzer(player.inventory, getTileForestry(world, x, y, z, player, TileAnalyzer.class));
return new ContainerAnalyzer(player.inventory, getTile(world, x, y, z, player, TileAnalyzer.class));
case NaturalistBenchGUI:
return new ContainerEscritoire(player, getTileForestry(world, x, y, z, player, TileEscritoire.class));
return new ContainerEscritoire(player, getTile(world, x, y, z, player, TileEscritoire.class));
case SolderingIronGUI:
ItemStack equipped = player.getCurrentEquippedItem();
+11 -12
View File
@@ -11,37 +11,36 @@
package forestry.core;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import cpw.mods.fml.common.network.IGuiHandler;
import forestry.api.genetics.AlleleManager;
import forestry.api.genetics.ISpeciesRoot;
import forestry.core.gadgets.TileForestry;
import forestry.core.gadgets.TileNaturalistChest;
import forestry.core.gui.ContainerNaturalistInventory;
import forestry.core.gui.GuiNaturalistInventory;
import forestry.core.network.IStreamableGui;
import forestry.core.network.PacketGuiUpdate;
import forestry.core.proxy.Proxies;
import forestry.core.utils.Utils;
public abstract class GuiHandlerBase implements IGuiHandler {
public <T extends TileForestry> T getTileForestry(World world, int x, int y, int z, EntityPlayer player, Class<T> tileClass) {
T tileForestry = null;
try {
tileForestry = tileClass.cast(world.getTileEntity(x, y, z));
} catch (ClassCastException ex) {
Proxies.log.warning("Failed to cast a tile entity to a TileForestry at " + x + '/' + y + '/' + z);
}
public static <T extends TileEntity> T getTile(World world, int x, int y, int z, EntityPlayer player, Class<T> tileClass) {
T tileForestry = Utils.getTile(world, x, y, z, tileClass);
if (tileForestry != null && !world.isRemote) {
tileForestry.sendGuiOpened(player);
if (tileForestry instanceof IStreamableGui && !world.isRemote) {
PacketGuiUpdate packet = new PacketGuiUpdate((IStreamableGui) tileForestry);
Proxies.net.sendToPlayer(packet, player);
}
return tileForestry;
}
public GuiNaturalistInventory getNaturalistChestGui(String rootUID, EntityPlayer player, World world, int x, int y, int z, int page) {
TileNaturalistChest tile = getTileForestry(world, x, y, z, player, TileNaturalistChest.class);
TileNaturalistChest tile = getTile(world, x, y, z, player, TileNaturalistChest.class);
ISpeciesRoot speciesRoot = AlleleManager.alleleRegistry.getSpeciesRoot(rootUID);
return new GuiNaturalistInventory(speciesRoot, player, new ContainerNaturalistInventory(player.inventory, tile, page, 25), tile, page, 5);
}
@@ -49,7 +48,7 @@ public abstract class GuiHandlerBase implements IGuiHandler {
public ContainerNaturalistInventory getNaturalistChestContainer(String rootUID, EntityPlayer player, World world, int x, int y, int z, int page) {
ISpeciesRoot speciesRoot = AlleleManager.alleleRegistry.getSpeciesRoot(rootUID);
speciesRoot.getBreedingTracker(world, player.getGameProfile()).synchToPlayer(player);
return new ContainerNaturalistInventory(player.inventory, getTileForestry(world, x, y, z, player, TileNaturalistChest.class), page, 25);
return new ContainerNaturalistInventory(player.inventory, getTile(world, x, y, z, player, TileNaturalistChest.class), page, 25);
}
public static int encodeGuiData(int guiId, int data) {
@@ -23,7 +23,6 @@ import cpw.mods.fml.common.eventhandler.SubscribeEvent;
import forestry.core.config.Config;
import forestry.core.config.ForestryBlock;
import forestry.core.proxy.Proxies;
import forestry.core.worldgen.WorldGenMinableMeta;
import forestry.plugins.PluginManager;
@@ -14,7 +14,6 @@ import java.util.ArrayList;
import java.util.List;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumChatFormatting;
import forestry.api.circuits.ChipsetManager;
@@ -24,7 +23,7 @@ import forestry.api.circuits.ICircuitLayout;
import forestry.core.proxy.Proxies;
import forestry.core.utils.StringUtil;
public class CircuitBoard implements ICircuitBoard {
public class CircuitBoard<T> implements ICircuitBoard {
private EnumCircuitBoardType type;
private ICircuitLayout layout;
@@ -83,7 +82,7 @@ public class CircuitBoard implements ICircuitBoard {
ChipsetManager.circuitRegistry.getDefaultLayout();
}
ArrayList<ICircuit> readcircuits = new ArrayList<ICircuit>();
List<ICircuit> readcircuits = new ArrayList<ICircuit>();
if (circuits != null) {
return;
@@ -124,42 +123,46 @@ public class CircuitBoard implements ICircuitBoard {
}
@Override
public void onInsertion(TileEntity tile) {
public void onInsertion(Object tile) {
for (int i = 0; i < circuits.length; i++) {
if (circuits[i] == null) {
ICircuit circuit = circuits[i];
if (circuit == null) {
continue;
}
circuits[i].onInsertion(i, tile);
circuit.onInsertion(i, tile);
}
}
@Override
public void onLoad(TileEntity tile) {
public void onLoad(Object tile) {
for (int i = 0; i < circuits.length; i++) {
if (circuits[i] == null) {
ICircuit circuit = circuits[i];
if (circuit == null) {
continue;
}
circuits[i].onLoad(i, tile);
circuit.onLoad(i, tile);
}
}
@Override
public void onRemoval(TileEntity tile) {
public void onRemoval(Object tile) {
for (int i = 0; i < circuits.length; i++) {
if (circuits[i] == null) {
ICircuit circuit = circuits[i];
if (circuit == null) {
continue;
}
circuits[i].onRemoval(i, tile);
circuit.onRemoval(i, tile);
}
}
@Override
public void onTick(TileEntity tile) {
public void onTick(Object tile) {
for (int i = 0; i < circuits.length; i++) {
if (circuits[i] == null) {
ICircuit circuit = circuits[i];
if (circuit == null) {
continue;
}
circuits[i].onTick(i, tile);
circuit.onTick(i, tile);
}
}
@@ -25,9 +25,9 @@ import forestry.api.circuits.ICircuit;
import forestry.api.circuits.ICircuitLayout;
import forestry.api.circuits.ISolderManager;
import forestry.api.core.ForestryAPI;
import forestry.api.core.IErrorSource;
import forestry.api.core.IErrorState;
import forestry.core.EnumErrorCode;
import forestry.core.interfaces.IErrorSource;
import forestry.core.inventory.ItemInventory;
import forestry.core.items.ItemForestry;
import forestry.core.network.GuiId;
@@ -86,6 +86,7 @@ public class Config {
public static boolean craftingStampsEnabled = true;
public static final ArrayList<String> collectorStamps = new ArrayList<String>();
public static int farmSize = 2;
public static boolean squareFarms = false;
public static boolean enableExUtilEnderLily = true;
public static boolean enableMagicalCropsSupport = true;
@@ -263,6 +264,7 @@ public class Config {
enablePermissions = configCommon.getBooleanLocalized("tweaks", "permissions", enablePermissions);
farmSize = configCommon.getIntLocalized("tweaks.farms", "size", farmSize, 1, 3);
squareFarms = configCommon.getBooleanLocalized("tweaks.farms", "square", squareFarms);
enableExUtilEnderLily = configCommon.getBooleanLocalized("tweaks.farms", "enderlily", enableExUtilEnderLily);
enableMagicalCropsSupport = configCommon.getBooleanLocalized("tweaks.farms", "magicalcrops", enableMagicalCropsSupport);
@@ -0,0 +1,149 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.core.delegates;
import java.io.IOException;
import java.util.UUID;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTUtil;
import com.mojang.authlib.GameProfile;
import forestry.api.core.INBTTagable;
import forestry.core.config.Config;
import forestry.core.interfaces.IAccessHandler;
import forestry.core.interfaces.IRestrictedAccessTile;
import forestry.core.network.DataInputStreamForestry;
import forestry.core.network.DataOutputStreamForestry;
import forestry.core.network.IStreamable;
import forestry.core.network.PacketCoordinates;
import forestry.core.network.PacketId;
import forestry.core.proxy.Proxies;
import forestry.core.utils.EnumAccess;
import forestry.core.utils.PlayerUtil;
public final class AccessHandler implements IAccessHandler, IStreamable, INBTTagable {
private final IRestrictedAccessTile tile;
private GameProfile owner = null;
private EnumAccess access = EnumAccess.SHARED;
public AccessHandler(IRestrictedAccessTile tile) {
this.tile = tile;
}
@Override
public final boolean allowsRemoval(EntityPlayer player) {
return !Config.enablePermissions || getAccessType() == EnumAccess.SHARED || !isOwned() || isOwner(player) || Proxies.common.isOp(player);
}
@Override
public final boolean allowsAlteration(EntityPlayer player) {
return allowsRemoval(player);
}
@Override
public final boolean allowsViewing(EntityPlayer player) {
return allowsAlteration(player) || getAccessType() == EnumAccess.VIEWABLE;
}
@Override
public final boolean allowsPipeConnections() {
return access == EnumAccess.SHARED;
}
@Override
public EnumAccess getAccessType() {
return access;
}
@Override
public boolean isOwned() {
return owner != null;
}
@Override
public GameProfile getOwner() {
return owner;
}
@Override
public void setOwner(GameProfile owner) {
this.owner = owner;
}
@Override
public boolean isOwner(EntityPlayer player) {
return PlayerUtil.isSameGameProfile(owner, player.getGameProfile());
}
@Override
public boolean switchAccessRule(EntityPlayer player) {
if (!isOwner(player)) {
return false;
}
EnumAccess oldAccess = access;
int ordinal = (access.ordinal() + 1) % EnumAccess.values().length;
access = EnumAccess.values()[ordinal];
if (player.worldObj.isRemote) {
Proxies.net.sendToServer(new PacketCoordinates(PacketId.ACCESS_SWITCH, tile.getCoordinates()));
} else {
tile.onSwitchAccess(oldAccess, access);
}
return true;
}
@Override
public void writeData(DataOutputStreamForestry data) throws IOException {
if (owner == null) {
data.writeByte(-1);
} else {
data.writeByte(access.ordinal());
data.writeLong(owner.getId().getMostSignificantBits());
data.writeLong(owner.getId().getLeastSignificantBits());
data.writeUTF(owner.getName());
}
}
@Override
public void readData(DataInputStreamForestry data) throws IOException {
byte accessOrdinal = data.readByte();
if (accessOrdinal >= 0) {
access = EnumAccess.values()[accessOrdinal];
owner = new GameProfile(new UUID(data.readLong(), data.readLong()), data.readUTF());
}
}
@Override
public void readFromNBT(NBTTagCompound data) {
access = EnumAccess.values()[data.getInteger("Access")];
if (data.hasKey("owner")) {
owner = NBTUtil.func_152459_a(data.getCompoundTag("owner"));
}
}
@Override
public void writeToNBT(NBTTagCompound data) {
data.setInteger("Access", access.ordinal());
if (this.owner != null) {
NBTTagCompound nbt = new NBTTagCompound();
NBTUtil.func_152460_a(nbt, owner);
data.setTag("owner", nbt);
}
}
}
@@ -0,0 +1,75 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.core.delegates;
import com.google.common.collect.ImmutableSet;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
import forestry.api.core.ForestryAPI;
import forestry.api.core.IErrorLogic;
import forestry.api.core.IErrorState;
public class ErrorLogic implements IErrorLogic {
private final Set<IErrorState> errorStates = new HashSet<IErrorState>();
@Override
public final boolean setCondition(boolean condition, IErrorState errorState) {
if (condition) {
errorStates.add(errorState);
} else {
errorStates.remove(errorState);
}
return condition;
}
public final boolean contains(IErrorState state) {
return errorStates.contains(state);
}
public final boolean hasErrors() {
return errorStates.size() > 0;
}
@Override
public final ImmutableSet<IErrorState> getErrorStates() {
return ImmutableSet.copyOf(errorStates);
}
@Override
public void clearErrors() {
errorStates.clear();
}
@Override
public void writeData(DataOutputStream data) throws IOException {
data.writeShort(errorStates.size());
for (IErrorState errorState : errorStates) {
data.writeShort(errorState.getID());
}
}
@Override
public void readData(DataInputStream data) throws IOException {
clearErrors();
short errorStateCount = data.readShort();
for (int i = 0; i < errorStateCount; i++) {
short errorStateId = data.readShort();
IErrorState errorState = ForestryAPI.errorStateRegistry.getErrorState(errorStateId);
errorStates.add(errorState);
}
}
}
@@ -0,0 +1,83 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.core.delegates;
import net.minecraft.entity.player.EntityPlayer;
import com.mojang.authlib.GameProfile;
import forestry.core.interfaces.IAccessHandler;
import forestry.core.utils.EnumAccess;
public class FakeAccessHandler implements IAccessHandler {
private static FakeAccessHandler instance;
public static FakeAccessHandler getInstance() {
if (instance == null) {
instance = new FakeAccessHandler();
}
return instance;
}
private FakeAccessHandler() {
}
@Override
public boolean switchAccessRule(EntityPlayer player) {
return false;
}
@Override
public EnumAccess getAccessType() {
return EnumAccess.SHARED;
}
@Override
public boolean allowsRemoval(EntityPlayer player) {
return true;
}
@Override
public boolean allowsAlteration(EntityPlayer player) {
return true;
}
@Override
public boolean allowsViewing(EntityPlayer player) {
return true;
}
@Override
public boolean allowsPipeConnections() {
return true;
}
@Override
public boolean isOwned() {
return false;
}
@Override
public GameProfile getOwner() {
return null;
}
@Override
public void setOwner(GameProfile owner) {
}
@Override
public boolean isOwner(EntityPlayer player) {
return true;
}
}
@@ -0,0 +1,64 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.core.delegates;
import com.google.common.collect.ImmutableSet;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import forestry.api.core.IErrorLogic;
import forestry.api.core.IErrorState;
public class FakeErrorLogic implements IErrorLogic {
public static final FakeErrorLogic instance = new FakeErrorLogic();
private FakeErrorLogic() {
}
@Override
public boolean setCondition(boolean condition, IErrorState errorState) {
return false;
}
@Override
public boolean contains(IErrorState state) {
return false;
}
@Override
public boolean hasErrors() {
return true;
}
@Override
public void clearErrors() {
}
@Override
public void writeData(DataOutputStream data) throws IOException {
}
@Override
public void readData(DataInputStream data) throws IOException {
}
@Override
public ImmutableSet<IErrorState> getErrorStates() {
return ImmutableSet.of();
}
}
@@ -1,31 +1,29 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.core.utils;
import net.minecraft.world.World;
public class DelayTimer {
private long markedTime;
public boolean delayPassed(World world, long delay) {
long currentTime = world.getTotalWorldTime();
if (currentTime < markedTime) {
markedTime = currentTime;
return false;
} else if (markedTime + delay <= currentTime) {
markedTime = currentTime;
return true;
} else {
return false;
}
}
}
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.core.delegates;
import com.google.common.collect.ImmutableSet;
import forestry.api.core.IErrorSource;
import forestry.api.core.IErrorState;
public class FakeErrorSource implements IErrorSource {
public static final FakeErrorSource instance = new FakeErrorSource();
private FakeErrorSource() {
}
@Override
public ImmutableSet<IErrorState> getErrorStates() {
return ImmutableSet.of();
}
}
@@ -0,0 +1,83 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.core.fluids;
import java.util.List;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.ICrafting;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidTank;
import forestry.core.fluids.tanks.FakeTank;
public class FakeTankManager implements ITankManager {
public static final FakeTankManager instance = new FakeTankManager();
private FakeTankManager() {
}
@Override
public void initGuiData(Container container, ICrafting player) {
}
@Override
public void updateGuiData(Container container, List<EntityPlayerMP> crafters) {
}
@Override
public void processGuiUpdate(int messageId, int data) {
}
@Override
public IFluidTank getTank(int tankIndex) {
return FakeTank.INSTANCE;
}
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
return FakeTank.INSTANCE.fill(resource, doFill);
}
@Override
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) {
return FakeTank.INSTANCE.drain(resource.amount, doDrain);
}
@Override
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) {
return FakeTank.INSTANCE.drain(maxDrain, doDrain);
}
@Override
public boolean canFill(ForgeDirection from, Fluid fluid) {
return false;
}
@Override
public boolean canDrain(ForgeDirection from, Fluid fluid) {
return false;
}
@Override
public FluidTankInfo[] getTankInfo(ForgeDirection from) {
return FakeTank.INFO;
}
}
@@ -0,0 +1,31 @@
/*******************************************************************************
* Copyright (c) 2011-2014 SirSengir.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the GNU Lesser Public License v3
* which accompanies this distribution, and is available at
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Various Contributors including, but not limited to:
* SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges
******************************************************************************/
package forestry.core.fluids;
import java.util.List;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.ICrafting;
import net.minecraftforge.fluids.IFluidHandler;
import net.minecraftforge.fluids.IFluidTank;
public interface ITankManager extends IFluidHandler {
void initGuiData(Container container, ICrafting player);
void updateGuiData(Container container, List<EntityPlayerMP> crafters);
void processGuiUpdate(int messageId, int data);
IFluidTank getTank(int tankIndex);
}
@@ -33,6 +33,7 @@ import net.minecraftforge.fluids.FluidRegistry;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidHandler;
import net.minecraftforge.fluids.IFluidTank;
import forestry.core.fluids.tanks.FakeTank;
import forestry.core.fluids.tanks.StandardTank;
@@ -45,7 +46,7 @@ import forestry.core.utils.NBTUtil.NBTList;
/**
* @author CovertJaguar <http://www.railcraft.info>
*/
public class TankManager extends ForwardingList<StandardTank> implements IFluidHandler, List<StandardTank> {
public class TankManager extends ForwardingList<StandardTank> implements ITankManager, List<StandardTank> {
public static final ITileFilter TANK_FILTER = new ITileFilter() {
@Override
@@ -158,13 +159,14 @@ public class TankManager extends ForwardingList<StandardTank> implements IFluidH
}
}
@Override
public void initGuiData(Container container, ICrafting player) {
for (StandardTank tank : tanks) {
initGuiData(container, player, tank.getTankIndex());
}
}
public void initGuiData(Container container, ICrafting player, int tankIndex) {
private void initGuiData(Container container, ICrafting player, int tankIndex) {
if (tankIndex >= tanks.size()) {
return;
}
@@ -181,13 +183,14 @@ public class TankManager extends ForwardingList<StandardTank> implements IFluidH
Proxies.net.sendToPlayer(packet, (EntityPlayerMP) player);
}
@Override
public void updateGuiData(Container container, List<EntityPlayerMP> crafters) {
for (StandardTank tank : tanks) {
updateGuiData(container, crafters, tank.getTankIndex());
}
}
public void updateGuiData(Container container, List<EntityPlayerMP> crafters, int tankIndex) {
private void updateGuiData(Container container, List<EntityPlayerMP> crafters, int tankIndex) {
StandardTank tank = tanks.get(tankIndex);
FluidStack fluidStack = tank.getFluid();
FluidStack prev = prevFluidStacks.get(tankIndex);
@@ -224,6 +227,7 @@ public class TankManager extends ForwardingList<StandardTank> implements IFluidH
prevColor.set(tankIndex, color);
}
@Override
public void processGuiUpdate(int messageId, int data) {
int tankIndex = messageId / NETWORK_DATA;
@@ -255,6 +259,11 @@ public class TankManager extends ForwardingList<StandardTank> implements IFluidH
}
}
@Override
public IFluidTank getTank(int tankIndex) {
return get(tankIndex);
}
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
for (StandardTank tank : tanks) {
Loaded 100 of 259 files, more files were not shown because too many files have changed in this diff. Show more