missiles can now be attacked

Assets/Scripts/GameObjects/Projectiles/projectileData.lua

@@ -51,6 +51,7 @@ projectiles = {
 	},
 	{
 		projectileClass = ProjectileClass.CRUISE_MISSILE,
+		health = 75,
 		size = {x = 6, y = 13.5, z = 2.54},
 		speed = .5,
 		rotAngle = .1,
@@ -64,6 +65,7 @@ projectiles = {
 	},
 	{
 		projectileClass = ProjectileClass.MISSILE,
+		health = 25,
 		size = {x = 3, y = 7., z = 1.27},
 		speed = .5,
 		rotAngle = .1,

cruiseMissile.cpp

@@ -18,6 +18,8 @@ namespace battleship{
 		targetPoint(tp), 
 		flightStage(FlightStage::ASCENT)
 	{
+		Destructable::initProperties();
+
 		Vector3 unitDir = unit->getDirVec(); 
 		Vector3 leftDir = unit->getLeftVec();
 		Vector3 targDir = (Vector3(targetPoint.x, pos.y, targetPoint.z) - pos).norm();

engineer.cpp

@@ -52,7 +52,7 @@ namespace battleship{
 
 	//TODO change unit colors after faction change
 	void Engineer::hack(Order order){
-		Unit *targUnit = order.targets[0].unit;
+		Unit *targUnit = (Unit*)order.targets[0].unit;
 		bool withinRange = (targUnit->getPos().getDistanceFrom(pos) < hackRange);
 		int hackRate = int(generateView()["units"][id + 1]["hackTime"]) / 100;
 		bool canHack = (getTime() - lastHackTime > hackRate);

freezer.cpp

@@ -9,7 +9,7 @@ namespace battleship{
 	void Freezer::attack(Order order){
 		Vehicle::attack(order);
 
-		Unit *target = order.targets[0].unit;
+		Unit *target = (Unit*)order.targets[0].unit;
 
 		if(target && target->getFreezeStatus() == 100)
 			removeOrder(0);

missile.cpp

@@ -7,7 +7,10 @@ namespace battleship{
 	Missile::Missile(Unit *un, int id, Vector3 tp, Vector3 pos, Quaternion rot) : 
 		Projectile(un, id, pos, rot),
 		Destructable(un->getPlayer(), id, GameObject::Type::PROJECTILE, pos, rot), 
-		targetPos(tp){}
+		targetPos(tp)
+	{
+		Destructable::initProperties();
+	}
 
 	void Missile::update(){
 		Vector3 targDir = (targetPos - Projectile::pos).norm();

player.cpp

@@ -255,4 +255,30 @@ namespace battleship{
 				break;
 			}
 	}
+
+	vector<Projectile*> Player::getDestructableProjectiles(){
+		vector<Projectile*> destProj;
+
+		for(Projectile *proj : projectiles)
+			switch(proj->getProjectileClass()){
+				case ProjectileClass::CRUISE_MISSILE:
+				case ProjectileClass::MISSILE:
+					destProj.push_back(proj);
+					break;
+			}
+
+		return destProj;
+	}
+
+	vector<Destructable*> Player::getDestructables(){
+		vector<Projectile*> destProj = getDestructableProjectiles();
+		vector<Destructable*> destructables;
+
+		for(Projectile *p : destProj)
+			destructables.push_back((Destructable*)p);
+
+		destructables.insert(destructables.end(), units.begin(), units.end());
+
+		return destructables;
+	}
 }

player.h

@@ -10,6 +10,7 @@
 
 namespace battleship{
 	class ResourceDeposit;
+	class Destructable;
 	class Projectile;
 	class Unit;
 	struct TradeOffer;
@@ -37,6 +38,8 @@ namespace battleship{
 		void addTradeOffer(Player*, TradeOffer*);
 		std::vector<TradeOffer*> getTradeOffers(Player*);
 		void deselectUnit(Unit*);
+        std::vector<Projectile*> getDestructableProjectiles();
+		std::vector<Destructable*> getDestructables();
 		inline int getResource(ResourceType rt){return resources[(int)rt];}
 		inline void updateResource(ResourceType rt, int amount, bool add){resources[(int)rt] = (add ? resources[(int)rt] + amount : amount);}
 		inline Trader* getTrader(){return trader;}

projectile.cpp

@@ -54,6 +54,8 @@ namespace battleship{
 		vector<int> currTechs = player->getTechnologies();
 
 		sol::table projTable = generateView()[GameObject::getGameObjTableName()][id + 1];
+		projClass = (ProjectileClass)projTable["projectileClass"];
+
         rayLength = projTable["rayLength"];
         directHitDamage = projTable["directHitDamage"]; directHitDamage += game->calcAbilFromTech(Ability::Type::DIRECT_HIT_DAMAGE, currTechs, (int)GameObject::type, id);
 

projectile.h

@@ -21,6 +21,7 @@ namespace battleship {
         virtual ~Projectile();
         virtual void update();
         virtual void debug();
+		inline ProjectileClass getProjectileClass(){return projClass;}
 	private:
 		void initProperties();
 		void detonate(Unit *u = nullptr);
@@ -31,6 +32,7 @@ namespace battleship {
 		void checkCollision();
 
 		vb01::Vector3 initPos;
+		ProjectileClass projClass; 
 		Unit *unit = nullptr;
 		FxManager::Fx *explosionFx = nullptr;
         float speed, rayLength, explosionRadius, rotAngle;

unit.cpp

@@ -235,22 +235,28 @@ namespace battleship{
         }
 	}
 
-	void Unit::targetUnitsAutomatically(){
+	//TODO clean up method code
+	void Unit::autoAttackTargets(){
+		if(!orders.empty()) return;
+
 		vector<Player*> players = Game::getSingleton()->getPlayers();
-		vector<Unit*> units;
+		vector<Destructable*> targets;
 
 		for(Player *pl : players)
 			if(!(pl == player || pl->getTeam() == player->getTeam())){
 				vector<Unit*> un = pl->getUnits();
-				units.insert(units.end(), un.begin(), un.end());
+				targets.insert(targets.end(), un.begin(), un.end());
+				vector<Projectile*> dp = pl->getDestructableProjectiles();
+
+				for(Projectile *p : dp)
+					targets.push_back((Destructable*)p);
 			}
 
-		if(orders.empty())
-			for(Unit *unit : units)
-				if(unit->getPos().getDistanceFrom(pos) < lineOfSight){
-					receiveOrder(Order(Order::TYPE::ATTACK, vector<Order::Target>{Order::Target(unit)}, Vector3::VEC_ZERO, -1, false), false);
-					break;
-				}
+		for(Destructable *targ : targets)
+			if(targ->getPos().getDistanceFrom(pos) < lineOfSight){
+				receiveOrder(Order(Order::TYPE::ATTACK, vector<Order::Target>{Order::Target(targ)}, Vector3::VEC_ZERO, -1, false), false);
+				break;
+			}
 	}
 
     void Unit::update() {
@@ -262,7 +268,7 @@ namespace battleship{
 		if(freezeStatus >= 100) condition = Condition::FROZEN;
 
 		if(state != State::HOLD_FIRE)
-			targetUnitsAutomatically();
+			autoAttackTargets();
 
 		ActiveGameState *activeState = (ActiveGameState*)GameManager::getSingleton()->getStateManager()->getAppStateByType(AppStateType::ACTIVE_STATE);
 		Player *mainPlayer = (activeState ? activeState->getPlayer() : nullptr);
@@ -350,16 +356,16 @@ namespace battleship{
 	}
 
 	void Unit::attack(Order order){
-		vector<Unit*> units;
+		vector<Destructable*> targets;
 
 		for(Player *pl : Game::getSingleton()->getPlayers()){
-			vector<Unit*> un = pl->getUnits();
-			units.insert(units.end(), un.begin(), un.end());
+			vector<Destructable*> targs = pl->getDestructables();
+			targets.insert(targets.end(), targs.begin(), targs.end());
 		}
 
 		for(Order::Target &target : orders[0].targets)
 			if(target.unit){
-				if(find(units.begin(), units.end(), target.unit) != units.end())
+				if(find(targets.begin(), targets.end(), target.unit) != targets.end())
 					break;
 
 				removeOrder(0);

unit.h

@@ -40,11 +40,11 @@ namespace battleship{
     struct Order {
         enum class TYPE {ATTACK, BUILD, MOVE, GARRISON, EJECT, PATROL, LAUNCH, SUPPLY, LOAD, UNLOAD, HACK};
 			struct Target{
-				Unit *unit = nullptr;
+				Destructable *unit = nullptr;
 				vb01::Vector3 pos;
 
 				Target(){}
-				Target(Unit *u, vb01::Vector3 p = vb01::Vector3::VEC_ZERO) : unit(u), pos(p){}
+				Target(Destructable *u, vb01::Vector3 p = vb01::Vector3::VEC_ZERO) : unit(u), pos(p){}
 			};
 
         TYPE type;
@@ -175,7 +175,7 @@ namespace battleship{
 		virtual void startCurrentOrder(){currOrderStarted = true;}
 		virtual bool validateLaunchOrder(){return !getWeaponsByOrder(Order::TYPE::LAUNCH).empty();}
 		virtual bool validateGarrisonOrder(Order){return false;}
-		virtual void targetUnitsAutomatically();
+		virtual void autoAttackTargets();
 		virtual void reinit();
 		virtual void initProperties();
 		virtual void destroySound();

vehicle.cpp

@@ -57,7 +57,7 @@ namespace battleship{
 	}
 
 	bool Vehicle::validateGarrisonOrder(Order order){
-		Unit *targUnit = order.targets[0].unit;
+		Unit *targUnit = (Unit*)order.targets[0].unit;
 
 		for(GarrisonSlot slot : targUnit->getGarrisonSlots())
 			if(!slot.vehicle && slot.category >= garrisonCategory)
@@ -259,7 +259,7 @@ namespace battleship{
 	}
 
 	void Vehicle::enterGarrisonable(){
-		Unit *targUnit = orders[0].targets[0].unit; 
+		Unit *targUnit = (Unit*)orders[0].targets[0].unit; 
 		targUnit->updateGarrison(this, true);
 
 		removeAllPathpoints();
@@ -282,7 +282,7 @@ namespace battleship{
 	}
 
 	void Vehicle::garrison(Order order){
-		Unit *targUnit = order.targets[0].unit;
+		Unit *targUnit = (Unit*)order.targets[0].unit;
 		float distToGarrisonable = pos.getDistanceFrom(targUnit->getPos()), garrisonDist = Map::getSingleton()->getCellSize().x;
 
 		if(distToGarrisonable > garrisonDist)
@@ -426,7 +426,7 @@ namespace battleship{
 	void Vehicle::build(Order order){
 		if(pathPoints.empty()){
 			if(!order.targets[0].unit)
-				player->addUnit(order.targets[0].unit);
+				player->addUnit((Unit*)order.targets[0].unit);
 			else {
 				Structure *structure = (Structure*)order.targets[0].unit;
 				sol::table targTable = generateView()["units"][structure->getId()];

weapon.cpp

@@ -106,7 +106,7 @@ namespace battleship{
 
 		int numOrders = unit->getNumOrders();
 		int ordTp = (numOrders > 0 ? (int)unit->getOrder(0).type : -1);
-		Unit *targUnit = (ordTp != -1 ? unit->getOrder(0).targets[0].unit : nullptr);
+		Destructable *targUnit = (ordTp != -1 ? unit->getOrder(0).targets[0].unit : nullptr);
 
 		if(ordTp == (int)orderType){
 			Vector3 targPos = (targUnit ? targUnit->getPos() : unit->getOrder(0).targets[0].pos);
@@ -164,17 +164,19 @@ namespace battleship{
 		}
 	}
 
-	void Weapon::updateTargetUnit(Unit *targetUnit){
-		targetUnit->takeDamage(damage);
-		unit->updateGameStats(targetUnit);
+	void Weapon::updateTarget(Destructable *target){
+		target->takeDamage(damage);
+
+		if(target->getType() == GameObject::Type::UNIT)
+			unit->updateGameStats((Unit*)target);
 	}
 
 	//TODO replace the 'laser' flag literal 
 	void Weapon::fire(Order order){
 		if(!canFire()) return;
 
-		Unit *targetUnit = order.targets[0].unit;
-		Vector3 targPos = (targetUnit ? targetUnit->getPos() : order.targets[0].pos);
+		Destructable *target = order.targets[0].unit;
+		Vector3 targPos = (target ? target->getPos() : order.targets[0].pos);
 
 		if(fireFx) useFx(fireFx, targPos, true);
 
@@ -183,8 +185,7 @@ namespace battleship{
 			FxManager *fxManager = FxManager::getSingleton();
 			string fxKey = "unitHitFx";
 
-			if(targetUnit)
-				updateTargetUnit(targetUnit);
+			if(target) updateTarget(target);
 			else{
 				Map *map = Map::getSingleton();
 				Map::Cell::Type cellType = map->getCells()[map->getCellId(targPos)].type;

weapon.h

@@ -15,6 +15,7 @@ namespace vb01{
 
 namespace battleship{
 	class FxManager;
+	class Destructable;
 
 	class Weapon{
 		public:
@@ -53,7 +54,7 @@ namespace battleship{
 		protected:
 			int rateOfFire;
 
-			virtual void updateTargetUnit(Unit*);
+			virtual void updateTarget(Destructable*);
 	};
 
 	class CryoGun : public Weapon{