Elements, LIGH, TESC, EMP and DEST thanks to MaksProg

7 files changed, 579 insertions, 4 deletions

diff --git a/src/elements/dest.c b/src/elements/dest.c
new file mode 100644
index 0000000..fb2a9d7
--- /dev/null
+++ b/src/elements/dest.c
@@ -0,0 +1,59 @@
+#include <element.h>
+
+int update_DEST(UPDATE_FUNC_ARGS) {
+	int r,rx,ry;
+	rx=rand()%5-2;
+	ry=rand()%5-2;
+
+    r = pmap[y+ry][x+rx];
+    if ((r>>8)>=NPART || !r)
+        return 0;
+    if ((r&0xFF)!=PT_DEST && (r&0xFF)!=PT_DMND)
+    {
+        if (parts[i].life<=0 || parts[i].life>37)
+        {
+            parts[i].life=30+rand()%20;
+            parts[i].temp+=20000;
+            pv[y/CELL][x/CELL]+=60.0f;
+        }
+        parts[i].temp+=10000;
+        if ((r&0xFF)==PT_PLUT || (r&0xFF)==PT_DEUT)
+        {
+            pv[y/CELL][x/CELL]+=20.0f;
+            parts[i].temp+=18000;
+            if (rand()%2==0)
+            {
+                part_change_type(r>>8, x+rx, y+ry, PT_NEUT);
+                float rad = (rand()%128+128)/127.0f;
+                float a = (rand()%360)*M_PI/180.0f;
+                parts[r>>8].vx = rad*cosf(a);
+                parts[r>>8].vy = rad*sinf(a);
+                parts[r>>8].temp+=40000;
+                pv[y/CELL][x/CELL]+=10.0f;
+                parts[i].life-=4;
+            }
+        }
+        if ((r&0xFF)==PT_INSL)
+        {
+            create_part(r>>8, x+rx, y+ry, PT_FIRE);
+            parts[r>>8].temp=10000;
+        }
+        else if (rand()%3==0)
+        {
+            kill_part(r>>8);
+            parts[i].life-=4*(ptypes[r&0xFF].properties==TYPE_SOLID?3:1);
+            if (parts[i].life<=0)
+                parts[i].life=1;
+            parts[i].temp+=10000;
+        }
+        else
+        {
+            parts[r>>8].temp+=10000;
+        }
+        int topv=pv[y/CELL][x/CELL]/9+parts[r>>8].temp/900;
+        if (topv>40.0f)
+            topv=40.0f;
+        pv[y/CELL][x/CELL]+=40.0f+topv;
+    }
+    return 0;
+}
diff --git a/src/elements/emp.c b/src/elements/emp.c
new file mode 100644
index 0000000..3017bc6
--- /dev/null
+++ b/src/elements/emp.c
@@ -0,0 +1,102 @@
+#include <element.h>
+
+int update_EMP(UPDATE_FUNC_ARGS) {
+	int r,rx,ry,ok=0,t;
+	if (parts[i].life)
+        return 0;
+	for (rx=-2; rx<3; rx++)
+		for (ry=-2; ry<3; ry++)
+			if (x+rx>=0 && y+ry>0 && x+rx<XRES && y+ry<YRES && (rx || ry))
+			{
+				r = pmap[y+ry][x+rx];
+				if ((r>>8)>=NPART || !r)
+					continue;
+                if ((r&0xFF)==PT_SPRK)
+                {
+                    ok=1;
+                    break;
+                }
+			}
+    if (!ok)
+        return 0;
+    parts[i].life=220;
+    emp_decor+=7;
+    if (emp_decor>100)
+        emp_decor=100;
+	for (r=0; r<=parts_lastActiveIndex; r++)
+	{
+	    t=parts[r].type;
+	    rx=parts[r].x;
+	    ry=parts[r].y;
+	    if (t==PT_SPRK || (t==PT_SWCH && parts[r].life!=0 && parts[r].life!=10) || (t==PT_WIRE && parts[r].ctype>0))
+        {
+            int is_elec=0;
+            if ((parts[r].ctype==PT_PSCN || parts[r].ctype==PT_NSCN || parts[r].ctype==PT_PTCT ||
+             parts[r].ctype==PT_NTCT || parts[r].ctype==PT_INST || parts[r].ctype==PT_SWCH) || t==PT_WIRE || t==PT_SWCH)
+            {
+                is_elec=1;
+                if (rand()%100==0)
+                    parts[r].temp+=3000;
+                if (rand()%80==0)
+                    part_change_type(r, rx, ry, PT_BREC);
+                else if (rand()%120==0)
+                    part_change_type(r, rx, ry, PT_NTCT);
+            }
+            int n,nx,ny;
+            for (nx=-2; nx<3; nx++)
+                for (ny=-2; ny<3; ny++)
+                    if (rx+nx>=0 && ry+ny>0 && rx+nx<XRES && ry+ny<YRES && (rx || ry))
+                    {
+                        n = pmap[ry+ny][rx+nx];
+                        if ((n>>8)>=NPART || !n)
+                            continue;
+                        /*if ((n&0xFF)==PT_BTRY && rand()%60==0)
+                        {
+                            part_change_type(n>>8, rx+nx, ry+ny, PT_PLSM);
+                            parts[n>>8].life=rand()%100+70;
+                            parts[n>>8].temp+=3000;
+                        }*/
+                        if (is_elec && ((n&0xFF)==PT_METL || (n&0xFF)==PT_BMTL) && rand()%280==0)
+                        {
+                            parts[n>>8].temp+=3000;
+                        }
+                        if (is_elec && (n&0xFF)==PT_BMTL && rand()%160==0)
+                        {
+                            part_change_type(n>>8, rx+nx, ry+ny, PT_BMTL);
+                            parts[n>>8].temp+=1000;
+                        }
+                        if (is_elec && (n&0xFF)==PT_METL && rand()%300==0)
+                        {
+                            part_change_type(n>>8, rx+nx, ry+ny, PT_BMTL);
+                        }
+                        if ((t==PT_PSCN || t==PT_NSCN) && (n&0xFF)==PT_SWCH && rand()%100==0)
+                        {
+                            part_change_type(n>>8, rx+nx, ry+ny, PT_BREC);
+                        }
+                        if ((t==PT_PSCN || t==PT_NSCN) && (n&0xFF)==PT_SWCH && rand()%100==0)
+                        {
+                            parts[n>>8].temp+=2000;
+                        }
+                        if (is_elec && (n&0xFF)==PT_WIFI && rand()%8==0)
+                        {
+                            parts[n>>8].temp=rand()%10000;
+                        }
+                        if (is_elec && (n&0xFF)==PT_WIFI && rand()%16==0)
+                        {
+                            create_part(n>>8, rx+nx, ry+ny, PT_BREC);
+                            parts[n>>8].temp+=1000;
+                        }
+                        if ((n&0xFF)==PT_ARAY && rand()%60==0)
+                        {
+                            create_part(n>>8, rx+nx, ry+ny, PT_BREC);
+                            parts[n>>8].temp+=1000;
+                        }
+                        if (t==PT_DLAY && rand()%70==0)
+                        {
+                            parts[n>>8].temp+=2000;
+                        }
+                    }
+        }
+	}
+	return 0;
+}
diff --git a/src/elements/ligh.c b/src/elements/ligh.c
new file mode 100644
index 0000000..7ce780a
--- /dev/null
+++ b/src/elements/ligh.c
@@ -0,0 +1,260 @@
+#include <element.h>
+
+int contact_part(int i, int tp)
+{
+    int x=parts[i].x, y=parts[i].y;
+    int r,rx,ry;
+    for (rx=-2; rx<3; rx++)
+        for (ry=-2; ry<3; ry++)
+            if (x+rx>=0 && y+ry>0 && x+rx<XRES && y+ry<YRES && (rx || ry))
+			{
+				r = pmap[y+ry][x+rx];
+				if ((r>>8)>=NPART || !r)
+					continue;
+                if ((r&0xFF)==tp)
+                    return r>>8;
+			}
+    return -1;
+}
+
+void create_line_par(int x1, int y1, int x2, int y2, int c, int temp, int life, int tmp, int tmp2)
+{
+    if (c==WL_EHOLE || c==WL_ALLOWGAS || c==WL_ALLOWALLELEC || c==WL_ALLOWSOLID || c==WL_ALLOWAIR || c==WL_WALL || c==WL_DESTROYALL || c==WL_ALLOWLIQUID || c==WL_FAN || c==WL_STREAM || c==WL_DETECT || c==WL_EWALL || c==WL_WALLELEC)
+        return; // this function only for particles, no walls
+    int cp=abs(y2-y1)>abs(x2-x1), x, y, dx, dy, sy;
+	float e, de;
+	if (cp)
+	{
+		y = x1;
+		x1 = y1;
+		y1 = y;
+		y = x2;
+		x2 = y2;
+		y2 = y;
+	}
+	if (x1 > x2)
+	{
+		y = x1;
+		x1 = x2;
+		x2 = y;
+		y = y1;
+		y1 = y2;
+		y2 = y;
+	}
+	dx = x2 - x1;
+	dy = abs(y2 - y1);
+	e = 0.0f;
+	if (dx)
+		de = dy/(float)dx;
+	else
+		de = 0.0f;
+	y = y1;
+	sy = (y1<y2) ? 1 : -1;
+	for (x=x1; x<=x2; x++)
+	{
+	    int p;
+		if (cp)
+			p=create_part(-1, y, x, c);
+		else
+			p=create_part(-1, x, y,c);
+        if (p!=-1)
+        {
+            parts[p].life=life;
+            parts[p].temp=temp;
+            parts[p].tmp=tmp;
+            parts[p].tmp2=tmp2;
+        }
+		e += de;
+		if (e >= 0.5f)
+		{
+			y += sy;
+			e -= 1.0f;
+		}
+	}
+}
+
+int update_LIGH(UPDATE_FUNC_ARGS)
+{
+    /*tmp2:
+    -1 - part will be removed
+    0 -
+    1 -
+    2 -
+    */
+	int r,rx,ry, multipler, powderful=parts[i].temp*(1+parts[i].life/40)/2;
+	hv[y/CELL][x/CELL]+=powderful/40;
+	if (hv[y/CELL][x/CELL]>MAX_TEMP)
+        hv[y/CELL][x/CELL]=MAX_TEMP;
+    for (rx=-2; rx<3; rx++) // destruction
+        for (ry=-2; ry<3; ry++)
+            if (x+rx>=0 && y+ry>0 && x+rx<XRES && y+ry<YRES && (rx || ry))
+			{
+				r = pmap[y+ry][x+rx];
+				if ((r>>8)>=NPART || !r)
+					continue;
+                if ((r&0xFF)!=PT_LIGH)
+				{
+				    if (parts[i].tmp2==3)
+				    {
+				    if ((ptypes[r&0xFF].properties&PROP_CONDUCTS) && parts[r>>8].life==0 && parts[r>>8].ctype!=PT_SPRK)
+				    {
+                        parts[r>>8].ctype = parts[r>>8].type;
+                        part_change_type(r>>8,x+rx,y+ry,PT_SPRK);
+                        parts[r>>8].life = 4;
+
+                        pv[y/CELL][x/CELL] += powderful/1200;
+                        parts[r>>8].temp+=powderful/20;
+                    }
+                    else if ((r&0xFF)!=PT_CLNE&&(r&0xFF)!=PT_THDR&&(r&0xFF)!=PT_SPRK&&(r&0xFF)!=PT_DMND&&(r&0xFF)!=PT_FIRE&&(r&0xFF)!=PT_NEUT&&(r&0xFF)!=PT_PHOT)
+                    {
+                        pv[y/CELL][x/CELL] += powderful/110;
+                        parts[r>>8].temp+=powderful/1.5;
+                    }
+                    if ((r&0xFF)==PT_DEUT || (r&0xFF)==PT_PLUT)
+                    {
+                        parts[r>>8].temp+=powderful;
+                        pv[y/CELL][x/CELL] +=powderful/35;
+                        if (rand()%3==0)
+                        {
+                            part_change_type(r>>8,x+rx,y+ry,PT_NEUT);
+                            parts[r>>8].vx=rand()%10-5;
+                            parts[r>>8].vy=rand()%10-5;
+                        }
+                    }
+				    }
+				    if ((r&0xFF)!=PT_CLNE&&(r&0xFF)!=PT_THDR&&(r&0xFF)!=PT_SPRK&&(r&0xFF)!=PT_DMND&&(r&0xFF)!=PT_FIRE&&(r&0xFF)!=PT_NEUT&&(r&0xFF)!=PT_PHOT)
+                        parts[r>>8].temp+=powderful/16;
+                    else
+                        parts[r>>8].temp+=powderful/70;
+				}
+            }
+    if (parts[i].tmp2==3)
+    {
+        //if (rand()&1)
+            parts[i].tmp2=1;
+        /*else
+            parts[i].tmp2=0;*/
+        return 1;
+    }
+
+	if (parts[i].tmp2==-1)
+	{
+	    kill_part(i);
+        return 0;
+	}
+	if (parts[i].tmp2<=0 || parts[i].life<=1)
+	{
+	    /*if (parts[i].tmp2!=3 && rand()%3000<400/(parts[i].life+1))
+        {
+            parts[i].tmp2=1;
+            return 1;
+        }*/
+	    if (parts[i].tmp2>0)
+            parts[i].tmp2=0;
+	    parts[i].tmp2--;
+        return 1;
+	}
+	if (parts[i].tmp2<=-2)
+	{
+	    killpart(i);
+	    return 0;
+	}
+
+	float angle, angle2=-1;
+
+	int near=nearest_part(i, -1, parts[i].life*3.5);
+	if (near!=-1 && (parts[near].type==PT_LIGH || parts[near].type==PT_THDR || parts[near].type==PT_NEUT))
+        near=-1;
+	if (near!=-1)
+	{
+	    int t=parts[near].type;
+
+        rx=parts[near].x-x;
+        ry=parts[near].y-y;
+        if (asin(ry-sqrt(rx*rx+ry*ry))<M_PI*2/3)
+        {
+            create_line_par(x, y, x+rx, y+ry, PT_LIGH, parts[i].temp, parts[i].life, parts[i].tmp-90, 0);
+
+        /*if (t!=PT_DMND && t!=PT_UDMT && t!=PT_TESC && parts[i].temp-300>rand()%2000)
+        {
+            part_change_type(near, x+rx, y+ry, PT_LIGH);
+            parts[near].tmp2=3;
+            parts[near].life=(int)(1.0*parts[i].life/2-1);
+            parts[near].tmp=parts[i].tmp-180;
+            parts[near].temp=parts[i].temp;
+        }*/
+            if (t!=PT_TESC)
+            {
+                near=contact_part(near, PT_LIGH);
+                if (near!=-1)
+                {
+                    parts[near].tmp2=3;
+                    parts[near].life=(int)(1.0*parts[i].life/2-1);
+                    parts[near].tmp=parts[i].tmp-180;
+                    parts[near].temp=parts[i].temp;
+                }
+            }
+        }
+        else near=-1;
+	}
+
+	//if (parts[i].tmp2==1/* || near!=-1*/)
+    angle=parts[i].tmp-30+rand()%60;
+    if (angle<0)
+        angle+=360;
+    if (angle>=360)
+        angle-=360;
+	if (parts[i].tmp2==2)
+	{
+        angle2=angle+100-rand()%200;
+        if (angle2<0)
+            angle2+=360;
+        if (angle2>=360)
+            angle-=360;
+        /*angle=parts[i].tmp-70+rand()%50;
+        if (angle<0)
+            angle+=360;
+        if (angle>=360)
+            angle-=360;*/
+	}
+
+	multipler=parts[i].life*1.5+rand()%((int)(parts[i].life+1));
+    rx=cos(angle*M_PI/180)*multipler;
+    ry=-sin(angle*M_PI/180)*multipler;
+	create_line_par(x, y, x+rx, y+ry, PT_LIGH, parts[i].temp, parts[i].life, angle, 0);
+
+	if (x+rx>=0 && y+ry>0 && x+rx<XRES && y+ry<YRES && (rx || ry))
+	{
+	    r = pmap[y+ry][x+rx];
+        if (!((r>>8)>=NPART || !r))
+        {
+            parts[r>>8].tmp2=1+(rand()%200>parts[i].tmp2*parts[i].tmp2/10+60);
+            parts[r>>8].life=(int)(1.0*parts[i].life/1.5-rand()%2);
+            parts[r>>8].tmp=angle;
+            parts[r>>8].temp=parts[i].temp;
+        }
+	}
+
+	if (angle2!=-1)
+	{
+	    multipler=parts[i].life*1.5+rand()%((int)(parts[i].life+1));
+        rx=cos(angle2*M_PI/180)*multipler;
+        ry=-sin(angle2*M_PI/180)*multipler;
+        create_line_par(x, y, x+rx, y+ry, PT_LIGH, parts[i].temp, parts[i].life, angle2, 0);
+
+        if (x+rx>=0 && y+ry>0 && x+rx<XRES && y+ry<YRES && (rx || ry))
+        {
+            r = pmap[y+ry][x+rx];
+            if (!((r>>8)>=NPART || !r))
+            {
+                parts[r>>8].tmp2=1+(rand()%200>parts[i].tmp2*parts[i].tmp2/10+40);
+                parts[r>>8].life=(int)(1.0*parts[i].life/1.5-rand()%2);
+                parts[r>>8].tmp=angle;
+                parts[r>>8].temp=parts[i].temp;
+            }
+        }
+	}
+
+    parts[i].tmp2=-1;
+	return 1;
+}
diff --git a/src/elements/sprk.c b/src/elements/sprk.c
index bae66e8..45b9acb 100644
--- a/src/elements/sprk.c
+++ b/src/elements/sprk.c
@@ -32,7 +32,7 @@ int update_SPRK(UPDATE_FUNC_ARGS) {
 	}
 	else if (ct==PT_ETRD&&parts[i].life==1)
 	{
-		nearp = nearest_part(i, PT_ETRD);
+		nearp = nearest_part(i, PT_ETRD, -1);
 		if (nearp!=-1&&parts_avg(i, nearp, PT_INSL)!=PT_INSL)
 		{
 			create_line(x, y, (int)(parts[nearp].x+0.5f), (int)(parts[nearp].y+0.5f), 0, 0, PT_PLSM, 0);
@@ -52,6 +52,40 @@ int update_SPRK(UPDATE_FUNC_ARGS) {
 		parts[i].temp = 3500;
 		pv[y/CELL][x/CELL] += 1;
 	}
+	else if (ct==PT_TESC) // tesla coil code
+	{
+	    if (parts[i].tmp>300)
+            parts[i].tmp=300;
+	    for (rx=-1; rx<2; rx++)
+			for (ry=-1; ry<2; ry++)
+                if (x+rx>=0 && y+ry>0 && x+rx<XRES && y+ry<YRES && (rx || ry))
+				{
+					r = pmap[y+ry][x+rx];
+					if ((r>>8)>=NPART || r)
+						continue;
+                    if (rand()%(parts[i].tmp*parts[i].tmp/20+6)==0)
+                    {
+                        int p=create_part(-1, x+rx*2, y+ry*2, PT_LIGH);
+                        if (p!=-1)
+                        {
+                            parts[p].life=rand()%(2+parts[i].tmp/15)+4+parts[i].tmp/7;
+                            if (parts[i].life>60)
+                                parts[i].life=60;
+                            parts[p].temp=parts[p].life*parts[i].tmp/2.5;
+                            parts[p].tmp2=1;
+                            parts[p].tmp=acos(1.0*rx/sqrt(rx*rx+ry*ry))/M_PI*360;
+                            parts[i].temp-=parts[i].tmp*2+parts[i].temp/5; // slight self-cooling
+                            if (fabs(pv[y/CELL][x/CELL])!=0.0f)
+                            {
+                                if (fabs(pv[y/CELL][x/CELL])<=0.5f)
+                                    pv[y/CELL][x/CELL]=0;
+                                else
+                                    pv[y/CELL][x/CELL]-=(pv[y/CELL][x/CELL]>0)?0.5:-0.5;
+                            }
+                        }
+                    }
+				}
+	}
 	else if (ct==PT_IRON) {
 		for (rx=-1; rx<2; rx++)
 			for (ry=-1; ry<2; ry++)
diff --git a/src/graphics.c b/src/graphics.c
index c038f10..83c9a5a 100644
--- a/src/graphics.c
+++ b/src/graphics.c
@@ -25,6 +25,8 @@ unsigned cmode = CM_FIRE;
 SDL_Surface *sdl_scrn;
 int sdl_scale = 1;
 
+int emp_decor = 0;
+
 int sandcolour_r = 0;
 int sandcolour_g = 0;
 int sandcolour_b = 0;
@@ -1724,6 +1726,26 @@ void xor_rect(pixel *vid, int x, int y, int w, int h)
 	}
 }
 
+void draw_other(pixel *vid) // EMP effect
+{
+    int i, j;
+    if (emp_decor>0 && !sys_pause) emp_decor-=emp_decor/50+1;
+	if (emp_decor>100) emp_decor=100;
+	if (cmode==CM_NOTHING) // no in nothing mode
+        return;
+    if (emp_decor)
+        for (j=0; j<YRES; j++)
+            for (i=0; i<XRES; i++)
+            {
+                int r=emp_decor*2.5, g=100+emp_decor*1.5, b=255;
+                float a=1.0*emp_decor/110;
+                if (r>255) r=255;
+                if (g>255) g=255;
+                if (b>255) g=255;
+                drawpixel(vid, i, j, r, g, b, a*255);
+            }
+}
+
 //the main function for drawing the particles
 void draw_parts(pixel *vid)
 {
@@ -3329,6 +3351,103 @@ void draw_parts(pixel *vid)
 					}
 
 				}
+				else if (t==PT_LIGH)
+				{
+					uint8 R = 235;
+					uint8 G = 245;
+					uint8 B = 255;
+					float a=0.8*parts[i].life/40;
+					if (a>0.8) a=0.8;
+					blendpixel(vid, nx, ny, R, G, B, 255);
+					if (cmode == CM_FIRE||cmode==CM_BLOB || cmode==CM_FANCY)
+					{
+						cr = a*R;
+						cg = a*G;
+						cb = a*B;
+						x = nx/CELL;
+						y = ny/CELL;
+						cg += fire_g[y][x];
+						if (cg > 255) cg = 255;
+						fire_g[y][x] = cg;
+						cb += fire_b[y][x];
+						if (cb > 255) cb = 255;
+						fire_b[y][x] = cb;
+						cr += fire_r[y][x];
+						if (cr > 255) cr = 255;
+						fire_r[y][x] = cr;
+
+						if (a>0.3)
+						{
+                        int rx, ry;
+						for (rx=-1; rx<2; rx++)
+                        for (ry=-1; ry<2; ry++)
+                        if (x+rx>=0 && y+ry>0 && x+rx<XRES && y+ry<YRES && (rx || ry))
+                        {
+                            cr = R*(a-0.3)/6;
+                            cg = G*(a-0.3)/6;
+                            cb = B*(a-0.3)/6;
+                            cg += fire_g[y+ry][x+rx];
+                            if (cg > 255) cg = 255;
+                            fire_g[y+ry][x+rx] = cg;
+                            cb += fire_b[y+ry][x+rx];
+                            if (cb > 255) cb = 255;
+                            fire_b[y+ry][x+rx] = cb;
+                            cr += fire_r[y+ry][x+rx];
+                            if (cr > 255) cr = 255;
+                            fire_r[y+ry][x+rx] = cr;
+                        }
+						}
+					}
+				}
+				else if (t==PT_DEST)
+				{
+                    cr = PIXR(ptypes[t].pcolors);
+                    cg = PIXG(ptypes[t].pcolors);
+                    cb = PIXB(ptypes[t].pcolors);
+                    if (cmode != CM_CRACK) {
+                        int newx = 0;
+                        float flicker = rand()%30;
+                        float gradv = flicker+(parts[i].life==0?20:1)+parts[i].life*8;
+                        blendpixel(vid, nx, ny, cr, cg, cb, (gradv*4)>255?255:(gradv*4) );
+                        blendpixel(vid, nx+1, ny, cr, cg, cb, (gradv*2)>255?255:(gradv*2) );
+                        blendpixel(vid, nx-1, ny, cr, cg, cb, (gradv*2)>255?255:(gradv*2) );
+                        blendpixel(vid, nx, ny+1, cr, cg, cb, (gradv*2)>255?255:(gradv*2) );
+                        blendpixel(vid, nx, ny-1, cr, cg, cb, (gradv*2)>255?255:(gradv*2) );
+                        if (gradv>255) gradv=255;
+                        blendpixel(vid, nx+1, ny-1, cr, cg, cb, gradv);
+                        blendpixel(vid, nx-1, ny-1, cr, cg, cb, gradv);
+                        blendpixel(vid, nx+1, ny+1, cr, cg, cb, gradv);
+                        blendpixel(vid, nx-1, ny+1, cr, cg, cb, gradv);
+                        for (newx = 1; gradv>0.5; newx++) {
+                            addpixel(vid, nx+newx, ny, cr, cg, cb, gradv);
+                            addpixel(vid, nx-newx, ny, cr, cg, cb, gradv);
+
+                            addpixel(vid, nx, ny+newx, cr, cg, cb, gradv);
+                            addpixel(vid, nx, ny-newx, cr, cg, cb, gradv);
+                            float div_n=1.2f-0.006*parts[i].life;
+                            if (div_n<1.01f)
+                                div_n=1.01f;
+                            gradv = gradv/div_n;
+                        }
+                    } else {
+                        blendpixel(vid, nx, ny, cr, cg, cb, 255);
+                    }
+                }
+				else if (t==PT_EMP && parts[i].life)
+				{
+				    cr = parts[i].life*1.5;
+					cg = parts[i].life*1.5;
+					cb = 200-parts[i].life;
+					if (cr>255)
+						cr = 255;
+					if (cg>255)
+						cg = 255;
+					if (cb>255)
+						cb = 255;
+                    if (cb<=0)
+						cb = 0;
+				    blendpixel(vid, nx, ny, cr, cg, cb, 255);
+				}
 				else if (t==PT_GBMB)
 				{
 					if (parts[i].life<=0) {//not yet detonated
diff --git a/src/main.c b/src/main.c
index f3d655f..a83ba3e 100644
--- a/src/main.c
+++ b/src/main.c
@@ -1815,6 +1815,7 @@ int main(int argc, char *argv[])
 		draw_walls(part_vbuf);
 		update_particles(part_vbuf); //update everything
 		draw_parts(part_vbuf); //draw particles
+		draw_other(part_vbuf);
 		if(sl == WL_GRAV+100 || sr == WL_GRAV+100)
 			draw_grav_zones(part_vbuf);
 		
diff --git a/src/powder.c b/src/powder.c
index 077a242..100ea96 100644
--- a/src/powder.c
+++ b/src/powder.c
@@ -1258,9 +1258,9 @@ inline int parts_avg(int ci, int ni,int t)
 }
 
 
-int nearest_part(int ci, int t)
+int nearest_part(int ci, int t, int max_d)
 {
-	int distance = MAX_DISTANCE;
+	int distance = (max_d!=-1)?max_d:MAX_DISTANCE;
 	int ndistance = 0;
 	int id = -1;
 	int i = 0;
@@ -1268,7 +1268,7 @@ int nearest_part(int ci, int t)
 	int cy = (int)parts[ci].y;
 	for (i=0; i<=parts_lastActiveIndex; i++)
 	{
-		if (parts[i].type==t&&!parts[i].life&&i!=ci)
+		if ((parts[i].type==t||t==-1)&&!parts[i].life&&i!=ci)
 		{
 			ndistance = abs(cx-parts[i].x)+abs(cy-parts[i].y);// Faster but less accurate  Older: sqrt(pow(cx-parts[i].x, 2)+pow(cy-parts[i].y, 2));
 			if (ndistance<distance)