Finishing EVERYTHING FOR MILESTONE 2

source/baseprojectile.cpp

@@ -14,22 +14,10 @@ bool BaseProjectile::hitScan() {
 			{
 				yVel=(size_/2)-y;
 			}
-			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
-			{
-				if((x+xVel-(size_/2)<(*it).x+(*it).w)&&(x+xVel+(size_/2)>(*it).x)&&(y+yVel-(size_/2)<(*it).y+(*it).h)&&(y+yVel+(size_/2)>(*it).y))
-				{
-					hit_=true;
-				}
-			}
 			if(yVel==0)
 			{
 				hit_=true;
 			}
-			else
-			{
-				origin_.setX(x+xVel);
-				origin_.setY(y+yVel);
-			}
 			break;
 		case 1:
 			xVel=speed_/2;
@@ -42,22 +30,10 @@ bool BaseProjectile::hitScan() {
 			{
 				xVel=(map_.getX()-(size_/2))-x;
 			}
-			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
-			{
-				if((x+xVel-(size_/2)<(*it).x+(*it).w)&&(x+xVel+(size_/2)>(*it).x)&&(y+yVel-(size_/2)<(*it).y+(*it).h)&&(y+yVel+(size_/2)>(*it).y))
-				{
-					hit_=true;
-				}
-			}
 			if((xVel==0)||(yVel==0))
 			{
 				hit_=true;
 			}
-			else
-			{
-				origin_.setX(x+xVel);
-				origin_.setY(y+yVel);
-			}
 			break;
 		case 2:
 			xVel=speed_;
@@ -66,22 +42,10 @@ bool BaseProjectile::hitScan() {
 			{
 				xVel=(map_.getX()-(size_/2))-x;
 			}
-			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
-			{
-				if((x+xVel-(size_/2)<(*it).x+(*it).w)&&(x+xVel+(size_/2)>(*it).x)&&(y+yVel-(size_/2)<(*it).y+(*it).h)&&(y+yVel+(size_/2)>(*it).y))
-				{
-					hit_=true;
-				}
-			}
 			if(xVel==0)
 			{
 				hit_=true;
 			}
-			else
-			{
-				origin_.setX(x+xVel);
-				origin_.setY(y+yVel);
-			}
 			break;
 		case 3:
 			xVel=speed_/2;
@@ -94,22 +58,10 @@ bool BaseProjectile::hitScan() {
 			{
 				xVel=(map_.getX()-(size_/2))-x;
 			}
-			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
-			{
-				if((x+xVel-(size_/2)<(*it).x+(*it).w)&&(x+xVel+(size_/2)>(*it).x)&&(y+yVel-(size_/2)<(*it).y+(*it).h)&&(y+yVel+(size_/2)>(*it).y))
-				{
-					hit_=true;
-				}
-			}
 			if((xVel==0)||(yVel==0))
 			{
 				hit_=true;
 			}
-			else
-			{
-				origin_.setX(x+xVel);
-				origin_.setY(y+yVel);
-			}
 			break;
 		case 4:
 			xVel=0;
@@ -118,22 +70,10 @@ bool BaseProjectile::hitScan() {
 			{
 				yVel=(map_.getY()-(size_/2))-y;
 			}
-			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
-			{
-				if((x+xVel-(size_/2)<(*it).x+(*it).w)&&(x+xVel+(size_/2)>(*it).x)&&(y+yVel-(size_/2)<(*it).y+(*it).h)&&(y+yVel+(size_/2)>(*it).y))
-				{
-					hit_=true;
-				}
-			}
 			if(yVel==0)
 			{
 				hit_=true;
 			}
-			else
-			{
-				origin_.setX(x+xVel);
-				origin_.setY(y+yVel);
-			}
 			break;
 		case 5:
 			xVel=-speed_/2;
@@ -146,22 +86,10 @@ bool BaseProjectile::hitScan() {
 			{
 				yVel=(map_.getY()-(size_/2))-y;
 			}
-			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
-			{
-				if((x+xVel-(size_/2)<(*it).x+(*it).w)&&(x+xVel+(size_/2)>(*it).x)&&(y+yVel-(size_/2)<(*it).y+(*it).h)&&(y+yVel+(size_/2)>(*it).y))
-				{
-					hit_=true;
-				}
-			}
 			if((xVel==0)||(yVel==0))
 			{
 				hit_=true;
 			}
-			else
-			{
-				origin_.setX(x+xVel);
-				origin_.setY(y+yVel);
-			}
 			break;
 		case 6:
 			xVel=-speed_;
@@ -170,22 +98,10 @@ bool BaseProjectile::hitScan() {
 			{
 				xVel=(size_/2)-x;
 			}
-			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
-			{
-				if((x+xVel-(size_/2)<(*it).x+(*it).w)&&(x+xVel+(size_/2)>(*it).x)&&(y+yVel-(size_/2)<(*it).y+(*it).h)&&(y+yVel+(size_/2)>(*it).y))
-				{
-					hit_=true;
-				}
-			}
 			if(xVel==0)
 			{
 				hit_=true;
 			}
-			else
-			{
-				origin_.setX(x+xVel);
-				origin_.setY(y+yVel);
-			}
 			break;
 		case 7:
 			xVel=-speed_/2;
@@ -198,24 +114,38 @@ bool BaseProjectile::hitScan() {
 			{
 				yVel=(size_/2)-y;
 			}
+			if((xVel==0)||(yVel==0))
+			{
+				hit_=true;
+			}
+			break;
+	}
+	
 	for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
 	{
+		if(hit_==true) break;
 		if((x+xVel-(size_/2)<(*it).x+(*it).w)&&(x+xVel+(size_/2)>(*it).x)&&(y+yVel-(size_/2)<(*it).y+(*it).h)&&(y+yVel+(size_/2)>(*it).y))
 		{
 			hit_=true;
 		}
 	}
-			if((xVel==0)||(yVel==0))
+	
+	for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
 	{
+		if(hit_==true) break;
+		if((x+xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+		{
+			(*(*it)).hurt(damage_);
 			hit_=true;
 		}
-			else
+	}
+	
+	if(hit_!=true)
 	{
 		origin_.setX(x+xVel);
 		origin_.setY(y+yVel);
 	}
-			break;
+	
-	}
 	return hit_;
 }
 

source/enemy.cpp

@@ -1,8 +1,458 @@
 #include "entities.h"
 
-int Enemy::findPlayer(int *xVel, int *yVel) {
+int Enemy::findPlayer(int *xVel, int *yVel)
-//Nedko svurshi si rabotata
+{
-//pip	
+	int x=origin_.getX();
+	int y=origin_.getY();
+	int xDiff=(*player_).getPosition().getX()-x;
+	int yDiff=(*player_).getPosition().getY()-y;
+	int dir;
+	int xDist;
+	int yDist;
+	
+	if(xDiff<0)
+	{
+		xDist=-xDiff;
+	}
+	else
+	{
+		xDist=xDiff;
+	}
+	
+	if(yDiff<0)
+	{
+		yDist=-yDiff;
+	}
+	else
+	{
+		yDist=yDiff;
+	}
+	
+	if(xDiff==0)
+	{
+		if(yDiff<0)
+		{
+			dir=0;
+		}
+		else
+		{
+			dir=4;
+		}
+	}
+	else if(yDiff==0)
+	{
+		if(xDiff<0)
+		{
+			dir=6;
+		}
+		else
+		{
+			dir=2;
+		}
+	}
+	else if((xDiff<0)&&(yDiff<0))
+	{
+		if(xDist<=tolerance_)
+		{
+			dir=0;
+		}
+		else if(yDist<=tolerance_)
+		{
+			dir=6;
+		}
+		else
+		{
+			dir=7;
+		}
+	}
+	else if((xDiff>0)&&(yDiff<0))
+	{
+		if(xDist<=tolerance_)
+		{
+			dir=0;
+		}
+		else if(yDist<=tolerance_)
+		{
+			dir=2;
+		}
+		else
+		{
+			dir=1;
+		}
+	}
+	else if((xDiff<0)&&(yDiff>0))
+	{
+		if(xDist<=tolerance_)
+		{
+			dir=4;
+		}
+		else if(yDist<=tolerance_)
+		{
+			dir=6;
+		}
+		else
+		{
+			dir=5;
+		}
+	}
+	else
+	{
+		if(xDist<=tolerance_)
+		{
+			dir=4;
+		}
+		else if(yDist<=tolerance_)
+		{
+			dir=2;
+		}
+		else
+		{
+			dir=3;
+		}
+	}
+
+	if((xDist<=tolerance_)&&(yDist<=tolerance_))
+	{
+		if((SDL_GetTicks()-hitTimer_)>=1000)
+		{
+			(*player_).hurt(damage_);
+			hitTimer_=SDL_GetTicks();
+		}
+		*xVel=0;
+		*yVel=0;
+	}
+	else
+	{
+	switch(dir)
+	{
+		case 0:
+			*xVel=0;
+			*yVel=-speed_;
+			
+			if((y+*yVel)<(size_/2))
+			{
+				*yVel=(size_/2)-y;
+			}
+			
+			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
+				{
+					*yVel=((*it).y+(*it).h+(size_/2))-y;
+				}
+			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((*(*it)).getPosition()==origin_)
+				{
+					continue;
+				}
+				
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					*yVel=((*(*it)).getPosition().getY()+(*(*it)).getSize()/2+(size_/2))-y;
+				}
+			}
+			break;
+			
+		case 1:
+			*xVel=speed_/2;
+			*yVel=-speed_/2;
+			
+			if((y+*yVel)<(size_/2))
+			{
+				*yVel=(size_/2)-y;
+			}
+			
+			if((x+*xVel)>(map_.getX()-(size_/2)))
+			{
+				*xVel=(map_.getX()-(size_/2))-x;
+			}
+			
+			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
+				{
+					if((y-(size_/2)<(*it).y+(*it).h)&&(y+size_/2>(*it).y))
+					{
+						*xVel=((*it).x-(size_/2))-x;
+					}
+					else if((x+(size_/2)>(*it).x)&&(x-size_/2<(*it).x+(*it).w))
+					{
+						*yVel=((*it).y+(*it).h+(size_/2))-y;
+					}
+				}
+			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((*(*it)).getPosition()==origin_)
+				{
+					continue;
+				}
+				
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					if((y-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+(size_/2)<(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+					{
+						*xVel=((*(*it)).getPosition().getX()-(size_/2))-x;
+					}
+					else if((x-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+(size_/2)<(*(*it)).getPosition().getX()-(*(*it)).getSize()/2))
+					{
+						*yVel=((*(*it)).getPosition().getY()+(*(*it)).getSize()/2+(size_/2))-y;
+					}
+				}
+			}
+			break;
+			
+		case 2:
+			*xVel=speed_;
+			*yVel=0;
+			
+			if((x+*xVel)>(map_.getX()-(size_/2)))
+			{
+				*xVel=(map_.getX()-(size_/2))-x;
+			}
+			
+			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
+				{
+					*xVel=((*it).x-(size_/2))-x;
+				}
+			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((*(*it)).getPosition()==origin_)
+				{
+					continue;
+				}
+				
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					*xVel=((*(*it)).getPosition().getX()-(*(*it)).getSize()/2-(size_/2))-x;
+				}
+			}
+			break;
+			
+		case 3:
+			*xVel=speed_/2;
+			*yVel=speed_/2;
+			
+			if((y+*yVel)>(map_.getY()-(size_/2)))
+			{
+				*yVel=(map_.getY()-(size_/2))-y;
+			}
+			
+			if((x+*xVel)>(map_.getX()-(size_/2)))
+			{
+				*xVel=(map_.getX()-(size_/2))-x;
+			}
+			
+			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
+				{
+					if((y-(size_/2)<(*it).y+(*it).h)&&(y+size_/2>(*it).y))
+					{
+						*xVel=((*it).x-(size_/2))-x;
+					}
+					else if((x+(size_/2)>(*it).x)&&(x-size_/2<(*it).x+(*it).w))
+					{
+						*yVel=((*it).y-(size_/2))-y;
+					}
+				}
+			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((*(*it)).getPosition()==origin_)
+				{
+					continue;
+				}
+				
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					if((y-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+(size_/2)<(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+					{
+						*xVel=((*(*it)).getPosition().getX()-(*(*it)).getSize()/2-(size_/2))-x;
+					}
+					else if((x-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+(size_/2)<(*(*it)).getPosition().getX()-(*(*it)).getSize()/2))
+					{
+						*yVel=((*(*it)).getPosition().getY()-(*(*it)).getSize()/2-(size_/2))-y;
+					}
+				}
+			}
+			break;
+			
+		case 4:
+			*xVel=0;
+			*yVel=speed_;
+			
+			if((y+*yVel)>(map_.getY()-(size_/2)))
+			{
+				*yVel=(map_.getY()-(size_/2))-y;
+			}
+			
+			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
+				{
+					*yVel=((*it).y-(size_/2))-y;
+				}
+			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((*(*it)).getPosition()==origin_)
+				{
+					continue;
+				}
+				
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					*yVel=((*(*it)).getPosition().getY()-(*(*it)).getSize()/2-(size_/2))-y;
+				}
+			}
+			break;
+			
+		case 5:
+			*xVel=-speed_/2;
+			*yVel=speed_/2;
+			
+			if((x+*xVel)<(size_/2))
+			{
+				*xVel=(size_/2)-x;
+			}
+			
+			if((y+*yVel)>(map_.getY()-(size_/2)))
+			{
+				*yVel=(map_.getY()-(size_/2))-y;
+			}
+			
+			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
+				{
+					if((y-(size_/2)<(*it).y+(*it).h)&&(y+size_/2>(*it).y))
+					{
+						*xVel=((*it).x+(*it).w+(size_/2))-x;
+					}
+					
+					if((x+(size_/2)>(*it).x)&&(x-size_/2<(*it).x+(*it).w))
+					{
+						*yVel=((*it).y-(size_/2))-y;
+					}
+				}
+			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((*(*it)).getPosition()==origin_)
+				{
+					continue;
+				}
+				
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					if((y-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+(size_/2)<(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+					{
+						*xVel=((*(*it)).getPosition().getX()+(*(*it)).getSize()/2+(size_/2))-x;
+					}
+					else if((x-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+(size_/2)<(*(*it)).getPosition().getX()-(*(*it)).getSize()/2))
+					{
+						*yVel=((*(*it)).getPosition().getY()-(*(*it)).getSize()/2-(size_/2))-y;
+					}
+				}
+			}
+			break;
+			
+		case 6:
+			*xVel=-speed_;
+			*yVel=0;
+			
+			if((x+*xVel)<(size_/2))
+			{
+				*xVel=(size_/2)-x;
+			}
+			
+			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
+				{
+					*xVel=((*it).x+(*it).w+(size_/2))-x;
+				}
+			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((*(*it)).getPosition()==origin_)
+				{
+					continue;
+				}
+				
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					*xVel=((*(*it)).getPosition().getX()+(*(*it)).getSize()/2+(size_/2))-x;
+				}
+			}
+			break;
+			
+		case 7:
+			*xVel=-speed_/2;
+			*yVel=-speed_/2;
+			
+			if((x+*xVel)<(size_/2))
+			{
+				*xVel=(size_/2)-x;
+			}
+			
+			if((y+*yVel)<(size_/2))
+			{
+				*yVel=(size_/2)-y;
+			}
+			
+			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
+				{
+					if((y-(size_/2)<(*it).y+(*it).h)&&(y+size_/2>(*it).y))
+					{
+						*xVel=((*it).x+(*it).w+(size_/2))-x;
+					}
+					
+					if((x+(size_/2)>(*it).x)&&(x-size_/2<(*it).x+(*it).w))
+					{
+						*yVel=((*it).y+(*it).h+(size_/2))-y;
+					}
+				}
+			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((*(*it)).getPosition()==origin_)
+				{
+					continue;
+				}
+				
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					if((y-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+(size_/2)<(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+					{
+						*xVel=((*(*it)).getPosition().getX()+(*(*it)).getSize()/2+(size_/2))-x;
+					}
+					else if((x-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+(size_/2)<(*(*it)).getPosition().getX()-(*(*it)).getSize()/2))
+					{
+						*yVel=((*(*it)).getPosition().getY()+(*(*it)).getSize()/2+(size_/2))-y;
+					}
+				}
+			}
+			break;
+	}
+	}
+	return dir;
 }
 
 void Enemy::move() {

source/entities.h

@@ -6,6 +6,8 @@
 #include "SDL/SDL.h"
 #include <vector>
 
+class Enemy;
+
 class Player {
 protected:
 	Point origin_;
@@ -14,6 +16,9 @@ protected:
 	int size_;
 	int speed_;
 	std::vector<SDL_Rect> *obstacles_;
+	int health_;
+	int maxHealth_;
+	std::vector<Enemy*> *enemies_;
 
 private:
 	void checkDirection(int dir, int *xVel, int *yVel) const;
@@ -25,32 +30,51 @@ public:
 		direction_(0),
 		size_(2),
 		speed_(0),
-		obstacles_(NULL)
+		obstacles_(NULL),
+		health_(100),
+		maxHealth_(100),
+		enemies_(NULL)
 	{}
 	
-	Player(Point origin, Point map, int dir, int size, int speed, std::vector<SDL_Rect> *obstacles)
+	Player(Point origin, Point map, int dir, int size, int speed, std::vector<SDL_Rect> *obstacles, int health, int maxHealth, std::vector<Enemy*> *enemies)
 	:	origin_(origin.getX(),origin.getY()),
 		map_(map.getX(),map.getY()),
 		direction_(dir),
 		size_(size),
 		speed_(speed),
-		obstacles_(obstacles)
+		obstacles_(obstacles),
+		health_(health),
+		maxHealth_(maxHealth),
+		enemies_(enemies)
 	{}
 	
 	Point getPosition() const;
 	int getDirection() const;
 	void move(int dir);
-	void init(Point origin, int size, int dir, Point map, std::vector<SDL_Rect> *obstacles, int speed);
+	void init(Point origin, int size, int dir, Point map, std::vector<SDL_Rect> *obstacles, int speed, int health, int maxHealth, std::vector<Enemy*> *enemies);
+	void hurt(int val);
+	void heal(int val);
+	int getHealth();
+	int getSize();
 };
 
-class Enemy::public Player {
+class Enemy: public Player {
-	Player player_;
+	Player *player_;
 	int findPlayer(int *xVel, int *yVel);
+	Uint32 hitTimer_;
+	int damage_;
+	int tolerance_;
 public:
-	Enemy(Point origin, Point map, int dir, int size, int speed, std::vector<SDL_Rect> *obstacles, Player player)
+	Enemy(Point origin, Point map, int dir, int size, int speed, std::vector<SDL_Rect> *obstacles, int health, int maxHealth, std::vector<Enemy*> *enemies, int damage, Player *player)
-	: Player(origin, map, dir, size, speed, obstacles),
+	: Player(origin, map, dir, size, speed, obstacles, health, maxHealth, enemies),
-	  player_(player)
+	  player_(player),
-	{}
+	  hitTimer_(0),
+	  damage_(damage),
+	  tolerance_(0)
+	{
+		tolerance_=(size_+(*player_).getSize())*3/4;
+	}
+	
 	void move();
 };
 #endif

source/main.cpp

@@ -12,6 +12,7 @@
 #include <vector>
 #include <string>
 #include <iostream>
+#include <sstream>
 
 const int SCREEN_WIDTH = 640;
 const int SCREEN_HEIGHT = 480;
@@ -22,10 +23,16 @@ SDL_Surface *screen = NULL;
 SDL_Surface *map = NULL;
 SDL_Surface *player = NULL;
 SDL_Surface *bullet = NULL;
+SDL_Surface *enemy = NULL;
+SDL_Surface *scoreDisplay = NULL;
+SDL_Surface *healthDisplay = NULL;
+SDL_Color textColor = {255,255,255};
+
 SDL_Event event;
 TTF_Font *font = NULL;
 Mix_Chunk *bulletSound = NULL;
 SDL_Rect playerSlice[8];
+SDL_Rect enemySlice[8];
 
 Player playerObject;
 Weapon primary;
@@ -34,6 +41,7 @@ Weapon melee;
 
 std::vector<BaseProjectile*> projectiles;
 std::vector<SDL_Rect> obstacles;
+std::vector<Enemy*> enemies;
 
 bool init()
 {
@@ -64,7 +72,8 @@ bool init()
 
 bool load_files()
 {
-	player=load_image("player.tga",true);
+	player=load_image("player.tga");
+	enemy=load_image("enemy.tga");
 	map=load_image("example_map.tga");
 	font=TTF_OpenFont("tf2professor.ttf",30);
 	bullet=load_image("bullet.tga",true);
@@ -73,6 +82,10 @@ bool load_files()
 	{
 		return false;
 	}
+	if((enemy->w)!=(enemy->h))
+	{
+		return false;
+	}
 	if((bullet->w)!=(bullet->h))
 	{
 		return false;
@@ -85,6 +98,10 @@ bool load_files()
 	{
 		return false;
 	}
+	if(((enemy->w)%6)!=0)
+	{
+		return false;
+	}
 	if(map==NULL)
 	{
 		return false;
@@ -144,31 +161,82 @@ bool load_files()
 	playerSlice[7].w=playerSize;
 	playerSlice[7].h=playerSize;
 	
-	Point temp((playerSize/2),(playerSize/2));
+	int enemySize=(enemy->w)/3;
-	Point temp2(map->w,map->h);
 	
-	playerObject.init(temp,playerSize,0,temp2,&obstacles,2);
+	enemySlice[0].x=enemySize;
-	primary.init(0,0,5,4,0,&projectiles);
+	enemySlice[0].y=0;
-	secondary.init(1,0,2,2,0,&projectiles);
+	enemySlice[0].w=enemySize;
-	melee.init(2,0,1,1,0,&projectiles);
+	enemySlice[0].h=enemySize;
+	
+	enemySlice[1].x=2*enemySize;
+	enemySlice[1].y=0;
+	enemySlice[1].w=enemySize;
+	enemySlice[1].h=enemySize;
+	
+	enemySlice[2].x=2*enemySize;
+	enemySlice[2].y=enemySize;
+	enemySlice[2].w=enemySize;
+	enemySlice[2].h=enemySize;
+	
+	enemySlice[3].x=2*enemySize;
+	enemySlice[3].y=2*enemySize;
+	enemySlice[3].w=enemySize;
+	enemySlice[3].h=enemySize;
+	
+	enemySlice[4].x=enemySize;
+	enemySlice[4].y=2*enemySize;
+	enemySlice[4].w=enemySize;
+	enemySlice[4].h=enemySize;
+	
+	enemySlice[5].x=0;
+	enemySlice[5].y=2*enemySize;
+	enemySlice[5].w=enemySize;
+	enemySlice[5].h=enemySize;
+	
+	enemySlice[6].x=0;
+	enemySlice[6].y=enemySize;
+	enemySlice[6].w=enemySize;
+	enemySlice[6].h=enemySize;
+	
+	enemySlice[7].x=0;
+	enemySlice[7].y=0;
+	enemySlice[7].w=enemySize;
+	enemySlice[7].h=enemySize;
+	
+	//Origin,Size,Direction,MapSize,&obstacles,Speed,Health,Max Health,&enemies)
+	playerObject.init(Point(playerSize/2,playerSize/2),playerSize,0,Point(map->w,map->h),&obstacles,8,100,100,&enemies);
+	//Type,Projectile Type,Projectile Speed,ROF,DMG,&projectiles)
+	primary.init(0,0,20,4,2,&projectiles);
+	secondary.init(1,0,15,2,4,&projectiles);
+	melee.init(2,0,10,1,6,&projectiles);
+
+	SDL_Rect test;
+	test.x=632;
+	test.y=632;
+	test.w=103;
+	test.h=103;
+	obstacles.push_back(test);
+	test.x=1185;
+	test.y=632;
+	test.w=103;
+	test.h=103;
+	obstacles.push_back(test);
+	test.x=1185;
+	test.y=1185;
+	test.w=103;
+	test.h=103;
+	obstacles.push_back(test);
+	test.x=632;
+	test.y=1185;
+	test.w=103;
+	test.h=103;
+	obstacles.push_back(test);
 	
 	if(bulletSound==NULL)
 	{
 		return false;
 	}
 	
-	/*SDL_Rect test;
-	test.x=100;
-	test.y=100;
-	test.w=500;
-	test.h=100;
-	obstacles.push_back(test);
-	test.x=100;
-	test.y=100;
-	test.w=100;
-	test.h=500;
-	obstacles.push_back(test);*/
-	
 	return true;
 }
 
@@ -182,6 +250,13 @@ void cleanup()
 		delete *it;
 		projectiles.erase(it);
 	}
+	
+	for(std::vector<Enemy*>::iterator it=enemies.begin();it!=enemies.end();)
+	{
+		delete *it;
+		enemies.erase(it);
+	}
+	
 	Mix_FreeChunk(bulletSound);
 	TTF_CloseFont(font);
 	Mix_CloseAudio();
@@ -197,9 +272,16 @@ int main(int argc, char* args[])
 	bool fireSound=false;
 	Uint8 *keyStates=SDL_GetKeyState(NULL);
 	
-	Uint32 moveTimer = 0;
+	Uint32 moveTimer=0;
-	Uint32 fps = 0;
+	Uint32 fps=0;
 	Uint32 changeWeapon=0;
+	Uint32 spawnTimer=0;
+	int spawnPlace=0;
+	
+	int score=0;
+	int health;
+	std::ostringstream temp;
+	std::string temp2;
 		
 	if(init()==false)
 	{
@@ -250,7 +332,30 @@ int main(int argc, char* args[])
 				}
 			}
 		}
-		
+		if((SDL_GetTicks()-spawnTimer)>=5000-250*(score/10))
+		{
+			if(spawnPlace==0)
+			{
+				enemies.push_back(new Enemy(Point(960,245),Point(map->w,map->h),4,(enemy->w)/3,4,&obstacles,10,10,&enemies,2,&playerObject));
+				spawnPlace++;
+			}
+			else if(spawnPlace==1)
+			{
+				enemies.push_back(new Enemy(Point(1675,960),Point(map->w,map->h),6,(enemy->w)/3,4,&obstacles,10,10,&enemies,2,&playerObject));
+				spawnPlace++;
+			}
+			else if(spawnPlace==2)
+			{
+				enemies.push_back(new Enemy(Point(960,1675),Point(map->w,map->h),0,(enemy->w)/3,4,&obstacles,10,10,&enemies,2,&playerObject));
+				spawnPlace++;
+			}
+			else
+			{
+				enemies.push_back(new Enemy(Point(245,960),Point(map->w,map->h),2,(enemy->w)/3,4,&obstacles,10,10,&enemies,2,&playerObject));
+				spawnPlace=0;
+			}
+			spawnTimer=SDL_GetTicks();
+		}
 		if((SDL_GetTicks()-moveTimer)>=50)
 		{
 			if(keyStates[SDLK_w]&&(!keyStates[SDLK_a])&&(!keyStates[SDLK_s])&&(!keyStates[SDLK_d]))
@@ -306,29 +411,27 @@ int main(int argc, char* args[])
 		
 		if(keyStates[SDLK_SPACE])
 		{
-			Point temp(map->w,map->h);
 			if(currentWeapon==0)
 			{
 				if(SDL_GetTicks()-changeWeapon>=500)
 				{
-					fireSound=primary.fire(playerObject,temp,bullet->w,&obstacles);
+					fireSound=primary.fire(playerObject,Point(map->w,map->h),bullet->w,&obstacles, &enemies);
 				}
 			}
 			else if(currentWeapon==1)
 			{
 				if(SDL_GetTicks()-changeWeapon>=500)
 				{
-					fireSound=secondary.fire(playerObject,temp,bullet->w,&obstacles);
+					fireSound=secondary.fire(playerObject,Point(map->w,map->h),bullet->w,&obstacles, &enemies);
 				}
 			}
 			else if(currentWeapon==2)
 			{
 				if(SDL_GetTicks()-changeWeapon>=500)
 				{
-					fireSound=melee.fire(playerObject,temp,bullet->w,&obstacles);
+					fireSound=melee.fire(playerObject,Point(map->w,map->h),bullet->w,&obstacles, &enemies);
 				}
 			}
-			
 			if(fireSound==true)
 			{
 				if(Mix_PlayChannel(-1,bulletSound,0)==-1)
@@ -340,7 +443,7 @@ int main(int argc, char* args[])
 		SDL_FillRect(screen,&screen->clip_rect,SDL_MapRGB(screen->format,0x00,0x00,0x00));
 		if(moveDirection!=-1)
 		{
-			playerObject.movePlayer(moveDirection);
+			playerObject.move(moveDirection);
 		}
 		
 		apply_surface(((SCREEN_WIDTH/2)-((playerObject.getPosition()).getX())),((SCREEN_HEIGHT/2)-((playerObject.getPosition()).getY())),map,screen);
@@ -348,6 +451,7 @@ int main(int argc, char* args[])
 		for(std::vector<BaseProjectile*>::iterator it=projectiles.begin();it!=projectiles.end();it++)
 		{
 			apply_surface((((SCREEN_WIDTH/2)-((playerObject.getPosition().getX())-((*(*it)).getPosition().getX())))-((*(*it)).getSize()/2)),(((SCREEN_HEIGHT/2)-((playerObject.getPosition().getY())-((*(*it)).getPosition().getY())))-((*(*it)).getSize()/2)),bullet,screen);
+			
 			if((*(*it)).hitScan()==true)
 			{
 				delete *it;
@@ -356,13 +460,52 @@ int main(int argc, char* args[])
 			}
 		}
 		
+		for(std::vector<Enemy*>::iterator it=enemies.begin();it!=enemies.end();it++)
+		{
+			if((*(*it)).getHealth()==0)
+			{
+				score++;
+				if(score==100)
+				{
+					playerObject.heal(10);
+				}
+				delete *it;
+				enemies.erase(it);
+				it--;
+			}
+			else
+			{
+				(*(*it)).move();
+				apply_surface((((SCREEN_WIDTH/2)-((playerObject.getPosition().getX())-((*(*it)).getPosition().getX())))-((*(*it)).getSize()/2)),(((SCREEN_HEIGHT/2)-((playerObject.getPosition().getY())-((*(*it)).getPosition().getY())))-((*(*it)).getSize()/2)),enemy,screen,&enemySlice[(*(*it)).getDirection()]);
+			}
+		}
+		
+		health=playerObject.getHealth();
+
 		apply_surface((SCREEN_WIDTH/2)-(player->w/6),((SCREEN_HEIGHT/2)-(player->h/6)),player,screen,&playerSlice[playerObject.getDirection()]);
 		
+		temp.str("");
+		temp<<health;
+		temp2=temp.str();
+		healthDisplay=TTF_RenderText_Solid(font,temp2.c_str(),textColor);
+		temp.str("");
+		temp<<score;
+		temp2=temp.str();
+		scoreDisplay=TTF_RenderText_Solid(font,temp2.c_str(),textColor);
+		
+		apply_surface(0,0,healthDisplay,screen);
+		apply_surface(200,0,scoreDisplay,screen);
+
 		if(SDL_Flip(screen)==-1)
 		{
 			return 1;
 		}
 		
+		if(playerObject.getHealth()==0)
+		{
+			quit=true;
+		}
+		
 		if((SDL_GetTicks()-fps)<(1000/FRAMES_PER_SECOND))
 		{
 			SDL_Delay((1000/FRAMES_PER_SECOND)-(SDL_GetTicks()-fps));

source/player.cpp

@@ -9,10 +9,12 @@ void Player::checkDirection(int dir, int *xVel, int *yVel) const
 		case 0:
 			*xVel=0;
 			*yVel=-speed_;
+			
 			if((y+*yVel)<(size_/2))
 			{
 				*yVel=(size_/2)-y;
 			}
+			
 			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
 			{
 				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
@@ -20,46 +22,70 @@ void Player::checkDirection(int dir, int *xVel, int *yVel) const
 					*yVel=((*it).y+(*it).h+(size_/2))-y;
 				}
 			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					*yVel=((*(*it)).getPosition().getY()+(*(*it)).getSize()/2+(size_/2))-y;
+				}
+			}
 			break;
+			
 		case 1:
 			*xVel=speed_/2;
 			*yVel=-speed_/2;
+			
 			if((y+*yVel)<(size_/2))
 			{
 				*yVel=(size_/2)-y;
 			}
+			
 			if((x+*xVel)>(map_.getX()-(size_/2)))
 			{
 				*xVel=(map_.getX()-(size_/2))-x;
 			}
+			
 			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
 			{
 				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
 				{
-					if(y-(size_/2)!=(*it).y+(*it).h)
+					if((y-(size_/2)<(*it).y+(*it).h)&&(y+size_/2>(*it).y))
-					{
-						if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x))
 					{
 						*xVel=((*it).x-(size_/2))-x;
 					}
-					}
+					else if((x+(size_/2)>(*it).x)&&(x-size_/2<(*it).x+(*it).w))
-					else if(x+(size_/2)!=(*it).x)
-					{
-						if((y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
 					{
 						*yVel=((*it).y+(*it).h+(size_/2))-y;
 					}
 				}
 			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					if((y-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+(size_/2)<(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+					{
+						*xVel=((*(*it)).getPosition().getX()-(size_/2))-x;
+					}
+					else if((x-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+(size_/2)<(*(*it)).getPosition().getX()-(*(*it)).getSize()/2))
+					{
+						*yVel=((*(*it)).getPosition().getY()+(*(*it)).getSize()/2+(size_/2))-y;
+					}
+				}
 			}
 			break;
+			
 		case 2:
 			*xVel=speed_;
 			*yVel=0;
+			
 			if((x+*xVel)>(map_.getX()-(size_/2)))
 			{
 				*xVel=(map_.getX()-(size_/2))-x;
 			}
+			
 			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
 			{
 				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
@@ -67,46 +93,70 @@ void Player::checkDirection(int dir, int *xVel, int *yVel) const
 					*xVel=((*it).x-(size_/2))-x;
 				}
 			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					*xVel=((*(*it)).getPosition().getX()-(*(*it)).getSize()/2-(size_/2))-x;
+				}
+			}
 			break;
+			
 		case 3:
 			*xVel=speed_/2;
 			*yVel=speed_/2;
+			
 			if((y+*yVel)>(map_.getY()-(size_/2)))
 			{
 				*yVel=(map_.getY()-(size_/2))-y;
 			}
+			
 			if((x+*xVel)>(map_.getX()-(size_/2)))
 			{
 				*xVel=(map_.getX()-(size_/2))-x;
 			}
+			
 			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
 			{
 				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
 				{
-					if(y+(size_/2)!=(*it).y)
+					if((y-(size_/2)<(*it).y+(*it).h)&&(y+size_/2>(*it).y))
-					{
-						if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x))
 					{
 						*xVel=((*it).x-(size_/2))-x;
 					}
-					}
+					else if((x+(size_/2)>(*it).x)&&(x-size_/2<(*it).x+(*it).w))
-					else if(x+(size_/2)!=(*it).x)
-					{
-						if((y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
 					{
 						*yVel=((*it).y-(size_/2))-y;
 					}
 				}
 			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					if((y-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+(size_/2)<(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+					{
+						*xVel=((*(*it)).getPosition().getX()-(*(*it)).getSize()/2-(size_/2))-x;
+					}
+					else if((x-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+(size_/2)<(*(*it)).getPosition().getX()-(*(*it)).getSize()/2))
+					{
+						*yVel=((*(*it)).getPosition().getY()-(*(*it)).getSize()/2-(size_/2))-y;
+					}
+				}
 			}
 			break;
+			
 		case 4:
 			*xVel=0;
 			*yVel=speed_;
+			
 			if((y+*yVel)>(map_.getY()-(size_/2)))
 			{
 				*yVel=(map_.getY()-(size_/2))-y;
 			}
+			
 			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
 			{
 				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
@@ -114,46 +164,71 @@ void Player::checkDirection(int dir, int *xVel, int *yVel) const
 					*yVel=((*it).y-(size_/2))-y;
 				}
 			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					*yVel=((*(*it)).getPosition().getY()-(*(*it)).getSize()/2-(size_/2))-y;
+				}
+			}
 			break;
+			
 		case 5:
 			*xVel=-speed_/2;
 			*yVel=speed_/2;
+			
 			if((x+*xVel)<(size_/2))
 			{
 				*xVel=(size_/2)-x;
 			}
+			
 			if((y+*yVel)>(map_.getY()-(size_/2)))
 			{
 				*yVel=(map_.getY()-(size_/2))-y;
 			}
+			
 			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
 			{
 				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
 				{
-					if(y+(size_/2)!=(*it).y)
+					if((y-(size_/2)<(*it).y+(*it).h)&&(y+size_/2>(*it).y))
-					{
-						if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x))
 					{
 						*xVel=((*it).x+(*it).w+(size_/2))-x;
 					}
-					}
+					
-					else if(x-(size_/2)!=(*it).x+(*it).w)
+					if((x+(size_/2)>(*it).x)&&(x-size_/2<(*it).x+(*it).w))
-					{
-						if((y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
 					{
 						*yVel=((*it).y-(size_/2))-y;
 					}
 				}
 			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					if((y-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+(size_/2)<(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+					{
+						*xVel=((*(*it)).getPosition().getX()+(*(*it)).getSize()/2+(size_/2))-x;
+					}
+					else if((x-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+(size_/2)<(*(*it)).getPosition().getX()-(*(*it)).getSize()/2))
+					{
+						*yVel=((*(*it)).getPosition().getY()-(*(*it)).getSize()/2-(size_/2))-y;
+					}
+				}
 			}
 			break;
+			
 		case 6:
 			*xVel=-speed_;
 			*yVel=0;
+			
 			if((x+*xVel)<(size_/2))
 			{
 				*xVel=(size_/2)-x;
 			}
+			
 			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
 			{
 				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
@@ -161,37 +236,59 @@ void Player::checkDirection(int dir, int *xVel, int *yVel) const
 					*xVel=((*it).x+(*it).w+(size_/2))-x;
 				}
 			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					*xVel=((*(*it)).getPosition().getX()+(*(*it)).getSize()/2+(size_/2))-x;
+				}
+			}
 			break;
+			
 		case 7:
 			*xVel=-speed_/2;
 			*yVel=-speed_/2;
+			
 			if((x+*xVel)<(size_/2))
 			{
 				*xVel=(size_/2)-x;
 			}
+			
 			if((y+*yVel)<(size_/2))
 			{
 				*yVel=(size_/2)-y;
 			}
+			
 			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
 			{
 				if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x)&&(y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
 				{
-					if(y-(size_/2)!=(*it).y+(*it).h)
+					if((y-(size_/2)<(*it).y+(*it).h)&&(y+size_/2>(*it).y))
-					{
-						if((x+*xVel-(size_/2)<(*it).x+(*it).w)&&(x+*xVel+(size_/2)>(*it).x))
 					{
 						*xVel=((*it).x+(*it).w+(size_/2))-x;
 					}
-					}
+					
-					else if(x-(size_/2)!=(*it).x+(*it).w)
+					if((x+(size_/2)>(*it).x)&&(x-size_/2<(*it).x+(*it).w))
-					{
-						if((y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
 					{
 						*yVel=((*it).y+(*it).h+(size_/2))-y;
 					}
 				}
 			}
+			
+			for(std::vector<Enemy*>::iterator it=(*enemies_).begin();it!=(*enemies_).end();it++)
+			{
+				if((x+*xVel-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+*xVel+(size_/2)>(*(*it)).getPosition().getX()-(*(*it)).getSize()/2)&&(y+*yVel-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+*yVel+(size_/2)>(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+				{
+					if((y-(size_/2)<(*(*it)).getPosition().getY()+(*(*it)).getSize()/2)&&(y+(size_/2)<(*(*it)).getPosition().getY()-(*(*it)).getSize()/2))
+					{
+						*xVel=((*(*it)).getPosition().getX()+(*(*it)).getSize()/2+(size_/2))-x;
+					}
+					else if((x-(size_/2)<(*(*it)).getPosition().getX()+(*(*it)).getSize()/2)&&(x+(size_/2)<(*(*it)).getPosition().getX()-(*(*it)).getSize()/2))
+					{
+						*yVel=((*(*it)).getPosition().getY()+(*(*it)).getSize()/2+(size_/2))-y;
+					}
+				}
 			}
 			break;
 	}
@@ -201,7 +298,7 @@ Point Player::getPosition() const
 	return origin_;
 }
 
-void Player::movePlayer(int dir)
+void Player::move(int dir)
 {
 	int xVel;
 	int yVel;
@@ -216,7 +313,7 @@ int Player::getDirection() const
 	return direction_;
 }
 
-void Player::init(Point origin, int size, int dir, Point map, std::vector<SDL_Rect> *obstacles, int speed)
+void Player::init(Point origin, int size, int dir, Point map, std::vector<SDL_Rect> *obstacles, int speed, int health, int maxHealth, std::vector<Enemy*> *enemies)
 {
 	origin_.setX(origin.getX());
 	origin_.setY(origin.getY());
@@ -226,4 +323,35 @@ void Player::init(Point origin, int size, int dir, Point map, std::vector<SDL_Re
 	map_.setY(map.getY());
 	obstacles_=obstacles;
 	speed_=speed;
+	health_=health;
+	maxHealth_=maxHealth;
+	enemies_=enemies;
+}
+
+void Player::hurt(int val)
+{
+	health_-=val;
+	if(health_<0)
+	{
+		health_=0;
+	}
+}
+
+void Player::heal(int val)
+{
+	health_+=val;
+	if(health_>maxHealth_)
+	{
+		health_=maxHealth_;
+	}
+}
+
+int Player::getHealth()
+{
+	return health_;
+}
+
+int Player::getSize()
+{
+	return size_;
 }

source/point.cpp

@@ -16,3 +16,15 @@ void Point::setY(int y)
 {
 	y_=y;
 }
+
+bool Point::operator==(const Point p) const
+{
+	if((x_==p.getX())&&(y_==p.getY()))
+	{
+		return true;
+	}
+	else
+	{
+		return false;
+	}
+}

source/point.h

@@ -16,6 +16,8 @@ public:
 	int getX() const;
 	void setX(int x);
 	void setY(int y);
+	
+	bool operator==(const Point p) const;
 };
 
 #endif

source/projectiles.h

@@ -14,6 +14,7 @@ class BaseProjectile {
 	int type_;
 	std::vector<SDL_Rect> *obstacles_;
 	int speed_;
+	std::vector<Enemy*> *enemies_;
 	
 public:
 	BaseProjectile()
@@ -25,10 +26,11 @@ public:
 	  size_(0),
 	  type_(0),
 	  obstacles_(NULL),
-	  speed_(4)
+	  speed_(4),
+	  enemies_(NULL)
 	{}
 	
-	BaseProjectile(Player p, int dmg = 0, Point map, int size, int type, std::vector<SDL_Rect> *obstacles, int speed)
+	BaseProjectile(Player p, int dmg = 0, Point map, int size, int type, std::vector<SDL_Rect> *obstacles, int speed, std::vector<Enemy*> *enemies)
 	: direction_(p.getDirection()),
 	  origin_(p.getPosition()),
 	  map_(map),
@@ -37,7 +39,8 @@ public:
 	  size_(size),
 	  type_(type),
 	  obstacles_(obstacles),
-	  speed_(speed)
+	  speed_(speed),
+	  enemies_(enemies)
 	{}
 	
 	bool hitScan();

source/weapons.cpp

@@ -9,11 +9,11 @@ void Weapon::init(int type, int pType, int pSpeed, int rof, int dmg, std::vector
 	projectiles_ = projectiles;
 }
 
-bool Weapon::fire(Player player, Point map, int size, std::vector<SDL_Rect> *obstacles) {
+bool Weapon::fire(Player player, Point map, int size, std::vector<SDL_Rect> *obstacles, std::vector<Enemy*> *enemies) {
 	if((SDL_GetTicks()-rofTimer_)>=(1000/rof_))
 	{
 		rofTimer_=SDL_GetTicks();
-		(*projectiles_).push_back(new BaseProjectile(player, damage_, map, size, projectileType_, obstacles, projectileSpeed_));
+		(*projectiles_).push_back(new BaseProjectile(player, damage_, map, size, projectileType_, obstacles, projectileSpeed_, enemies));
 		return true;
 	}
 	return false;

source/weapons.h

@@ -29,6 +29,6 @@ public:
 	{}
 	
 	void init(int type, int pType, int pSpeed, int rof, int dmg, std::vector<BaseProjectile*> *projectiles);
-	bool fire(Player player, Point map, int size, std::vector<SDL_Rect> *obstacles);
+	bool fire(Player player, Point map, int size, std::vector<SDL_Rect> *obstacles, std::vector<Enemy*> *enemies);
 };
 #endif