Merge pull request #86 from devZoGok/ft-83-cpu-ai

Ft 83 cpu ai

Assets/Scripts/Core/player.lua

@@ -1,106 +1,243 @@
-Player.sizeTaskForce = 5
-Player.trainingStarted = false 
-Player.taskForceSent = false 
-Player.buildOrdered = false 
+Player.numStartEngis = 3
+Player.dirToCenter = nil 
+Player.numDefWarMechs = 5
+Player.numTaskForceWarMechs = 5
+Player.numTaskForceTanks = 5
+Player.numTaskForceArtillery = 5
+Player.givenOrder = false
 
-function Player:sendTaskForce()
-	if self.taskForceSent then
+--TODO use enum-like values instead of literals for order types
+--TODO simplify building construction
+function Player:buildFort()
+	if #self:getUnitsByClass(UnitClass.FORT, 1) > 0 then
 		return true
 	end
 
-	self:deselectUnits()
-	taskForce = {}
+	engis = self:getUnitsByClass(UnitClass.ENGINEER, 1)
+	if #engis == 0 then return false end
 
-	for i = 1, self:getNumUnits() do
-		if self:getUnit(i - 1):getUnitClass() == UnitClass.TANK then
-			taskForce[#taskForce + 1] = self:getUnit(i - 1)
+	engineer = engis[1]
+	self:deselectUnits()
+	self:selectUnits({engineer})
+
+	fort = GameObjectFactory.createUnit(self, UnitId.FORT, self:getSpawnPoint(), Quaternion:new(1, 0, 0, 0), 0)
+	self:addUnit(fort)
+	self:issueOrder(1, Vector3:new(0, 0, 0), {Target:new(fort, Vector3:new(0, 0, 0))}, false)
+
+	return true
+end
+
+function Player:trainEngineers()
+	forts = self:getUnitsByClass(UnitClass.FORT, 1)
+
+	if #forts == 0 or (#forts > 0 and forts[1]:toFactory():getBuildStatus() < 100) then
+		return false
+	end
+
+	fort = forts[1]:toFactory()
+	dirToCenter = Vector3:new(0, 0, 0):subtr(fort:getPos()):norm()
+
+	while #fort:getQueue() + #self:getUnitsByClass(UnitClass.ENGINEER, -1) < self.numStartEngis do
+		fort:appendToQueue(UnitId.ENGINEER)
+	end
+
+	return #self:getUnitsByClass(UnitClass.ENGINEER, -1) == self.numStartEngis
+end
+
+--Correct resource deposit selection
+function Player:buildExtractor()
+	if #self:getUnitsByClass(UnitClass.EXTRACTOR, 1) > 0 then
+		return true
+	end
+
+	engineer = self:getUnitsByClass(UnitClass.ENGINEER, -1)[1]
+	self:deselectUnits()
+	self:selectUnits({engineer})
+
+	deposits = self:getResourceDeposits()
+	if #deposits == 0 then return false end
+
+	depPos = deposits[1]:getPos()
+	spawnPoint = self:getSpawnPoint()
+
+	for i = 1, #deposits do
+		if deposits[i]:getPos():getDistanceFrom(spawnPoint) < depPos:getDistanceFrom(spawnPoint) then
+			depPos = deposits[i]:getPos()
 		end
 	end
 
-	if #taskForce >= self.sizeTaskForce then
-		self.taskForceSent = true
-		self:selectUnits(taskForce)
-		self:issueOrder(2, Vector3:new(0, 0, 0), {Target:new(nil, Vector3:new(0, 0, 0))}, false)
-		return true
-	else
-		return false
-	end
+	extractor = GameObjectFactory.createUnit(self, UnitId.EXTRACTOR, depPos, Quaternion:new(1, 0, 0, 0), 0)
+	self:addUnit(extractor)
+	self:issueOrder(1, Vector3:new(0, 0, 0), {Target:new(extractor, Vector3:new(0, 0, 0))}, false)
+ 
+	return true
 end
 
-function Player:trainTaskForce()
-	if self.trainingStarted then
-		return true
+function Player:startBuilding(buildingId, engiId, angle)
+	engineer = self:getUnitsByClass(UnitClass.ENGINEER, -1)[engiId]
+	self:deselectUnits()
+	self:selectUnits({engineer})
+	
+	dirVec = Quaternion:new(angle, Vector3:new(0, 1, 0)):multVec(dirToCenter)
+	refPos = self:getSpawnPoint():add(dirVec:mult(20))
+	building = GameObjectFactory.createUnit(self, buildingId, refPos, Quaternion:new(1, 0, 0, 0), 0)
+	self:addUnit(building)
+	self:issueOrder(1, Vector3:new(0, 0, 0), {Target:new(building, Vector3:new(0, 0, 0))}, false)
+end
+
+function Player:buildRefinery()
+	if #self:getUnitsByClass(UnitClass.REFINERY, 1) == 0 then
+		self:startBuilding(UnitId.REFINERY, 2, -.6)
 	end
 
-	landFactory = nil
+	refineries = self:getUnitsByClass(UnitClass.REFINERY, -1)
+	refineryBuilt = false
 
-	for i = 1, self:getNumUnits() do
-		if self:getUnit(i - 1):getUnitClass() == UnitClass.LAND_FACTORY then
-			landFactory = self:getUnit(i - 1):toFactory()
+	for i = 1, #refineries do
+		if refineries[i]:toStructure():getBuildStatus() == 100 then
+			refineryBuilt = true
 			break
 		end
 	end
 
-	if landFactory ~= nil then
-		print('Training...')
-		for i = 1, self.sizeTaskForce do
-			landFactory:appendToQueue(UnitClass.TANK)
-		end
-
-		self.trainingStarted = true
-		return true
-	else
-		return false
-	end
-	
+	return refineryBuilt
 end
 
-function Player:selectEngi()
-	taskForce = self:getSelectedUnitsByClass(UnitClass.ENGINEER)
+function Player:buildLandFactory()
+	if #self:getUnitsByClass(UnitClass.LAND_FACTORY, 1) == 0 then
+		self:startBuilding(UnitId.LAND_FACTORY, 3, .6)
+	end
 
-	if #taskForce == 0 then
-		for i = 1, self:getNumUnits() do
-			if self:getUnit(i - 1):getUnitClass() == UnitClass.ENGINEER then
-				taskForce = {self:getUnit(i - 1)}
-				self:selectUnits(taskForce)
-				break
-			end
+	factories = self:getUnitsByClass(UnitClass.LAND_FACTORY, -1)
+	factoryBuilt = false
+
+	for i = 1, #factories do
+		if factories[i]:toStructure():getBuildStatus() == 100 then
+			factoryBuilt = true
+			break
 		end
 	end
 
-	return #taskForce > 0
+	return factoryBuilt
 end
 
-function Player:issueBuildOrder()
-	if self.buildOrdered then
+function Player:buildHarvester()
+	if #self:getUnitsByClass(UnitClass.RESOURCE_ROVER, 1) > 0 then
 		return true
 	end
 
-	for i = 1, self:getNumUnits() do
-		if self:getUnit(i - 1):getUnitClass() == UnitClass.LAND_FACTORY then
+	landFactories = self:getUnitsByClass(UnitClass.LAND_FACTORY, 1)
+	if #landFactories == 0 then return false end
+
+	factory = landFactories[1]:toFactory()
+
+	if #factory:getQueue() == 0 then
+		factory:appendToQueue(UnitId.RESOURCE_ROVER)
+	end
+
+	return false
+end
+
+function Player:startHarvesting()
+	harvesters = self:getUnitsByClass(UnitClass.RESOURCE_ROVER, -1)
+
+	for i = 1, #harvesters do
+		if harvesters[i]:getNumOrders() > 0 and harvesters[i]:getOrder(0).type == 7 then
 			return true
 		end
 	end
 
-	spawnPoint = self:getSpawnPoint()
-	structure = GameObjectFactory.createUnit(self, UnitId.LAND_FACTORY, spawnPoint, Quaternion:new(1, 0, 0, 0), 0)
-	self:addUnit(structure)
+	extrs = self:getUnitsByClass(UnitClass.EXTRACTOR, 1)
+	if #extrs == 0 then return false end
+
+	self:deselectUnits()
+	self:selectUnits({harvesters[1]})
+	self:issueOrder(7, Vector3:new(0, 0, 0), {Target:new(extrs[1], Vector3:new(0, 0, 0))}, false)
+
+	return true
+end
+
+function Player:buildTaskforceUnitGroup(numUnits, currNumUnits, factory, unitId)
+	if currNumUnits < numUnits then
+		for i = 1, numUnits - currNumUnits do
+			factory:appendToQueue(unitId)
+		end
+	end
+end
+
+function Player:buildTaskforce()
+	currNumBuiltWarMechs = #self:getUnitsByClass(UnitClass.WAR_MECH, -1)
+	currNumBuiltTanks = #self:getUnitsByClass(UnitClass.TANK, -1)
+	currNumBuiltArtillery = #self:getUnitsByClass(UnitClass.ARTILLERY, -1)
+	currNumWarMechs = currNumBuiltWarMechs
+	currNumTanks = currNumBuiltTanks
+	currNumArtillery = currNumBuiltArtillery
+	currLandFactories = self:getUnitsByClass(UnitClass.LAND_FACTORY, -1)
+
+	for i = 1, #currLandFactories do
+		currNumWarMechs = currNumWarMechs + currLandFactories[i]:toFactory():getNumQueueUnitsById(UnitId.WAR_MECH)
+		currNumTanks = currNumTanks + currLandFactories[i]:toFactory():getNumQueueUnitsById(UnitId.TANK)
+		currNumArtillery = currNumArtillery + currLandFactories[i]:toFactory():getNumQueueUnitsById(UnitId.ARTILLERY)
+	end
+
+	numWarMechs = self.numDefWarMechs + self.numTaskForceWarMechs
+	numTanks = self.numTaskForceTanks
+	numArtillery = self.numTaskForceArtillery
+
+	if currNumBuiltWarMechs >= numWarMechs and currNumBuiltTanks >= numTanks and currNumBuiltArtillery >= numArtillery then
+		return true
+	end
+
+	landFactory = currLandFactories[1]:toFactory()
+
+	self:buildTaskforceUnitGroup(numWarMechs, currNumWarMechs, landFactory, UnitId.WAR_MECH)
+	self:buildTaskforceUnitGroup(numTanks, currNumTanks, landFactory, UnitId.TANK)
+	self:buildTaskforceUnitGroup(numArtillery, currNumArtillery, landFactory, UnitId.ARTILLERY)
+
+	return false
+end
+
+function Player:sendTaskforce()
+	if --[[taskForceMechs[1]:getNumOrders() > 0 and taskForceMechs[1]:getOrder(0).type == 2--]] self.givenOrder then
+		return true
+	end
+
+	taskForceMechs = self:getUnitsByClass(UnitClass.WAR_MECH, self.numTaskForceWarMechs)
+	taskForceTanks = self:getUnitsByClass(UnitClass.TANK, self.numTaskForceTanks)
+	taskForceArtillery = self:getUnitsByClass(UnitClass.ARTILLERY, self.numTaskForceArtillery)
+
+	self:deselectUnits()
+	self:selectUnits(taskForceMechs)
+	self:selectUnits(taskForceTanks)
+	self:selectUnits(taskForceArtillery)
+
+	players = Game.getSingleton():getPlayers()
+	enemySpawnPoint = nil
+
+	for i = 1, #players do
+		if players[i] ~= self then
+			enemySpawnPoint = players[i]:getSpawnPoint()
+			break
+		end
+	end
+
+	self:issueOrder(2, Vector3:new(0, 0, 0), {Target:new(nil, enemySpawnPoint)}, false)
+	self.givenOrder = true
 
-	self:issueOrder(1, Vector3:new(0, 0, 0), {Target:new(structure, Vector3:new(0, 0, 0))}, false)
-	self.buildOrdered = true
 	return true
 end
 
 Player.behaviour = {
-	type = BTNodeType.SELECTOR,
+	type = BTNodeType.SEQUENCE,
 	children = {
-		{type = BTNodeType.FUNCTION, func = 'sendTaskForce'},
-		{type = BTNodeType.FUNCTION, func = 'trainTaskForce'},
-		{
-			type = BTNodeType.SEQUENCE, children = {
-				{type = BTNodeType.FUNCTION, func = 'selectEngi'},
-				{type = BTNodeType.FUNCTION, func = 'issueBuildOrder'},
-			}
-		}
+		{type = BTNodeType.FUNCTION, func = 'buildFort'},
+		{type = BTNodeType.FUNCTION, func = 'trainEngineers'},
+		{type = BTNodeType.FUNCTION, func = 'buildExtractor'},
+		{type = BTNodeType.FUNCTION, func = 'buildRefinery'},
+		{type = BTNodeType.FUNCTION, func = 'buildLandFactory'},
+		{type = BTNodeType.FUNCTION, func = 'buildHarvester'},
+		{type = BTNodeType.FUNCTION, func = 'startHarvesting'},
+		{type = BTNodeType.FUNCTION, func = 'buildTaskforce'},
+		{type = BTNodeType.FUNCTION, func = 'sendTaskforce'},
 	}
 }

Assets/Scripts/GameObjects/Units/unitData.lua

@@ -194,8 +194,11 @@ units = {
 	{
 		weapons = {},
 		unitClass = UnitClass.RESOURCE_ROVER,
-		unitType = UnitType.SEA_LEVEL,
+		unitType = UnitType.HOVER,
 		armor = {ArmorType.CAST},
+		capacity = 3000,
+		loadRate = 1,
+		loadSpeed = 5,
 		isVehicle = true,
 		health = 500,
 		buildTime = 1000,
@@ -516,6 +519,8 @@ units = {
 		isVehicle = false,
 		health = 500,
 		buildTime = 1000,
+		drawRate = 1,
+		drawSpeed = 5,
 		cost = 500,
 		size = {x = 4, y = 1.15, z = 4},
 		hitboxOffset = {x = 0, y = 0, z = 0},

Assets/Scripts/Gui/playerSelection.lua

@@ -0,0 +1,62 @@
+Pos = {x = 110, y = 150} 
+Size = {x = 100, y = 20}
+space = 60
+
+gui = {
+	{
+		pos = Pos,
+		size = Size,
+		guiType = GuiType.LISTBOX,
+		numMaxDisplay = 3,
+		listboxType = ListboxType.FACTIONS
+	},
+	{
+		pos = {x = Pos.x, y = Pos.y + Size.y + space},
+		size = Size,
+		guiType = GuiType.LISTBOX,
+		numMaxDisplay = 3,
+		listboxType = ListboxType.FACTIONS
+	},
+	{
+		pos = {x = Pos.x, y = Pos.y + 2 * (Size.y + space)},
+		size = Size,
+		guiType = GuiType.LISTBOX,
+		numMaxDisplay = 3,
+		listboxType = ListboxType.FACTIONS
+	},
+	{
+		pos = {x = Pos.x, y = Pos.y + 3 * (Size.y + space)},
+		size = Size,
+		guiType = GuiType.LISTBOX,
+		numMaxDisplay = 3,
+		listboxType = ListboxType.FACTIONS
+	},
+	{
+		pos = {x = Pos.x, y = Pos.y + 4 * (Size.y + space)},
+		size = Size,
+		guiType = GuiType.LISTBOX,
+		numMaxDisplay = 3,
+		listboxType = ListboxType.FACTIONS
+	},
+	{
+		pos = {x = Pos.x, y = Pos.y + 5 * (Size.y + space)},
+		size = Size,
+		guiType = GuiType.LISTBOX,
+		numMaxDisplay = 3,
+		listboxType = ListboxType.FACTIONS
+	},
+	{
+		pos = {x = Pos.x, y = Pos.y + 6 * (Size.y + space)},
+		size = Size,
+		guiType = GuiType.LISTBOX,
+		numMaxDisplay = 3,
+		listboxType = ListboxType.FACTIONS
+	},
+	{
+		pos = {x = Pos.x, y = Pos.y + 7 * (Size.y + space)},
+		size = Size,
+		guiType = GuiType.LISTBOX,
+		numMaxDisplay = 3,
+		listboxType = ListboxType.FACTIONS
+	},
+}

activeGameState.cpp

@@ -163,6 +163,16 @@ namespace battleship{
 		buttons.clear();
 	}
 
+	bool ActiveGameState::selectedUnitsAmongst(vector<Unit*> units){
+		vector<Unit*> selUnits = mainPlayer->getSelectedUnits();
+
+		for(Unit *unit : units)
+			if(find(selUnits.begin(), selUnits.end(), unit) != selUnits.end())
+				return true;
+
+		return false;
+	}
+
 	//TODO fix fog of war for hostile units
     void ActiveGameState::renderUnits() {
 		vector<Unit*> units;
@@ -192,13 +202,13 @@ namespace battleship{
             	Vector2 pos = u->getScreenPos();
 
 				if(buttons.empty()){
-					if(!mainPlayer->getSelectedUnitsByClass(UnitClass::ENGINEER).empty())
+					if(selectedUnitsAmongst(mainPlayer->getUnitsByClass(UnitClass::ENGINEER)))
 						guiManager->readLuaScreenScript("engineerCommands.lua", buttons, listboxes, checkboxes, sliders, textboxes, guiRects, texts);
-					else if(!mainPlayer->getSelectedUnitsByClass(UnitClass::FORT).empty())
+					else if(selectedUnitsAmongst(mainPlayer->getUnitsByClass(UnitClass::FORT)))
 						guiManager->readLuaScreenScript("fortCommands.lua", buttons, listboxes, checkboxes, sliders, textboxes, guiRects, texts);
-					else if(!mainPlayer->getSelectedUnitsByClass(UnitClass::LAND_FACTORY).empty())
+					else if(selectedUnitsAmongst(mainPlayer->getUnitsByClass(UnitClass::LAND_FACTORY)))
 						guiManager->readLuaScreenScript("landFactoryCommands.lua", buttons, listboxes, checkboxes, sliders, textboxes, guiRects, texts);
-					else if(!mainPlayer->getSelectedUnitsByClass(UnitClass::NAVAL_FACTORY).empty())
+					else if(selectedUnitsAmongst(mainPlayer->getUnitsByClass(UnitClass::NAVAL_FACTORY)))
 						guiManager->readLuaScreenScript("navalFactoryCommands.lua", buttons, listboxes, checkboxes, sliders, textboxes, guiRects, texts);
 				}
 

activeGameState.h

@@ -31,6 +31,7 @@ namespace battleship{
         inline Player* getPlayer(){return mainPlayer;}
         inline std::vector<Unit*>& getUnitGroup(int i){return unitGroups[i];}
     private:
+		bool selectedUnitsAmongst(std::vector<Unit*>);
 		void updateGameObjHoveredOn();
 		void initDragbox();
 		void removeDragbox();

extractor.cpp

@@ -11,7 +11,7 @@ namespace battleship{
 	using namespace vb01;
 	using namespace gameBase;
 
-	Extractor::Extractor(Player *player, int id, Vector3 pos, Quaternion rot, int buildStatus, ResourceDeposit *rd) : Structure(player, id, pos, rot, buildStatus), drawRate(10){
+	Extractor::Extractor(Player *player, int id, Vector3 pos, Quaternion rot, int buildStatus, ResourceDeposit *rd) : Structure(player, id, pos, rot, buildStatus){
 		if(!rd){
 			vector<ResourceDeposit*> deposits;
 
@@ -27,6 +27,10 @@ namespace battleship{
 				}
 		}
 
+		sol::table unitTable = generateView()["units"][id + 1];
+		drawRate = unitTable["drawRate"];
+		drawSpeed = unitTable["drawSpeed"];
+
 		Vector2 size = Vector2(lenHpBar, 10);
 		ammountBackground = Unit::createBar(Vector2::VEC_ZERO, size,  Vector4(0, 0, 0, 1));
 		ammountForeground = Unit::createBar(Vector2::VEC_ZERO, size,  Vector4(0, 0, 1, 1));
@@ -56,7 +60,7 @@ namespace battleship{
 	}
 
 	void Extractor::draw(){
-		deposit->decrementAmmount();
+		deposit->decreaseAmmount(drawSpeed);
 		lastDrawTime = getTime();
 	}
 }

extractor.h

@@ -17,7 +17,7 @@ namespace battleship{
 			bool canDraw(){return vb01::getTime() - lastDrawTime > drawRate;}
 			inline ResourceDeposit* getDeposit(){return deposit;}
 		private:
-			int drawRate;
+			int drawSpeed, drawRate;
 			vb01::s64 lastDrawTime = 0;
 			vb01::Node *ammountBackground = nullptr, *ammountForeground = nullptr;
 			ResourceDeposit *deposit = nullptr;

factory.cpp

@@ -22,6 +22,16 @@ namespace battleship{
 			train();
 	}
 
+	int Factory::getNumQueueUnitsById(int unitId){
+		int numUnits = 0;
+
+		for(int qu : unitQueue)
+			if(qu == unitId)
+				numUnits++;
+
+		return numUnits;
+	}
+
 	void Factory::train(){
 		bool training = !unitQueue.empty();
 		buildStatusForeground->setVisible(training);
@@ -35,7 +45,7 @@ namespace battleship{
 			bool mainPlayerSelecting = (activeState && find(selectingPlayers.begin(), selectingPlayers.end(), mainPlayer) != selectingPlayers.end());
 
 			Unit::displayUnitStats(buildStatusForeground, buildStatusBackground, trainingStatus, 100, mainPlayer == player && mainPlayerSelecting, Vector2(0, -10));
-			sol::table targTable = generateView()["units"][unitQueue[0]];
+			sol::table targTable = generateView()["units"][unitQueue[0] + 1];
 			int costRate = (int)targTable["cost"] / 100, trainRate = (int)targTable["buildTime"] / 100;
 
 			if(player->getRefineds() >= costRate && getTime() - lastTrainTime > trainRate){

factory.h

@@ -18,7 +18,8 @@ namespace battleship{
 			Factory(Player*, int, vb01::Vector3, vb01::Quaternion, int = 0);
 			~Factory(){}
 			void update();
-			void appendToQueue(int uc){unitQueue.push_back(uc);}
+			int getNumQueueUnitsById(int);
+			void appendToQueue(int uid){unitQueue.push_back(uid);}
 			inline std::vector<int> getQueue(){return unitQueue;}
 		private:
 			const int MAX_LEN_QUEUE = 10;

gameManager.cpp

@@ -8,6 +8,7 @@
 
 #include "gameManager.h"
 #include "gameObjectFactory.h"
+#include "game.h"
 #include "guiAppState.h"
 #include "defConfigs.h"
 #include "player.h"
@@ -54,15 +55,28 @@ namespace battleship{
 
 		SOL_LUA_STATE.new_usertype<Unit>(
 			"Unit", sol::constructors<Unit(Player*, int, Vector3, Quaternion)>(),
+			"getOrder", &Unit::getOrder,
+			"getNumOrders", &Unit::getNumOrders,
+			"getPos", &GameObject::getPos,
 			"getUnitClass", &Unit::getUnitClass,
 			"toEngineer", &Unit::toEngineer,
 			"toPointDefense", &Unit::toPointDefense,
+			"toStructure", &Unit::toStructure,
 			"toFactory", &Unit::toFactory
 		);
 
+		SOL_LUA_STATE.new_usertype<Structure>(
+			"Structure", sol::constructors<Structure(Player*, int, Vector3, Quaternion, int)>(),
+			"getPos", &GameObject::getPos,
+			"getBuildStatus", &Structure::getBuildStatus
+		);
+
 		SOL_LUA_STATE.new_usertype<Factory>(
 			"Factory", sol::constructors<Factory(Player*, int, Vector3, Quaternion, int)>(),
+			"getPos", &GameObject::getPos,
 			"appendToQueue", &Factory::appendToQueue,
+			"getBuildStatus", &Structure::getBuildStatus,
+			"getNumQueueUnitsById", &Factory::getNumQueueUnitsById,
 			"getQueue", &Factory::getQueue
 		);
 
@@ -71,26 +85,46 @@ namespace battleship{
 			"addUnit", &Player::addUnit,
 			"getUnit", &Player::getUnit,
 			"getNumUnits", &Player::getNumUnits,
+			"getResourceDeposits", &Player::getResourceDeposits,
 			"issueOrder", &Player::issueOrder,
 			"selectUnits", &Player::selectUnits,
 			"deselectUnits", &Player::deselectUnits,
 			"getSpawnPoint", &Player::getSpawnPoint,
-			"getSelectedUnitsByClass", &Player::getSelectedUnitsByClass
+			"getUnitsById", &Player::getUnitsById,
+			"getUnitsByClass", &Player::getUnitsByClass
+		);
+
+		SOL_LUA_STATE.new_usertype<ResourceDeposit>(
+			"ResourceDeposit", sol::constructors<ResourceDeposit(Player*, int, Vector3, Quaternion, int)>(),
+			"getPos", &GameObject::getPos
+		);
+
+		SOL_LUA_STATE.new_usertype<Game>(
+			"Game",
+			"getSingleton", &Game::getSingleton,
+			"getPlayers", &Game::getPlayers
 		);
 
 		SOL_LUA_STATE.new_usertype<Vector3>(
 			"Vector3", sol::constructors<Vector3(), Vector3(float, float, float)>(),
 			"x", &Vector3::x,
 			"y", &Vector3::y,
-			"z", &Vector3::z
+			"z", &Vector3::z,
+			"norm", &Vector3::norm,
+			"getDistanceFrom", &Vector3::getDistanceFrom,
+			"add", [](Vector3 v1, Vector3 v2){return v1 + v2;},
+			"subtr", [](Vector3 v1, Vector3 v2){return v1 - v2;},
+			"mult", [](Vector3 v1, float s){return v1 * s;},
+			"div", [](Vector3 v1, float s){return v1 / s;}
 		);
 
 		SOL_LUA_STATE.new_usertype<Quaternion>(
-			"Quaternion", sol::constructors<Quaternion(), Quaternion(float, float, float, float)>(),
+			"Quaternion", sol::constructors<Quaternion(), Quaternion(float, float, float, float), Quaternion(float, Vector3)>(),
 			"w", &Quaternion::w,
 			"x", &Quaternion::x,
 			"y", &Quaternion::y,
-			"z", &Quaternion::z
+			"z", &Quaternion::z,
+			"multVec", [](Quaternion q, Vector3 v){return q * v;}
 		);
 	}
 

mapListbox.cpp

@@ -0,0 +1,34 @@
+#include "mapListbox.h"
+#include "map.h"
+#include "concreteGuiManager.h"
+#include "gameManager.h"
+
+#include <button.h>
+#include <checkbox.h>
+#include <slider.h>
+#include <textbox.h>
+#include <node.h>
+#include <text.h>
+
+namespace battleship{
+	using namespace vb01;
+	using namespace vb01Gui;
+	using namespace std;
+
+	MapListbox::MapListbox(Vector2 pos, Vector2 size, std::vector<string> &lines, int maxDisplay, string fontPath, bool closeable) : Listbox(pos, size, lines, maxDisplay, fontPath, closeable){}
+
+	void MapListbox::onClose(){
+		ConcreteGuiManager *guiManager = ConcreteGuiManager::getSingleton();
+
+		Listbox *mapListbox = guiManager->getListboxes()[0];
+		int selectedMap = mapListbox->getSelectedOption();
+		string mapName = wstringToString(mapListbox->getContents()[selectedMap]);
+		string mapPath = GameManager::getSingleton()->getPath() + "Models/Maps/" + mapName + "/" + mapName + ".lua";
+		int numSpawnPoints = Map::getNumSpawnPointsByMap(mapPath);
+
+		guiManager->readLuaScreenScript("singlePlayerMenu.lua");
+		mapListbox = guiManager->getListboxes()[0];
+		vector<Button*> buttons = guiManager->getButtons();
+		guiManager->readLuaScreenScript("playerSelection.lua", buttons, vector<Listbox*>{mapListbox}, vector<Checkbox*>{}, vector<Slider*>{}, vector<Textbox*>{}, vector<Node*>{}, vector<Text*>{}, numSpawnPoints);
+	}
+}

player.cpp

@@ -11,7 +11,7 @@ namespace battleship{
 	using namespace gameBase;
 	using namespace std;
 
-    Player::Player(int diff, int fac, int t, Vector3 col, bool cpuPl, Vector3 sp, string n) : difficulty(diff), faction(fac), team(t), color(col), cpuPlayer(cpuPl), spawnPoint(sp), name(n) {}
+    Player::Player(int diff, int fac, int t, Vector3 col, bool cpuPl, Vector3 sp, string n) : difficulty(diff), faction(fac), team(t), color(col), cpuPlayer(cpuPl), spawnPoint(sp), name(n), refineds(30000) {}
 
     Player::~Player() {}
 
@@ -144,20 +144,39 @@ namespace battleship{
 		projectiles.erase(projectiles.begin() + id);
 	}
 
-	vector<Unit*> Player::getSelectedUnitsByClass(UnitClass uc){
-		vector<Unit*> selectedUnits = getSelectedUnits(), unitsByClass;
-
-		for(Unit *u : selectedUnits)
-			if(u->getUnitClass() == uc)
-				unitsByClass.push_back(u);
-
-		return unitsByClass;
+	void Player::selectUnits(vector<Unit*> selUnits){
+		for(Unit *u : selUnits)
+			if(find(selectedUnits.begin(), selectedUnits.end(), u) == selectedUnits.end()){
+				selectedUnits.push_back(u);
+				u->select();
+			}
 	}
 
-	void Player::selectUnits(vector<Unit*> selUnits){
-		for(Unit *u : selUnits){
-			selectedUnits.push_back(u);
-			u->select();
+	vector<Unit*> Player::getUnitsById(int id, int numUnits){
+		vector<Unit*> idUnits;
+
+		for(Unit *unit : units){
+			if(numUnits != -1 && idUnits.size() == numUnits)
+				break;
+
+			if(unit->getId() == id)
+				idUnits.push_back(unit);
 		}
+
+		return idUnits;
+	}
+
+	vector<Unit*> Player::getUnitsByClass(UnitClass uc, int numUnits){
+		vector<Unit*> ucUnits;
+
+		for(Unit *unit : units){
+			if(numUnits != -1 && ucUnits.size() == numUnits)
+				break;
+
+			if(unit->getUnitClass() == uc)
+				ucUnits.push_back(unit);
+		}
+
+		return ucUnits;
 	}
 }

player.h

@@ -22,8 +22,9 @@ namespace battleship{
 		void removeProjectile(int);
 		void removeProjectile(Projectile*);
         bool isThisPlayersUnit(GameObject*);
-		std::vector<Unit*> getSelectedUnitsByClass(UnitClass);
 		void selectUnits(std::vector<Unit*>);
+		std::vector<Unit*> getUnitsById(int, int = -1);
+		std::vector<Unit*> getUnitsByClass(UnitClass, int = -1);
 		inline void deselectUnits(){selectedUnits.clear();}
 		inline Unit* getSelectedUnit(int id){return selectedUnits[id];}
 		inline std::vector<Unit*> getSelectedUnits(){return selectedUnits;}

resourceDeposit.h

@@ -10,7 +10,7 @@ namespace battleship{
 			~ResourceDeposit();
 			inline int getAmmount(){return ammount;}
 			inline int getInitAmmount(){return initAmmount;}
-			inline void decrementAmmount(){ammount--;}
+			inline void decreaseAmmount(int amnt){ammount -= amnt;}
 		private:
 			int ammount, initAmmount;
 

resourceRover.cpp

@@ -13,11 +13,12 @@ namespace battleship{
 	using namespace vb01;
 	using namespace gameBase;
 
-	ResourceRover::ResourceRover(Player *player, int id, Vector3 pos, Quaternion rot) : 
-		Vehicle(player, id, pos, rot), 
-		capacity(300),
-		loadRate(10) 
-	{
+	ResourceRover::ResourceRover(Player *player, int id, Vector3 pos, Quaternion rot) : Vehicle(player, id, pos, rot) {
+		sol::table unitTable = generateView()["units"][id + 1];
+		capacity = unitTable["capacity"];
+		loadSpeed = unitTable["loadSpeed"];
+		loadRate = unitTable["loadRate"];
+
 		Vector2 size = Vector2(lenHpBar, 10);
 		loadBackground = Unit::createBar(Vector2::VEC_ZERO, size,  Vector4(0, 0, 0, 1));
 		loadForeground = Unit::createBar(Vector2::VEC_ZERO, size,  Vector4(1, 1, 0, 1));
@@ -53,7 +54,7 @@ namespace battleship{
 				if(canLoad() && deposit->getAmmount() > 0){
 					if(nearestExtractor->canDraw()){
 						nearestExtractor->draw();
-						load++;
+						load += loadSpeed;
 						lastLoadTime = getTime();
 					}
 				}
@@ -69,7 +70,7 @@ namespace battleship{
 
 			if(nearestRefinery && nearestRefinery->getPos().getDistanceFrom(pos) <= minDist){
 				if(canUnload()){
-					load--;
+					load -= loadSpeed;
 					player->addRefineds(1);
 					lastLoadTime = getTime();
 				}

resourceRover.h

@@ -21,7 +21,7 @@ namespace battleship{
 			inline bool canUnload(){return vb01::getTime() - lastLoadTime > loadRate && load > 0;}
 
 			vb01::s64 lastLoadTime = 0;
-			int load = 0, capacity, loadRate;
+			int load = 0, capacity, loadRate, loadSpeed;
 			Extractor *nearestExtractor = nullptr; 
 			Unit *nearestRefinery = nullptr;
 			vb01::Node *loadBackground = nullptr, *loadForeground = nullptr;

trainButton.cpp

@@ -19,9 +19,10 @@ namespace battleship{
 		ActiveGameState *activeState = (ActiveGameState*)(GameManager::getSingleton()->getStateManager()->getAppStateByType((int)AppStateType::ACTIVE_STATE));
 		Player *player = activeState->getPlayer();
 		UnitClass facClass = (UnitClass)generateView()["units"][factoryId + 1]["unitClass"]; 
-		vector<Unit*> factories = player->getSelectedUnitsByClass(facClass);
+		vector<Unit*> selUnits = player->getSelectedUnits(), factories = player->getUnitsByClass(facClass);
 
 		for(Unit *fac : factories)
-			((Factory*)fac)->appendToQueue(trainableUnitId);
+			if(find(selUnits.begin(), selUnits.end(), fac) != selUnits.end())
+				((Factory*)fac)->appendToQueue(trainableUnitId);
 	}
 }

unit.h

@@ -28,6 +28,7 @@ namespace battleship{
     class Player;
 	class Unit;
 	class Vehicle;
+	class Structure;
 	class Factory;
 	class Cruiser;
 	class PointDefense;
@@ -127,6 +128,7 @@ namespace battleship{
         virtual void addOrder(Order);
 		bool canGarrison(Vehicle*);
 		inline Engineer* toEngineer(){return (Engineer*)this;}
+		inline Structure* toStructure(){return (Structure*)this;}
 		inline Factory* toFactory(){return (Factory*)this;}
 		inline Cruiser* toCruiser(){return (Cruiser*)this;}
 		inline PointDefense* toPointDefense(){return (PointDefense*)this;}