feat: add further MovementAI skeleton (#1499)

* add movement ai skeleton

Zone loading code is tested to load and read the correct values using logs.  other ldf data is unaffected as I walked around crux and dragons/apes can still spawn and be killed.

* format

dCommon/dEnums/eWaypointCommandType.h

@@ -0,0 +1,59 @@
+
+#ifndef __EWAYPOINTCOMMANDTYPES__H__
+#define __EWAYPOINTCOMMANDTYPES__H__
+
+#include <cstdint>
+
+enum class eWaypointCommandType : uint32_t {
+	INVALID,
+	BOUNCE,
+	STOP,
+	GROUP_EMOTE,
+	SET_VARIABLE,
+	CAST_SKILL,
+	EQUIP_INVENTORY,
+	UNEQUIP_INVENTORY,
+	DELAY,
+	EMOTE,
+	TELEPORT,
+	PATH_SPEED,
+	REMOVE_NPC,
+	CHANGE_WAYPOINT,
+	DELETE_SELF,
+	KILL_SELF,
+	SPAWN_OBJECT,
+	PLAY_SOUND,
+};
+
+class WaypointCommandType {
+public:
+	static eWaypointCommandType StringToWaypointCommandType(std::string commandString) {
+		const std::map<std::string, eWaypointCommandType> WaypointCommandTypeMap = {
+			{"bounce", eWaypointCommandType::BOUNCE},
+			{"stop", eWaypointCommandType::STOP},
+			{"groupemote", eWaypointCommandType::GROUP_EMOTE},
+			{"setvar", eWaypointCommandType::SET_VARIABLE},
+			{"castskill", eWaypointCommandType::CAST_SKILL},
+			{"eqInvent", eWaypointCommandType::EQUIP_INVENTORY},
+			{"unInvent", eWaypointCommandType::UNEQUIP_INVENTORY},
+			{"delay", eWaypointCommandType::DELAY},
+			{"femote", eWaypointCommandType::EMOTE},
+			{"emote", eWaypointCommandType::EMOTE},
+			{"teleport", eWaypointCommandType::TELEPORT},
+			{"pathspeed", eWaypointCommandType::PATH_SPEED},
+			{"removeNPC", eWaypointCommandType::REMOVE_NPC},
+			{"changeWP", eWaypointCommandType::CHANGE_WAYPOINT},
+			{"DeleteSelf", eWaypointCommandType::DELETE_SELF},
+			{"killself", eWaypointCommandType::KILL_SELF},
+			{"removeself", eWaypointCommandType::DELETE_SELF},
+			{"spawnOBJ", eWaypointCommandType::SPAWN_OBJECT},
+			{"playSound", eWaypointCommandType::PLAY_SOUND},
+		};
+
+		auto intermed = WaypointCommandTypeMap.find(commandString);
+		return (intermed != WaypointCommandTypeMap.end()) ? intermed->second : eWaypointCommandType::INVALID;
+	};
+};
+
+
+#endif  //!__EWAYPOINTCOMMANDTYPES__H__

dGame/dComponents/TriggerComponent.cpp

@@ -15,6 +15,7 @@
 #include "PlayerManager.h"
 #include "Game.h"
 #include "EntityManager.h"
+#include "MovementAIComponent.h"
 
 TriggerComponent::TriggerComponent(Entity* parent, const std::string triggerInfo) : Component(parent) {
 	m_Parent = parent;
@@ -68,7 +69,9 @@ void TriggerComponent::HandleTriggerCommand(LUTriggers::Command* command, Entity
 		case eTriggerCommandType::RESET_REBUILD:
 			HandleResetRebuild(targetEntity, command->args);
 			break;
-			case eTriggerCommandType::SET_PATH: break;
+		case eTriggerCommandType::SET_PATH:
+			HandleSetPath(targetEntity, argArray);
+			break;
 		case eTriggerCommandType::SET_PICK_TYPE: break;
 		case eTriggerCommandType::MOVE_OBJECT:
 			HandleMoveObject(targetEntity, argArray);
@@ -99,11 +102,21 @@ void TriggerComponent::HandleTriggerCommand(LUTriggers::Command* command, Entity
 			break;
 		case eTriggerCommandType::SET_BOUNCER_STATE: break;
 		case eTriggerCommandType::BOUNCE_ALL_ON_BOUNCER: break;
-			case eTriggerCommandType::TURN_AROUND_ON_PATH: break;
+		case eTriggerCommandType::TURN_AROUND_ON_PATH:
-			case eTriggerCommandType::GO_FORWARD_ON_PATH: break;
+			HandleTurnAroundOnPath(targetEntity);
-			case eTriggerCommandType::GO_BACKWARD_ON_PATH: break;
+			break;
-			case eTriggerCommandType::STOP_PATHING: break;
+		case eTriggerCommandType::GO_FORWARD_ON_PATH:
-			case eTriggerCommandType::START_PATHING: break;
+			HandleGoForwardOnPath(targetEntity);
+			break;
+		case eTriggerCommandType::GO_BACKWARD_ON_PATH:
+			HandleGoBackwardOnPath(targetEntity);
+			break;
+		case eTriggerCommandType::STOP_PATHING:
+			HandleStopPathing(targetEntity);
+			break;
+		case eTriggerCommandType::START_PATHING:
+			HandleStartPathing(targetEntity);
+			break;
 		case eTriggerCommandType::LOCK_OR_UNLOCK_CONTROLS: break;
 		case eTriggerCommandType::PLAY_EFFECT:
 			HandlePlayEffect(targetEntity, argArray);
@@ -164,20 +177,25 @@ std::vector<Entity*> TriggerComponent::GatherTargets(LUTriggers::Command* comman
 	std::vector<Entity*> entities = {};
 
 	if (command->target == "self") entities.push_back(m_Parent);
-	else if (command->target == "zone") { /*TODO*/ }
+	else if (command->target == "zone") {
-	else if (command->target == "target" && optionalTarget) entities.push_back(optionalTarget);
+		/*TODO*/
-	else if (command->target == "targetTeam" && optionalTarget) {
+	} else if (command->target == "target" && optionalTarget) {
+		entities.push_back(optionalTarget);
+	} else if (command->target == "targetTeam" && optionalTarget) {
 		auto* team = TeamManager::Instance()->GetTeam(optionalTarget->GetObjectID());
 		for (const auto memberId : team->members) {
 			auto* member = Game::entityManager->GetEntity(memberId);
 			if (member) entities.push_back(member);
 		}
-	} else if (command->target == "objGroup") entities = Game::entityManager->GetEntitiesInGroup(command->targetName);
+	} else if (command->target == "objGroup") {
-	else if (command->target == "allPlayers") {
+		entities = Game::entityManager->GetEntitiesInGroup(command->targetName);
+	} else if (command->target == "allPlayers") {
 		for (auto* player : PlayerManager::GetAllPlayers()) {
 			entities.push_back(player);
 		}
-	} else if (command->target == "allNPCs") { /*UNUSED*/ }
+	} else if (command->target == "allNPCs") {
+		/*UNUSED*/
+	}
 
 	return entities;
 }
@@ -435,3 +453,44 @@ void TriggerComponent::HandleActivatePhysics(Entity* targetEntity, std::string a
 		LOG_DEBUG("Invalid argument for ActivatePhysics Trigger: %s", args.c_str());
 	}
 }
+
+void TriggerComponent::HandleSetPath(Entity* targetEntity, std::vector<std::string> argArray) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	if (!movementAIComponent) return;
+	// movementAIComponent->SetupPath(argArray.at(0));
+	if (argArray.size() >= 2) {
+		auto index = GeneralUtils::TryParse<int32_t>(argArray.at(1));
+		if (!index) return;
+		// movementAIComponent->SetPathStartingWaypointIndex(index.value());
+	}
+	if (argArray.size() >= 3 && argArray.at(2) == "1") {
+		// movementAIComponent->ReversePath();
+	}
+}
+
+void TriggerComponent::HandleTurnAroundOnPath(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	// if (movementAIComponent) movementAIComponent->ReversePath();
+}
+
+void TriggerComponent::HandleGoForwardOnPath(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	if (!movementAIComponent) return;
+	// if (movementAIComponent->GetIsInReverse()) movementAIComponent->ReversePath();
+}
+
+void TriggerComponent::HandleGoBackwardOnPath(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	if (!movementAIComponent) return;
+	// if (!movementAIComponent->GetIsInReverse()) movementAIComponent->ReversePath();
+}
+
+void TriggerComponent::HandleStopPathing(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	// if (movementAIComponent) movementAIComponent->Pause();
+}
+
+void TriggerComponent::HandleStartPathing(Entity* targetEntity) {
+	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
+	// if (movementAIComponent) movementAIComponent->Resume();
+}

dGame/dComponents/TriggerComponent.h

@@ -44,6 +44,12 @@ private:
 	void HandleResetSpawnerNetwork(std::string args);
 	void HandleDestroySpawnerNetworkObjects(std::string args);
 	void HandleActivatePhysics(Entity* targetEntity, std::string args);
+	void HandleTurnAroundOnPath(Entity* targetEntity);
+	void HandleGoForwardOnPath(Entity* targetEntity);
+	void HandleGoBackwardOnPath(Entity* targetEntity);
+	void HandleStopPathing(Entity* targetEntity);
+	void HandleStartPathing(Entity* targetEntity);
+	void HandleSetPath(Entity* targetEntity, std::vector<std::string> argArray);
 
 	LUTriggers::Trigger* m_Trigger;
 };

dZoneManager/Zone.cpp

@@ -17,6 +17,7 @@
 
 #include "eTriggerCommandType.h"
 #include "eTriggerEventType.h"
+#include "eWaypointCommandType.h"
 #include "dNavMesh.h"
 
 Zone::Zone(const LWOMAPID& mapID, const LWOINSTANCEID& instanceID, const LWOCLONEID& cloneID) :
@@ -452,15 +453,23 @@ void Zone::LoadPath(std::istream& file) {
 				std::string value;
 				BinaryIO::ReadString<uint8_t>(file, value, BinaryIO::ReadType::WideString);
 
-				LDFBaseData* ldfConfig = nullptr;
 				if (path.pathType == PathType::Movement || path.pathType == PathType::Rail) {
-					ldfConfig = LDFBaseData::DataFromString(parameter + "=0:" + value);
+					// cause NetDevil puts spaces in things that don't need spaces
+					parameter.erase(std::remove_if(parameter.begin(), parameter.end(), ::isspace), parameter.end());
+					auto waypointCommand = WaypointCommandType::StringToWaypointCommandType(parameter);
+					if (waypointCommand == eWaypointCommandType::DELAY) value.erase(std::remove_if(value.begin(), value.end(), ::isspace), value.end());
+					if (waypointCommand != eWaypointCommandType::INVALID) {
+						auto& command = waypoint.commands.emplace_back();
+						command.command = waypointCommand;
+						command.data = value;
+					} else LOG("Tried to load invalid waypoint command '%s'", parameter.c_str());
 				} else {
-					ldfConfig = LDFBaseData::DataFromString(parameter + "=" + value);
+					waypoint.config.emplace_back(LDFBaseData::DataFromString(parameter + "=" + value));
 				}
-				if (ldfConfig) waypoint.config.push_back(ldfConfig);
+
 			}
 		}
+
 		// We verify the waypoint heights against the navmesh because in many movement paths,
 		// the waypoint is located near 0 height, 
 		if (path.pathType == PathType::Movement) {

dZoneManager/Zone.h

@@ -13,6 +13,14 @@ namespace LUTriggers {
 
 class Level;
 
+enum class eWaypointCommandType : uint32_t;
+
+struct WaypointCommand {
+	eWaypointCommandType command;
+	std::string data;
+};
+
+
 struct SceneRef {
 	std::string filename;
 	uint32_t id;
@@ -69,6 +77,7 @@ struct PathWaypoint {
 	RacingPathWaypoint racing;
 	float speed;
 	std::vector<LDFBaseData*> config;
+	std::vector<WaypointCommand> commands;
 };
 
 enum class PathType : uint32_t {