cargo ships move between extractor and refinery

activeGameState.cpp

@@ -355,7 +355,10 @@ namespace battleship{
 								if(canGarrison)
 									issueOrder(Order::TYPE::GARRISON, vector<Order::Target>{Order::Target((Unit*)gameObjHoveredOn, gameObjHoveredOn->getPos())}, shiftPressed);
 							}
-							else if(gameObjHoveredOn && (controlPressed || !ownGameObj))
+							else if(gameObjHoveredOn && ownGameObj && ((Unit*)gameObjHoveredOn)->getUnitClass() == UnitClass::EXTRACTOR){
+								issueOrder(Order::TYPE::SUPPLY, vector<Order::Target>{Order::Target((Unit*)gameObjHoveredOn)}, shiftPressed);
+							}
+							else if(gameObjHoveredOn && (controlPressed || (!ownGameObj && gameObjHoveredOn->getType() == GameObject::Type::UNIT)))
 								issueOrder(Order::TYPE::ATTACK, vector<Order::Target>{Order::Target((Unit*)gameObjHoveredOn, gameObjHoveredOn->getPos())}, shiftPressed);
 							else if(controlPressed && !gameObjHoveredOn){
                     			castRayToTerrain();

extractor.h

@@ -3,11 +3,15 @@
 
 #include "structure.h"
 
+#include <util.h>
+
 namespace battleship{
 	class Extractor : public Structure{
 		public:
 			Extractor(Player*, int, vb01::Vector3, vb01::Quaternion, int);
 		private:
+			int drawRate;
+			vb01::s64 lastDrawTime = 0;
 	};
 }
 

player.cpp

@@ -44,6 +44,7 @@ namespace battleship{
 				color = Vector3::VEC_K;
 				break;
       	    case Order::TYPE::BUILD:
+      	    case Order::TYPE::SUPPLY:
 				color = Vector3(1, 1, 0);
       	        break;
       	}

resourceRover.cpp

@@ -1,8 +1,62 @@
 #include "resourceRover.h"
+#include "map.h"
+#include "player.h"
 
 namespace battleship{
 	using namespace std;
 	using namespace vb01;
 
-	ResourceRover::ResourceRover(Player *player, int id, Vector3 pos, Quaternion rot) : Vehicle(player, id, pos, rot){}
+	ResourceRover::ResourceRover(Player *player, int id, Vector3 pos, Quaternion rot) : 
+		Vehicle(player, id, pos, rot), 
+		capacity(300),
+		loadRate(100) {}
+
+	void ResourceRover::supply(Order order){
+		float minDist = .6 * Map::getSingleton()->getCellSize().x;
+
+		if(!pathPoints.empty())
+			navigate(minDist);
+		else{
+			vector<Unit*> units = player->getUnits(), extractors, refineries;
+
+			for(Unit *unit : units){
+				if(unit->getUnitClass() == UnitClass::EXTRACTOR)
+					extractors.push_back(unit);
+				else if(unit->getUnitClass() == UnitClass::REFINERY)
+					refineries.push_back(unit);
+			}
+
+			nearestExtractor = getClosestUnit(extractors);
+			nearestRefinery = getClosestUnit(refineries);
+
+			if(nearestExtractor->getPos().getDistanceFrom(pos) <= minDist){
+				if(canLoad()){
+					load++;
+					lastLoadTime = getTime();
+				}
+				else if(!canLoad() && nearestRefinery)
+					preparePathpoints(order, nearestRefinery->getPos());
+			}
+			else if(nearestRefinery->getPos().getDistanceFrom(pos) <= minDist){
+				if(canUnload()){
+					load--;
+					lastLoadTime = getTime();
+				}
+				else if(!canUnload() && nearestExtractor)
+					preparePathpoints(order, nearestExtractor->getPos());
+			}
+		}
+	}
+
+	Unit* ResourceRover::getClosestUnit(vector<Unit*> units){
+		if(units.empty()) return nullptr;
+
+		int minDistId = 0;
+
+		for(int i = 0; i < units.size(); i++)
+			if(units[minDistId]->getPos().getDistanceFrom(pos) > units[i]->getPos().getDistanceFrom(pos))
+				minDistId = i;
+
+		return units[minDistId];
+	}
 }

resourceRover.h

@@ -3,11 +3,21 @@
 
 #include "vehicle.h"
 
+#include <util.h>
+
 namespace battleship{
 	class ResourceRover : public Vehicle{
 		public:
 			ResourceRover(Player*, int, vb01::Vector3, vb01::Quaternion);
 		private:
+			void supply(Order);
+			Unit* getClosestUnit(std::vector<Unit*>);
+			inline bool canLoad(){return vb01::getTime() - lastLoadTime > loadRate && load < capacity;}
+			inline bool canUnload(){return vb01::getTime() - lastLoadTime > loadRate && load > 0;}
+
+			vb01::s64 lastLoadTime = 0;
+			int load = 0, capacity, loadRate;
+			Unit *nearestExtractor = nullptr, *nearestRefinery = nullptr;
 	};
 }
 

unit.cpp

@@ -345,6 +345,9 @@ namespace battleship{
                 case Order::TYPE::LAUNCH:
                     launch(order);
                     break;
+                case Order::TYPE::SUPPLY:
+                    supply(order);
+                    break;
                 default:
                     break;
             }

unit.h

@@ -35,7 +35,7 @@ namespace battleship{
 	class Engineer;
     
     struct Order {
-        enum class TYPE {ATTACK, BUILD, MOVE, GARRISON, EJECT, PATROL, LAUNCH};
+        enum class TYPE {ATTACK, BUILD, MOVE, GARRISON, EJECT, PATROL, LAUNCH, SUPPLY};
 			struct Target{
 				Unit *unit = nullptr;
 				vb01::Vector3 pos;
@@ -184,6 +184,7 @@ namespace battleship{
         virtual void move(Order){}
         virtual void patrol(Order){}
         virtual void launch(Order);
+		virtual void supply(Order){}
 		float calculateRotation(vb01::Vector3, float, float);
 		void removeBar(vb01::Node*);
 		vb01::Node* createBar(vb01::Vector2, vb01::Vector2, vb01::Vector4);

vehicle.h

@@ -33,7 +33,6 @@ namespace battleship{
 			void addOrder(Order);
 			void advance(float, MoveDir = MoveDir::FORW);
 			void addPathpoint(vb01::Vector3);
-			void preparePathpoints(Order&, vb01::Vector3);
 			void removePathpoint(int = 0);
 			void removeAllPathpoints();
 			void select();
@@ -41,6 +40,7 @@ namespace battleship{
 			std::vector<vb01::Vector3> pathPoints;
 
         	void navigate(float = 0.);
+			void preparePathpoints(Order&, vb01::Vector3);
 			void alignToSurface();
 			void attack(Order);
 			void garrison(Order);