Collision Detection

source/baseprojectile.cpp

@@ -0,0 +1,284 @@
+#include "projectiles.h"
+
+bool BaseProjectile::hitScan() {
+	int x=origin_.getX();
+	int y=origin_.getY();
+	int xVel;
+	int yVel;
+	switch(direction_)
+	{
+		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;
+				}
+			}
+			if(yVel==0)
+			{
+				hit_=true;
+			}
+			else
+			{
+				origin_.setX(x+xVel);
+				origin_.setY(y+yVel);
+			}
+			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((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)
+					{
+						if((y+yVel-(size_/2)<(*it).y+(*it).h)&&(y+yVel+(size_/2)>(*it).y))
+						{
+							yVel=((*it).y+(*it).h+(size_/2))-y;
+						}
+					}
+				}
+			}
+			if((yVel==0)||(xVel==0))
+			{
+				hit_=true;
+			}
+			else
+			{
+				origin_.setX(x+xVel);
+				origin_.setY(y+yVel);
+			}
+			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;
+				}
+			}
+			if(xVel==0)
+			{
+				hit_=true;
+			}
+			else
+			{
+				origin_.setX(x+xVel);
+				origin_.setY(y+yVel);
+			}
+			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((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)
+					{
+						if((y+yVel-(size_/2)<(*it).y+(*it).h)&&(y+yVel+(size_/2)>(*it).y))
+						{
+							yVel=((*it).y-(size_/2))-y;
+						}
+					}
+				}
+			}
+			if((yVel==0)||(xVel==0))
+			{
+				hit_=true;
+			}
+			else
+			{
+				origin_.setX(x+xVel);
+				origin_.setY(y+yVel);
+			}
+			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;
+				}
+			}
+			if(yVel==0)
+			{
+				hit_=true;
+			}
+			else
+			{
+				origin_.setX(x+xVel);
+				origin_.setY(y+yVel);
+			}
+			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((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((y+yVel-(size_/2)<(*it).y+(*it).h)&&(y+yVel+(size_/2)>(*it).y))
+						{
+							yVel=((*it).y-(size_/2))-y;
+						}
+					}
+				}
+			}
+			if((yVel==0)||(xVel==0))
+			{
+				hit_=true;
+			}
+			else
+			{
+				origin_.setX(x+xVel);
+				origin_.setY(y+yVel);
+			}
+			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;
+				}
+			}
+			if(xVel==0)
+			{
+				hit_=true;
+			}
+			else
+			{
+				origin_.setX(x+xVel);
+				origin_.setY(y+yVel);
+			}
+			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((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((y+yVel-(size_/2)<(*it).y+(*it).h)&&(y+yVel+(size_/2)>(*it).y))
+						{
+							yVel=((*it).y+(*it).h+(size_/2))-y;
+						}
+					}
+				}
+			}
+			if((yVel==0)||(xVel==0))
+			{
+				hit_=true;
+			}
+			else
+			{
+				origin_.setX(x+xVel);
+				origin_.setY(y+yVel);
+			}
+			break;
+	}
+	return hit_;
+}
+
+Point BaseProjectile::getPosition() const {
+	return origin_;
+}
+
+int BaseProjectile::getSize() const {
+	return size_;
+}
+
+int	BaseProjectile::getType() const {
+	return type_;
+}

source/bullet.cpp

@@ -1,59 +0,0 @@
-#include "projectiles.h"
-#include "entities.h"
-#include "point.h"
-
-bool Bullet::hitScan() {
-	if((origin_.getX()+(size_/2))>=map_.getX()) {
-		hit_=true;
-	}
-	else if((origin_.getX()-(size_/2))<=0) {
-		hit_=true;
-	}
-	else if((origin_.getY()+(size_/2))>=map_.getY()) {
-		hit_=true;
-	}
-	else if((origin_.getY()-(size_/2))<=0) {
-		hit_=true;
-	}
-	else {
-		switch(direction_) {
-			case 0:
-				origin_.setY(origin_.getY()-4);
-				break;
-			case 1:
-				origin_.setX(origin_.getX()+2);
-				origin_.setY(origin_.getY()-2);
-				break;
-			case 2:
-				origin_.setX(origin_.getX()+4);
-				break;
-			case 3:
-				origin_.setX(origin_.getX()+2);
-				origin_.setY(origin_.getY()+2);
-				break;
-			case 4:
-				origin_.setY(origin_.getY()+4);
-				break;
-			case 5:
-				origin_.setX(origin_.getX()-2);
-				origin_.setY(origin_.getY()+2);
-				break;
-			case 6:
-				origin_.setX(origin_.getX()-4);
-				break;
-			case 7:
-				origin_.setX(origin_.getX()-2);
-				origin_.setY(origin_.getY()-2);
-				break;
-		}
-	}
-	return hit_;
-}
-
-Point Bullet::getPosition() const {
-	return origin_;
-}
-
-int Bullet::getSize() const {
-	return size_;
-}

source/entities.h

@@ -3,27 +3,34 @@
 
 #include "point.h"
 
+#include "SDL/SDL.h"
+#include <vector>
+
 class Player {
 	Point origin_;
 	Point map_;
 	int direction_;
 	int size_;
+	int speed_;
+	std::vector<SDL_Rect> *obstacles_;
 	
-	int checkDirection(int dir) const;
+	void checkDirection(int dir, int *xVel, int *yVel) const;
 	
 public:
 	
 	Player()
-	:	origin_(5,5),
+	:	origin_(1,1),
 		map_(640,480),
 		direction_(0),
-		size_(10)
+		size_(2),
+		speed_(0),
+		obstacles_(NULL)
 	{}
 	
 	Point getPosition() const;
 	int getDirection() const;
 	void movePlayer(int dir);
-	void init(Point origin, int size, int dir, Point map);
+	void init(Point origin, int size, int dir, Point map, std::vector<SDL_Rect> *obstacles, int speed);
 };
 
 #endif

source/main.cpp

@@ -27,7 +27,8 @@ Mix_Chunk *bulletSound = NULL;
 SDL_Rect playerSlice[8];
 
 Player playerObject;
-std::vector<Bullet*> bulletObjects;
+std::vector<BaseProjectile*> bulletObjects;
+std::vector<SDL_Rect> obstacles;
 
 bool init()
 {
@@ -141,13 +142,25 @@ bool load_files()
 	Point temp((playerSize/2),(playerSize/2));
 	Point temp2(map->w,map->h);
 	
-	playerObject.init(temp,playerSize,0,temp2);
+	playerObject.init(temp,playerSize,0,temp2,&obstacles,2);
 
 	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;
 }
 
@@ -156,7 +169,7 @@ void cleanup()
 	SDL_FreeSurface(map);
 	SDL_FreeSurface(player);
 	
-	for(std::vector<Bullet*>::iterator it=bulletObjects.begin();it!=bulletObjects.end();)
+	for(std::vector<BaseProjectile*>::iterator it=bulletObjects.begin();it!=bulletObjects.end();)
 	{
 		delete *it;
 		bulletObjects.erase(it);
@@ -255,7 +268,7 @@ int main(int argc, char* args[])
 			{
 				shootTimer=SDL_GetTicks();
 				Point temp(map->w,map->h);
-				bulletObjects.push_back(new Bullet(playerObject,0,temp,bullet->w));
+				bulletObjects.push_back(new BaseProjectile(playerObject,0,temp,bullet->w,0,&obstacles,4));
 				if(Mix_PlayChannel(-1,bulletSound,0)==-1)
 				{
 					return 1;
@@ -271,7 +284,7 @@ int main(int argc, char* args[])
 		
 		apply_surface(((SCREEN_WIDTH/2)-((playerObject.getPosition()).getX())),((SCREEN_HEIGHT/2)-((playerObject.getPosition()).getY())),map,screen);
 		
-		for(std::vector<Bullet*>::iterator it=bulletObjects.begin();it!=bulletObjects.end();it++)
+		for(std::vector<BaseProjectile*>::iterator it=bulletObjects.begin();it!=bulletObjects.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)

source/mainfunctions.h

@@ -1,10 +1,10 @@
-#include <string>
+#ifndef MAINFUNCTIONS_H_
+#define MAINFUNCTIONS_H_
 
 #include "SDL/SDL.h"
 #include "SDL/SDL_image.h"
 
-#ifndef MAINFUNCTIONS_H_
+#include <string>
-#define MAINFUNCTIONS_H_
 
 SDL_Surface *load_image(std::string filename, bool alpha=false);
 void apply_surface(int x, int y, SDL_Surface* source, SDL_Surface* destination, SDL_Rect* clip = NULL);

source/player.cpp

@@ -1,188 +1,229 @@
-#include "point.h"
 #include "entities.h"
 
-int Player::checkDirection(int dir) const {
+void Player::checkDirection(int dir, int *xVel, int *yVel) const
+{
 	int x=origin_.getX();
 	int y=origin_.getY();
-	switch(dir) {
+	switch(dir)
+	{
 		case 0:
-			if(y==(size_/2)) {
+			*xVel=0;
-				return 12;
+			*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;
 				}
-			else if(y==(size_/2)+1) {
-				return 8;
 			}
-			else return 0;
 			break;
 		case 1:
-			if((y==(size_/2))&&(x!=(map_.getX()-(size_/2)))) {
+			*xVel=speed_/2;
-				return 9;
+			*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((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)
+					{
+						if((y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
+						{
+							*yVel=((*it).y+(*it).h+(size_/2))-y;
+						}
 					}
-			else if((y==(size_/2))&&(x==(map_.getX()-(size_/2)))) {
-				return 13;
 				}
-			else if((y!=(size_/2))&&(x==(map_.getX()-(size_/2)))) {
-				return 8;
 			}
-			else return 1;
 			break;
 		case 2:
-			if(x==(map_.getX()-(size_/2))) {
+			*xVel=speed_;
-				return 14;
+			*yVel=0;
+			if((x+*xVel)>(map_.getX()-(size_/2)))
+			{
+				*xVel=(map_.getX()-(size_/2))-x;
 			}
-			else if(x==(map_.getX()-((size_/2)+1))) {
+			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
-				return 9;
+			{
+				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;
 				}
-			else {
-				return 2;
 			}
 			break;
 		case 3:
-			if((y==(map_.getY()-(size_/2)))&&(x!=(map_.getX()-(size_/2)))) {
+			*xVel=speed_/2;
-				return 9;
+			*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((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)
+					{
+						if((y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
+						{
+							*yVel=((*it).y-(size_/2))-y;
+						}
 					}
-			else if((y==(map_.getY()-(size_/2)))&&(x==(map_.getX()-(size_/2)))) {
-				return 15;
 				}
-			else if((y!=(map_.getY()-(size_/2)))&&(x==(map_.getX()-(size_/2)))) {
-				return 10;
 			}
-			else return 3;
 			break;
 		case 4:
-			if(y==(map_.getY()-(size_/2))) {
+			*xVel=0;
-				return 16;
+			*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;
 				}
-			else if(y==(map_.getX()-((size_/2)+1))) {
-				return 10;
 			}
-			else return 4;
 			break;
 		case 5:
-			if((y==(map_.getY()-(size_/2)))&&(x!=(size_/2))) {
+			*xVel=-speed_/2;
-				return 11;
+			*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((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((y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
+						{
+							*yVel=((*it).y-(size_/2))-y;
+						}
 					}
-			else if((y==(map_.getY()-(size_/2)))&&(x==(size_/2))) {
-				return 17;
 				}
-			else if((y!=(map_.getY()-(size_/2)))&&(x==(size_/2))) {
-				return 10;
 			}
-			else return 5;
 			break;
 		case 6:
-			if(x==(size_/2)) {
+			*xVel=-speed_;
-				return 18;
+			*yVel=0;
+			if((x+*xVel)<(size_/2))
+			{
+				*xVel=(size_/2)-x;
 			}
-			else if(x==((size_/2)+1)) {
+			for(std::vector<SDL_Rect>::iterator it=(*obstacles_).begin();it!=(*obstacles_).end();it++)
-				return 11;
+			{
+				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;
 				}
-			else {
-				return 6;
 			}
 			break;
 		case 7:
-			if((y==(size_/2))&&(x!=(size_/2))) {
+			*xVel=-speed_/2;
-				return 11;
+			*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((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((y+*yVel-(size_/2)<(*it).y+(*it).h)&&(y+*yVel+(size_/2)>(*it).y))
+						{
+							*yVel=((*it).y+(*it).h+(size_/2))-y;
+						}
 					}
-			else if((y==(size_/2))&&(x==(size_/2))) {
-				return 19;
 				}
-			else if((y!=(size_/2))&&(x==(size_/2))) {
-				return 8;
 			}
-			else return 7;
 			break;
 	}
 }
-
+Point Player::getPosition() const
-Point Player::getPosition() const {
+{
 	return origin_;
 }
 
-void Player::movePlayer(int dir) {
+void Player::movePlayer(int dir)
-	direction_=checkDirection(dir);
+{
-	switch(direction_) {
+	int xVel;
-		case 0:
+	int yVel;
-			origin_.setY(origin_.getY()-2);
+	direction_=dir;
-			break;
+	checkDirection(direction_,&xVel,&yVel);
-		case 1:
+	origin_.setX(origin_.getX()+xVel);
-			origin_.setX(origin_.getX()+1);
+	origin_.setY(origin_.getY()+yVel);
-			origin_.setY(origin_.getY()-1);
-			break;
-		case 2:
-			origin_.setX(origin_.getX()+2);
-			break;
-		case 3:
-			origin_.setX(origin_.getX()+1);
-			origin_.setY(origin_.getY()+1);
-			break;
-		case 4:
-			origin_.setY(origin_.getY()+2);
-			break;
-		case 5:
-			origin_.setX(origin_.getX()-1);
-			origin_.setY(origin_.getY()+1);
-			break;
-		case 6:
-			origin_.setX(origin_.getX()-2);
-			break;
-		case 7:
-			origin_.setX(origin_.getX()-1);
-			origin_.setY(origin_.getY()-1);
-			break;
-		case 8:
-			direction_=0;
-			origin_.setY(origin_.getY()-1);
-			break;
-		case 9:
-			direction_=2;
-			origin_.setX(origin_.getX()+1);
-			break;
-		case 10:
-			direction_=4;
-			origin_.setY(origin_.getY()+1);
-			break;
-		case 11:
-			direction_=6;
-			origin_.setX(origin_.getX()-1);
-			break;
-		case 12:
-			direction_=0;
-			break;
-		case 13:
-			direction_=1;
-			break;
-		case 14:
-			direction_=2;
-			break;
-		case 15:
-			direction_=3;
-			break;
-		case 16:
-			direction_=4;
-			break;
-		case 17:
-			direction_=5;
-			break;
-		case 18:
-			direction_=6;
-			break;
-		case 19:
-			direction_=7;
-			break;
-	}
 }
 	
-int Player::getDirection() const {
+int Player::getDirection() const
+{
 	return direction_;
 }
 
-void Player::init(Point origin, int size, int dir, Point map) {
+void Player::init(Point origin, int size, int dir, Point map, std::vector<SDL_Rect> *obstacles, int speed)
+{
 	origin_.setX(origin.getX());
 	origin_.setY(origin.getY());
 	size_=size;
 	direction_=dir;
 	map_.setX(map.getX());
 	map_.setY(map.getY());
+	obstacles_=obstacles;
+	speed_=speed;
 }

source/point.cpp

@@ -1,14 +1,18 @@
 #include "point.h"
 
-int Point::getY() const {
+int Point::getY() const
+{
 	return y_;
 }
-int Point::getX() const {
+int Point::getX() const
+{
 	return x_;
 }
-void Point::setX(int x) {
+void Point::setX(int x)
+{
 	x_=x;
 }
-void Point::setY(int y) {
+void Point::setY(int y)
+{
 	y_=y;
 }

source/point.h

@@ -1,7 +1,8 @@
 #ifndef POINT_H_
 #define POINT_H_
 
-class Point {
+class Point
+{
 	int x_;
 	int y_;
 	

source/projectiles.h

@@ -1,37 +1,48 @@
 #ifndef PROJECTILES_H_
 #define PROJECTILES_H_
+
 #include "point.h"
 #include "entities.h"
 
-class Bullet {
+class BaseProjectile {
 	int direction_;
 	Point origin_;
 	Point map_;
 	bool hit_;
 	int damage_;
 	int size_;
+	int type_;
+	std::vector<SDL_Rect> *obstacles_;
+	int speed_;
 	
 public:
-	Bullet()
+	BaseProjectile()
 	: direction_(0),
 	  origin_(0,0),
 	  map_(640,480),
 	  hit_(false),
 	  damage_(0),
-	  size_(0)
+	  size_(0),
+	  type_(0),
+	  obstacles_(NULL),
+	  speed_(4)
 	{}
 	
-	Bullet(Player p, int dmg = 0, Point map, int size)
+	BaseProjectile(Player p, int dmg = 0, Point map, int size, int type, std::vector<SDL_Rect> *obstacles, int speed)
 	: direction_(p.getDirection()),
 	  origin_(p.getPosition()),
 	  map_(map),
 	  hit_(false),
 	  damage_(dmg),
-	  size_(size)
+	  size_(size),
+	  type_(type),
+	  obstacles_(obstacles),
+	  speed_(speed)
 	{}
 	
 	bool hitScan();
 	Point getPosition() const;
 	int getSize() const;
+	int getType() const;
 };
 #endif