CPU player AI to build and send a tank task force to the middle of the map

Assets/Models/Maps/222/222.lua

@@ -5,7 +5,7 @@ impassibleNodeValue = 65535,
 numPlayers = 1,
 numSpawnPoints = 1,
 spawnPoints = {
-{x = 0.000000, y = 0.000000, z = 0.000000},
+{x = -50.000000, y = 0.000000, z = -50.000000},
 },
 players = {
 {

Assets/Scripts/Core/player.lua

@@ -1,22 +1,59 @@
-function Player:selectTaskForce()
-	taskForce = self:getSelectedUnitsByClass(UnitClass.TANK)
-	return #taskForce > 5
-end
+Player.sizeTaskForce = 5
+Player.trainingStarted = false 
+Player.taskForceSent = false 
+Player.buildOrdered = false 
 
-function Player:issueMoveOrder()
-	return false
-end
+function Player:sendTaskForce()
+	if self.taskForceSent then
+		return true
+	end
 
-function Player:selectLandFactory()
-	return false
+	self:deselectUnits()
+	taskForce = {}
+
+	for i = 1, self:getNumUnits() do
+		if self:getUnit(i - 1):getUnitClass() == UnitClass.TANK then
+			taskForce[i] = self:getUnit(i - 1)
+			taskForce[i]:toggleSelection(true)
+		end
+	end
+
+	if #taskForce >= self.sizeTaskForce then
+		print('Sending...')
+		self.taskForceSent = true
+		self:issueOrder(2, Vector3:new(0, 0, 0), {Target:new(nil, Vector3:new(0, 0, 0))}, false)
+		return true
+	else
+		return false
+	end
 end
 
 function Player:trainTaskForce()
-	return false
-end
+	if self.trainingStarted then
+		return true
+	end
 
-function Player:selectLandCell()
-	return true
+	landFactory = nil
+
+	for i = 1, self:getNumUnits() do
+		if self:getUnit(i - 1):getUnitClass() == UnitClass.LAND_FACTORY then
+			landFactory = self:getUnit(i - 1):toFactory()
+			break
+		end
+	end
+
+	if landFactory ~= nil then
+		print('Training...')
+		for i = 0, self.sizeTaskForce do
+			landFactory:appendToQueue(UnitClass.TANK)
+		end
+
+		self.trainingStarted = true
+		return true
+	else
+		return false
+	end
+	
 end
 
 function Player:selectEngi()
@@ -31,6 +68,10 @@ function Player:selectEngi()
 end
 
 function Player:issueBuildOrder()
+	if self.buildOrdered then
+		return true
+	end
+
 	for i = 1, self:getNumUnits() do
 		if self:getUnit(i - 1):getUnitClass() == UnitClass.LAND_FACTORY then
 			return true
@@ -41,30 +82,21 @@ function Player:issueBuildOrder()
 	structure = GameObjectFactory.createUnit(self, 8, spawnPoint, Quaternion:new(1, 0, 0, 0), 0)
 	self:addUnit(structure)
 
-	targets = {Target:new(structure, Vector3:new(0, 0, 0))}
-	self:issueOrder(1, Vector3:new(0, 0, 0), targets, false)
+	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,
 	children = {
+		{type = BTNodeType.FUNCTION, func = 'sendTaskForce'},
+		{type = BTNodeType.FUNCTION, func = 'trainTaskForce'},
 		{
 			type = BTNodeType.SEQUENCE, children = {
-				{type = BTNodeType.FUNCTION, func = 'selectTaskForce'},
-				{type = BTNodeType.FUNCTION, func = 'issueMoveOrder'},
-			},
-			type = BTNodeType.SEQUENCE, children = {
-				{type = BTNodeType.FUNCTION, func = 'selectLandFactory'},
-				{type = BTNodeType.FUNCTION, func = 'trainTaskForce'}
-			},
-			type = BTNodeType.SEQUENCE, children = {
-				{type = BTNodeType.FUNCTION, func = 'selectLandCell'},
 				{type = BTNodeType.FUNCTION, func = 'selectEngi'},
-				{type = BTNodeType.FUNCTION, func = 'issueBuildOrder'}
+				{type = BTNodeType.FUNCTION, func = 'issueBuildOrder'},
 			}
 		}
-		--[[
-		]]--
 	}
 }

factory.h

@@ -19,6 +19,7 @@ namespace battleship{
 			~Factory(){}
 			void update();
 			void appendToQueue(int);
+			inline std::vector<int> getQueue(){return unitQueue;}
 		private:
 			const int MAX_LEN_QUEUE = 10;
 			int trainingStatus = 0, rateOfTraining = 50;

gameManager.cpp

@@ -11,6 +11,10 @@
 #include "guiAppState.h"
 #include "defConfigs.h"
 #include "player.h"
+#include "factory.h"
+#include "transport.h"
+#include "engineer.h"
+#include "pointDefense.h"
 #include "resourceDeposit.h"
 
 using namespace std;
@@ -27,59 +31,70 @@ namespace battleship{
 		return gameManager;
 	}
 
-	void GameManager::registerOrderMembers(){
+	void GameManager::registerMembers(){
 		sol::state_view SOL_LUA_STATE = generateView();
-		sol::usertype<Order> orderType = SOL_LUA_STATE.new_usertype<Order>("Order", sol::constructors<Order(), Order(Order::TYPE, vector<Order::Target>, Vector3, int)>());
-		orderType["type"] = &Order::type;
-		orderType["direction"] = &Order::direction;
-		orderType["targets"] = &Order::targets;
 
-		sol::usertype<Order::Target> targetType = SOL_LUA_STATE.new_usertype<Order::Target>("Target", sol::constructors<Order::Target(), Order::Target(Unit*, Vector3)>());
-		targetType["unit"] = &Order::Target::unit;
-		targetType["pos"] = &Order::Target::pos;
-	}
+		SOL_LUA_STATE.new_usertype<Order>(
+			"Order", sol::constructors<Order(), Order(Order::TYPE, vector<Order::Target>, Vector3, int)>(),
+			"type", &Order::type,
+			"direction", &Order::direction,
+			"targets", &Order::targets
+		);
 
-	void GameManager::registerGameObjectFactoryMembers(){
-		sol::state_view SOL_LUA_STATE = generateView();
-		sol::usertype<GameObjectFactory> gmObjFacType = SOL_LUA_STATE.new_usertype<GameObjectFactory>("GameObjectFactory");
-		gmObjFacType["createUnit"] = &GameObjectFactory::createUnit;
-		gmObjFacType["createResourceDeposit"] = &GameObjectFactory::createResourceDeposit;
-	}
+		SOL_LUA_STATE.new_usertype<Order::Target>(
+			"Target", sol::constructors<Order::Target(), Order::Target(Unit*, Vector3)>(),
+			"unit", &Order::Target::unit,
+			"pos", &Order::Target::pos
+		);
 
-	void GameManager::registerUnitMembers(){
-		sol::state_view SOL_LUA_STATE = generateView();
-		sol::usertype<Unit> unitType = SOL_LUA_STATE.new_usertype<Unit>("Unit", sol::constructors<Unit(Player*, int, Vector3, Quaternion)>());
-		unitType["getUnitClass"] = &Unit::getUnitClass;
-	}
+		SOL_LUA_STATE.new_usertype<GameObjectFactory>(
+			"GameObjectFactory",
+			"createUnit", &GameObjectFactory::createUnit,
+			"createResourceDeposit", &GameObjectFactory::createResourceDeposit
+		);
 
-	void GameManager::registerPlayerMembers(){
-		sol::state_view SOL_LUA_STATE = generateView();
-		sol::usertype<Player> playerType = SOL_LUA_STATE.new_usertype<Player>("Player", sol::constructors<Player(int, int, int, bool, Vector3)>());
-		playerType["addUnit"] = &Player::addUnit;
-		playerType["getUnit"] = &Player::getUnit;
-		playerType["getNumUnits"] = &Player::getNumberOfUnits;
-		playerType["issueOrder"] = &Player::issueOrder;
-		playerType["selectUnits"] = &Player::selectUnits;
-		playerType["deselectUnits"] = &Player::deselectUnits;
-		playerType["getSpawnPoint"] = &Player::getSpawnPoint;
-		playerType["getSelectedUnitsByClass"] = &Player::getSelectedUnitsByClass;
-	}
+		SOL_LUA_STATE.new_usertype<Unit>(
+			"Unit", sol::constructors<Unit(Player*, int, Vector3, Quaternion)>(),
+			"toggleSelection", &Unit::toggleSelection,
+			"getUnitClass", &Unit::getUnitClass,
+			"toEngineer", &Unit::toEngineer,
+			"toPointDefense", &Unit::toPointDefense,
+			"toTransport", &Unit::toTransport,
+			"toFactory", &Unit::toFactory
+		);
 
-	void GameManager::registerVectorMembers(){
-		sol::state_view SOL_LUA_STATE = generateView();
-		sol::usertype<Vector3> vec3Type = SOL_LUA_STATE.new_usertype<Vector3>("Vector3", sol::constructors<Vector3(), Vector3(float, float, float)>());
-		vec3Type["x"] = &Vector3::x;
-		vec3Type["y"] = &Vector3::y;
-		vec3Type["z"] = &Vector3::z;
-	}
+		SOL_LUA_STATE.new_usertype<Factory>(
+			"Factory", sol::constructors<Factory(Player*, int, Vector3, Quaternion, int)>(),
+			"appendToQueue", &Factory::appendToQueue,
+			"getQueue", &Factory::getQueue
+		);
 
-	void GameManager::registerQuaternionMembers(){
-		sol::state_view SOL_LUA_STATE = generateView();
-		sol::usertype<Quaternion> quatType = SOL_LUA_STATE.new_usertype<Quaternion>("Quaternion", sol::constructors<Quaternion(), Quaternion(float, float, float, float)>());
-		quatType["w"] = &Quaternion::w;
-		quatType["x"] = &Quaternion::x;
-		quatType["y"] = &Quaternion::y;
-		quatType["z"] = &Quaternion::z;
+		SOL_LUA_STATE.new_usertype<Player>(
+			"Player", sol::constructors<Player(int, int, int, bool, Vector3)>(),
+			"addUnit", &Player::addUnit,
+			"getUnit", &Player::getUnit,
+			"getNumUnits", &Player::getNumberOfUnits,
+			"issueOrder", &Player::issueOrder,
+			"selectUnits", &Player::selectUnits,
+			"deselectUnits", &Player::deselectUnits,
+			"getSpawnPoint", &Player::getSpawnPoint,
+			"getSelectedUnitsByClass", &Player::getSelectedUnitsByClass
+		);
+
+		SOL_LUA_STATE.new_usertype<Vector3>(
+			"Vector3", sol::constructors<Vector3(), Vector3(float, float, float)>(),
+			"x", &Vector3::x,
+			"y", &Vector3::y,
+			"z", &Vector3::z
+		);
+
+		SOL_LUA_STATE.new_usertype<Quaternion>(
+			"Quaternion", sol::constructors<Quaternion(), Quaternion(float, float, float, float)>(),
+			"w", &Quaternion::w,
+			"x", &Quaternion::x,
+			"y", &Quaternion::y,
+			"z", &Quaternion::z
+		);
 	}
 
 	void GameManager::initLua(string gameDir){
@@ -97,12 +112,7 @@ namespace battleship{
 	}
 
 	void GameManager::start(string gameDir) {
-		registerVectorMembers();
-		registerQuaternionMembers();
-		registerOrderMembers();
-		registerGameObjectFactoryMembers();
-		registerUnitMembers();
-		registerPlayerMembers();
+		registerMembers();
 		initLua(gameDir);
 
 		Root *root = Root::getSingleton();

gameManager.h

@@ -29,12 +29,7 @@ namespace battleship{
     private:
         GameManager(){}
         ~GameManager(){}
-		void registerOrderMembers();
-		void registerVectorMembers();
-		void registerQuaternionMembers();
-		void registerGameObjectFactoryMembers();
-		void registerUnitMembers();
-		void registerPlayerMembers();
+		void registerMembers();
 		void initLua(std::string);
 
 		gameBase::StateManager *stateManager = nullptr;

playButton.cpp

@@ -37,7 +37,7 @@ namespace battleship{
 			int numPlayers = map->getNumSpawnPoints();
 
 			for(int i = 0; i < numPlayers; i++){
-				Player *player = new Player(0, 0, i);
+				Player *player = new Player(0, 0, i, true, map->getSpawnPoint(i));
 				map->loadPlayerGameObjects(player);
 				Game::getSingleton()->addPlayer(player);
 			}

unit.h

@@ -28,6 +28,10 @@ namespace battleship{
     class Player;
 	class Unit;
 	class Vehicle;
+	class Factory;
+	class Transport;
+	class PointDefense;
+	class Engineer;
     
     struct Order {
         enum class TYPE {ATTACK, BUILD, MOVE, GARRISON, EJECT, PATROL, LAUNCH};
@@ -74,6 +78,10 @@ namespace battleship{
         std::vector<Projectile*> getProjectiles();
         virtual void addOrder(Order);
 		virtual void reinit();
+		inline Engineer* toEngineer(){return (Engineer*)this;}
+		inline Transport* toTransport(){return (Transport*)this;}
+		inline Factory* toFactory(){return (Factory*)this;}
+		inline PointDefense* toPointDefense(){return (PointDefense*)this;}
 		inline int getNumGarrisonSlots(){return garrisonSlots.size();}
 		inline const std::vector<GarrisonSlot>& getGarrisonSlots(){return garrisonSlots;}
         inline vb01::Vector3* getPosPtr() {return &pos;}

vehicle.cpp

@@ -49,7 +49,9 @@ namespace battleship{
 
 	void Vehicle::addOrder(Order order){
 		if(order.type != Order::TYPE::EJECT){
-			preparePathpoints(order.targets[0].pos);
+			Order::Target targ = order.targets[0];
+			Vector3 targPos = (targ.unit ? targ.unit->getPos() : targ.pos);
+			preparePathpoints(targPos);
 
 			if(!pathPoints.empty())
 				orders.push_back(order);