ok this should finally work now

src/client/Minecraft.cpp

@@ -1125,6 +1125,7 @@ void Minecraft::init()
 	textures = new Textures(&options, platform());
 	textures->addDynamicTexture(new WaterTexture());
 	textures->addDynamicTexture(new WaterSideTexture());
+	textures->addDynamicTexture(new FireTexture());
 	gui.texturesLoaded(textures);
 
 	levelRenderer = new LevelRenderer(this);

src/client/renderer/TileRenderer.cpp

@@ -13,6 +13,7 @@
 #include "../../world/level/tile/BedTile.h"
 #include "../../world/level/tile/StemTile.h"
 #include "../../world/level/tile/StairTile.h"
+#include "../../world/level/tile/FireTile.h"
 #include "../../world/Direction.h"
 #include "../../world/Facing.h"
 #include "tileentity/TileEntityRenderer.h"
@@ -157,8 +158,8 @@ bool TileRenderer::tesselateInWorld( Tile* tt, int x, int y, int z )
         return tesselateRowInWorld(tt, x, y, z);
 	} else if (shape == Tile::SHAPE_TORCH) {
 		return tesselateTorchInWorld(tt, x, y, z);
-    //} else if (shape == Tile::SHAPE_FIRE) {
-    //    return tesselateFireInWorld(tt, x, y, z);
+    } else if (shape == Tile::SHAPE_FIRE) {
+        return tesselateFireInWorld(tt, x, y, z);
     //} else if (shape == Tile::SHAPE_RED_DUST) {
     //    return tesselateDustInWorld(tt, x, y, z);
 	} else if (shape == Tile::SHAPE_LADDER) {
@@ -222,6 +223,278 @@ bool TileRenderer::tesselateTorchInWorld( Tile* tt, int x, int y, int z )
 	return true;
 }
 
+bool TileRenderer::tesselateFireInWorld( Tile* tt, int x, int y, int z )
+{
+	// @todo: fire alpha transparency seems to be scuffed, also it seems i might have messed up the second layer while porting from lce/java , need to look into it - shredder
+
+	Tesselator& t = Tesselator::instance;
+
+	int tex = tt->getTexture(0);
+
+	if (fixedTexture >= 0) tex = fixedTexture;
+	
+	float br = tt->getBrightness( level, x, y, z );
+	t.color( br, br, br );
+	
+	int xt = ((tex & 0xf) << 4);
+	int yt = tex & 0xf0;
+
+	float u0 = (xt) / 256.0f;
+	float u1 = (xt + 15.99f) / 256.0f;
+	float v0 = (yt) / 256.0f;
+	float v1 = (yt + 15.99f) / 256.0f;
+	float h = 1.4f;
+
+	if ( level->isSolidBlockingTile( x, y - 1, z ) || Tile::fire->canBurn( level, x, y - 1, z ) )
+	{
+		float	x0 = x + 0.5f + 0.2f;
+		float	x1 = x + 0.5f - 0.2f;
+		float	z0 = z + 0.5f + 0.2f;
+		float	z1 = z + 0.5f - 0.2f;
+
+		float	x0_ = x + 0.5f - 0.3f;
+		float	x1_ = x + 0.5f + 0.3f;
+		float	z0_ = z + 0.5f - 0.3f;
+		float	z1_ = z + 0.5f + 0.3f;
+
+		t.vertexUV( ( float )( x0_ ), ( float )( y + h ), ( float )( z + 1 ), ( float )( u1 ), ( float )( v0 ) );
+		t.vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z + 1 ), ( float )( u1 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z + 0 ), ( float )( u0 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x0_ ), ( float )( y + h ), ( float )( z + 0 ), ( float )( u0 ), ( float )( v0 ) );
+
+		t.vertexUV( ( float )( x1_ ), ( float )( y + h ), ( float )( z + 0 ), ( float )( u1 ), ( float )( v0 ) );
+		t.vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z + 0 ), ( float )( u1 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z + 1 ), ( float )( u0 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x1_ ), ( float )( y + h ), ( float )( z + 1 ), ( float )( u0 ), ( float )( v0 ) );
+
+
+
+		u0 = (xt) / 256.0f;
+		u1 = (xt + 15.99f) / 256.0f;
+		v0 = (yt) / 256.0f;
+		v1 = (yt + 15.99f) / 256.0f;
+
+		t.vertexUV( ( float )( x + 1 ), ( float )( y + h ), ( float )( z1_ ), ( float )( u1 ), ( float )( v0 ) );
+		t.vertexUV( ( float )( x + 1 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x + 0 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u0 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x + 0 ), ( float )( y + h ), ( float )( z1_ ), ( float )( u0 ), ( float )( v0 ) );
+
+		t.vertexUV( ( float )( x + 0 ), ( float )( y + h ), ( float )( z0_ ), ( float )( u1 ), ( float )( v0 ) );
+		t.vertexUV( ( float )( x + 0 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u1 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x + 1 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u0 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x + 1 ), ( float )( y + h ), ( float )( z0_ ), ( float )( u0 ), ( float )( v0 ) );
+
+		x0 = x + 0.5f - 0.5f;
+		x1 = x + 0.5f + 0.5f;
+		z0 = z + 0.5f - 0.5f;
+		z1 = z + 0.5f + 0.5f;
+
+		x0_ = x + 0.5f - 0.4f;
+		x1_ = x + 0.5f + 0.4f;
+		z0_ = z + 0.5f - 0.4f;
+		z1_ = z + 0.5f + 0.4f;
+
+		t.vertexUV( ( float )( x0_ ), ( float )( y + h ), ( float )( z + 0 ), ( float )( u0 ), ( float )( v0 ) );
+		t.vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z + 0 ), ( float )( u0 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z + 1 ), ( float )( u1 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x0_ ), ( float )( y + h ), ( float )( z + 1 ), ( float )( u1 ), ( float )( v0 ) );
+
+		t.vertexUV( ( float )( x1_ ), ( float )( y + h ), ( float )( z + 1 ), ( float )( u0 ), ( float )( v0 ) );
+		t.vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z + 1 ), ( float )( u0 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x1 ), ( float )( y + 0 ), ( float )( z + 0 ), ( float )( u1 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x1_ ), ( float )( y + h ), ( float )( z + 0 ), ( float )( u1 ), ( float )( v0 ) );
+
+
+		u0 = (xt) / 256.0f;
+		u1 = (xt + 15.99f) / 256.0f;
+		v0 = (yt) / 256.0f;
+		v1 = (yt + 15.99f) / 256.0f;
+
+		t.vertexUV( ( float )( x + 0 ), ( float )( y + h ), ( float )( z1_ ), ( float )( u0 ), ( float )( v0 ) );
+		t.vertexUV( ( float )( x + 0 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u0 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x + 1 ), ( float )( y + 0 ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x + 1 ), ( float )( y + h ), ( float )( z1_ ), ( float )( u1 ), ( float )( v0 ) );
+
+		t.vertexUV( ( float )( x + 1 ), ( float )( y + h ), ( float )( z0_ ), ( float )( u0 ), ( float )( v0 ) );
+		t.vertexUV( ( float )( x + 1 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u0 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x + 0 ), ( float )( y + 0 ), ( float )( z0 ), ( float )( u1 ), ( float )( v1 ) );
+		t.vertexUV( ( float )( x + 0 ), ( float )( y + h ), ( float )( z0_ ), ( float )( u1 ), ( float )( v0 ) );
+	}
+	else
+	{
+		float	r = 0.2f;
+		float	yo = 1 / 16.0f;
+		if ( ( ( x + y + z ) & 1 ) == 1 )
+		{
+			u0 = (xt) / 256.0f;
+			u1 = (xt + 15.99f) / 256.0f;
+			v0 = (yt) / 256.0f;
+			v1 = (yt + 15.99f) / 256.0f;
+		}
+		if ( ( ( x / 2 + y / 2 + z / 2 ) & 1 ) == 1 )
+		{
+			float tmp = u1;
+			u1 = u0;
+			u0 = tmp;
+		}
+		if ( Tile::fire->canBurn( level, x - 1, y, z ) )
+		{
+			t.vertexUV( ( float )( x + r ), ( float )( y + h + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v0 ) );
+			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + r ), ( float )( y + h + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v0 ) );
+
+			t.vertexUV( ( float )( x + r ), ( float )( y + h + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v0 ) );
+			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + r ), ( float )( y + h + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v0 ) );
+		}
+		if ( Tile::fire->canBurn( level, x + 1, y, z ) )
+		{
+			t.vertexUV( ( float )( x + 1 - r ), ( float )( y + h + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v0 ) );
+			t.vertexUV( ( float )( x + 1 - 0 ), ( float )( y + 0 + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + 1 - 0 ), ( float )( y + 0 + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + 1 - r ), ( float )( y + h + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v0 ) );
+
+			t.vertexUV( ( float )( x + 1.0f - r ), ( float )( y + h + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v0 ) );
+			t.vertexUV( ( float )( x + 1.0f - 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 1.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + 1.0f - 0 ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + 1.0f - r ), ( float )( y + h + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v0 ) );
+		}
+		if ( Tile::fire->canBurn( level, x, y, z - 1 ) )
+		{
+			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + h + yo ), ( float )( z +
+						 r ), ( float )( u1 ), ( float )( v0 ) );
+			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 0.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + h + yo ), ( float )( z +
+						 r ), ( float )( u0 ), ( float )( v0 ) );
+
+			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + h + yo ), ( float )( z +
+						 r ), ( float )( u0 ), ( float )( v0 ) );
+			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z +
+						 0.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + h + yo ), ( float )( z +
+						 r ), ( float )( u1 ), ( float )( v0 ) );
+		}
+		if ( Tile::fire->canBurn( level, x, y, z + 1 ) )
+		{
+			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + h + yo ), ( float )( z + 1.0f -
+						 r ), ( float )( u0 ), ( float )( v0 ) );
+			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + 0.0f + yo ), ( float )( z + 1.0f -
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z + 1.0f -
+						 0.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + h + yo ), ( float )( z + 1.0f -
+						 r ), ( float )( u1 ), ( float )( v0 ) );
+
+			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + h + yo ), ( float )( z + 1.0f -
+						 r ), ( float )( u1 ), ( float )( v0 ) );
+			t.vertexUV( ( float )( x + 0.0f ), ( float )( y + 0.0f + yo ), ( float )( z + 1.0f -
+						 0.0f ), ( float )( u1 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + 0.0f + yo ), ( float )( z + 1.0f -
+						 0.0f ), ( float )( u0 ), ( float )( v1 ) );
+			t.vertexUV( ( float )( x + 1.0f ), ( float )( y + h + yo ), ( float )( z + 1.0f -
+						 r ), ( float )( u0 ), ( float )( v0 ) );
+		}
+		if ( Tile::fire->canBurn( level, x, y + 1.0f, z ) )
+		{
+			double	x0 = x + 0.5f + 0.5f;
+			double	x1 = x + 0.5f - 0.5f;
+			double	z0 = z + 0.5f + 0.5f;
+			double	z1 = z + 0.5f - 0.5f;
+
+			double	x0_ = x + 0.5f - 0.5f;
+			double	x1_ = x + 0.5f + 0.5f;
+			double	z0_ = z + 0.5f - 0.5f;
+			double	z1_ = z + 0.5f + 0.5f;
+
+			u0 = (xt) / 256.0f;
+			u1 = (xt + 15.99f) / 256.0f;
+			v0 = (yt) / 256.0f;
+			v1 = (yt + 15.99f) / 256.0f;
+
+			y += 1;
+			h = -0.2f;
+
+			if ( ( ( x + y + z ) & 1 ) == 0 )
+			{
+				t.vertexUV( ( float )( x0_ ), ( float )( y + h ), ( float )( z +
+							 0 ), ( float )( u1 ), ( float )( v0 ) );
+				t.vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z +
+							 0 ), ( float )( u1 ), ( float )( v1 ) );
+				t.vertexUV( ( float )( x0 ), ( float )( y + 0 ), ( float )( z +
+							 1 ), ( float )( u0 ), ( float )( v1 ) );
+				t.vertexUV( ( float )( x0_ ), ( float )( y + h ), ( float )( z +
+							 1 ), ( float )( u0 ), ( float )( v0 ) );
+
+				u0 = (xt) / 256.0f;
+				u1 = (xt + 15.99f) / 256.0f;
+				v0 = (yt) / 256.0f;
+				v1 = (yt + 15.99f) / 256.0f;
+
+				t.vertexUV( ( float )( x1_ ), ( float )( y + h ), ( float )( z +
+							 1.0f ), ( float )( u1 ), ( float )( v0 ) );
+				t.vertexUV( ( float )( x1 ), ( float )( y + 0.0f ), ( float )( z +
+							 1.0f ), ( float )( u1 ), ( float )( v1 ) );
+				t.vertexUV( ( float )( x1 ), ( float )( y + 0.0f ), ( float )( z +
+							 0 ), ( float )( u0 ), ( float )( v1 ) );
+				t.vertexUV( ( float )( x1_ ), ( float )( y + h ), ( float )( z +
+							 0 ), ( float )( u0 ), ( float )( v0 ) );
+			}
+			else
+			{
+				t.vertexUV( ( float )( x + 0.0f ), ( float )( y +
+							 h ), ( float )( z1_ ), ( float )( u1 ), ( float )( v0 ) );
+				t.vertexUV( ( float )( x + 0.0f ), ( float )( y +
+							 0.0f ), ( float )( z1 ), ( float )( u1 ), ( float )( v1 ) );
+				t.vertexUV( ( float )( x + 1.0f ), ( float )( y +
+							 0.0f ), ( float )( z1 ), ( float )( u0 ), ( float )( v1 ) );
+				t.vertexUV( ( float )( x + 1.0f ), ( float )( y +
+							 h ), ( float )( z1_ ), ( float )( u0 ), ( float )( v0 ) );
+
+				u0 = (xt) / 256.0f;
+				u1 = (xt + 15.99f) / 256.0f;
+				v0 = (yt) / 256.0f;
+				v1 = (yt + 15.99f) / 256.0f;
+
+				t.vertexUV( ( float )( x + 1.0f ), ( float )( y +
+							 h ), ( float )( z0_ ), ( float )( u1 ), ( float )( v0 ) );
+				t.vertexUV( ( float )( x + 1.0f ), ( float )( y +
+							 0.0f ), ( float )( z0 ), ( float )( u1 ), ( float )( v1 ) );
+				t.vertexUV( ( float )( x + 0.0f ), ( float )( y +
+							 0.0f ), ( float )( z0 ), ( float )( u0 ), ( float )( v1 ) );
+				t.vertexUV( ( float )( x + 0.0f ), ( float )( y +
+							 h ), ( float )( z0_ ), ( float )( u0 ), ( float )( v0 ) );
+			}
+		}
+	}
+
+	return true;
+
+}
+
+
 bool TileRenderer::tesselateLadderInWorld( Tile* tt, int x, int y, int z )
 {
 	Tesselator& t = Tesselator::instance;

src/client/renderer/TileRenderer.h

@@ -34,6 +34,8 @@ public:
 	bool tesselateFenceGateInWorld(FenceGateTile* tt, int x, int y, int z);
 	bool tesselateBedInWorld(Tile *tt, int x, int y, int z);
 	bool tesselateRowInWorld(Tile* tt, int x, int y, int z);
+	bool tesselateFireInWorld(Tile* tt, int x, int y, int z);
+
 
     void tesselateTorch(Tile* tt, float x, float y, float z, float xxa, float zza);
 	void tesselateCrossTexture(Tile* tt, int data, float x, float y, float z);

src/client/renderer/ptexture/DynamicTexture.cpp

@@ -206,3 +206,93 @@ void WaterSideTexture::tick() {
 		pixels[i * 4 + 3] = a;
 	}
 }
+
+FireTexture::FireTexture()
+:   super(((Tile*)Tile::fire)->tex),
+	_tick(0),
+	_frame(0)
+{
+	current = new float[16*20];
+	next = new float[16*20];
+	heat = new float[16*20];
+	heata = new float[16*20];
+
+	for (int i = 0; i < 256; ++i) {
+		current[i] = 0;
+		next[i] = 0;
+		heat[i] = 0;
+		heata[i] = 0;
+	}
+}
+
+FireTexture::~FireTexture() {
+	delete[] current;
+	delete[] next;
+	delete[] heat;
+	delete[] heata;
+}
+
+
+// oh boy time to implement fire textures, i am so fucked - shredder
+
+void FireTexture::tick() {
+//  loop generates fire texture  on the empty texture grid, hopefully shouldnt be too taxing on older hardware - shredder
+    for (int x = 0; x < 16; x++) {
+        for (int y = 0; y < 20; y++) {
+            int count = 18;
+            float pow = this->current[x + (y + 1) % 20 * 16] * (float)(count);
+            for (int xx = x - 1; xx <= x + 1; xx++) {
+                for (int yy = y; yy <= y + 1; yy++) {
+                    if (xx >= 0 && yy >= 0 && xx < 16 && yy < 20) {
+                        pow += this->current[xx + yy * 16];
+                    }
+                    count++;
+                }
+            }
+            this->next[x + y * 16] = pow / (float(count) * 1.06f);
+            if (y >= 19) {
+                this->next[x + y * 16] = float(Mth::random() * Mth::random() * Mth::random() * 4.0 + Mth::random() * 0.1f + 0.2f);
+            }
+        }
+    }
+
+    // hopefully this doesn't cause any mysterious issues - shredder
+	float* tmp = next;
+	next = current;
+	current = tmp;
+
+    for (int i = 0; i < 256; i++) {
+        float pow = this->current[i] * 1.8f;
+        if (pow > 1.0f) {
+            pow = 1.0f;
+        }
+        if (pow < 0.0f) {
+            pow = 0.0f;
+        }
+		
+	
+        int r = (int) (pow * 155.0f + 100.0f);
+        int g = (int)(pow * pow * 255.0f);
+        int b = (int)(pow * pow * pow * pow * pow * pow * pow * pow * pow * pow * 255.0f);
+        int a = 255;
+        if (pow < 0.5f) {
+            a = 0;
+        }
+
+		// @TODO: cant be arsed rn to implement the anaglyph3d check would be nice to check if it does - shredder
+        //if (this->anaglyph3d) {
+        //    float rr = (r * 30 + g * 59 + b * 11) / 100;
+        //    float gg = (r * 30 + g * 70) / 100;
+        //    float bb = (r * 30 + b * 70) / 100;
+        //    r = rr;
+        //    g = gg;
+        //    b = bb;
+        //}
+
+		pixels[i * 4 + 0] = r;
+		pixels[i * 4 + 1] = g;
+		pixels[i * 4 + 2] = b;
+		pixels[i * 4 + 3] = a;
+
+    }
+}

src/client/renderer/ptexture/DynamicTexture.h

@@ -56,4 +56,21 @@ public:
 	void tick();
 };
 
+class FireTexture: public DynamicTexture
+{
+    typedef DynamicTexture super;
+    int _tick;
+	int _frame;
+
+	float* current;
+	float* next;
+	float* heat;
+	float* heata;
+
+public:
+    FireTexture();
+	~FireTexture();
+
+    void tick();
+};
 #endif /*NET_MINECRAFT_CLIENT_RENDERER_PTEXTURE__DynamicTexture_H__*/

src/world/item/FlintAndSteelItem.h

@@ -19,7 +19,7 @@ public:
 		setMaxDamage(64);
     }
 
-    /*
+    
     bool useOn(ItemInstance* instance, Player* player, Level* level, int x, int y, int z, int face, float clickX, float clickY, float clickZ) {
         if (face == 0) y--;
         if (face == 1) y++;
@@ -30,14 +30,14 @@ public:
 
         int targetType = level->getTile(x, y, z);
         if (targetType == 0) {
-            level->playSound(x + 0.5, y + 0.5, z + 0.5, "fire.ignite", 1, sharedRandom.nextFloat() * 0.4f + 0.8f);
-            level->setTile(x, y, z, Tile::fire->id);
+            level->playSound(x + 0.5, y + 0.5, z + 0.5, "fire.ignite", 1, random.nextFloat() * 0.4f + 0.8f);
+            level->setTile(x, y, z, ((Tile*)Tile::fire)->id);
         }
 
         instance->hurt(1);
         return true;
     }
-    */
+    
 };
 
 #endif /*NET_MINECRAFT_WORLD_ITEM__FlintAndSteelItem_H__*/

src/world/level/Level.cpp

@@ -1599,8 +1599,8 @@ bool Level::containsFireTile(const AABB& box) {
                 for (int z = z0; z < z1; z++) {
                     int t = getTile(x, y, z);
 
-                    if (/*t == ((Tile*)(Tile::fire))->id
-					 ||*/ t == Tile::lava->id
+                    if (t == ((Tile*)(Tile::fire))->id
+					 || t == Tile::lava->id
 					 || t == Tile::calmLava->id) {
  						 return true;
 					}

src/world/level/biome/Biome.cpp

@@ -2,6 +2,7 @@
 
 #include "../levelgen/feature/TreeFeature.h"
 #include "../levelgen/feature/TallgrassFeature.h"
+#include "../levelgen/feature/BasicTree.h"
 
 #include "../../entity/EntityTypes.h"
 #include "../../entity/MobCategory.h"
@@ -140,7 +141,7 @@ void Biome::teardownBiomes() {
 Feature* Biome::getTreeFeature( Random* random )
 {
 	if (random->nextInt(10) == 0) {
-		//return /*new*/ BasicTree();
+		return new BasicTree(false);
 	}
 	return new TreeFeature(false);
 }
@@ -148,6 +149,15 @@ Feature* Biome::getGrassFeature( Random* random ) {
 	return new TallgrassFeature(Tile::tallgrass->id, TallGrass::TALL_GRASS);
 }
 
+Feature* Biome::getBasicTreeFeature( Random* random )
+{
+	if (random->nextInt(10) == 0) {
+		return new BasicTree(false);
+	}
+	
+}
+
+
 Biome* Biome::getBiome( float temperature, float downfall )
 {
 	int a = (int) (temperature * 63);

src/world/level/biome/Biome.h

@@ -71,6 +71,7 @@ public:
 
 	virtual Feature* getTreeFeature(Random* random);
 	virtual Feature* getGrassFeature(Random* random);
+	virtual Feature* getBasicTreeFeature(Random* random);
 
     static Biome* getBiome(float temperature, float downfall);
     static Biome* _getBiome(float temperature, float downfall);

src/world/level/biome/ForestBiome.h

@@ -6,6 +6,7 @@
 #include "Biome.h"
 #include "../levelgen/feature/TreeFeature.h"
 #include "../levelgen/feature/BirchFeature.h"
+#include "../levelgen/feature/BasicTree.h"
 
 class ForestBiome: public Biome
 {
@@ -15,7 +16,7 @@ public:
             return new BirchFeature();
         }
         if (random->nextInt(3) == 0) {
-            //return new BasicTree();
+            return new BasicTree(false);
         }
         return new TreeFeature(false);
     }

src/world/level/biome/RainforestBiome.h

@@ -6,13 +6,14 @@
 #include "Biome.h"
 #include "../../../util/Random.h"
 #include "../levelgen/feature/TreeFeature.h"
+#include "../levelgen/feature/BasicTree.h"
 
 class RainforestBiome: public Biome
 {
 public:
     Feature* getTreeFeature(Random* random) {
         if (random->nextInt(3) == 0) {
-            //return new BasicTree();
+            return new BasicTree(false);
         }
         return new TreeFeature(false);
     }

src/world/level/levelgen/RandomLevelSource.cpp

@@ -370,6 +370,18 @@ void RandomLevelSource::postProcess(ChunkSource* parent, int xt, int zt) {
 		}
 		//printf("placing tree at %d, %d, %d\n", x, y, z);
     }
+  //  for (int i = 0; i < forests; i++) {
+  //      int x = xo + random.nextInt(16) + 8;
+  //      int z = zo + random.nextInt(16) + 8;
+		//int y = level->getHeightmap(x, z);
+  //      Feature* tree = biome->getBasicTreeFeature(&random);
+		//if (tree) {
+	 //       tree->init(1, 1, 1);
+		//    tree->place(level, &random, x, y, z);
+		//	delete tree;
+		//}
+		////printf("placing tree at %d, %d, %d\n", x, y, z);
+  //  }
 
     for (int i = 0; i < 2; i++) {
         int x = xo + random.nextInt(16) + 8;

src/world/level/levelgen/feature/BasicTree.h

@@ -0,0 +1,446 @@
+#ifndef NET_MINECRAFT_WORLD_LEVEL_LEVELGEN_FEATURE__BasicTree_H__
+#define NET_MINECRAFT_WORLD_LEVEL_LEVELGEN_FEATURE__BasicTree_H__
+
+//package net.minecraft.world.level.levelgen.feature;
+
+#include "Feature.h"
+
+#include "../../../../util/Random.h"
+#include "../../Level.h"
+
+#include "../../tile/TreeTile.h"
+
+class Level;
+
+class BasicTree : public Feature
+{
+	typedef Feature super;
+private:
+
+	
+
+	unsigned char axisConversionArray[6];
+	Random *rnd;
+	Level *thisLevel;
+	int origin[3];
+	int height;
+	int trunkHeight;
+	double trunkHeightScale;
+	double branchDensity;
+	double branchSlope;
+	double widthScale;
+	double foliageDensity;
+	int trunkWidth;
+	int heightVariance;
+	int foliageHeight;
+	int **foliageCoords;
+	int foliageCoordsLength;
+	void prepare(){
+		trunkHeight = (int) (height * trunkHeightScale);
+		if (trunkHeight >= height) trunkHeight = height - 1;
+		int clustersPerY = (int) (1.382 + pow(foliageDensity * height / 13.0, 2));
+		if (clustersPerY < 1) clustersPerY = 1;
+		int **tempFoliageCoords = new int *[clustersPerY * height];
+		for( int i = 0; i < clustersPerY * height; i++ )
+		{
+			tempFoliageCoords[i] = new int[4];
+		}
+		int y = origin[1] + height - foliageHeight;
+		int clusterCount = 1;
+		int trunkTop = origin[1] + trunkHeight;
+		int relativeY = y - origin[1];
+
+		tempFoliageCoords[0][0] = origin[0];
+		tempFoliageCoords[0][1] = y;
+		tempFoliageCoords[0][2] = origin[2];
+		tempFoliageCoords[0][3] = trunkTop;
+		y--;
+
+		while (relativeY >= 0)
+		{
+			int num = 0;
+
+			float shapefac = treeShape(relativeY);
+			if (shapefac < 0)
+			{
+				y--;
+				relativeY--;
+				continue;
+			}
+
+			double originOffset = 0.5;
+			while (num < clustersPerY)
+			{
+				double radius = widthScale * (shapefac * (rnd->nextFloat() + 0.328));
+				double angle = rnd->nextFloat() * 2.0 * 3.14159;
+				int x = Mth::floor(radius * sin(angle) + origin[0] + originOffset);
+				int z = Mth::floor(radius * cos(angle) + origin[2] + originOffset);
+				int checkStart[] = { x, y, z };
+				int checkEnd[] = { x, y + foliageHeight, z };
+				if (checkLine(checkStart, checkEnd) == -1) {
+					int checkBranchBase[] = { origin[0], origin[1], origin[2] };
+					double distance = sqrt(pow(abs(origin[0] - checkStart[0]), 2.0) + pow(abs(origin[2] - checkStart[2]), 2.0));
+					double branchHeight = distance * branchSlope;
+					if ((checkStart[1] - branchHeight) > trunkTop)
+					{
+						checkBranchBase[1] = trunkTop;
+					}
+					else
+					{
+						checkBranchBase[1] = (int) (checkStart[1] - branchHeight);
+					}
+					if (checkLine(checkBranchBase, checkStart) == -1)
+					{
+						tempFoliageCoords[clusterCount][0] = x;
+						tempFoliageCoords[clusterCount][1] = y;
+						tempFoliageCoords[clusterCount][2] = z;
+						tempFoliageCoords[clusterCount][3] = checkBranchBase[1];
+						clusterCount++;
+					}
+				}
+				num++;
+			}
+			y--;
+			relativeY--;
+		}
+
+		foliageCoordsLength = clusterCount;
+		foliageCoords = tempFoliageCoords;
+
+		for( int i = clusterCount; i < clustersPerY * height; i++ )
+		{
+			delete [] tempFoliageCoords[i];
+			tempFoliageCoords[i] = NULL;
+		}
+
+
+	}
+
+	void crossection(int x, int y, int z, float radius, unsigned char direction, int material)
+	{
+
+		int rad = (int) (radius + 0.618);
+		unsigned char secidx1 = axisConversionArray[direction];
+		unsigned char secidx2 = axisConversionArray[direction + 3];
+		int center[] = { x, y, z };
+		int position[] = { 0, 0, 0 };
+		int offset1 = -rad;
+		int offset2 = -rad;
+		int thismat;
+		position[direction] = center[direction];
+		while (offset1 <= rad)
+		{
+			position[secidx1] = center[secidx1] + offset1;
+			offset2 = -rad;
+			while (offset2 <= rad)
+			{
+				double thisdistance = pow(abs(offset1) + 0.5, 2) + pow(abs(offset2) + 0.5, 2);
+				if (thisdistance > radius * radius)
+				{
+					offset2++;
+					continue;
+				}
+				position[secidx2] = center[secidx2] + offset2;
+
+				thismat = thisLevel->getTile(position[0], position[1], position[2]);
+
+				if (!((thismat == 0) || (thismat == Tile::leaves->id)))
+				{
+					offset2++;
+					continue;
+				}
+
+				placeBlock(thisLevel, position[0], position[1], position[2], material, 0);
+
+				offset2++;
+			}
+			offset1++;
+		}
+
+	}
+	float treeShape(int y){
+		if (y < (((float) height) * 0.3)) return (float) -1.618;
+		float radius = ((float) height) / ((float) 2.0);
+		float adjacent = (((float) height) / ((float) 2.0)) - y;
+		float distance;
+		if (adjacent == 0) distance = radius;
+		else if (abs(adjacent) >= radius) distance = (float) 0.0;
+		else distance = (float) sqrt(pow(abs(radius), 2) - pow(abs(adjacent), 2));
+		distance *= (float) 0.5;
+		return distance;
+	}
+	float foliageShape(int y){
+		if ((y < 0) || (y >= foliageHeight)) return (float) -1;
+		else if ((y == 0) || (y == (foliageHeight - 1))) return (float) 2;
+		else return (float) 3;
+	}
+	void foliageCluster(int x, int y, int z){
+
+		int topy = y + foliageHeight;
+		int cury = topy - 1;
+		float radius;
+		while (cury >= y)
+		{
+			radius = foliageShape(cury - y);
+			crossection(x, cury, z, radius, (unsigned char) 1, Tile::leaves->id);
+			cury--;
+		}
+
+	}
+	void limb(int *start, int *end, int material)
+	{
+		int delta[] = { 0, 0, 0 };
+		unsigned char idx = 0;
+		unsigned char primidx = 0;
+		while (idx < 3)
+		{
+			delta[idx] = end[idx] - start[idx];
+			if (abs(delta[idx]) > abs(delta[primidx]))
+			{
+				primidx = idx;
+			}
+			idx++;
+		}
+		if (delta[primidx] == 0) return;
+		unsigned char secidx1 = axisConversionArray[primidx];
+		unsigned char secidx2 = axisConversionArray[primidx + 3];
+		char primsign;
+		if (delta[primidx] > 0) primsign = 1;
+		else primsign = -1;
+		double secfac1 = ((double) delta[secidx1]) / ((double) delta[primidx]);
+		double secfac2 = ((double) delta[secidx2]) / ((double) delta[primidx]);
+		int coordinate[] = { 0, 0, 0 };
+		int primoffset = 0;
+		int endoffset = delta[primidx] + primsign;
+		while (primoffset != endoffset)
+		{
+			coordinate[primidx] = Mth::floor(start[primidx] + primoffset + 0.5);
+			coordinate[secidx1] = Mth::floor(start[secidx1] + (primoffset * secfac1) + 0.5);
+			coordinate[secidx2] = Mth::floor(start[secidx2] + (primoffset * secfac2) + 0.5);
+
+			int dir = 0;
+			int xdiff = abs(coordinate[0] - start[0]);
+			int zdiff = abs(coordinate[2] - start[2]);
+			int maxdiff = (std::max)(xdiff, zdiff);
+
+			if (maxdiff > 0)
+			{
+				if (xdiff == maxdiff)
+				{
+					dir = 0;
+				}
+				else if (zdiff == maxdiff)
+				{
+					dir = 0;
+				}
+			}
+			placeBlock(thisLevel, coordinate[0], coordinate[1], coordinate[2], material, dir);
+			primoffset += primsign;
+		}
+	}
+	void makeFoliage(){
+		int idx = 0;
+		int finish = foliageCoordsLength;
+		while (idx < finish)
+		{
+			int x = foliageCoords[idx][0];
+			int y = foliageCoords[idx][1];
+			int z = foliageCoords[idx][2];
+			foliageCluster(x, y, z);
+			idx++;
+		}
+	}
+	bool trimBranches(int localY){
+		if (localY < (height * 0.2)) return false;
+		else return true;
+	}
+	void makeTrunk(){
+		int x = origin[0];
+		int startY = origin[1];
+		int topY = origin[1] + trunkHeight;
+		int z = origin[2];
+		int startCoord[] = { x, startY, z };
+		int endCoord[] = { x, topY, z };
+		limb(startCoord, endCoord, Tile::treeTrunk->id);
+		if (trunkWidth == 2)
+		{
+			startCoord[0] += 1;
+			endCoord[0] += 1;
+			limb(startCoord, endCoord, Tile::treeTrunk->id);
+			startCoord[2] += 1;
+			endCoord[2] += 1;
+			limb(startCoord, endCoord, Tile::treeTrunk->id);
+			startCoord[0] += -1;
+			endCoord[0] += -1;
+			limb(startCoord, endCoord, Tile::treeTrunk->id);
+		}
+	}
+	void makeBranches(){
+		int idx = 0;
+		int finish = foliageCoordsLength;
+		int baseCoord[] = { origin[0], origin[1], origin[2] };
+		while (idx < finish)
+		{
+			int *coordValues = foliageCoords[idx];
+			int endCoord[] = { coordValues[0], coordValues[1], coordValues[2] };
+			baseCoord[1] = coordValues[3];
+			int localY = baseCoord[1] - origin[1];
+			if (trimBranches(localY))
+			{
+				limb(baseCoord, endCoord, Tile::treeTrunk->id);
+			}
+			idx++;
+		}
+	}
+	int checkLine(int *start, int *end){
+
+		int delta[] = { 0, 0, 0 };
+		unsigned char idx = 0;
+		unsigned char primidx = 0;
+		while (idx < 3)
+		{
+			delta[idx] = end[idx] - start[idx];
+			if (abs(delta[idx]) > abs(delta[primidx]))
+			{
+				primidx = idx;
+			}
+			idx++;
+		}
+		if (delta[primidx] == 0) return -1;
+		unsigned char secidx1 = axisConversionArray[primidx];
+		unsigned char secidx2 = axisConversionArray[primidx + 3];
+		char primsign; 
+		if (delta[primidx] > 0) primsign = 1;
+		else primsign = -1;
+		double secfac1 = ((double) delta[secidx1]) / ((double) delta[primidx]);
+		double secfac2 = ((double) delta[secidx2]) / ((double) delta[primidx]);
+		int coordinate[] = { 0, 0, 0 };
+		int primoffset = 0;
+		int endoffset = delta[primidx] + primsign;
+		int thismat;
+		while (primoffset != endoffset)
+		{
+			coordinate[primidx] = start[primidx] + primoffset;
+			coordinate[secidx1] = Mth::floor(start[secidx1] + (primoffset * secfac1));
+			coordinate[secidx2] = Mth::floor(start[secidx2] + (primoffset * secfac2));
+			thismat = thisLevel->getTile(coordinate[0], coordinate[1], coordinate[2]);
+			if (!((thismat == 0) || (thismat == Tile::leaves->id)))
+			{
+
+				break;
+			}
+			primoffset += primsign;
+		}
+	
+		if (primoffset == endoffset)
+		{
+			return -1;
+		}
+	
+		else
+		{
+			return abs(primoffset);
+		}
+	}
+	bool checkLocation(){
+	
+		int startPosition[] = { origin[0], origin[1], origin[2] };
+		int endPosition[] = { origin[0], origin[1] + height - 1, origin[2] };
+
+
+		int baseMaterial = thisLevel->getTile(origin[0], origin[1] - 1, origin[2]);
+		if (!((baseMaterial == 2) || (baseMaterial == 3)))
+		{
+			return false;
+		}
+		int allowedHeight = checkLine(startPosition, endPosition);
+		if (allowedHeight == -1)
+		{
+			return true;
+		}
+
+		else if (allowedHeight < 6)
+		{
+			return false;
+		}
+		else
+		{
+			height = allowedHeight;
+			return true;
+		}
+	}
+
+public:
+	BasicTree(bool doUpdate){
+		axisConversionArray[0] = 2;
+        axisConversionArray[1] = 0;
+        axisConversionArray[2] = 0;
+        axisConversionArray[3] = 1;
+        axisConversionArray[4] = 2;
+        axisConversionArray[5] = 1;
+		rnd = new Random();
+		origin[0] = 0;
+		origin[1] = 0;
+		origin[2] = 0;
+		height = 0;
+		trunkHeight = 0;
+		trunkHeightScale = 0.618;
+		branchDensity = 1.0;
+		branchSlope = 0.381;
+		widthScale = 1.0;
+		foliageDensity = 1.0;
+		trunkWidth = 1;
+		heightVariance = 12;
+		foliageHeight = 4;
+		foliageCoords = NULL;
+		foliageCoordsLength = 0;
+	}
+	virtual ~BasicTree(){
+		delete rnd;
+
+		for( int i = 0; i < foliageCoordsLength; i++ )
+		{
+			delete [] foliageCoords[i];
+		}
+		delete [] foliageCoords;
+	}
+
+	virtual void init(double heightInit, double widthInit, double foliageDensityInit){
+
+		heightVariance = (int) (heightInit * 12);
+		if (heightInit > 0.5) foliageHeight = 5;
+		widthScale = widthInit;
+		foliageDensity = foliageDensityInit;
+	}
+	virtual bool place(Level *level, Random *random, int x, int y, int z){
+
+		thisLevel = level;
+		int seed = random->nextLong();
+		rnd->setSeed(seed);
+		origin[0] = x;
+		origin[1] = y;
+		origin[2] = z;
+		if (height == 0)
+		{
+			height = 5 + rnd->nextInt(heightVariance);
+		}
+		if (!(checkLocation()))
+		{
+
+			return false;
+		}
+
+	
+
+		prepare();
+
+		makeFoliage();
+
+		makeTrunk();
+
+		makeBranches();
+
+		return true;
+	}
+};
+#endif /*NET_MINECRAFT_WORLD_LEVEL_LEVELGEN_FEATURE__BasicTree_H__*/

src/world/level/tile/FireTile.h

@@ -38,7 +38,7 @@ public:
         setFlammable(Tile::tnt->id, FLAME_MEDIUM, BURN_INSTANT);
         setFlammable(Tile::cloth->id, FLAME_EASY, BURN_EASY);
 
-        //setTicking(true); //@fire
+        setTicking(true); //@fire
     }
 
     AABB* getAABB(Level* level, int x, int y, int z) {
@@ -70,9 +70,9 @@ public:
     }
 
     void tick(Level* level, int x, int y, int z, Random* random) {
-		return; //@fire
+		
 
-        bool infiniBurn = false;//level->getTile(x, y - 1, z) == Tile::hellRock->id;
+        bool infiniBurn = level->getTile(x, y - 1, z) == Tile::netherrack->id;
 
         int age = level->getData(x, y, z);
         if (age < 15) {
@@ -148,7 +148,6 @@ public:
     }
 
     void neighborChanged(Level* level, int x, int y, int z, int type) {
-		return; //@fire
         if (!level->isSolidBlockingTile(x, y - 1, z) && !isValidFireLocation(level, x, y, z)) {
             level->setTile(x, y, z, 0);
             return;
@@ -156,7 +155,6 @@ public:
     }
 
     void onPlace(Level* level, int x, int y, int z) {
-		return; //@fire
         if (!level->isSolidBlockingTile(x, y - 1, z) && !isValidFireLocation(level, x, y, z)) {
             level->setTile(x, y, z, 0);
             return;
@@ -169,7 +167,6 @@ public:
     }
 
     void ignite(Level* level, int x, int y, int z) {
-		return; //@fire
 
         bool lit = false;
         if (!lit) lit = tryIgnite(level, x, y + 1, z);
@@ -184,11 +181,10 @@ public:
     }
 
     void animateTick(Level* level, int x, int y, int z, Random* random) {
-		return; //@fire
 
-        //if (random.nextInt(24) == 0) {
-        //    level->playSound(x + 0.5f, y + 0.5f, z + 0.5f, "fire.fire", 1 + random.nextFloat(), random.nextFloat() * 0.7f + 0.3f);
-        //}
+        if (random->nextInt(24) == 0) {
+            level->playSound(x + 0.5f, y + 0.5f, z + 0.5f, "fire.fire", 1 + random->nextFloat(), random->nextFloat() * 0.7f + 0.3f);
+        }
 
         if (level->isSolidBlockingTile(x, y - 1, z) || Tile::fire->canBurn(level, x, y - 1, z)) {
             for (int i = 0; i < 3; i++) {
@@ -248,7 +244,6 @@ private:
     }
 
     void checkBurn(Level* level, int x, int y, int z, int chance, Random* random) {
-        return; //@fire
 
 		int odds = burnOdds[level->getTile(x, y, z)];
         if (random->nextInt(chance) < odds) {
@@ -265,7 +260,6 @@ private:
     }
 
     bool isValidFireLocation(Level* level, int x, int y, int z) {
-		return false; //@fire
 
         if (canBurn(level, x + 1, y, z)) return true;
         if (canBurn(level, x - 1, y, z)) return true;
@@ -278,7 +272,6 @@ private:
     }
 
     int getFireOdds(Level* level, int x, int y, int z) {
-        return 0; //@fire
 
 		int odds = 0;
         if (!level->isEmptyTile(x, y, z)) return 0;
@@ -294,7 +287,6 @@ private:
     }
 
 	bool tryIgnite(Level* level, int x, int y, int z) {
-        return false; //@fire
 
 		int t = level->getTile(x, y, z);
         if (t == Tile::fire->id) return true;