implemented garrisoning

activeGameState.cpp

@@ -232,6 +232,8 @@ namespace battleship{
 				color = Vector3::VEC_I;
       	        break;
       	    case Order::TYPE::PATROL:
+      	    case Order::TYPE::GARRISON:
+      	    case Order::TYPE::EJECT:
 				color = Vector3::VEC_K;
 				break;
       	    case Order::TYPE::BUILD:

unit.cpp

@@ -157,7 +157,7 @@ namespace battleship{
 		displayUnitStats(hpForegroundNode, hpBackgroundNode, health, maxHealth);
 
 		for(GarrisonSlot &slot : garrisonSlots)
-			displayUnitStats(slot.foreground, slot.background, (int)(slot.vehicle ? 1 : 0), (int)1, slot.offset);
+			displayUnitStats(slot.foreground, slot.background, (int)((bool)slot.vehicle), (int)true, slot.offset);
 
         if (health <= 0) 
 			blowUp();
@@ -204,11 +204,12 @@ namespace battleship{
 		if(selected){
 			Vector3 offset3d = Vector3(offset.x, offset.y, 0);
 
-			Quad *fgQuad = (Quad*)foreground->getMesh(0);
-			Vector3 size = fgQuad->getSize();
+			Quad *bgQuad = (Quad*)background->getMesh(0);
+			Vector3 size = bgQuad->getSize();
 			float shiftedX = screenPos.x - 0.5 * size.x;
 			background->setPosition(Vector3(shiftedX, screenPos.y, .1) + offset3d);
 
+			Quad *fgQuad = (Quad*)foreground->getMesh(0);
 			fgQuad->setSize(Vector3((float)currVal / maxVal * size.x, size.y, 0));
 			fgQuad->updateVerts(fgQuad->getMeshBase());
 			foreground->setPosition(Vector3(shiftedX, screenPos.y, 0) + offset3d);
@@ -229,6 +230,9 @@ namespace battleship{
                 case Order::TYPE::MOVE:
                     move(order);
                     break;
+				case Order::TYPE::GARRISON:
+					garrison(order);
+					break;
                 case Order::TYPE::PATROL:
                     patrol(order);
                     break;
@@ -254,6 +258,14 @@ namespace battleship{
             removeOrder(orders.size() - 1);
     }
 
+	void Unit::updateGarrison(Vehicle *garrison){
+		for(GarrisonSlot &slot : garrisonSlots)
+			if(!slot.vehicle){
+				slot.vehicle = garrison;
+				break;
+			}
+	}
+
 	void Unit::addOrder(Order order){
 		orders.push_back(order);
 	}

unit.h

@@ -28,7 +28,7 @@ namespace battleship{
 	class Vehicle;
     
     struct Order {
-        enum class TYPE {ATTACK, BUILD, MOVE, PATROL, LAUNCH};
+        enum class TYPE {ATTACK, BUILD, MOVE, GARRISON, EJECT, PATROL, LAUNCH};
 			struct Target{
 				Unit *unit = nullptr;
 				vb01::Vector3 pos;
@@ -65,7 +65,8 @@ namespace battleship{
         virtual void update();
         virtual void blowUp();
         virtual void halt();
-        void toggleSelection(bool);
+		void updateGarrison(Vehicle*);
+        virtual void toggleSelection(bool);
         void setOrder(Order);
         std::vector<Projectile*> getProjectiles();
         virtual void addOrder(Order);
@@ -108,6 +109,8 @@ namespace battleship{
 		virtual void initUnitStats();
         virtual void executeOrders();
         virtual void attack(Order){}
+        virtual void garrison(Order){}
+        virtual void eject(Order){}
         virtual void build(Order){}
         virtual void move(Order){}
         virtual void patrol(Order){}

vehicle.cpp

@@ -10,7 +10,6 @@
 
 #include "vehicle.h"
 #include "pathfinder.h"
-#include "garrisonable.h"
 #include "map.h"
 
 using namespace gameBase;
@@ -34,6 +33,12 @@ namespace battleship{
 		Unit::~Unit();
 	}
 
+	void Vehicle::update(){
+		Unit::update();
+
+		model->setVisible(!garrisoned);
+	}
+
 	void Vehicle::halt(){
 		Unit::halt();
 		removeAllPathpoints();
@@ -150,7 +155,28 @@ namespace battleship{
 			removeOrder(0);
     }
 
-	void Vehicle::garrison(Garrisonable *garrisonable){
+	void Vehicle::garrison(Order order){
+		float garrisonDist = 1.25 * Map::getSingleton()->getCellSize().x;
+		Unit *targUnit = order.targets[0].unit;
+		float distToGarrisonable = pos.getDistanceFrom(targUnit->getPos());
+
+		if(distToGarrisonable > garrisonDist){
+			if(!pursuingTarget){
+				preparePathpoints(order);
+				pursuingTarget = true;
+			}
+
+			navigate(order, garrisonDist);
+		}
+		else{
+			targUnit->updateGarrison(this);
+
+			removeAllPathpoints();
+			removeOrder(0);
+
+			garrisoned = true;
+			pursuingTarget = false;
+		}
 	}
 
 	//TODO add hover unit type
@@ -242,4 +268,9 @@ namespace battleship{
 		if(targetUnit)
 			targetUnit->takeDamage(1);
 	}
+
+	void Vehicle::toggleSelection(bool selection){
+		if(!garrisoned)
+			Unit::toggleSelection(selection);
+	}
 }

vehicle.h

@@ -14,8 +14,8 @@ namespace battleship{
 		public:
 			Vehicle(Player*, int, vb01::Vector3, vb01::Quaternion);
 			~Vehicle();
+			virtual void update();
         	void move(Order);
-			void garrison(Garrisonable*);
 			bool isGarrisoned(){return garrisoned;}
 		private:
 			bool pursuingTarget = false, garrisoned = false;
@@ -32,12 +32,14 @@ namespace battleship{
 			void preparePathpoints(Order);
 			void removePathpoint(int = 0);
 			void removeAllPathpoints();
+			void toggleSelection(bool);
 		protected:
 			std::vector<vb01::Vector3> pathPoints;
 
         	void navigate(Order, float = 0.);
 			void alignToSurface();
 			void attack(Order);
+			void garrison(Order);
 			virtual void initProperties();
 			virtual void fire();
 	};