Anvilcraft/resonant-induction
2
1
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

A little work on the mixer

Browse source
This commit is contained in:
Calclavia 2014-01-25 01:29:47 +08:00
parent 96de7fbdff
commit f5a055b615
8 changed files with 102 additions and 108 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/main/java/resonantinduction/archaic/firebox/BlockHotPlate.java
View file

@ -28,7 +28,7 @@ public class BlockHotPlate extends BlockRI
{
super("hotPlate", Material.wood);
setBlockBounds(0, 0, 0, 1, 0.2f, 1);
this.setTickRandomly(true);
setTickRandomly(true);
}
@Override

2
src/main/java/resonantinduction/electrical/Electrical.java
View file

@ -41,7 +41,7 @@ import resonantinduction.electrical.wire.EnumWireMaterial;
import resonantinduction.electrical.wire.ItemWire;
import resonantinduction.mechanical.process.BlockGrinderWheel;
import resonantinduction.mechanical.process.TileGrinderWheel;
import resonantinduction.mechanical.process.TilePurifier;
import resonantinduction.mechanical.process.TileMixer;
import calclavia.lib.content.ContentRegistry;
import calclavia.lib.network.PacketHandler;
import calclavia.lib.recipe.UniversalRecipe;

42
src/main/java/resonantinduction/electrical/purifier/BlockMixer.java
View file

@ -6,7 +6,7 @@ import net.minecraft.world.World;
import net.minecraftforge.common.ForgeDirection;
import resonantinduction.core.Settings;
import resonantinduction.core.prefab.block.BlockRIRotatable;
import resonantinduction.mechanical.process.TilePurifier;
import resonantinduction.mechanical.process.TileMixer;
import universalelectricity.api.vector.VectorWorld;
/**
@ -22,44 +22,6 @@ public class BlockMixer extends BlockRIRotatable implements ITileEntityProvider
super("mixer", Settings.getNextBlockID());
}
@Override
public void onBlockAdded(World world, int x, int y, int z)
{
this.checkConflicts(world, x, y, z);
}
@Override
public void onNeighborBlockChange(World world, int x, int y, int z, int par5)
{
this.checkConflicts(world, x, y, z);
}
/**
* Checks for any conflicting directions with other grinders.
*/
private void checkConflicts(World world, int x, int y, int z)
{
ForgeDirection facing = this.getDirection(world, x, y, z);
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
{
if (dir != facing && dir != facing.getOpposite())
{
VectorWorld checkPos = (VectorWorld) new VectorWorld(world, x, y, z).modifyPositionFromSide(dir);
TileEntity tileEntity = checkPos.getTileEntity();
if (tileEntity instanceof TilePurifier)
{
if (this.getDirection(world, checkPos.intX(), checkPos.intY(), checkPos.intZ()) == facing)
{
this.dropBlockAsItem(world, x, y, z, 0, 0);
world.setBlockToAir(x, y, z);
}
}
}
}
}
@Override
public boolean isOpaqueCube()
{
@ -75,6 +37,6 @@ public class BlockMixer extends BlockRIRotatable implements ITileEntityProvider
@Override
public TileEntity createNewTileEntity(World world)
{
return new TilePurifier();
return new TileMixer();
}
}

4
src/main/java/resonantinduction/mechanical/Mechanical.java
View file

@ -29,7 +29,7 @@ import resonantinduction.mechanical.network.IMechanical;
import resonantinduction.mechanical.network.PacketNetwork;
import resonantinduction.mechanical.process.BlockGrinderWheel;
import resonantinduction.mechanical.process.TileGrinderWheel;
import resonantinduction.mechanical.process.TilePurifier;
import resonantinduction.mechanical.process.TileMixer;
import calclavia.lib.content.ContentRegistry;
import calclavia.lib.network.PacketHandler;
import cpw.mods.fml.common.Mod;
@ -112,7 +112,7 @@ public class Mechanical
// Machines
blockGrinderWheel = contentRegistry.createTile(BlockGrinderWheel.class, TileGrinderWheel.class);
blockPurifier = contentRegistry.createTile(BlockMixer.class, TilePurifier.class);
blockPurifier = contentRegistry.createTile(BlockMixer.class, TileMixer.class);
OreDictionary.registerOre("gear", itemGear);

4
src/main/java/resonantinduction/mechanical/process/BlockGrinderWheel.java
View file

@ -56,9 +56,9 @@ public class BlockGrinderWheel extends BlockRIRotatable implements ITileEntityPr
tile.grindingItem = (EntityItem) entity;
}
if (!TileGrinderWheel.getTimer().containsKey(entity))
if (!TileGrinderWheel.timer.containsKey((EntityItem) entity))
{
TileGrinderWheel.getTimer().put((EntityItem) entity, TileGrinderWheel.DEFAULT_TIME);
TileGrinderWheel.timer.put((EntityItem) entity, TileGrinderWheel.DEFAULT_TIME);
}
}
else

26
src/main/java/resonantinduction/mechanical/process/TileGrinderWheel.java
View file

@ -28,9 +28,8 @@ public class TileGrinderWheel extends TileMechanical implements IRotatable
public static final long POWER = 500000;
public static final int DEFAULT_TIME = 20 * 20;
/** A map of ItemStacks and their remaining grind-time left. */
private static final HashMap<EntityItem, Integer> clientTimer = new HashMap<EntityItem, Integer>();
private static final HashMap<EntityItem, Integer> serverTimer = new HashMap<EntityItem, Integer>();
public static final Timer<EntityItem> timer = new Timer<EntityItem>();
public EntityItem grindingItem = null;
private final long requiredTorque = 1000;
@ -62,10 +61,9 @@ public class TileGrinderWheel extends TileMechanical implements IRotatable
if (grindingItem != null)
{
if (getTimer().containsKey(grindingItem) && !grindingItem.isDead && new Vector3(this).add(0.5).distance(grindingItem) < 1)
if (timer.containsKey(grindingItem) && !grindingItem.isDead && new Vector3(this).add(0.5).distance(grindingItem) < 1)
{
int timeLeft = getTimer().get(grindingItem) - 1;
getTimer().put(grindingItem, timeLeft);
int timeLeft = timer.decrease(grindingItem);
if (timeLeft <= 0)
{
@ -74,14 +72,14 @@ public class TileGrinderWheel extends TileMechanical implements IRotatable
if (--grindingItem.getEntityItem().stackSize <= 0)
{
grindingItem.setDead();
getTimer().remove(grindingItem);
timer.remove(grindingItem);
grindingItem = null;
}
else
{
grindingItem.setEntityItemStack(grindingItem.getEntityItem());
// Reset timer
getTimer().put(grindingItem, DEFAULT_TIME);
timer.put(grindingItem, DEFAULT_TIME);
}
}
}
@ -103,7 +101,7 @@ public class TileGrinderWheel extends TileMechanical implements IRotatable
}
else
{
getTimer().remove(grindingItem);
timer.remove(grindingItem);
grindingItem = null;
}
}
@ -152,16 +150,6 @@ public class TileGrinderWheel extends TileMechanical implements IRotatable
return false;
}
public static HashMap<EntityItem, Integer> getTimer()
{
if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER)
{
return serverTimer;
}
return clientTimer;
}
@Override
public ForgeDirection getDirection()
{

79
src/main/java/resonantinduction/mechanical/process/TilePurifier.java → src/main/java/resonantinduction/mechanical/process/TileMixer.java
View file

@ -1,38 +1,29 @@
package resonantinduction.mechanical.process;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import net.minecraft.entity.Entity;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.item.ItemStack;
import net.minecraft.util.AxisAlignedBB;
import net.minecraftforge.common.ForgeDirection;
import resonantinduction.api.recipe.MachineRecipes;
import resonantinduction.core.Reference;
import resonantinduction.core.resource.item.ItemOreResource;
import universalelectricity.api.energy.EnergyStorageHandler;
import resonantinduction.mechanical.network.TileMechanical;
import universalelectricity.api.vector.Vector3;
import calclavia.lib.prefab.tile.TileElectrical;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.relauncher.Side;
/**
* @author Calclavia
*
*/
public class TilePurifier extends TileElectrical
public class TileMixer extends TileMechanical
{
public static final long POWER = 500000;
public static final int DEFAULT_TIME = 10 * 20;
/** A map of ItemStacks and their remaining grind-time left. */
private static final HashMap<EntityItem, Integer> clientTimer = new HashMap<EntityItem, Integer>();
private static final HashMap<EntityItem, Integer> serverTimer = new HashMap<EntityItem, Integer>();
public EntityItem processingItem = null;
public TilePurifier()
{
this.energy = new EnergyStorageHandler(POWER * 2);
}
public static final Timer<EntityItem> timer = new Timer<EntityItem>();
@Override
public void updateEntity()
@ -52,7 +43,6 @@ public class TilePurifier extends TileElectrical
*/
public boolean canWork()
{
// TODO: Add electricity support.
return true;
}
@ -61,37 +51,46 @@ public class TilePurifier extends TileElectrical
boolean didWork = false;
// Search for an item to "process"
AxisAlignedBB aabb = AxisAlignedBB.getBoundingBox(this.xCoord - 1, this.yCoord, this.zCoord - 1, this.xCoord + 1, this.yCoord, this.zCoord + 1);
AxisAlignedBB aabb = AxisAlignedBB.getAABBPool().getAABB(this.xCoord - 1, this.yCoord, this.zCoord - 1, this.xCoord + 2, this.yCoord + 1, this.zCoord + 2);
List<Entity> entities = this.worldObj.getEntitiesWithinAABB(Entity.class, aabb);
Set<EntityItem> processItems = new LinkedHashSet<EntityItem>();
for (Entity entity : entities)
{
/**
* Rotate entities around purifier
* Rotate entities around the mixer
*/
double speed = 0.1;
double speed = 1;
Vector3 originalPosition = new Vector3(this);
Vector3 relativePosition = originalPosition.clone().subtract(new Vector3(this));
Vector3 originalPosition = new Vector3(entity);
Vector3 relativePosition = originalPosition.clone().subtract(new Vector3(this).add(0.5));
relativePosition.rotate(speed, 0, 0);
Vector3 newPosition = new Vector3(this).add(relativePosition);
Vector3 newPosition = new Vector3(this).add(0.5).add(relativePosition);
Vector3 difference = newPosition.difference(originalPosition).scale(0.5);
if (this.processingItem == null && entity instanceof EntityItem)
entity.addVelocity(difference.x, difference.y, difference.z);
if (entity instanceof EntityItem)
{
// TODO: Use machine recipe
if (((EntityItem) entity).getEntityItem().getItem() instanceof ItemOreResource)
{
this.processingItem = (EntityItem) entity;
processItems.add((EntityItem) entity);
}
}
}
if (processingItem != null)
for (EntityItem processingItem : processItems)
{
if (getTimer().containsKey(processingItem) && !processingItem.isDead && new Vector3(this).add(0.5).distance(processingItem) < 1)
if (!timer.containsKey(processingItem))
{
int timeLeft = getTimer().get(processingItem) - 1;
getTimer().put(processingItem, timeLeft);
timer.put(processingItem, DEFAULT_TIME);
}
if (!processingItem.isDead && new Vector3(this).add(0.5).distance(processingItem) < 2)
{
int timeLeft = timer.decrease(processingItem);
if (timeLeft <= 0)
{
if (this.doneWork(processingItem))
@ -99,14 +98,14 @@ public class TilePurifier extends TileElectrical
if (--processingItem.getEntityItem().stackSize <= 0)
{
processingItem.setDead();
getTimer().remove(processingItem);
timer.remove(processingItem);
processingItem = null;
}
else
{
processingItem.setEntityItemStack(processingItem.getEntityItem());
// Reset timer
getTimer().put(processingItem, DEFAULT_TIME);
timer.put(processingItem, DEFAULT_TIME);
}
}
}
@ -120,7 +119,7 @@ public class TilePurifier extends TileElectrical
}
else
{
getTimer().remove(processingItem);
timer.remove(processingItem);
processingItem = null;
}
}
@ -129,10 +128,8 @@ public class TilePurifier extends TileElectrical
{
if (this.ticks % 20 == 0)
{
this.worldObj.playSoundEffect(this.xCoord + 0.5, this.yCoord + 0.5, this.zCoord + 0.5, Reference.PREFIX + "grinder", 0.5f, 1);
this.worldObj.playSoundEffect(this.xCoord + 0.5, this.yCoord + 0.5, this.zCoord + 0.5, Reference.PREFIX + "mixer", 0.5f, 1);
}
this.energy.extractEnergy(POWER / 20, true);
}
}
@ -143,13 +140,9 @@ public class TilePurifier extends TileElectrical
return false;
}
public static HashMap<EntityItem, Integer> getTimer()
@Override
public boolean canConnect(ForgeDirection direction)
{
if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER)
{
return serverTimer;
}
return clientTimer;
return direction == ForgeDirection.UP || direction == ForgeDirection.DOWN;
}
}

51
src/main/java/resonantinduction/mechanical/process/Timer.java Normal file
View file

@ -0,0 +1,51 @@
package resonantinduction.mechanical.process;
import java.util.HashMap;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.relauncher.Side;
import net.minecraft.entity.item.EntityItem;
public class Timer<K>
{
private final HashMap<K, Integer> clientTimer = new HashMap<K, Integer>();
private final HashMap<K, Integer> serverTimer = new HashMap<K, Integer>();
public void put(K key, int defaultTime)
{
getTimeMap().put(key, defaultTime);
}
public boolean containsKey(K key)
{
return getTimeMap().containsKey(key);
}
public void remove(K key)
{
getTimeMap().remove(key);
}
public int decrease(K key)
{
return decrease(key, 1);
}
public int decrease(K key, int amount)
{
int timeLeft = getTimeMap().get(key) - amount;
getTimeMap().put(key, timeLeft);
return timeLeft;
}
public HashMap<K, Integer> getTimeMap()
{
if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER)
{
return serverTimer;
}
return clientTimer;
}
}