fix missing source folder

1 files changed, 433 insertions, 0 deletions

diff --git a/src/main/java/ihl/enviroment/MirrorTileEntity.java b/src/main/java/ihl/enviroment/MirrorTileEntity.java
new file mode 100644
index 0000000..4060e59
--- /dev/null
+++ b/src/main/java/ihl/enviroment/MirrorTileEntity.java
@@ -0,0 +1,433 @@
+package ihl.enviroment;

+

+import java.util.ArrayList;

+import java.util.List;

+

+import ic2.core.block.TileEntityBlock;

+import ihl.IHLMod;

+import ihl.handpump.BlockWithCoordinates;

+import ihl.utils.IHLUtils;

+import net.minecraft.block.Block;

+import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher;

+import net.minecraft.entity.Entity;

+import net.minecraft.entity.EntityLivingBase;

+import net.minecraft.entity.item.EntityBoat;

+import net.minecraft.entity.item.EntityItem;

+import net.minecraft.entity.item.EntityMinecart;

+import net.minecraft.entity.player.EntityPlayer;

+import net.minecraft.item.ItemStack;

+import net.minecraft.tileentity.TileEntity;

+import net.minecraft.util.AxisAlignedBB;

+import net.minecraft.world.ChunkCache;

+import net.minecraftforge.common.util.ForgeDirection;

+

+public class MirrorTileEntity extends TileEntityBlock

+{

+	public final List<BlockWithCoordinates> bwc = new ArrayList<BlockWithCoordinates>();

+	public final List<Entity> reflectedEntity = new ArrayList<Entity>();

+	public final List<TileEntity> reflectedTileEntity = new ArrayList<TileEntity>();

+	private int bwcListPos=0;

+	private int reflectedTileEntityListPos=0;

+	private int reflectionVolumePos=0;

+	boolean firstTick=true;

+	public int dnx,dpx,dny,dpy,dnz,dpz;

+	boolean shouldReflect=true;

+	int reflectExtensionRight=0;

+	int reflectExtensionTop=0;

+	int timer=0;

+	int blockReflectionUpdateTimer=0;

+	int reflectionVolumeSize=-1;

+	AxisAlignedBB reflectionArea;

+	int displayListCache=-1;

+	public ChunkCache chunkCache;

+	public boolean needRenderUpdate=false;

+	private int minX;

+	private int maxX;

+	private int minY;

+	private int maxY;

+	private int minZ;

+	private int maxZ;

+	private int lastBWCSize;

+	

+	public MirrorTileEntity() 

+	{}

+

+    @SuppressWarnings("unchecked")

+	@Override

+    public void updateEntityClient()

+    {

+    	super.updateEntityClient();

+    	if(this.shouldReflect)

+    	{

+    		int i=0;

+    		for(i=0;i<Math.min(this.reflectionVolumeSize, IHLMod.config.mirrorReflectionUpdateSpeed);i++)

+    		{

+        		this.checkReflectionVolume();

+    		}

+    		for(i=0;i<Math.min(this.bwc.size(), IHLMod.config.mirrorReflectionUpdateSpeed);i++)

+    		{

+        		this.checkBWCList();

+    		}

+    		for(i=0;i<Math.min(this.reflectedTileEntity.size(), IHLMod.config.mirrorReflectionUpdateSpeed);i++)

+    		{

+        		this.checkTileEntityList();

+    		}

+    	}

+    	if(timer++>20)

+    	{

+    		boolean isFirst=true;

+			TileEntity t = worldObj.getTileEntity(xCoord-mXT(),yCoord-mYT(), zCoord-mZT());

+			if(t instanceof MirrorTileEntity)

+			{

+				if(((MirrorTileEntity)t).getFacing()==this.getFacing())

+				{

+					isFirst=false;

+				}

+			}

+			t = worldObj.getTileEntity(xCoord-mXR(),yCoord-mYR(), zCoord-mZR());

+			if(t instanceof MirrorTileEntity)

+			{

+				if(((MirrorTileEntity)t).getFacing()==this.getFacing())

+				{

+					isFirst=false;

+				}

+			}

+			if(isFirst)

+			{

+				this.shouldReflect=true;

+				this.reflectExtensionTop=0;

+				this.reflectExtensionRight=0;

+				for(int i=1;i<=IHLMod.config.mirrorReflectionRange+2;i++)

+				{

+					t = worldObj.getTileEntity(xCoord+mXT()*i,yCoord+mYT()*i, zCoord+mZT()*i);

+					if(t instanceof MirrorTileEntity && ((MirrorTileEntity)t).getFacing()==this.getFacing())

+					{

+						MirrorTileEntity te = (MirrorTileEntity) t;

+						te.shouldReflect=false;

+						this.reflectExtensionTop=i;

+					}

+					else

+					{

+						break;

+					}

+				}

+				a:for(int i0=1;i0<=IHLMod.config.mirrorReflectionRange+2;i0++)

+				{

+					for(int i=0;i<=this.reflectExtensionTop;i++)

+					{

+						t = worldObj.getTileEntity(xCoord+mXT()*i+mXR()*i0,yCoord+mYT()*i+mYR()*i0, zCoord+mZT()*i+mZR()*i0);

+						if(t instanceof MirrorTileEntity && ((MirrorTileEntity)t).getFacing()==this.getFacing())

+						{

+							MirrorTileEntity te = (MirrorTileEntity) t;

+							te.shouldReflect=false;

+						}

+						else

+						{

+							break a;

+						}

+					}

+					this.reflectExtensionRight=i0;

+				}

+			}

+			if(this.reflectionArea!=null)

+			{

+				this.reflectedEntity.clear();

+				this.reflectedEntity.addAll(worldObj.getEntitiesWithinAABB(EntityLivingBase.class, this.reflectionArea));

+				this.reflectedEntity.addAll(worldObj.getEntitiesWithinAABB(EntityBoat.class, this.reflectionArea));

+				this.reflectedEntity.addAll(worldObj.getEntitiesWithinAABB(EntityItem.class, this.reflectionArea));

+				this.reflectedEntity.addAll(worldObj.getEntitiesWithinAABB(EntityMinecart.class, this.reflectionArea));

+			}

+    		timer=0;

+    	}

+		if(firstTick && this.shouldReflect)

+		{

+			int ix,iy,iz;

+			int range=IHLMod.config.mirrorReflectionRange;

+			ForgeDirection direction = ForgeDirection.getOrientation(this.getFacing());

+			bwc.clear();

+			{

+				dpx = direction.offsetX==-1?0:1;

+				dnx = direction.offsetX==1?0:1;

+				dpy = direction.offsetY==-1?0:1;

+				dny = direction.offsetY==1?0:1;

+				dpz = direction.offsetZ==-1?0:1;

+				dnz = direction.offsetZ==1?0:1;

+				reflectionVolumeSize=(range*dnx+range*dpx+dnx)*(range*dny+range*dpy+dny)*(range*dnz+range*dpz+dnz);

+				reflectionArea = AxisAlignedBB.getBoundingBox(xCoord-range*dnx-1d, yCoord-range*dny-1d, zCoord-range*dnz-1d, xCoord+range*dpx+dnx+1d, yCoord+range*dpy+dny+1d, zCoord+range*dpz+dnz+1d);

+				minX = xCoord-range*dnx;

+				maxX = xCoord+range*dpx+dnx;

+				minY = Math.max(yCoord-range*dny,0);

+				maxY = Math.min(yCoord+range*dpy+dny,this.worldObj.getActualHeight());

+				minZ = zCoord-range*dnz;

+				maxZ = zCoord+range*dpz+dnz;

+				chunkCache = new ChunkCache(worldObj, minX, minY, minZ, maxX, maxY, maxZ, 16);

+				for(ix=minX;ix<maxX;ix++)

+				{

+					for(iy=minY;iy<maxY;iy++)

+					{

+						for(iz=minZ;iz<maxZ;iz++)

+						{

+							Block block = worldObj.getBlock(ix, iy, iz);

+							if(block!=null && !block.isAir(worldObj, ix, iy, iz) && isBlockVisible(block,ix,iy,iz))

+							{						

+								TileEntity te = worldObj.getTileEntity(ix, iy, iz);

+								if(te!=null && !te.isInvalid() && !reflectedTileEntity.contains(te) && TileEntityRendererDispatcher.instance.hasSpecialRenderer(te) && !(te instanceof MirrorTileEntity))

+								{

+									reflectedTileEntity.add(te);

+								}

+				    			if(block.getRenderType()>=0)

+								{

+									bwc.add(new BlockWithCoordinates(block, ix, iy, iz, worldObj.getBlockMetadata(ix, iy, iz)));

+								}

+							}

+							

+						}

+					}

+				}

+			}

+			lastBWCSize=bwc.size();

+			firstTick=false;

+		}

+	}

+

+	private boolean isBlockVisible(Block block, int x, int y, int z) 

+	{

+		if(block instanceof MirrorBlock)

+		{

+			ForgeDirection direction = ForgeDirection.getOrientation(this.getFacing());

+			int x1=x*direction.offsetX;

+			int y1=y*direction.offsetY;

+			int z1=z*direction.offsetZ;

+			int x2=xCoord*direction.offsetX;

+			int y2=yCoord*direction.offsetY;

+			int z2=zCoord*direction.offsetZ;

+			return !(x1==x2 && y1==y2 && z1==z2);

+		}

+        if(block.shouldSideBeRendered(worldObj, x, y-1, z, 0))

+    	{

+        	return true;

+    	}

+        if(block.shouldSideBeRendered(worldObj, x, y+1, z, 1))

+    	{

+        	return true;

+    	}

+    	if(block.shouldSideBeRendered(worldObj, x, y, z-1, 2))

+    	{

+        	return true;

+        }

+    	if(block.shouldSideBeRendered(worldObj, x, y, z+1, 3))

+    	{

+        	return true;

+        }

+    	if(block.shouldSideBeRendered(worldObj, x-1, y, z, 4))

+    	{

+        	return true;

+        }

+    	if(block.shouldSideBeRendered(worldObj, x+1, y, z, 5))

+    	{

+        	return true;

+    	}

+		return false;

+	}

+

+	@Override

+	public boolean wrenchCanSetFacing(EntityPlayer entityPlayer, int side) {

+		return false;

+	}

+

+	@Override

+	public boolean wrenchCanRemove(EntityPlayer entityPlayer) {

+		return true;

+	}

+	

+	@Override

+	public void setFacing(short side) 

+	{

+		super.setFacing(side);

+		this.bwc.clear();

+		this.firstTick=true;

+	}

+

+	@Override

+	public float getWrenchDropRate() {

+		return 1F;

+	}

+

+	@Override

+	public ItemStack getWrenchDrop(EntityPlayer entityPlayer) {

+		return IHLUtils.getThisModItemStack("mirror");

+	}

+	

+	public float[] getMirrorAxis()

+	{

+		ForgeDirection direction = ForgeDirection.getOrientation(this.getFacing());

+		int mx = direction.offsetX!=0?-1:1;

+		int my = direction.offsetY!=0?-1:1;

+		int mz = direction.offsetZ!=0?-1:1;

+		return new float[] {mx,my,mz,direction.offsetX,direction.offsetY,direction.offsetZ};

+	}

+	

+	private void checkBWCList()

+	{

+    	if(++this.bwcListPos>=bwc.size())

+    	{

+    		this.bwcListPos=0;

+    	}

+    	if(!bwc.isEmpty())

+    	{

+    		BlockWithCoordinates bwcEntry = bwc.get(bwcListPos);

+    		if(bwcEntry.block!=worldObj.getBlock(bwcEntry.x, bwcEntry.y, bwcEntry.z))

+    		{

+    			bwc.remove(bwcListPos);

+    		}

+    	}

+	}

+	

+	private void checkTileEntityList()

+	{

+    	if(++this.reflectedTileEntityListPos>=reflectedTileEntity.size())

+    	{

+    		this.reflectedTileEntityListPos=0;

+    	}

+    	if(!reflectedTileEntity.isEmpty())

+    	{

+    		TileEntity entry = reflectedTileEntity.get(reflectedTileEntityListPos);

+    		if(entry==null || entry.isInvalid() || entry!=worldObj.getTileEntity(entry.xCoord, entry.yCoord, entry.zCoord))

+    		{

+    			reflectedTileEntity.remove(reflectedTileEntityListPos);

+    		}

+    	}

+	}

+	

+	private void checkReflectionVolume()

+	{

+    	if(++this.reflectionVolumePos>=reflectionVolumeSize)

+    	{

+    		this.reflectionVolumePos=0;

+    		if(lastBWCSize!=bwc.size())

+    		{

+    			this.needRenderUpdate=true;

+    			lastBWCSize=bwc.size();

+    		}

+    	}

+    	if(reflectionVolumeSize>0)

+    	{

+			//reflectionVolumePos = x+y*maxX+z*maxX*maxY;

+    		int z = reflectionVolumePos / (maxX-minX) / (maxY-minY);

+    		int y = (reflectionVolumePos % ((maxX-minX) * (maxY-minY)))/ (maxX-minX);

+    		int x = reflectionVolumePos - y * (maxX-minX) - z * (maxX-minX) * (maxY-minY);

+    		//for example position is 69 volume is 4*5*5=100, therefore z will be 69 / (4*5)=3

+    		//y will be (69 % (4*5))/4=9/4=2

+    		//x will be 69 - 2*4 - 3*4*5 = 69-8-60=1

+    		//for check 1+2*4+3*4*5=1+8+60

+    		int ix = minX+x;

+    		int iy = minY+y;

+    		int iz = minZ+z;

+    		Block block = worldObj.getBlock(ix, iy, iz);

+    		if(block!=null  && !block.isAir(worldObj, ix, iy, iz) && isBlockVisible(block,ix,iy,iz))

+    		{

+				TileEntity te = worldObj.getTileEntity(ix, iy, iz);

+				if(te!=null && !te.isInvalid() && !reflectedTileEntity.contains(te) && TileEntityRendererDispatcher.instance.hasSpecialRenderer(te) && !(te instanceof MirrorTileEntity))

+				{

+					reflectedTileEntity.add(te);

+				}

+    			if(block.getRenderType()>=0)

+				{

+					BlockWithCoordinates bwc1 = new BlockWithCoordinates(block, ix, iy, iz, worldObj.getBlockMetadata(ix, iy, iz));

+					if(!bwc.contains(bwc1))

+					{

+						bwc.add(bwc1);

+					}

+				}

+    		}

+    	}

+	}

+

+	private int mXR()

+			{

+				switch(this.getFacing())

+				{

+				case 0:

+				return 1;

+				case 1:

+				return -1;

+				case 2:

+				return 1;

+				case 3:

+				return -1;

+				default:

+				return 0;

+				}

+			}

+		    

+	    private int mYR()

+			{

+				return 0;

+			}

+			

+	    private int mZR()

+			{

+				switch(this.getFacing())

+				{

+				case 4:

+				return -1;

+				case 5:

+				return 1;

+				default:

+				return 0;

+				}

+			}

+			

+	    private int mXT()

+				{

+					return 0;

+				}

+			

+	    private int mYT()

+				{

+					switch(this.getFacing())

+					{

+					case 2:

+					return 1;

+					case 3:

+					return 1;

+					case 4:

+					return 1;

+					case 5:

+					return 1;

+					default:

+					return 0;

+					}

+				}

+

+	    private int mZT()

+				{

+					switch(this.getFacing())

+					{

+					case 0:

+					return 1;

+					case 1:

+					return -1;

+					default:

+					return 0;

+					}

+				}

+	    

+	    @Override

+		public AxisAlignedBB  getRenderBoundingBox()

+		{

+			double xMinD=(double)this.xCoord-this.reflectExtensionRight*Math.abs(this.mXR())-this.reflectExtensionTop*Math.abs(this.mXT());

+			double xMaxD=(double)this.xCoord+this.reflectExtensionRight*Math.abs(this.mXR())+this.reflectExtensionTop*Math.abs(this.mXT())+1d;

+			double yMinD=(double)this.yCoord-this.reflectExtensionRight*Math.abs(this.mYR())-this.reflectExtensionTop*Math.abs(this.mYT());

+			double yMaxD=(double)this.yCoord+this.reflectExtensionRight*Math.abs(this.mYR())+this.reflectExtensionTop*Math.abs(this.mYT())+1d;

+			double zMinD=(double)this.zCoord-this.reflectExtensionRight*Math.abs(this.mZR())-this.reflectExtensionTop*Math.abs(this.mZT());

+			double zMaxD=(double)this.zCoord+this.reflectExtensionRight*Math.abs(this.mZR())+this.reflectExtensionTop*Math.abs(this.mZT())+1d;

+			return AxisAlignedBB.getBoundingBox(xMinD, yMinD, zMinD, xMaxD, yMaxD, zMaxD);		    

+		}	 

+	    

+		@Override

+	    public boolean shouldRenderInPass(int pass)

+	    {

+	        return pass==0;

+	    }

+}
\ No newline at end of file