well I am trying to solve it. Heres what Im doing now. I scrapped the swordbeam and all projectiles from my game. Now im reimplementing the octorock class with better incapsulated code:

class OCTOROCK
{

private:
	SPRITE sprite;
public:

	//Constructor
	OCTOROCK()
	{
	}

	//Destructor
	~OCTOROCK()
	{
	}


	//Set the position of the octorock
	void setPosition(int x, int y)
	{
		sprite.x = x;
		sprite.y = y;
	}

	//Set the dimensions
	void setDimensions(int width, int height)
	{
		sprite.width = width;
		sprite.height = height;
	}

	//Set the frames
	void setFrames(int curframe, int maxframe, int framecount, int framedelay)
	{
		sprite.curframe = curframe;
		sprite.maxframe = maxframe;
		sprite.framecount = framecount;
		sprite.framedelay = framedelay;
	}

	//Set the speed of the octorock
	void setSpeed(int speed)
	{
		sprite.xspeed = speed;
		sprite.yspeed = speed;
	}

	//set the direction of the octorock
	void setDirection(int dir)
	{
		sprite.dir = dir;
	}

	//is it alive?
	void isAlive(int alive)
	{
		sprite.alive = alive;
	}

	//moves the octorock
	void moveOctorock()
	{
		if(sprite.dir == RIGHT)
		{
			sprite.x += sprite.xspeed;
			sprite.y += 0;
			sprite.curframe = 4;
		}
		else if(sprite.dir == LEFT)
		{
			sprite.x -= sprite.xspeed;
			sprite.y += 0;
			sprite.curframe = 6;
		}
		else if(sprite.dir == UP)
		{
			sprite.x += 0;
			sprite.y -= sprite.yspeed;
			sprite.curframe = 2;
		}
		else if(sprite.dir == DOWN)
		{
			sprite.x += 0;
			sprite.y += sprite.yspeed;
			sprite.curframe = 0;
		}
	}


	//Draw the octorock
	void drawOctorock()
	{
		al_draw_bitmap(octorock_images[sprite.curframe],
			           sprite.x - mapxoff, sprite.y - mapyoff, NULL);
	}
};

class OCTOROCK
{
private:

    int width, height; //SWAP
    int x, y; // SWAP
    int curframe, maxframe;
    int framecount, framedelay;
    int dir;
    int alive;
    int pathx1, pathx2;
    int pathy1, pathy2;
    int speed;

Swapping the variables is a good idea to get a better idea if the variables are overwritten "by name" or "by address".

Anyway, if you already know which variable changes, any decent debugger lets you set a breakpoint to when this variable changes and have a condition for the new value. It's a lot less painful than stepping through code that might run dozens of frames before the bug happens while manually staring at the watch window.

I tried finding the bug and just couldn't, also I wasn't happy with the overall implementation of it, so I decided to nuke it and code it much cleaner this time.

For those of you still wondering, heres what the new octorock class looks like now:

class OCTOROCK
{

public:

	SPRITE sprite;
	int pathx1, pathx2;
	int pathy1, pathy2;
	bool isExplode;

	//Constructor
	OCTOROCK()
	{
	}

	//Destructor
	~OCTOROCK()
	{
	}

	//moves the octorock
	void moveOctorock()
	{
		if(sprite.alive)
		{
			//Make sure the octorock does not leave its specified path
			if(sprite.x > pathx2)
			{
				sprite.dir = LEFT;
				sprite.curframe = 6;
			}
			else if(sprite.x < pathx1)
			{
				sprite.dir = RIGHT;
				sprite.curframe = 4;
			}
			if(sprite.y > pathy2)
			{
				sprite.dir = UP;
				sprite.curframe = 2;
			}
			else if(sprite.y < pathy1)
			{
				sprite.dir = DOWN;
				sprite.curframe = 0;
			}


			//Move the octorock according to its direction.
			if(sprite.dir == RIGHT)
			{
				sprite.x += sprite.xspeed;
				sprite.y += 0;
				//sprite.curframe = 4;
			}
			else if(sprite.dir == LEFT)
			{
				sprite.x -= sprite.xspeed;
				sprite.y += 0;
				//sprite.curframe = 6;
			}
			else if(sprite.dir == UP)
			{
				sprite.x += 0;
				sprite.y -= sprite.yspeed;
				//sprite.curframe = 2;
			}
			else if(sprite.dir == DOWN)
			{
				sprite.x += 0;
				sprite.y += sprite.yspeed;
				//sprite.curframe = 0;
			}
		}
	}

	//Detects if the player collides with the octorock
	void detectCollision(SPRITE *spr)
	{
		//Variables to record everyones bound box dimensions
		int playerx, playery, playerw, playerh;
		int top, bottom, left, right;

		int heartcount = 0;
		int heartdelay = 200;

		if(sprite.alive)
		{
			//record players box
			playerx = spr->x; 
			playery = spr->y;
			playerw = playerx + spr->width;
			playerh = playery + spr->height;
			

			//record the octorocks box
			top = sprite.y;
			left = sprite.x;
			bottom = top + sprite.height;
			right = left + sprite.width;

			//Check if they collide
			if(accurateInside(playerx, playery, playerw, playerh, left, top, right, bottom))
			{

				//If the players attacking frame is active during collision
				if(spr->curframe == 8 ||
                   spr->curframe == 9 ||
				   spr->curframe == 10 ||
				   spr->curframe == 11)
				{
					//Kill the octorock
					sprite.alive = 0;
					cout << "octorock killed" << endl;
					al_play_sample_instance(killInstance);
					isExplode = true;
					
				}
				else
				{
					//flinch a bit and lose 1 heart
					if(++heartcount > heartdelay)
					{
						hearts -= 1;
						heartcount = 0;
						//al_play_sample_instance(hurtInstance);
					}
					
					if(spr->dir == RIGHT)
					{
						spr->x -= 15;//8;
						hearts -= 1;
						al_play_sample_instance(hurtInstance);
					}
					else if(spr->dir == LEFT)
					{
						spr->x += 15;//8;
						hearts -= 1;
						al_play_sample_instance(hurtInstance);
					}
					else if(spr->dir == DOWN)
					{
						spr->y -= 15;//8;
						hearts -= 1;
						al_play_sample_instance(hurtInstance);
					}
					else if(spr->dir == UP)
					{
						spr->y += 15;//8;
						hearts -= 1;
						al_play_sample_instance(hurtInstance);
					}
					
					

					
				}
			}
		}
	}


	//Draw the octorock
	void drawOctorock()
	{
		if(sprite.alive)
		{
			if(sprite.dir == RIGHT)
			{
				if(++sprite.framecount > sprite.framedelay)
				{
					sprite.framecount = 0;

					if(++sprite.curframe > 5)
					{
						sprite.curframe = 4;
					}
				}
			}

			if(sprite.dir == LEFT)
			{
				if(++sprite.framecount > sprite.framedelay)
				{
					sprite.framecount = 0;

					if(++sprite.curframe > 7)
					{
						sprite.curframe = 6;
					}
				}
			}

			if(sprite.dir == UP)
			{
				if(++sprite.framecount > sprite.framedelay)
				{
					sprite.framecount = 0;

					if(++sprite.curframe > 3)
					{
						sprite.curframe = 2;
					}
				}
			}

			if(sprite.dir == DOWN)
			{
				if(++sprite.framecount > sprite.framedelay)
				{
					sprite.framecount = 0;

					if(++sprite.curframe > 1)
					{
						sprite.curframe = 0;
					}
				}
			}

			//Finally draw the octorock
			al_draw_bitmap(octorock_images[sprite.curframe],
						   sprite.x - mapxoff, sprite.y - mapyoff, NULL);
		}
	}
	
};

It works perfectly, I have multiple enemies on the map and no problem. Collision is a bit amateurish but so am I

If anybody cares to see:

Just curious. You set a lot of class variables as private. Any reason why you do that?

wat