From 66dcf910bd4744d8ced56cb9586aa937a1a2d4c5 Mon Sep 17 00:00:00 2001
From: vg <vgm+dev@devys.org>
Date: Tue, 7 Jul 2020 16:24:01 +0200
Subject: first commit

---
 cube_pc_test1/effect.c | 1478 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1478 insertions(+)
 create mode 100644 cube_pc_test1/effect.c

(limited to 'cube_pc_test1/effect.c')

diff --git a/cube_pc_test1/effect.c b/cube_pc_test1/effect.c
new file mode 100644
index 0000000..e6ed54a
--- /dev/null
+++ b/cube_pc_test1/effect.c
@@ -0,0 +1,1478 @@
+#include "effect.h"
+#include "draw.h"
+#include "font.h"
+#include <math.h>
+
+void effect_test (void)
+{
+
+	int x,y,i;
+
+	for (i=0;i<1000;i++)
+	{
+		x = sin(i/8)*2+3.5;
+		y = cos(i/8)*2+3.5;
+
+		setvoxel(x,y,1);
+		setvoxel(x,y,1);
+		delay_ms(1000);
+		fill(0x00);
+	}
+
+}
+
+
+//void effext_stringfly2 (char *str, char axis, char mirror, char direction, int delay, int space)
+void effect_stringfly2(char * str)
+{
+	int x,y,i,ii;
+	int state;
+	
+	unsigned char chr[5];
+	
+	while (*str)
+	{
+		font_getchar(*str++, chr);
+		
+		for (x = 0; x < 5; x++)
+		{
+			for (y = 0; y < 8; y++)
+			{
+				if ((chr[x] & (0x80>>y)))
+				{
+					setvoxel(7,x+2,y);
+				}
+			}
+		}
+		
+		for (ii = 0; ii<6; ii++)
+		{
+			delay_ms(1500);
+			for (i = 0; i < 7; i++)
+			{
+				for (x = 0; x < 8; x++)
+				{
+					for (y = 0; y < 8; y++)
+					{
+						state = getvoxel(i+1,x,y);
+						altervoxel(i,x,y,state);
+					}
+				}
+			}
+			for (x = 0; x < 8; x++)
+			{
+				for (y = 0; y < 8; y++)
+				{
+					clrvoxel(7,x,y);
+				}
+			}
+		}
+	}
+	for (ii = 0; ii<8; ii++)
+	{
+		delay_ms(1500);
+		for (i = 0; i < 7; i++)
+		{
+			for (x = 0; x < 8; x++)
+			{
+				for (y = 0; y < 8; y++)
+				{
+					state = getvoxel(i+1,x,y);
+					altervoxel(i,x,y,state);
+				}
+			}
+		}
+		for (x = 0; x < 8; x++)
+		{
+			for (y = 0; y < 8; y++)
+			{
+				clrvoxel(7,x,y);
+			}
+		}
+	}
+	
+}
+
+void effect_planboing (int plane, int speed)
+{
+	int i;
+	for (i=0;i<8;i++)
+	{
+		fill(0x00);
+		if (plane == AXIS_Z)
+			setplane_z(i);
+		
+		if (plane == AXIS_X)
+			setplane_x(i);
+		
+		if (plane == AXIS_Y)
+			setplane_y(i);
+		
+		delay_ms(speed);
+	}
+	
+	for (i=7;i>=0;i--)
+	{
+		fill(0x00);
+		if (plane == AXIS_Z)
+			setplane_z(i);
+		
+		if (plane == AXIS_X)
+			setplane_x(i);
+		
+		if (plane == AXIS_Y)
+			setplane_y(i);
+			
+		delay_ms(speed);
+	}
+}
+
+void effect_blinky2()
+{
+	int i,r;
+	fill(0x00);
+	
+	for (r=0;r<2;r++)
+	{
+		i = 750;
+		while (i>0)
+		{
+			fill(0x00);
+			delay_ms(i);
+			
+			fill(0xff);
+			delay_ms(100);
+			
+			i = i - (15+(1000/(i/10)));
+		}
+		
+		delay_ms(1000);
+		
+		i = 750;
+		while (i>0)
+		{
+			fill(0x00);
+			delay_ms(751-i);
+			
+			fill(0xff);
+			delay_ms(100);
+			
+			i = i - (15+(1000/(i/10)));
+		}
+	}
+
+}
+
+void effect_box_shrink_grow (int iterations, int mode, int direction, uint16_t delay)
+{
+	int x;
+	int i;
+	
+	int x1 = 0;
+	int y1 = 0;
+	int z1 = 0;
+	int x2 = 0;
+	int y2 = 0;
+	int z2 = 0;
+	
+	
+	for (x=0;x<iterations;x++)
+	{
+		for (i=7;i>=0;i--)
+		{
+			if(direction == 0)
+			{
+				// Dette funker også..
+				// memcpy(test, (int[]){1, 2, 3, 4, 5, 6}, 6 * sizeof(int));
+				x1=0; y1=0; z1=0; x2=i; y2=i; z2=i;
+			}
+
+			if(direction == 1) // fail
+			{
+				x1=0; y1=0; z1=7-i; x2=i; y2=i; z2=7;
+			}
+
+			if(direction == 2)
+			{
+				x1=0; y1=7; z1=0; x2=i; y2=7-i; z2=i;
+			}
+
+			if(direction == 3) //fail
+			{
+				x1=0; y1=7; z1=7; x2=i; y2=7-i; z2=7-i;
+			}
+
+			if(direction == 4) //fail
+			{
+				x1=7; y1=0; z1=0; x2=7-i; y2=i; z2=i;
+			}
+
+			if(direction == 5)
+			{
+				x1=7; y1=0; z1=7; x2=7-i; y2=i; z2=7-i;
+			}
+
+			if(direction == 6) //fail
+			{
+				x1=7; y1=7; z1=0; x2=7-i; y2=7-i; z2=i;
+			}
+
+			if(direction == 7)
+			{
+				x1=7; y1=7; z1=7; x2=7-i; y2=7-i; z2=7-i;
+			}
+
+			if (mode == 3)
+			{
+				box_filled(x1,y1,z1,x2,y2,z2);
+			}
+			else if (mode == 2)
+			{
+				box_walls(x1,y1,z1,x2,y2,z2);
+			}
+			else
+			{
+				box_wireframe(x1,y1,z1,x2,y2,z2);
+			}
+
+			delay_ms(delay);
+			fill(0x00);
+		}
+		for (i=0;i<8;i++)
+		{
+			if(direction == 0)
+			{
+				x1=0; y1=0; z1=0; x2=i; y2=i; z2=i;
+			}
+
+			if(direction == 1) // fail
+			{
+				x1=0; y1=0; z1=7-i; x2=i; y2=i; z2=7;
+			}
+
+			if(direction == 2)
+			{
+				x1=0; y1=7; z1=0; x2=i; y2=7-i; z2=i;
+			}
+
+			if(direction == 3) //fail
+			{
+				x1=0; y1=7; z1=7; x2=i; y2=7-i; z2=7-i;
+			}
+
+			if(direction == 4) //fail
+			{
+				x1=7; y1=0; z1=0; x2=7-i; y2=i; z2=i;
+			}
+
+			if(direction == 5)
+			{
+				x1=7; y1=0; z1=7; x2=7-i; y2=i; z2=7-i;
+			}
+
+			if(direction == 6) //fail
+			{
+				x1=7; y1=7; z1=0; x2=7-i; y2=7-i; z2=i;
+			}
+
+			if(direction == 7)
+			{
+				x1=7; y1=7; z1=7; x2=7-i; y2=7-i; z2=7-i;
+			}
+
+			if (mode == 3)
+			{
+				box_filled(x1,y1,z1,x2,y2,z2);
+			}
+			else if (mode == 2)
+			{
+				box_walls(x1,y1,z1,x2,y2,z2);
+			}
+			else
+			{
+				box_wireframe(x1,y1,z1,x2,y2,z2);
+			}
+			
+			delay_ms(delay);
+			fill(0x00);
+                }
+        }
+}
+
+
+void effect_box_woopwoop (int delay, int grow)
+{
+	int i;
+	
+	fill(0x00);
+	if (grow == 1)
+	{
+		for (i=0;i<4;i++)
+		{
+			box_wireframe(4+i,4+i,4+i,3-i,3-i,3-i);
+			delay_ms(delay);
+			fill(0x00);
+		}
+	} else
+	{
+		for (i=3;i>=0;i--)
+		{
+			box_wireframe(4+i,4+i,4+i,3-i,3-i,3-i);
+			delay_ms(delay);
+			fill(0x00);
+		}
+	}
+}
+
+
+// Send a voxel flying from one side of the cube to the other
+// It its at the bottom, send it to the top..
+void sendvoxel_z (unsigned char x, unsigned char y, unsigned char z, int delay)
+{
+	int i, ii;
+	for (i=0; i<8; i++)
+	{
+		if (z == 7)
+		{
+			ii = 7-i;
+			clrvoxel(x,y,ii+1);
+		} else
+		{
+			ii = i;
+			clrvoxel(x,y,ii-1);
+		}
+		setvoxel(x,y,ii);
+		delay_ms(delay);
+	}
+}
+
+// Send all the voxels from one side of the cube to the other
+// Start at z and send to the opposite side.
+// Sends in random order.
+void sendplane_rand_z (unsigned char z, int delay, int wait)
+{
+	unsigned char loop = 16;
+	unsigned char x, y;
+
+	fill(0x00);
+
+	setplane_z(z);
+	
+	// Send voxels at random untill all 16 have crossed the cube.
+	while(loop)
+	{
+		x = rand()%4;
+		y = rand()%4;
+		if (getvoxel(x,y,z))
+		{
+			// Send the voxel flying
+			sendvoxel_z(x,y,z,delay);
+			delay_ms(wait);
+			loop--; // one down, loop-- to go. when this hits 0, the loop exits. 
+		}
+	}
+}
+
+// For each coordinate along X and Y, a voxel is set either at level 0 or at level 7
+// for n iterations, a random voxel is sent to the opposite side of where it was.
+void sendvoxels_rand_z (int iterations, int delay, int wait)
+{
+	unsigned char x, y, last_x, last_y, i;
+
+	last_x = 0;
+	last_y = 0;
+
+	fill(0x00);
+	
+	//srand(123);
+
+	// Loop through all the X and Y coordinates
+	for (x=0;x<8;x++)
+	{
+		for (y=0;y<8;y++)
+		{
+			// Then set a voxel either at the top or at the bottom
+			if (rand()%2 == 0)
+			{
+				
+				setvoxel(x,y,0);
+			} else
+			{
+				setvoxel(x,y,7);
+			}
+			
+			
+		}
+	}
+
+	for (i=0;i<iterations;i++)
+	{
+		// Pick a random x,y position
+		x = rand()%8;
+		y = rand()%8;
+		// but not the sameone twice in a row
+		if (y != last_y && x != last_x)
+		{
+			// If the voxel at this x,y is at the bottom
+			if (getvoxel(x,y,0))
+			{
+				// send it to the top
+				sendvoxel_z(x,y,0,delay);
+			} else
+			{
+				// if its at the top, send it to the bottom
+				sendvoxel_z(x,y,7,delay);
+			}
+			delay_ms(wait);
+			
+			// Remember the last move
+			last_y = y;
+			last_x = x;
+		}
+	}
+
+}
+
+
+// Big ugly function :p but it looks pretty
+void boingboing(uint16_t iterations, int delay, unsigned char mode, unsigned char drawmode)
+{
+	fill(0x00);		// Blank the cube
+
+	int x, y, z;		// Current coordinates for the point
+	int dx, dy, dz;	// Direction of movement
+	int lol, i;		// lol?
+	unsigned char crash_x, crash_y, crash_z;
+
+	// Coordinate array for the snake.
+	int snake[8][3];
+	for (i=0;i<8;i++)
+	{
+		snake[i][0] = 4;
+		snake[i][1] = 4;
+		snake[i][2] = 4;
+	}
+	
+	y = rand()%8;
+	x = rand()%8;
+	z = rand()%8;
+	
+	dx = 1;
+	dy = 1;
+	dz = 1;
+	
+	while(iterations)
+	{
+		crash_x = 0;
+		crash_y = 0;
+		crash_z = 0;
+	
+
+		// Let's mix things up a little:
+		if (rand()%3 == 0)
+		{
+			// Pick a random axis, and set the speed to a random number.
+			lol = rand()%3;
+			if (lol == 0)
+				dx = rand()%3 - 1;
+			
+			if (lol == 1)
+				dy = rand()%3 - 1;
+				
+			if (lol == 2)
+				dz = rand()%3 - 1;
+		}
+
+	
+		if (dx == -1 && x == 0)
+		{
+			crash_x = 0x01;
+			if (rand()%3 == 1)
+			{
+				dx = 1;
+			} else
+			{
+				dx = 0;
+			}
+		}
+		
+		if (dy == -1 && y == 0)
+		{
+			crash_y = 0x01;
+			if (rand()%3 == 1)
+			{
+				dy = 1;
+			} else
+			{
+				dy = 0;
+			}
+		}
+		
+		if (dz == -1 && z == 0)
+		{
+			crash_z = 0x01;
+			if (rand()%3 == 1)
+			{
+				dz = 1;
+			} else
+			{
+				dz = 0;
+			}
+		}
+			
+		if (dx == 1 && x == 7)
+		{
+			crash_x = 0x01;
+			if (rand()%3 == 1)
+			{
+				dx = -1;
+			} else
+			{
+				dx = 0;
+			}
+		}
+		
+		if (dy == 1 && y == 7)
+		{
+			crash_y = 0x01;
+			if (rand()%3 == 1)
+			{
+				dy = -1;
+			} else
+			{
+				dy = 0;
+			}
+		}
+		
+		if (dz == 1 && z == 7)
+		{
+			crash_z = 0x01;
+			if (rand()%3 == 1)
+			{
+				dz = -1;
+			} else
+			{
+				dz = 0;
+			}
+		}
+		
+		// mode bit 0 sets crash action enable
+		if (mode | 0x01)
+		{
+			if (crash_x)
+			{
+				if (dy == 0)
+				{
+					if (y == 7)
+					{
+						dy = -1;
+					} else if (y == 0)
+					{
+						dy = +1;
+					} else
+					{
+						if (rand()%2 == 0)
+						{
+							dy = -1;
+						} else
+						{
+							dy = 1;
+						}
+					}
+				}
+				if (dz == 0)
+				{
+					if (z == 7)
+					{
+						dz = -1;
+					} else if (z == 0)
+					{
+						dz = 1;
+					} else
+					{
+						if (rand()%2 == 0)
+						{
+							dz = -1;
+						} else
+						{
+							dz = 1;
+						}
+					}	
+				}
+			}
+			
+			if (crash_y)
+			{
+				if (dx == 0)
+				{
+					if (x == 7)
+					{
+						dx = -1;
+					} else if (x == 0)
+					{
+						dx = 1;
+					} else
+					{
+						if (rand()%2 == 0)
+						{
+							dx = -1;
+						} else
+						{
+							dx = 1;
+						}
+					}
+				}
+				if (dz == 0)
+				{
+					if (z == 3)
+					{
+						dz = -1;
+					} else if (z == 0)
+					{
+						dz = 1;
+					} else
+					{
+						if (rand()%2 == 0)
+						{
+							dz = -1;
+						} else
+						{
+							dz = 1;
+						}
+					}	
+				}
+			}
+			
+			if (crash_z)
+			{
+				if (dy == 0)
+				{
+					if (y == 7)
+					{
+						dy = -1;
+					} else if (y == 0)
+					{
+						dy = 1;
+					} else
+					{
+						if (rand()%2 == 0)
+						{
+							dy = -1;
+						} else
+						{
+							dy = 1;
+						}
+					}	
+				}
+				if (dx == 0)
+				{
+					if (x == 7)
+					{
+						dx = -1;
+					} else if (x == 0)
+					{
+						dx = 1;
+					} else
+					{
+						if (rand()%2 == 0)
+						{
+							dx = -1;
+						} else
+						{
+							dx = 1;
+						}
+					}	
+				}
+			}
+		}
+		
+		// mode bit 1 sets corner avoid enable
+		if (mode | 0x02)
+		{
+			if (	// We are in one of 8 corner positions
+				(x == 0 && y == 0 && z == 0) ||
+				(x == 0 && y == 0 && z == 7) ||
+				(x == 0 && y == 7 && z == 0) ||
+				(x == 0 && y == 7 && z == 7) ||
+				(x == 7 && y == 0 && z == 0) ||
+				(x == 7 && y == 0 && z == 7) ||
+				(x == 7 && y == 7 && z == 0) ||
+				(x == 7 && y == 7 && z == 7)
+			)
+			{
+				// At this point, the voxel would bounce
+				// back and forth between this corner,
+				// and the exact opposite corner
+				// We don't want that!
+			
+				// So we alter the trajectory a bit,
+				// to avoid corner stickyness
+				lol = rand()%3;
+				if (lol == 0)
+					dx = 0;
+				
+				if (lol == 1)
+					dy = 0;
+					
+				if (lol == 2)
+					dz = 0;
+			}
+		}
+	
+		// Finally, move the voxel.
+		x = x + dx;
+		y = y + dy;
+		z = z + dz;
+		
+		if (drawmode == 0x01) // show one voxel at time
+		{
+			setvoxel(x,y,z);
+			delay_ms(delay);
+			clrvoxel(x,y,z);	
+		} else if (drawmode == 0x02) // flip the voxel in question
+		{
+			flpvoxel(x,y,z);
+			delay_ms(delay);
+		} if (drawmode == 0x03)
+		{
+			for (i=7;i>=0;i--)
+			{
+				snake[i][0] = snake[i-1][0];
+				snake[i][1] = snake[i-1][1];
+				snake[i][2] = snake[i-1][2];
+			}
+			snake[0][0] = x;
+			snake[0][1] = y;
+			snake[0][2] = z;
+				
+			for (i=0;i<8;i++)
+			{
+				setvoxel(snake[i][0],snake[i][1],snake[i][2]);
+			}
+			delay_ms(delay);
+			for (i=0;i<8;i++)
+			{
+				clrvoxel(snake[i][0],snake[i][1],snake[i][2]);
+			}
+		}
+		
+	
+		iterations--;
+	}
+}
+
+// Set or clear exactly 512 voxels in a random order.
+void effect_random_filler (int delay, int state)
+{
+	int x,y,z;
+	int loop = 0;
+	
+	
+	if (state == 1)
+	{
+		fill(0x00);
+	} else
+	{
+		fill(0xff);
+	}
+	
+	while (loop<511)
+	{
+		x = rand()%8;
+		y = rand()%8;
+		z = rand()%8;
+
+		if ((state == 0 && getvoxel(x,y,z) == 0x01) || (state == 1 && getvoxel(x,y,z) == 0x00))
+		{
+			altervoxel(x,y,z,state);
+			delay_ms(delay);
+			loop++;
+		}	
+	}
+}
+
+
+void effect_rain (int iterations)
+{
+	int i, ii;
+	int rnd_x;
+	int rnd_y;
+	int rnd_num;
+	
+	for (ii=0;ii<iterations;ii++)
+	{
+		rnd_num = rand()%4;
+		
+		for (i=0; i < rnd_num;i++)
+		{
+			rnd_x = rand()%8;
+			rnd_y = rand()%8;
+			setvoxel(rnd_x,rnd_y,7);
+		}
+		
+		delay_ms(1000);
+		shift(AXIS_Z,-1);
+	}
+}
+
+void effect_z_updown (int iterations, int delay)
+{
+	unsigned char positions[64];
+	unsigned char destinations[64];
+
+	int i,y,move,px;
+	
+	for (i=0; i<64; i++)
+	{
+		positions[i] = 4;
+		destinations[i] = rand()%8;
+	}
+
+	for (i=0; i<8; i++)
+	{
+		effect_z_updown_move(positions, destinations, AXIS_Z);
+		delay_ms(delay);
+	}
+	
+	for (i=0;i<iterations;i++)
+	{
+		for (move=0;move<8;move++)
+		{
+			effect_z_updown_move(positions, destinations, AXIS_Z);
+			delay_ms(delay);
+		}
+
+		delay_ms(delay*4);
+
+
+		for (y=0;y<10;y++)
+		{
+				destinations[rand()%64] = rand()%8;
+		}
+		
+	}
+
+}
+
+void effect_z_updown_move (unsigned char positions[64], unsigned char destinations[64], char axis)
+{
+	int px;
+	for (px=0; px<64; px++)
+	{
+		if (positions[px]<destinations[px])
+		{
+			positions[px]++;
+		}
+		if (positions[px]>destinations[px])
+		{
+			positions[px]--;
+		}
+	}
+		
+	draw_positions_axis (AXIS_Z, positions,0);
+}
+
+void effect_axis_updown_randsuspend (char axis, int delay, int sleep, int invert)
+{
+	unsigned char positions[64];
+	unsigned char destinations[64];
+
+	int i,px;
+	
+	for (i=0; i<64; i++)
+	{
+		positions[i] = 0;
+		destinations[i] = rand()%8;
+	}
+
+	for (i=0; i<8; i++)
+	{
+		for (px=0; px<64; px++)
+		{
+			if (positions[px]<destinations[px])
+			{
+				positions[px]++;
+			}
+			if (positions[px]>destinations[px])
+			{
+				positions[px]--;
+			}
+		}
+		draw_positions_axis (axis, positions,invert);
+		delay_ms(delay);
+	}
+	
+	for (i=0; i<64; i++)
+	{
+		destinations[i] = 7;
+	}
+	
+	delay_ms(sleep);
+	
+	for (i=0; i<8; i++)
+	{
+		for (px=0; px<64; px++)
+		{
+			if (positions[px]<destinations[px])
+			{
+				positions[px]++;
+			}
+			if (positions[px]>destinations[px])
+			{
+				positions[px]--;
+			}
+		}
+		draw_positions_axis (axis, positions,invert);
+		delay_ms(delay);
+	}
+	
+	
+
+}
+
+void draw_positions_axis (char axis, unsigned char positions[64], int invert)
+{
+	int x, y, p;
+	
+	fill(0x00);
+	
+	for (x=0; x<8; x++)
+	{
+		for (y=0; y<8; y++)
+		{
+			if (invert)
+			{
+				p = (7-positions[(x*8)+y]);
+			} else
+			{
+				p = positions[(x*8)+y];
+			}
+		
+			if (axis == AXIS_Z)
+				setvoxel(x,y,p);
+				
+			if (axis == AXIS_Y)
+				setvoxel(x,p,y);
+				
+			if (axis == AXIS_X)
+				setvoxel(p,y,x);
+		}
+	}
+	
+}
+
+
+void effect_boxside_randsend_parallel (char axis, int origin, int delay, int mode)
+{
+	int i;
+	int done;
+	unsigned char cubepos[64];
+	unsigned char pos[64];
+	int notdone = 1;
+	int notdone2 = 1;
+	int sent = 0;
+	
+	for (i=0;i<64;i++)
+	{
+		pos[i] = 0;
+	}
+	
+	while (notdone)
+	{
+		if (mode == 1)
+		{
+			notdone2 = 1;
+			while (notdone2 && sent<64)
+			{
+				i = rand()%64;
+				if (pos[i] == 0)
+				{
+					sent++;
+					pos[i] += 1;
+					notdone2 = 0;
+				}
+			}
+		} else if (mode == 2)
+		{
+			if (sent<64)
+			{
+				pos[sent] += 1;
+				sent++;
+			}
+		}
+		
+		done = 0;
+		for (i=0;i<64;i++)
+		{
+			if (pos[i] > 0 && pos[i] <7)
+			{
+				pos[i] += 1;
+			}
+				
+			if (pos[i] == 7)
+				done++;
+		}
+		
+		if (done == 64)
+			notdone = 0;
+		
+		for (i=0;i<64;i++)
+		{
+			if (origin == 0)
+			{
+				cubepos[i] = pos[i];
+			} else
+			{
+				cubepos[i] = (7-pos[i]);
+			}
+		}
+		
+		
+		delay_ms(delay);
+		draw_positions_axis(axis,cubepos,0);
+		LED_PORT ^= LED_RED;
+	}
+	
+}
+
+
+
+
+// Light all leds layer by layer,
+// then unset layer by layer
+void effect_loadbar(int delay)
+{
+	fill(0x00);
+	
+	int z,y;
+	
+	for (z=0;z<8;z++)
+	{
+		for (y=0;y<8;y++)
+			cube[z][y] = 0xff;
+			
+		delay_ms(delay);
+	}
+	
+	delay_ms(delay*3);
+	
+	for (z=0;z<8;z++)
+	{
+		for (y=0;y<8;y++)
+			cube[z][y] = 0x00;
+			
+		delay_ms(delay);
+	}
+}
+
+
+// Set n number of voxels at random positions
+void effect_random_sparkle_flash (int iterations, int voxels, int delay)
+{
+	int i;
+	int v;
+	for (i = 0; i < iterations; i++)
+	{
+		for (v=0;v<=voxels;v++)
+			setvoxel(rand()%8,rand()%8,rand()%8);
+			
+		delay_ms(delay);
+		fill(0x00);
+	}
+}
+
+// blink 1 random voxel, blink 2 random voxels..... blink 20 random voxels
+// and back to 1 again.
+void effect_random_sparkle (void)
+{
+	int i;
+	
+	for (i=1;i<20;i++)
+	{
+		effect_random_sparkle_flash(5,i,200);
+	}
+	
+	for (i=20;i>=1;i--)
+	{
+		effect_random_sparkle_flash(5,i,200);
+	}
+	
+}
+
+int effect_telcstairs_do(int x, int val, int delay)
+{
+	int y,z;
+
+	for(y = 0, z = x; y <= z; y++, x--)
+	{
+		if(x < CUBE_SIZE && y < CUBE_SIZE)
+		{
+			cube[x][y] = val;
+		}
+	}
+	delay_ms(delay);
+	return z;
+}
+
+void effect_telcstairs (int invert, int delay, int val)
+{
+	int x;
+
+	if(invert)
+	{
+		for(x = CUBE_SIZE*2; x >= 0; x--)
+		{
+			x = effect_telcstairs_do(x,val,delay);
+		}
+	}
+	else
+	{
+		for(x = 0; x < CUBE_SIZE*2; x++)
+		{
+			x = effect_telcstairs_do(x,val,delay);
+		}
+	}
+}
+
+void effect_wormsqueeze (int size, int axis, int direction, int iterations, int delay)
+{
+	int x, y, i,j,k, dx, dy;
+	int cube_size;
+	int origin = 0;
+	
+	if (direction == -1)
+		origin = 7;
+	
+	cube_size = 8-(size-1);
+	
+	x = rand()%cube_size;
+	y = rand()%cube_size;
+	
+	for (i=0; i<iterations; i++)
+	{
+		dx = ((rand()%3)-1);
+		dy = ((rand()%3)-1);
+	
+		if ((x+dx) > 0 && (x+dx) < cube_size)
+			x += dx;
+			
+		if ((y+dy) > 0 && (y+dy) < cube_size)
+			y += dy;
+	
+		shift(axis, direction);
+		
+
+		for (j=0; j<size;j++)
+		{
+			for (k=0; k<size;k++)
+			{
+				if (axis == AXIS_Z)
+					setvoxel(x+j,y+k,origin);
+					
+				if (axis == AXIS_Y)
+					setvoxel(x+j,origin,y+k);
+					
+				if (axis == AXIS_X)
+					setvoxel(origin,y+j,x+k);
+			}
+		}
+		
+		delay_ms(delay);
+	}
+}
+
+void effect_smileyspin (int count, int delay, char bitmap)
+{
+	unsigned char dybde[] = {0,1,2,3,4,5,6,7,1,1,2,3,4,5,6,6,2,2,3,3,4,4,5,5,3,3,3,3,4,4,4,4};
+	int d = 0;
+	int flip = 0;
+	int x, y, off;
+	int i, s;
+	for (i = 0; i<count; i++)
+	{
+		flip = 0;
+		d = 0;
+		off = 0;
+		// front:
+		for (s=0;s<7;s++){
+			if(!flip){
+				off++;
+				if (off == 4){
+					flip = 1;
+					off = 0;
+				}
+			} else {
+				off++;
+			}
+		        for (x=0; x<8; x++)
+        		{
+				d = 0;
+                		for (y=0; y<8; y++)
+	                	{
+					if (font_getbitmappixel ( bitmap, 7-x, y)){
+						if (!flip)
+							setvoxel(y,dybde[8 * off + d++],x);
+						else
+							setvoxel(y,dybde[31 - 8 * off - d++],x);
+					} else {
+						d++;
+					}
+				}
+			}
+			delay_ms(delay);
+			fill(0x00);
+		}
+
+		// side:
+		off = 0;
+		flip = 0;
+		d = 0;
+		int s;
+		for (s=0;s<7;s++){
+			if(!flip){
+				off++;
+				if (off == 4){
+					flip = 1;
+					off = 0;
+				}
+			} else {
+				off++;
+			}
+		        for (x=0; x<8; x++)
+        		{
+				d = 0;
+                		for (y=0; y<8; y++)
+	                	{
+					if (font_getbitmappixel ( bitmap, 7-x, y)){
+						if (!flip)
+							setvoxel(dybde[8 * off + d++], 7 - y,x);
+						else
+							setvoxel(dybde[31 - 8 * off - d++],7 - y,x);
+					} else {
+						d++;
+					}
+				}
+			}
+			delay_ms(delay);
+			fill(0x00);
+		}
+
+
+		flip = 0;
+		d = 0;
+		off = 0;
+		// back:
+		for (s=0;s<7;s++){
+			if(!flip){
+				off++;
+				if (off == 4){
+					flip = 1;
+					off = 0;
+				}
+			} else {
+				off++;
+			}
+		        for (x=0; x<8; x++)
+        		{
+				d = 0;
+                		for (y=0; y<8; y++)
+	                	{
+					if (font_getbitmappixel ( bitmap, 7-x, 7-y)){
+						if (!flip)
+							setvoxel(y,dybde[8 * off + d++],x);
+						else
+							setvoxel(y,dybde[31 - 8 * off - d++],x);
+					} else {
+						d++;
+					}
+				}
+			}
+			delay_ms(delay);
+			fill(0x00);
+		}
+
+		// other side:
+		off = 0;
+		flip = 0;
+		d = 0;
+		for (s=0;s<7;s++){
+			if(!flip){
+				off++;
+				if (off == 4){
+					flip = 1;
+					off = 0;
+				}
+			} else {
+				off++;
+			}
+		        for (x=0; x<8; x++)
+        		{
+				d = 0;
+                		for (y=0; y<8; y++)
+	                	{
+					if (font_getbitmappixel ( bitmap, 7-x, 7-y)){
+						if (!flip)
+							setvoxel(dybde[8 * off + d++], 7 - y,x);
+						else
+							setvoxel(dybde[31 - 8 * off - d++],7 - y,x);
+					} else {
+						d++;
+					}
+				}
+			}
+			delay_ms(delay);
+			fill(0x00);
+		}
+
+	}
+}
+
+
+void effect_pathmove (unsigned char *path, int length)
+{
+	int i,z;
+	unsigned char state;
+	
+	for (i=(length-1);i>=1;i--)
+	{
+		for (z=0;z<8;z++)
+		{
+		
+			state = getvoxel(((path[(i-1)]>>4) & 0x0f), (path[(i-1)] & 0x0f), z);
+			altervoxel(((path[i]>>4) & 0x0f), (path[i] & 0x0f), z, state);
+		}
+	}
+	for (i=0;i<8;i++)
+		clrvoxel(((path[0]>>4) & 0x0f), (path[0] & 0x0f),i);
+}
+
+void effect_rand_patharound (int iterations, int delay)
+{
+	int z, dz, i;
+	z = 4;
+	unsigned char path[28];
+	
+	font_getpath(0,path,28);
+	
+	for (i = 0; i < iterations; i++)
+	{
+		dz = ((rand()%3)-1);
+		z += dz;
+		
+		if (z>7)
+			z = 7;
+			
+		if (z<0)
+			z = 0;
+		
+		effect_pathmove(path, 28);
+		setvoxel(0,7,z);
+		delay_ms(delay);
+	}
+}
+
+void effect_pathspiral (int iterations, int delay)
+{
+	int z, i;
+	z = 4;
+	unsigned char path[16];
+	
+	font_getpath(1,path,16);
+	
+	for (i = 0; i < iterations; i++)
+	{
+		setvoxel(4,0,i%8);
+		delay_ms(delay);
+		effect_pathmove(path, 28);
+		
+	}
+}
+
+void effect_path_text (int delay, char *str)
+{
+	int z, i,ii;
+	z = 4;
+	unsigned char path[28];
+	font_getpath(0,path,28);
+	
+	unsigned char chr[5];
+	unsigned char stripe;
+	
+	while (*str)
+	{
+		//charfly(*str++, direction, axis, mode, delay);
+		
+		
+		font_getchar(*str++, chr);
+		
+		for (ii=0;ii<5;ii++)
+		{
+			//stripe = pgm_read_byte(&font[(chr*5)+ii]);
+			stripe = chr[ii];
+			
+			for (z=0;z<8;z++)
+			{
+				if ((stripe>>(7-z)) & 0x01)
+				{
+					setvoxel(0,7,z);
+				} else
+				{
+					clrvoxel(0,7,z);
+				}
+				
+			}
+			effect_pathmove(path, 28);
+			delay_ms(delay);
+		}
+	
+		effect_pathmove(path, 28);
+		delay_ms(delay);
+	}
+	for (i=0;i<28;i++)
+	{
+		effect_pathmove(path, 28);
+		delay_ms(delay);
+	}
+}
+
+void effect_path_bitmap (int delay, char bitmap, int iterations)
+{
+	int z, i, ii;
+	z = 4;
+	unsigned char path[28];
+	font_getpath(0,path,28);
+	
+	for (i=0; i < iterations; i++)
+	{	
+		for (ii=0;ii<8;ii++)
+		{		
+			for (z=0;z<8;z++)
+			{
+				if (font_getbitmappixel(bitmap,(7-z),ii))
+				{
+					setvoxel(0,7,z);
+				} else
+				{
+					clrvoxel(0,7,z);
+				}
+				
+			}
+			delay_ms(delay);
+			effect_pathmove(path, 28);
+		}
+	
+		for (ii=0;ii<20;ii++)
+		{
+			delay_ms(delay);
+			effect_pathmove(path, 28);
+		}
+	}
+	for (ii=0;ii<10;ii++)
+	{
+		delay_ms(delay);
+		effect_pathmove(path, 28);
+	}
+}
+
+
+
-- 
cgit v1.2.3