// ***********************************************************************************
// Program written by B. Swan - BURROWINGGERBIL@HOTMAIL.COM
// ***********************************************************************************

// ***********************************************************************************
// Decide whether a new enemy needs to be created and if so, do so
// ***********************************************************************************

void NewEnemies()
	{
	if (LevelX > LevelTriggers[CurrentTrigger].position)
		{
		// Create new enemy types

		if (TotalEnemies < (NUMBER_OF_ENEMIES))
			{
			switch (LevelTriggers[CurrentTrigger].type)
			{
			case 1: case 2: case 3:
				// Set comet type

				CreateNewComet(LevelTriggers[CurrentTrigger].x, LevelTriggers[CurrentTrigger].y, LevelTriggers[CurrentTrigger].type);
				break;
			case 4:
				// Random comet

				CreateNewComet(340, rand() % 200 + 20, rand() % 3 + 1);
				break;
			case 5:
				// Volcano

				CreateNewVolcano(LevelTriggers[CurrentTrigger].x, LevelTriggers[CurrentTrigger].y);
				break;
			case 6:
				// Volcano rock

				CreateNewRock(LevelTriggers[CurrentTrigger].x, LevelTriggers[CurrentTrigger].y, -1, rand() % 12 - 16);
				break;
			case 9:
				// Worm

				CreateNewWorm(LevelTriggers[CurrentTrigger].x, LevelTriggers[CurrentTrigger].y, LevelTriggers[CurrentTrigger].misc1, LevelTriggers[CurrentTrigger].misc2);
				break;
			case 12:
				// Powerup

				CreateNewPowerUp(LevelTriggers[CurrentTrigger].y, LevelTriggers[CurrentTrigger].misc1);
				break;
			default:
				break;
			}
		CurrentTrigger += 1;
		}
	}
}

// ***********************************************************************************
// Update all types of enemies
// ***********************************************************************************

void UpdateEnemies()
	{
	u_short tTemp1, tTemp2, tTemp3, tTemp4;

	tTemp1 = Enemies[0].next;
	tTemp2 = 0;

	for (tTemp4 = 0; tTemp4 < NUMBER_OF_ENEMIES; tTemp4++)
		{
		// Update current enemy types

		switch (Enemies[tTemp1].type)
			{
			case 0:
				tTemp3 = UpdateBigExplosion(tTemp1);
				break;
			case 1:
				tTemp3 = UpdateComet(tTemp1);
				break;
			case 5:
				tTemp3 = UpdateVolcano(tTemp1);
				break;
			case 6:
				tTemp3 = UpdateRock(tTemp1);
				break;
			case 7:
				tTemp3 = UpdateMediumExplosion(tTemp1);
				break;
			case 8:
				tTemp3 = UpdateSmallExplosion(tTemp1);
				break;
			case 9:
				tTemp3 = UpdateWormHead(tTemp1);
				break;
			case 10:
				tTemp3 = UpdateWormBody(tTemp1);
				break;
			case 11:
				tTemp3 = UpdateWormTail(tTemp1);
				break;
			case 12:
				tTemp3 = UpdatePowerUp(tTemp1);
				break;
			case 13:
				tTemp3 = UpdatePowerUpGlow(tTemp1);
			default:
				break;
			}

		// Set pointer correctly depending on whether enemy remains or not

		if (tTemp3 == 1)
			{
			tTemp2 = tTemp1;
			tTemp1 = Enemies[tTemp1].next;
			}
		else
			{
			tTemp1 = Enemies[tTemp2].next;
			}
		}
	}

// ***********************************************************************************
// Create new comet
// ***********************************************************************************

void CreateNewComet(short tX, short tY, short tSpeed)
	{
	u_short tTemp;

	tTemp = Enemies[LastEnemyPointer].next;

	Enemies[tTemp].type = 1;
	Enemies[tTemp].x = tX;
	Enemies[tTemp].y = tY;
	Enemies[tTemp].dy = 0;
	Enemies[tTemp].anim = 0;
	Enemies[tTemp].r = 127;
	Enemies[tTemp].misc1 = (rand() % 10 + 355) % 360;
	Enemies[tTemp].misc2 = tSpeed;
	Enemies[tTemp].dx = 0 - Enemies[tTemp].misc2;
	Enemies[tTemp].strength = 10;
	LastEnemyPointer = tTemp;
	TotalEnemies += 1;
	}

// ***********************************************************************************
// Create new volcano
// ***********************************************************************************

void CreateNewVolcano(short tX, short tY)
	{
	u_short tTemp;

	tTemp = Enemies[LastEnemyPointer].next;

	Enemies[tTemp].type = 5;
	Enemies[tTemp].x = tX;
	Enemies[tTemp].y = tY;
	Enemies[tTemp].dy = 0;
	Enemies[tTemp].anim = 0;
	LastEnemyPointer = tTemp;
	TotalEnemies += 1;
	}

// ***********************************************************************************
// Create new volcano rock
// ***********************************************************************************

void CreateNewRock(short tX, short tY, short tSpeedX, short tSpeedY)
	{
	u_short tTemp;

	tTemp = Enemies[LastEnemyPointer].next;

	Enemies[tTemp].type = 6;
	Enemies[tTemp].anim = 0;
	Enemies[tTemp].x = tX;
	Enemies[tTemp].y = tY;
	Enemies[tTemp].misc1 = Enemies[tTemp].dx = tSpeedX;
	Enemies[tTemp].misc2 = Enemies[tTemp].dy = tSpeedY;
	Enemies[tTemp].strength = 2;
	LastEnemyPointer = tTemp;
	TotalEnemies += 1;
	}

// ***********************************************************************************
// Create new worm
// ***********************************************************************************

void CreateNewWorm(short tAngle, short tPos, short tTime, short tSAngle)
	{
	u_short tTemp1, tTemp2;

	if (TotalEnemies < NUMBER_OF_ENEMIES - 10)
		{
		tTemp1 = Enemies[LastEnemyPointer].next;

		Enemies[tTemp1].type = 9;
		Enemies[tTemp1].dx = 0;
		Enemies[tTemp1].dy = 0;
		Enemies[tTemp1].anim = 0;
		Enemies[tTemp1].misc1 = tAngle;

		switch (Enemies[tTemp1].misc1)
			{
			case 0:
				Enemies[tTemp1].x = tPos;
				Enemies[tTemp1].y = -20;
				break;
			case 90:
				Enemies[tTemp1].x = -20;
				Enemies[tTemp1].y = tPos;
				break;
			case 180:
				Enemies[tTemp1].x = tPos;
				Enemies[tTemp1].y = 260;
				break;
			case 270:
				Enemies[tTemp1].x = 340;
				Enemies[tTemp1].y = tPos;
				break;
			default:
				Enemies[tTemp1].x = 160;
				Enemies[tTemp1].y = 120;
				break;
			}

		Enemies[tTemp1].misc2 = tSAngle;
		Enemies[tTemp1].misc3 = 1;
		Enemies[tTemp1].misc4 = tTime;
		Enemies[tTemp1].strength = 100;
		Enemies[tTemp1].r = 127;
		LastEnemyPointer = tTemp1;
		TotalEnemies += 10;

		for (tTemp2 = 0; tTemp2<100; tTemp2++)
			{
			WormPos[tTemp1][tTemp2][0] = Enemies[tTemp1].x;
			WormPos[tTemp1][tTemp2][1] = Enemies[tTemp1].y;
			WormPos[tTemp1][tTemp2][2] = Enemies[tTemp1].misc1;
			}

		for (tTemp2 = 1; tTemp2<10; tTemp2++)
			{
			LastEnemyPointer = Enemies[LastEnemyPointer].next;
			WormPos[tTemp1][tTemp2][3] = LastEnemyPointer;
			
			Enemies[LastEnemyPointer].x = Enemies[tTemp1].x;
			Enemies[LastEnemyPointer].y = Enemies[tTemp1].y;
			Enemies[LastEnemyPointer].strength = 10000;
			Enemies[LastEnemyPointer].r = 127;
			Enemies[LastEnemyPointer].type = 10;
			Enemies[LastEnemyPointer].dx = 0;
			Enemies[LastEnemyPointer].dy = 0;
			Enemies[LastEnemyPointer].anim = 0;
			Enemies[LastEnemyPointer].misc2 = tTemp1;
			}

		Enemies[LastEnemyPointer].type = 11;
		}
	}

// ***********************************************************************************
// Create new powerup
// ***********************************************************************************

void CreateNewPowerUp(short tY, short tType)
	{
	u_short tTemp;

	tTemp = Enemies[LastEnemyPointer].next;

	Enemies[tTemp].type = 12;
	Enemies[tTemp].x = 340;
	Enemies[tTemp].y = tY;
	Enemies[tTemp].dx = -1;
	Enemies[tTemp].dy = 0;
	Enemies[tTemp].anim = 0;
	Enemies[tTemp].misc1 = tType;
	Enemies[tTemp].r = Enemies[tTemp].g = Enemies[tTemp].b = 64;

	switch (tType)
		{
		case 1:
			Enemies[tTemp].r = 127;
			break;
		case 2:
			Enemies[tTemp].g = 127;
			break;
		case 3:
			Enemies[tTemp].b = 127;
			break;
		case 4:
			Enemies[tTemp].r = Enemies[tTemp].g = Enemies[tTemp].b = 127;
		default:
			break;
		}

	LastEnemyPointer = tTemp;
	TotalEnemies += 1;
	}

// ***********************************************************************************
// Create new small explosion
// ***********************************************************************************

void CreateSmallExplosion(short tX, short tY)
	{
	u_short tTemp;

	tTemp = Enemies[LastEnemyPointer].next;

	Enemies[tTemp].type = 8;
	Enemies[tTemp].x = tX;
	Enemies[tTemp].y = tY;
	Enemies[tTemp].dx = 0;
	Enemies[tTemp].dy = 0;
	Enemies[tTemp].anim = 0;

	LastEnemyPointer = tTemp;
	TotalEnemies += 1;
	}

// ***********************************************************************************
// Update comet enemy
// ***********************************************************************************

u_short UpdateComet(u_short tEnemy)
	{
	u_short tTemp, tAlive;

	tAlive = 1;

	Enemies[tEnemy].anim += (ONE * Enemies[tEnemy].misc1) % (ONE * 360);
	Enemies[tEnemy].x -= Enemies[tEnemy].misc2;

	if (Enemies[tEnemy].r > 127)		Enemies[tEnemy].r -= 4;

	Comet.x = Enemies[tEnemy].x;
	Comet.y = Enemies[tEnemy].y;
	Comet.rotate = Enemies[tEnemy].anim;

	Comet.r = Comet.g = Comet.b = Enemies[tEnemy].r;

	GsSortSprite(&Comet, &OTable_Header[currentBuffer], 4);

	// check if collided with players

	tTemp = EnemyAgainstPlayer((Enemies[tEnemy].x - 16), (Enemies[tEnemy].y - 16), 32, 32);

	if (tTemp == 1)
		{
		Enemies[tEnemy].type = 0;
		Enemies[tEnemy].anim = 0;
		}

	// check if collided with player bullets

	if (tTemp == 0)
		{
		tTemp = EnemyAgainstBullets(tEnemy, (Enemies[tEnemy].x - 16), (Enemies[tEnemy].y - 16), 32, 32);

		// If hit then sort out as necessary

		if (tTemp == 2)
			{
			Enemies[tEnemy].type = 0;
			Enemies[tEnemy].anim = 0;
			}
		else if (tTemp == 1)
			{
			Glows[0].x = Enemies[tEnemy].x;
			Glows[0].y = Enemies[tEnemy].y;
			Glows[0].rotate = 0;
			Glows[0].scalex = Glows[0].scaley = ONE;
			Glows[0].r = Glows[0].g = Glows[0].b = 127;						

			GsSortSprite(&Glows[0], &OTable_Header[currentBuffer], 1);
			}
		}

	if (Enemies[tEnemy].x < -20)
		{
		Enemies[tEnemy].type = -1;
		DeleteEnemy(tEnemy);
		tAlive = 0;
		}

	return tAlive;
	}

// ***********************************************************************************
// Update volcano 
// ***********************************************************************************

u_short UpdateVolcano(u_short tEnemy)
	{
	short tTemp1, tTemp2;
	u_short tAlive;

	tAlive = 1;

	Enemies[tEnemy].anim += 1;

	if (Enemies[tEnemy].anim == 2)
		{
		Enemies[tEnemy].x -= 1;
		Enemies[tEnemy].anim = 0;

		if (TotalEnemies < (NUMBER_OF_ENEMIES))
			{
			tTemp1 = rand() % 9 - 6;
			tTemp2 = rand() % 12 - 16;
			CreateNewRock((Enemies[tEnemy].x << 2), (Enemies[tEnemy].y << 2), tTemp1, tTemp2);
			}
		}

	if (Enemies[tEnemy].x < -100)
		{
		Enemies[tEnemy].type = -1;
		DeleteEnemy(tEnemy);
		tAlive = 0;
		}
	
	return tAlive;
	}

// ***********************************************************************************
// Update volcano rock
// ***********************************************************************************

u_short UpdateRock(u_short tEnemy)
	{
	u_short tTemp, tAlive;

	tAlive = 1;

	Enemies[tEnemy].anim += 1;

	if (Enemies[tEnemy].anim == 4)
		{
		Enemies[tEnemy].misc2 += 1;
		Enemies[tEnemy].anim = 0;
		}

	Enemies[tEnemy].x += Enemies[tEnemy].misc1;
	Rock.x = (Enemies[tEnemy].x >> 2);
	Enemies[tEnemy].y += Enemies[tEnemy].misc2;
	Rock.y = (Enemies[tEnemy].y >> 2);

	Enemies[tEnemy].dx = (Enemies[tEnemy].misc1 >> 2);
	Enemies[tEnemy].dy = (Enemies[tEnemy].misc2 >> 2);

	GsSortFastSprite(&Rock, &OTable_Header[currentBuffer], 5);

	// check if collided with players

	tTemp = EnemyAgainstPlayer(Rock.x, Rock.y, 16, 16);

	if (tTemp == 1)
		{
		Enemies[tEnemy].x = (Enemies[tEnemy].x >> 2);
		Enemies[tEnemy].y = (Enemies[tEnemy].y >> 2);
		Enemies[tEnemy].type = 8;
		Enemies[tEnemy].anim = 0;
		}

	// check if collided with player bullets

	if (tTemp == 0)
		{
		tTemp = EnemyAgainstBullets(tEnemy, Rock.x, Rock.y, 16, 16);

		// If hit then sort out as necessary

		if (tTemp == 2)
			{
			Enemies[tEnemy].x = (Enemies[tEnemy].x >> 2);
			Enemies[tEnemy].y = (Enemies[tEnemy].y >> 2);
			Enemies[tEnemy].type = 8;
			Enemies[tEnemy].anim = 0;
			}
		}

	if ((Rock.x < -100) || (Rock.y > 260))
		{
		Enemies[tEnemy].type = -1;
		DeleteEnemy(tEnemy);
		tAlive = 0;
		}
	
	return tAlive;
	}

// ***********************************************************************************
// Update big explosion
// ***********************************************************************************

u_short UpdateBigExplosion(u_short tEnemy)
	{
	short tTemp;
	u_short tAlive;

	tAlive = 1;

	// Play explosion sound

	if (Enemies[tEnemy].anim == 0)
		{
		PlaySound(1, 127, Enemies[tEnemy].x);
		}

	Enemies[tEnemy].anim += 1;
	tTemp = Enemies[tEnemy].anim;

	Enemies[tEnemy].x += Enemies[tEnemy].dx;
	Enemies[tEnemy].y += Enemies[tEnemy].dy;

	Glows[2].x = Enemies[tEnemy].x;
	Glows[2].y = Enemies[tEnemy].y;
	Glows[2].rotate = ONE * tTemp * 7;
	Glows[2].scalex = Glows[2].scaley = (ONE >> 1) + ((ONE * tTemp) >> 4);
	Glows[2].r = MIN(255 - tTemp * 8, 127);
	Glows[2].g = Glows[2].b = 127 - tTemp * 4;

	GsSortSprite(&Glows[2], &OTable_Header[currentBuffer], 1);

	if (Enemies[tEnemy].anim == 31)
		{
		Enemies[tEnemy].type = -1;
		DeleteEnemy(tEnemy);
		tAlive = 0;
		}

	return tAlive;
	}

// ***********************************************************************************
// Update medium explosion
// ***********************************************************************************

u_short UpdateMediumExplosion(u_short tEnemy)
	{
	short tTemp;
	u_short tAlive;

	tAlive = 1;

	// Play explosion sound

	if (Enemies[tEnemy].anim == 0)
		{
		PlaySound(1, 96, Enemies[tEnemy].x);
		}

	Enemies[tEnemy].anim += 1;
	tTemp = Enemies[tEnemy].anim;

	Enemies[tEnemy].x += Enemies[tEnemy].dx;
	Enemies[tEnemy].y += Enemies[tEnemy].dy;

	Glows[4].x = Enemies[tEnemy].x;
	Glows[4].y = Enemies[tEnemy].y;
	Glows[4].rotate = ONE * tTemp * 7;
	Glows[4].scalex = Glows[4].scaley = (ONE >> 1) + ((ONE * tTemp) >> 4);
	Glows[4].r = MIN(255 - tTemp * 8, 127);
	Glows[4].g = Glows[4].b = 127 - tTemp * 4;

	GsSortSprite(&Glows[4], &OTable_Header[currentBuffer], 1);

	if (Enemies[tEnemy].anim == 31)
		{
		Enemies[tEnemy].type = -1;
		DeleteEnemy(tEnemy);
		tAlive = 0;
		}

	return tAlive;
	}

// ***********************************************************************************
// Update small explosion
// ***********************************************************************************

u_short UpdateSmallExplosion(u_short tEnemy)
	{
	short tTemp;
	u_short tAlive;

	tAlive = 1;

	// Play explosion sound

	if (Enemies[tEnemy].anim == 0)
		{
		PlaySound(1, 64, Enemies[tEnemy].x);
		}

	Enemies[tEnemy].anim += 1;
	tTemp = Enemies[tEnemy].anim;

	Enemies[tEnemy].x += Enemies[tEnemy].dx;
	Enemies[tEnemy].y += Enemies[tEnemy].dy;

	Glows[6].x = Enemies[tEnemy].x;
	Glows[6].y = Enemies[tEnemy].y;
	Glows[6].r = MIN(255 - tTemp * 16, 127);
	Glows[6].g = Glows[6].b = 127 - tTemp * 8;

	GsSortFastSprite(&Glows[6], &OTable_Header[currentBuffer], 1);

	if (Enemies[tEnemy].anim == 15)
		{
		Enemies[tEnemy].type = -1;
		DeleteEnemy(tEnemy);
		tAlive = 0;
		}

	return tAlive;
	}

// ***********************************************************************************
// Update worm head
// ***********************************************************************************

u_short UpdateWormHead(u_short tEnemy)
	{
	u_short tTemp;
	u_short tAlive;

	tAlive = 1;

	// Fade back from being hit

	if (Enemies[tEnemy].r > 127)	Enemies[tEnemy].r -= 16;

	// Set new direction

	if (Enemies[tEnemy].misc4 > 0)
		{
		Enemies[tEnemy].misc4 -= 1;
		}
	else
		{
		if (Enemies[tEnemy].misc4 > -70)
			{
			Enemies[tEnemy].misc4 -= 1;
			}
		else
			{
			if (rand() % 5 == 0)
				{
				Enemies[tEnemy].misc2 = rand() % 15 - 7;
				}
			}
		Enemies[tEnemy].misc1 = (Enemies[tEnemy].misc1 + Enemies[tEnemy].misc2 + 360) % 360;
		}

	// Store where worm has been

	Enemies[tEnemy].anim -= 1;
	
	if (Enemies[tEnemy].anim == -1)		Enemies[tEnemy].anim += 100;

	// update head

	if (Enemies[tEnemy].misc3 == 1)
		{
		Enemies[tEnemy].dx = (short) (SIN[Enemies[tEnemy].misc1] * 2);
		Enemies[tEnemy].dy = (short) (COS[Enemies[tEnemy].misc1] * 2);
		Enemies[tEnemy].x += Enemies[tEnemy].dx;
		Enemies[tEnemy].y += Enemies[tEnemy].dy;
		}

	// Draw head

	Worm[0].r = Worm[0].g = Worm[0].b = Enemies[tEnemy].r;
	Worm[0].g = Worm[0].b = MIN((Enemies[tEnemy].r - 127) * 2, 255);

	Worm[0].x = Enemies[tEnemy].x;
	Worm[0].y = Enemies[tEnemy].y;
	Worm[0].rotate = ONE * ((630 - Enemies[tEnemy].misc1) % 360);

	GsSortSprite(&Worm[0], &OTable_Header[currentBuffer], 5);

	// Store head pos

	WormPos[tEnemy][Enemies[tEnemy].anim][0] = Enemies[tEnemy].x;
	WormPos[tEnemy][Enemies[tEnemy].anim][1] = Enemies[tEnemy].y;
	WormPos[tEnemy][Enemies[tEnemy].anim][2] = Enemies[tEnemy].misc1;

	// draw body parts

	if (Enemies[tEnemy].r == 223)
		{
		Enemies[WormPos[tEnemy][1][3]].r = 255;
		}

	for (tTemp = 1; tTemp<9; tTemp++)
		{
		Enemies[WormPos[tEnemy][tTemp][3]].x = WormPos[tEnemy][(Enemies[tEnemy].anim + tTemp * 10) % 100][0] - 8;
		Enemies[WormPos[tEnemy][tTemp][3]].y = WormPos[tEnemy][(Enemies[tEnemy].anim + tTemp * 10) % 100][1] - 8;

		if (Enemies[WormPos[tEnemy][tTemp][3]].r == 223)
			{
			Enemies[WormPos[tEnemy][tTemp + 1][3]].r = 255;
			}
		}

	// draw tail

	Enemies[WormPos[tEnemy][9][3]].x = WormPos[tEnemy][(Enemies[tEnemy].anim + 90) % 100][0];
	Enemies[WormPos[tEnemy][9][3]].y = WormPos[tEnemy][(Enemies[tEnemy].anim + 90) % 100][1];
	Enemies[WormPos[tEnemy][9][3]].misc1 = WormPos[tEnemy][(Enemies[tEnemy].anim + 90) % 100][2];
	
	// check if collided with players

	tTemp = EnemyAgainstPlayer(Worm[0].x - 8, Worm[0].y - 8, 16, 16);

	if (tTemp == 1)
		{
		Enemies[tEnemy].type = 0;
		Enemies[tEnemy].anim = 0;
	
		// blow up body segments

		for (tTemp = 1; tTemp<10; tTemp++)
			{
			Enemies[WormPos[tEnemy][tTemp][3]].x += 8;
			Enemies[WormPos[tEnemy][tTemp][3]].y += 8;
			Enemies[WormPos[tEnemy][tTemp][3]].type = 7;
			Enemies[WormPos[tEnemy][tTemp][3]].anim = 0;
			}
		}

	// check if collided with player bullets

	if (tTemp == 0)
		{
		tTemp = EnemyAgainstBullets(tEnemy, Worm[0].x - 12, Worm[0].y - 12, 24, 24);

		// If hit then sort out as necessary

		if (tTemp == 2)
			{
			Enemies[tEnemy].type = 0;
			Enemies[tEnemy].anim = 0;

			// blow up body segments

			for (tTemp = 1; tTemp<10; tTemp++)
				{
				Enemies[WormPos[tEnemy][tTemp][3]].x += 8;
				Enemies[WormPos[tEnemy][tTemp][3]].y += 8;
				Enemies[WormPos[tEnemy][tTemp][3]].type = 7;
				Enemies[WormPos[tEnemy][tTemp][3]].anim = 0;
				}
			}
		else if (tTemp == 1)
			{
			Enemies[tEnemy].r = 255;
			PlaySound(1, 96, Enemies[tEnemy].x);
			}
		}

	// If off screen pause and let body catch up off screen

	if ((Worm[0].x < -31) || (Worm[0].x > 351) || (Worm[0].y < -31) || (Worm[0].y > 271))
		{
		Enemies[tEnemy].misc3 -= 1;
		}

	// if all offscreen then remove worm
	
	if (Enemies[tEnemy].misc3 == -50)
		{
		for (tTemp = 1; tTemp<10; tTemp++)
			{
			Enemies[WormPos[tEnemy][tTemp][3]].type = -1;
			DeleteEnemy(WormPos[tEnemy][tTemp][3]);
			}

		Enemies[tEnemy].type = -1;
		DeleteEnemy(tEnemy);
		tAlive = 0;
		}

	return tAlive;
	}

// ***********************************************************************************
// Update worm body
// ***********************************************************************************

u_short UpdateWormBody(u_short tEnemy)
	{
	u_short tTemp;

	if (Enemies[tEnemy].r > 127)		Enemies[tEnemy].r -= 16;

	Worm[1].x = Enemies[tEnemy].x;
	Worm[1].y = Enemies[tEnemy].y;
	Worm[1].r = Worm[1].g = Worm[1].b = Enemies[tEnemy].r;
	Worm[1].g = Worm[1].b = MIN((Enemies[tEnemy].r - 127) * 2, 255);

	GsSortFastSprite(&Worm[1], &OTable_Header[currentBuffer], 5);

	// check if collided with players

	tTemp = EnemyAgainstPlayer(Worm[1].x, Worm[1].y, 16, 16);

	// check if collided with player bullets

	tTemp = EnemyAgainstBullets(tEnemy, Worm[1].x, Worm[1].y, 16, 16);

	if (tTemp != 0)
		{
		Enemies[tEnemy].r = 255;
		PlaySound(1, 64, Enemies[tEnemy].x);
		}

	return (u_short) 1;
	}

// ***********************************************************************************
// Update worm tail
// ***********************************************************************************

u_short UpdateWormTail(u_short tEnemy)
	{
	u_short tTemp;

	if (Enemies[tEnemy].r > 127)	Enemies[tEnemy].r -= 16;

	Worm[2].x = Enemies[tEnemy].x;
	Worm[2].y = Enemies[tEnemy].y;
	Worm[2].rotate = ONE * ((630 - Enemies[tEnemy].misc1) % 360);
	Worm[2].r = Worm[2].g = Worm[2].b = Enemies[tEnemy].r;
	Worm[2].g = Worm[2].b = MIN((Enemies[tEnemy].r - 127) * 2, 255);

	GsSortSprite(&Worm[2], &OTable_Header[currentBuffer], 5);

	// check if collided with players

	tTemp = EnemyAgainstPlayer(Worm[2].x - 8, Worm[2].y - 8, 16, 16);

	// check if collided with player bullets

	tTemp = EnemyAgainstBullets(tEnemy, Worm[2].x - 8, Worm[2].y - 8, 16, 16);

	if (tTemp != 0)
		{
		Enemies[tEnemy].r = 255;
		PlaySound(1, 64, Enemies[tEnemy].x);
		}

	return (u_short) 1;
	}

// ***********************************************************************************
// Update power up
// ***********************************************************************************

u_short UpdatePowerUp(u_short tEnemy)
	{
	u_short tTemp1, tTemp2, tAlive;

	tAlive = 1;

	Enemies[tEnemy].x -= 1;

	PowerUp.x = Enemies[tEnemy].x;
	PowerUp.y = Enemies[tEnemy].y;

	PowerUp.r = Enemies[tEnemy].r;
	PowerUp.g = Enemies[tEnemy].g;
	PowerUp.b = Enemies[tEnemy].b;

	GsSortFastSprite(&PowerUp, &OTable_Header[currentBuffer], 4);

	Glows[0].r = PowerUp.r / 2;
	Glows[0].g = PowerUp.g / 2;
	Glows[0].b = PowerUp.b / 2;
	Glows[0].x = PowerUp.x + 5;
	Glows[0].y = PowerUp.y + 5;
	Glows[0].rotate = ONE * ((Counter * 5) % 360);
	Glows[0].scalex = Glows[0].scaley = (ONE >> 1);

	GsSortSprite(&Glows[0], &OTable_Header[currentBuffer], 1);

	Glows[0].r = PowerUp.r;
	Glows[0].g = PowerUp.g;
	Glows[0].b = PowerUp.b;
	Glows[0].x = PowerUp.x + 11;
	Glows[0].y = PowerUp.y + 16;
	Glows[0].rotate = ONE * ((Counter * 5) % 360);
	Glows[0].scalex = Glows[0].scaley = ONE;

	GsSortSprite(&Glows[0], &OTable_Header[currentBuffer], 1);

	// check if collided with players

	for (tTemp1 = 0; (tTemp1<2 && tAlive == 1); tTemp1++)
		{
		if (Player[tTemp1].alive == 1)
			{
			tTemp2 = Hit(Player[tTemp1].x, Player[tTemp1].y, 40, 23, PowerUp.x, PowerUp.y, 32, 32);

			if (tTemp2 == 1)
				{
				Enemies[tEnemy].type = 13;
				Enemies[tEnemy].anim = 0;

				switch (Enemies[tEnemy].misc1)
					{
					case 1:
						// red laser

						if (Player[tTemp1].weapon == Enemies[tEnemy].misc1 + 1)
							{
							Player[tTemp1].weaponlevel = MIN(Player[tTemp1].weaponlevel + 1, 3);
							}
						else
							{
							Player[tTemp1].weapon = Enemies[tEnemy].misc1 + 1;
							}
						break;
					case 2:
						// speed up

							Player[tTemp1].speed += 2;
						break;
					case 3:
						// blue laser

						if (Player[tTemp1].weapon == Enemies[tEnemy].misc1)
							{
							Player[tTemp1].weaponlevel = MIN(Player[tTemp1].weaponlevel + 1, 3);
							}
						else
							{
							Player[tTemp1].weapon = Enemies[tEnemy].misc1;
							}
						break;
					case 4:
						// weapon up

						Player[tTemp1].weaponlevel = MIN(Player[tTemp1].weaponlevel + 1, 3);
						break;
					}
				PlaySound(2, 127, Enemies[tEnemy].x);

				tAlive = 0;
				}
			}
		}

	if ((Enemies[tEnemy].x < -20) && (tAlive == 1))
		{
		Enemies[tEnemy].type = -1;
		DeleteEnemy(tEnemy);
		tAlive = 0;
		}

	return tAlive;
	}

// ***********************************************************************************
// Update power up glow
// ***********************************************************************************

u_short UpdatePowerUpGlow(u_short tEnemy)
	{
	u_short tAlive;

	tAlive = 1;

	Enemies[tEnemy].anim += 1;

	Enemies[tEnemy].x -= 1;

	Glows[0].r = (32 - Enemies[tEnemy].anim) * Enemies[tEnemy].r / 16;
	Glows[0].g = (32 - Enemies[tEnemy].anim) * Enemies[tEnemy].g / 16;
	Glows[0].b = (32 - Enemies[tEnemy].anim) * Enemies[tEnemy].b / 16;
	Glows[0].x = Enemies[tEnemy].x + 16;
	Glows[0].y = Enemies[tEnemy].y + 16;
	Glows[0].rotate = ONE * ((Counter * 5) % 360);
	Glows[0].scalex = Glows[0].scaley = ONE * (32 - Enemies[tEnemy].anim) / 12;

	GsSortSprite(&Glows[0], &OTable_Header[currentBuffer], 1);

	if (Enemies[tEnemy].anim == 32)
		{
		Enemies[tEnemy].type = -1;
		DeleteEnemy(tEnemy);
		tAlive = 0;
		}

	return tAlive;
	}

// ***********************************************************************************
// Delete enemy from array
// ***********************************************************************************

void DeleteEnemy(u_short tEnemy)
	{
	if (tEnemy == LastEnemyPointer)		LastEnemyPointer = Enemies[tEnemy].previous;

	// Register as unused enemy

	Enemies[tEnemy].type = -1;

	// Make enemies either side point to each other

	Enemies[Enemies[tEnemy].previous].next = Enemies[tEnemy].next;
	Enemies[Enemies[tEnemy].next].previous = Enemies[tEnemy].previous;

	// Make this enemy point to enemies at end of list

	Enemies[tEnemy].next = NUMBER_OF_ENEMIES + 1;
	Enemies[tEnemy].previous = Enemies[(NUMBER_OF_ENEMIES + 1)].previous;

	// Make enemies at end of list point to this enemy

	Enemies[NUMBER_OF_ENEMIES + 1].previous = tEnemy;
	Enemies[Enemies[tEnemy].previous].next = tEnemy;

	TotalEnemies -= 1;
	}

// ***********************************************************************************
// Compare enemy against players
// ***********************************************************************************

u_short EnemyAgainstPlayer(short tx, short ty, short tw, short th)
	{
	u_short tTemp1, tTemp2;
	u_short tTemp3 = 0;

	for (tTemp1 = 0; tTemp1<2; tTemp1++)
		{
		if (Player[tTemp1].alive == 1)
			{
			tTemp2 = Hit(Player[tTemp1].x, Player[tTemp1].y, 40, 23, tx, ty, tw, th);

			if (tTemp2 == 1)
				{
				// Kill player

				KillPlayer(tTemp1);
				tTemp3 = 1;
				}
			}
		}
	return tTemp3;
	}

// ***********************************************************************************
// Compare enemy against player bullets
// ***********************************************************************************

u_short EnemyAgainstBullets(u_short tEnemy, short tx, short ty, short tw, short th)
	{
	u_short tTemp1, tTemp2, tTemp3, tTemp4;
	u_short tTemp5 = 0;

	for (tTemp1 = 0; tTemp1<2; tTemp1++)
		{
		if (Player[tTemp1].alive == 1)
			{
			// check if collided with player bullets

			for (tTemp3 = 0; (tTemp3<NUMBER_OF_BULLETS) && (tTemp5 != 2); tTemp3++)
				{
				tTemp2 = 0;
				switch (Bullets[tTemp1][tTemp3].type)
					{
					case 0:
						tTemp4 = Bullets[tTemp1][tTemp3].w;
						tTemp2 = Hit(tx, ty, tw, th, Bullets[tTemp1][tTemp3].x - tTemp4 / 2, Bullets[tTemp1][tTemp3].y - tTemp4 / 2, tTemp4, tTemp4);
						break;
					case 1:
						tTemp2 = Hit(tx, ty, tw, th, Bullets[tTemp1][tTemp3].x - 2, Bullets[tTemp1][tTemp3].y - 2, Bullets[tTemp1][tTemp3].w, Bullets[tTemp1][tTemp3].h);
						break;
					case 2:
						tTemp2 = Hit(tx, ty, tw, th, Bullets[tTemp1][tTemp3].x - 2, Bullets[tTemp1][tTemp3].y - 2, Bullets[tTemp1][tTemp3].w, Bullets[tTemp1][tTemp3].h);
						break;
					default:
						break;
					}

				// if enemy is hit by bullets

				if (tTemp2 > 0)
					{
					tTemp4 = Enemies[tEnemy].strength;
					Enemies[tEnemy].r = Enemies[tEnemy].g = Enemies[tEnemy].b = 255;
					Enemies[tEnemy].strength -= Bullets[tTemp1][tTemp3].strength;
					Bullets[tTemp1][tTemp3].strength -= tTemp4;

					// If strength = 0 then remove

					if (Enemies[tEnemy].strength < 1)
						{
						tTemp5 = 2;
						}
					else
						{
						tTemp5 = 1;
						}
					// If bullet has no power left then free it up

					if (Bullets[tTemp1][tTemp3].strength < 1)		Bullets[tTemp1][tTemp3].type = -1;
					}
				}
			}
		}
	return tTemp5;
	}