Add mandlers for all the trigger related waypoint commands

And add a call to the cppscript for reaching a waypoint

dCommon/DluAssert.h

@@ -4,7 +4,7 @@
 #include <assert.h>
 
 #ifdef _DEBUG
-#	define DluAssert(expression) do { assert(expression) } while(0)
+#	define DluAssert(expression) do { assert(expression); } while(0)
 #else
 #	define DluAssert(expression)
 #endif

dCommon/LDFFormat.h

@@ -83,6 +83,12 @@ public:
 		this->value = value;
 	}
 
+	//! Initializer
+	LDFData(const std::string& key, const T& value) {
+		this->key = GeneralUtils::ASCIIToUTF16(key);
+		this->value = value;
+	}
+
 	//! Destructor
 	~LDFData(void) override {}
 

dGame/Entity.cpp

@@ -1994,6 +1994,38 @@ void Entity::SetRotation(const NiQuaternion& rotation) {
 	Game::entityManager->SerializeEntity(this);
 }
 
+void Entity::SetVelocity(const NiPoint3& velocity) {
+	auto* controllable = GetComponent<ControllablePhysicsComponent>();
+
+	if (controllable != nullptr) {
+		controllable->SetVelocity(velocity);
+	}
+
+	auto* simple = GetComponent<SimplePhysicsComponent>();
+
+	if (simple != nullptr) {
+		simple->SetVelocity(velocity);
+	}
+
+	Game::entityManager->SerializeEntity(this);
+}
+
+const NiPoint3& Entity::GetVelocity() const {
+	auto* controllable = GetComponent<ControllablePhysicsComponent>();
+
+	if (controllable != nullptr) {
+		return controllable->GetVelocity();
+	}
+
+	auto* simple = GetComponent<SimplePhysicsComponent>();
+
+	if (simple != nullptr) {
+		return simple->GetVelocity();
+	}
+
+	return NiPoint3Constant::ZERO;
+}
+
 bool Entity::GetBoolean(const std::u16string& name) const {
 	return GetVar<bool>(name);
 }

dGame/Entity.h

@@ -124,6 +124,8 @@ public:
 	// then return the collision group from that.
 	int32_t GetCollisionGroup() const;
 
+	const NiPoint3& GetVelocity() const;
+
 	/**
 	 * Setters
 	 */
@@ -148,6 +150,8 @@ public:
 
 	void SetRespawnRot(const NiQuaternion& rotation);
 
+	void SetVelocity(const NiPoint3& velocity);
+
 	/**
 	 * Component management
 	 */
@@ -329,7 +333,7 @@ public:
 	 * @brief The observable for player entity position updates.
 	 */
 	static Observable<Entity*, const PositionUpdate&> OnPlayerPositionUpdate;
-	
+
 protected:
 	LWOOBJID m_ObjectID;
 
@@ -435,7 +439,7 @@ const T& Entity::GetVar(const std::u16string& name) const {
 template<typename T>
 T Entity::GetVarAs(const std::u16string& name) const {
 	const auto data = GetVarAsString(name);
-	
+
 	return GeneralUtils::TryParse<T>(data).value_or(LDFData<T>::Default);
 }
 

dGame/EntityManager.cpp

@@ -364,6 +364,8 @@ void EntityManager::ConstructEntity(Entity* entity, const SystemAddress& sysAddr
 
 	if (sysAddr == UNASSIGNED_SYSTEM_ADDRESS) {
 		for (auto* player : PlayerManager::GetAllPlayers()) {
+			// Don't need to construct the player to themselves 
+			if (entity->GetObjectID() == player->GetObjectID()) continue;
 			if (player->GetPlayerReadyForUpdates()) {
 				Game::server->Send(stream, player->GetSystemAddress(), false);
 			} else {

dGame/dComponents/ModelComponent.cpp

@@ -30,10 +30,16 @@ bool ModelComponent::OnResetModelToDefaults(GameMessages::GameMsg& msg) {
 	unsmash.target = GetParent()->GetObjectID();
 	unsmash.duration = 0.0f;
 	unsmash.Send(UNASSIGNED_SYSTEM_ADDRESS);
+
+	m_Parent->SetPosition(m_OriginalPosition);
+	m_Parent->SetRotation(m_OriginalRotation);
+	m_Parent->SetVelocity(NiPoint3Constant::ZERO);
+
 	m_NumListeningInteract = 0;
 	m_NumActiveUnSmash = 0;
 	m_Dirty = true;
 	Game::entityManager->SerializeEntity(GetParent());
+
 	return true;
 }
 
@@ -203,3 +209,31 @@ void ModelComponent::RemoveUnSmash() {
 	LOG_DEBUG("Removing UnSmash %i", m_NumActiveUnSmash);
 	m_NumActiveUnSmash--;
 }
+
+bool ModelComponent::TrySetVelocity(const NiPoint3& velocity) const {
+	auto currentVelocity = m_Parent->GetVelocity();
+
+	// If we're currently moving on an axis, prevent the move so only 1 behavior can have control over an axis
+	if (velocity != NiPoint3Constant::ZERO) {
+		const auto [x, y, z] = velocity;
+		if (x != 0.0f) {
+			if (currentVelocity.x != 0.0f) return false;
+			currentVelocity.x = x;
+		} else if (y != 0.0f) {
+			if (currentVelocity.y != 0.0f) return false;
+			currentVelocity.y = y;
+		} else if (z != 0.0f) {
+			if (currentVelocity.z != 0.0f) return false;
+			currentVelocity.z = z;
+		}
+	} else {
+		currentVelocity = velocity;
+	}
+
+	m_Parent->SetVelocity(currentVelocity);
+	return true;
+}
+
+void ModelComponent::SetVelocity(const NiPoint3& velocity) const {
+	m_Parent->SetVelocity(velocity);
+}

dGame/dComponents/ModelComponent.h

@@ -41,7 +41,7 @@ public:
 	 * Returns the original position of the model
 	 * @return the original position of the model
 	 */
-	const NiPoint3& GetPosition() { return m_OriginalPosition; }
+	const NiPoint3& GetOriginalPosition() { return m_OriginalPosition; }
 
 	/**
 	 * Sets the original position of the model
@@ -53,7 +53,7 @@ public:
 	 * Returns the original rotation of the model
 	 * @return the original rotation of the model
 	 */
-	const NiQuaternion& GetRotation() { return m_OriginalRotation; }
+	const NiQuaternion& GetOriginalRotation() { return m_OriginalRotation; }
 
 	/**
 	 * Sets the original rotation of the model
@@ -130,6 +130,14 @@ public:
 	bool IsUnSmashing() const { return m_NumActiveUnSmash != 0; }
 
 	void Resume();
+
+	// Attempts to set the velocity of an axis for movement.
+	// If the axis currently has a velocity of zero, returns true.
+	// If the axis is currently controlled by a behavior, returns false.
+	bool TrySetVelocity(const NiPoint3& velocity) const;
+
+	// Force sets the velocity to a value.
+	void SetVelocity(const NiPoint3& velocity) const;
 private:
 	// Number of Actions that are awaiting an UnSmash to finish.
 	uint32_t m_NumActiveUnSmash{};

dGame/dComponents/MovementAIComponent.cpp

@@ -66,6 +66,67 @@ void MovementAIComponent::SetPath(const std::string pathName) {
 	SetMaxSpeed(1);
 	SetCurrentSpeed(m_BaseSpeed);
 	SetPath(m_Path->pathWaypoints);
+	
+	auto start_index = m_Parent->GetVarAs<uint32_t>(u"attached_path_start");
+	if (start_index >= m_Path->waypointCount) start_index = 0;
+	
+	SetDestination(m_Path->pathWaypoints[m_PathIndex].position);
+	m_PathIndex = start_index;
+
+}
+
+void MovementAIComponent::SetPath(const std::string pathName, uint32_t startIndex, bool reverse) {
+	m_Path = Game::zoneManager->GetZone()->GetPath(pathName);
+	if (!pathName.empty()) LOG("WARNING: %s path %s", m_Path ? "Found" : "Failed to find", pathName.c_str());
+	if (!m_Path) return;
+	SetMaxSpeed(1);
+	SetCurrentSpeed(m_BaseSpeed);
+
+	if (reverse) {
+		m_IsBounced = !m_IsBounced;
+		auto pathWaypoints = m_Path->pathWaypoints;
+		std::reverse(pathWaypoints.begin(), pathWaypoints.end());
+		SetPath(pathWaypoints);
+	} else {
+		SetPath(m_Path->pathWaypoints);
+	}
+
+	SetDestination(m_Path->pathWaypoints[startIndex].position);
+	m_PathIndex = startIndex;
+}
+
+void MovementAIComponent::TurnAroundOnPath() {
+	if (m_Path) {
+		auto currentIndex = m_PathIndex;
+		m_IsBounced = !m_IsBounced;
+		std::vector<PathWaypoint> waypoints = m_Path->pathWaypoints;
+		if (m_IsBounced) std::reverse(waypoints.begin(), waypoints.end());
+		SetPath(waypoints);
+		SetDestination(waypoints[currentIndex].position);
+		m_PathIndex = currentIndex;
+	}
+}
+
+void MovementAIComponent::GoForwardOnPath() {
+	if (m_Path) {
+		auto currentIndex = m_PathIndex;
+		m_IsBounced = false;
+		SetPath(m_Path->pathWaypoints);
+		SetDestination(m_Path->pathWaypoints[currentIndex].position);
+		m_PathIndex = currentIndex;
+	}
+}
+
+void MovementAIComponent::GoBackwardOnPath() {
+	if (m_Path) {
+		auto currentIndex = m_PathIndex;
+		m_IsBounced = true;
+		std::vector<PathWaypoint> waypoints = m_Path->pathWaypoints;
+		std::reverse(waypoints.begin(), waypoints.end());
+		SetPath(waypoints);
+		SetDestination(waypoints[currentIndex].position);
+		m_PathIndex = currentIndex;
+	}
 }
 
 void MovementAIComponent::Pause() {
@@ -188,7 +249,7 @@ bool MovementAIComponent::AdvanceWaypointIndex() {
 	if (m_PathIndex >= m_InterpolatedWaypoints.size()) {
 		return false;
 	}
-
+	m_Parent->GetScript()->OnWaypointReached(m_Parent, m_PathIndex);
 	m_PathIndex++;
 
 	return true;

dGame/dComponents/MovementAIComponent.h

@@ -65,6 +65,10 @@ public:
 	MovementAIComponent(Entity* parentEntity, MovementAIInfo info);
 
 	void SetPath(const std::string pathName);
+	void SetPath(const std::string pathName, uint32_t startIndex, bool reverse);
+	void TurnAroundOnPath();
+	void GoForwardOnPath();
+	void GoBackwardOnPath();
 
 	void Update(float deltaTime) override;
 

dGame/dComponents/PropertyManagementComponent.cpp

@@ -272,6 +272,10 @@ void PropertyManagementComponent::OnStartBuilding() {
 			model->HandleMsg(reset);
 		}
 	}
+
+	for (auto* const entity : Game::entityManager->GetEntitiesInGroup("SpawnedPropertyEnemies")) {
+		if (entity) entity->Smash();
+	}
 }
 
 void PropertyManagementComponent::OnFinishBuilding() {
@@ -296,6 +300,10 @@ void PropertyManagementComponent::OnFinishBuilding() {
 			model->HandleMsg(reset);
 		}
 	}
+
+	for (auto* const entity : Game::entityManager->GetEntitiesInGroup("SpawnedPropertyEnemies")) {
+		if (entity) entity->Smash();
+	}
 }
 
 void PropertyManagementComponent::UpdateModelPosition(const LWOOBJID id, const NiPoint3 position, NiQuaternion rotation) {
@@ -696,8 +704,9 @@ void PropertyManagementComponent::Save() {
 			Database::Get()->AddBehavior(info);
 		}
 
-		const auto position = entity->GetPosition();
-		const auto rotation = entity->GetRotation();
+		// Always save the original position so we can move the model freely
+		const auto& position = modelComponent->GetOriginalPosition();
+		const auto& rotation = modelComponent->GetOriginalRotation();
 
 		if (std::find(present.begin(), present.end(), id) == present.end()) {
 			IPropertyContents::Model model;

dGame/dComponents/SimplePhysicsComponent.cpp

@@ -33,6 +33,13 @@ SimplePhysicsComponent::SimplePhysicsComponent(Entity* parent, int32_t component
 SimplePhysicsComponent::~SimplePhysicsComponent() {
 }
 
+void SimplePhysicsComponent::Update(const float deltaTime) {
+	if (m_Velocity == NiPoint3Constant::ZERO) return;
+	m_Position += m_Velocity * deltaTime;
+	m_DirtyPosition = true;
+	Game::entityManager->SerializeEntity(m_Parent);
+}
+
 void SimplePhysicsComponent::Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) {
 	if (bIsInitialUpdate) {
 		outBitStream.Write(m_ClimbableType != eClimbableType::CLIMBABLE_TYPE_NOT);

dGame/dComponents/SimplePhysicsComponent.h

@@ -33,6 +33,8 @@ public:
 	SimplePhysicsComponent(Entity* parent, int32_t componentID);
 	~SimplePhysicsComponent() override;
 
+	void Update(const float deltaTime) override;
+
 	void Serialize(RakNet::BitStream& outBitStream, bool bIsInitialUpdate) override;
 
 	/**

dGame/dComponents/TriggerComponent.cpp

@@ -457,40 +457,43 @@ void TriggerComponent::HandleActivatePhysics(Entity* targetEntity, std::string a
 void TriggerComponent::HandleSetPath(Entity* targetEntity, std::vector<std::string> argArray) {
 	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
 	if (!movementAIComponent) return;
-	// movementAIComponent->SetupPath(argArray.at(0));
+	uint32_t start_index = 0;
+	bool reverse = false;
 	if (argArray.size() >= 2) {
 		auto index = GeneralUtils::TryParse<int32_t>(argArray.at(1));
-		if (!index) return;
-		// movementAIComponent->SetPathStartingWaypointIndex(index.value());
+		if (index) {
+			start_index = index.value();
+		}
 	}
 	if (argArray.size() >= 3 && argArray.at(2) == "1") {
-		// movementAIComponent->ReversePath();
+			reverse = true;
 	}
+	movementAIComponent->SetPath(argArray.at(0), start_index, reverse);
 }
 
 void TriggerComponent::HandleTurnAroundOnPath(Entity* targetEntity) {
 	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
-	// if (movementAIComponent) movementAIComponent->ReversePath();
+	if (movementAIComponent) movementAIComponent->TurnAroundOnPath();
 }
 
 void TriggerComponent::HandleGoForwardOnPath(Entity* targetEntity) {
 	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
 	if (!movementAIComponent) return;
-	// if (movementAIComponent->GetIsInReverse()) movementAIComponent->ReversePath();
+	movementAIComponent->GoForwardOnPath();
 }
 
 void TriggerComponent::HandleGoBackwardOnPath(Entity* targetEntity) {
 	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
 	if (!movementAIComponent) return;
-	// if (!movementAIComponent->GetIsInReverse()) movementAIComponent->ReversePath();
+	movementAIComponent->GoBackwardOnPath();
 }
 
 void TriggerComponent::HandleStopPathing(Entity* targetEntity) {
 	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
-	// if (movementAIComponent) movementAIComponent->Pause();
+	if (movementAIComponent) movementAIComponent->Pause();
 }
 
 void TriggerComponent::HandleStartPathing(Entity* targetEntity) {
 	auto* movementAIComponent = targetEntity->GetComponent<MovementAIComponent>();
-	// if (movementAIComponent) movementAIComponent->Resume();
+	if (movementAIComponent) movementAIComponent->Resume();
 }

dGame/dGameMessages/GameMessages.cpp

@@ -5207,7 +5207,7 @@ void GameMessages::HandlePickupCurrency(RakNet::BitStream& inStream, Entity* ent
 	if (currency == 0) return;
 
 	auto* ch = entity->GetCharacter();
-	if (entity->CanPickupCoins(currency)) {
+	if (ch && entity->CanPickupCoins(currency)) {
 		ch->SetCoins(ch->GetCoins() + currency, eLootSourceType::PICKUP);
 	}
 }

dGame/dPropertyBehaviors/Strip.cpp

@@ -84,9 +84,11 @@ void Strip::HandleMsg(MigrateActionsMessage& msg) {
 
 template<>
 void Strip::HandleMsg(GameMessages::RequestUse& msg) {
-	if (m_PausedTime > 0.0f) return;
+	if (m_PausedTime > 0.0f || !HasMinimumActions()) return;
 
-	if (m_Actions[m_NextActionIndex].GetType() == "OnInteract") {
+	auto& nextAction = GetNextAction();
+
+	if (nextAction.GetType() == "OnInteract") {
 		IncrementAction();
 		m_WaitingForAction = false;
 	}
@@ -97,6 +99,8 @@ void Strip::HandleMsg(GameMessages::ResetModelToDefaults& msg) {
 	m_WaitingForAction = false;
 	m_PausedTime = 0.0f;
 	m_NextActionIndex = 0;
+	m_InActionMove = NiPoint3Constant::ZERO;
+	m_PreviousFramePosition = NiPoint3Constant::ZERO;
 }
 
 void Strip::IncrementAction() {
@@ -111,7 +115,9 @@ void Strip::Spawn(LOT lot, Entity& entity) {
 	info.pos = entity.GetPosition();
 	info.rot = NiQuaternionConstant::IDENTITY;
 	info.spawnerID = entity.GetObjectID();
-	Game::entityManager->ConstructEntity(Game::entityManager->CreateEntity(info, nullptr, &entity));
+	auto* const spawnedEntity = Game::entityManager->CreateEntity(info, nullptr, &entity);
+	spawnedEntity->AddToGroup("SpawnedPropertyEnemies");
+	Game::entityManager->ConstructEntity(spawnedEntity);
 }
 
 // Spawns a specific drop for all
@@ -127,19 +133,39 @@ void Strip::ProcNormalAction(float deltaTime, ModelComponent& modelComponent) {
 	auto number = nextAction.GetValueParameterDouble();
 	auto numberAsInt = static_cast<int32_t>(number);
 	auto nextActionType = GetNextAction().GetType();
-	if (nextActionType == "SpawnStromling") {
-		Spawn(10495, entity); // Stromling property
-	} else if (nextActionType == "SpawnPirate") {
-		Spawn(10497, entity); // Maelstrom Pirate property
-	} else if (nextActionType == "SpawnRonin") {
-		Spawn(10498, entity); // Dark Ronin property
-	} else if (nextActionType == "DropImagination") {
-		for (; numberAsInt > 0; numberAsInt--) SpawnDrop(935, entity); // 1 Imagination powerup
-	} else if (nextActionType == "DropHealth") {
-		for (; numberAsInt > 0; numberAsInt--) SpawnDrop(177, entity); // 1 Life powerup
-	} else if (nextActionType == "DropArmor") {
-		for (; numberAsInt > 0; numberAsInt--) SpawnDrop(6431, entity); // 1 Armor powerup
-	} else if (nextActionType == "Smash") {
+
+	// TODO replace with switch case and nextActionType with enum
+	/* BEGIN Move */
+	if (nextActionType == "MoveRight" || nextActionType == "MoveLeft") {
+		// X axis
+		bool isMoveLeft = nextActionType == "MoveLeft";
+		// Default velocity is 3 units per second.
+		if (modelComponent.TrySetVelocity(NiPoint3{ isMoveLeft ? -3.0f : 3.0f, 0.0f, 0.0f })) {
+			m_PreviousFramePosition = entity.GetPosition();
+			m_InActionMove.x = isMoveLeft ? -number : number;
+		}
+	} else if (nextActionType == "FlyUp" || nextActionType == "FlyDown") {
+		// Y axis
+		bool isFlyDown = nextActionType == "FlyDown";
+		// Default velocity is 3 units per second.
+		if (modelComponent.TrySetVelocity(NiPoint3{ 0.0f, isFlyDown ? -3.0f : 3.0f, 0.0f })) {
+			m_PreviousFramePosition = entity.GetPosition();
+			m_InActionMove.y = isFlyDown ? -number : number;
+		}
+
+	} else if (nextActionType == "MoveForward" || nextActionType == "MoveBackward") {
+		// Z axis
+		bool isMoveBackward = nextActionType == "MoveBackward";
+		// Default velocity is 3 units per second.
+		if (modelComponent.TrySetVelocity(NiPoint3{ 0.0f, 0.0f, isMoveBackward ? -3.0f : 3.0f })) {
+			m_PreviousFramePosition = entity.GetPosition();
+			m_InActionMove.z = isMoveBackward ? -number : number;
+		}
+	}
+	/* END Move */
+
+	/* BEGIN Action */
+	else if (nextActionType == "Smash") {
 		if (!modelComponent.IsUnSmashing()) {
 			GameMessages::Smash smash{};
 			smash.target = entity.GetObjectID();
@@ -162,13 +188,29 @@ void Strip::ProcNormalAction(float deltaTime, ModelComponent& modelComponent) {
 		sound.target = modelComponent.GetParent()->GetObjectID();
 		sound.soundID = numberAsInt;
 		sound.Send(UNASSIGNED_SYSTEM_ADDRESS);
-	} else {
+	}
+	/* END Action */
+	/* BEGIN Gameplay */
+	else if (nextActionType == "SpawnStromling") {
+		Spawn(10495, entity); // Stromling property
+	} else if (nextActionType == "SpawnPirate") {
+		Spawn(10497, entity); // Maelstrom Pirate property
+	} else if (nextActionType == "SpawnRonin") {
+		Spawn(10498, entity); // Dark Ronin property
+	} else if (nextActionType == "DropImagination") {
+		for (; numberAsInt > 0; numberAsInt--) SpawnDrop(935, entity); // 1 Imagination powerup
+	} else if (nextActionType == "DropHealth") {
+		for (; numberAsInt > 0; numberAsInt--) SpawnDrop(177, entity); // 1 Life powerup
+	} else if (nextActionType == "DropArmor") {
+		for (; numberAsInt > 0; numberAsInt--) SpawnDrop(6431, entity); // 1 Armor powerup
+	}
+	/* END Gameplay */
+	else {
 		static std::set<std::string> g_WarnedActions;
 		if (!g_WarnedActions.contains(nextActionType.data())) {
 			LOG("Tried to play action (%s) which is not supported.", nextActionType.data());
 			g_WarnedActions.insert(nextActionType.data());
 		}
-		return;
 	}
 
 	IncrementAction();
@@ -187,12 +229,67 @@ void Strip::RemoveStates(ModelComponent& modelComponent) const {
 	}
 }
 
+bool Strip::CheckMovement(float deltaTime, ModelComponent& modelComponent) {
+	auto& entity = *modelComponent.GetParent();
+	const auto& currentPos = entity.GetPosition();
+	const auto diff = currentPos - m_PreviousFramePosition;
+	const auto [moveX, moveY, moveZ] = m_InActionMove;
+	m_PreviousFramePosition = currentPos;
+
+	// Only want to subtract from the move if one is being performed.
+	// Starts at true because we may not be doing a move at all.
+	// If one is being done, then one of the move_ variables will be non-zero
+	bool moveFinished = true;
+	NiPoint3 finalPositionAdjustment = NiPoint3Constant::ZERO;
+	if (moveX != 0.0f) {
+		m_InActionMove.x -= diff.x;
+		// If the sign bit is different between the two numbers, then we have finished our move.
+		moveFinished = std::signbit(m_InActionMove.x) != std::signbit(moveX);
+		finalPositionAdjustment.x = m_InActionMove.x;
+	} else if (moveY != 0.0f) {
+		m_InActionMove.y -= diff.y;
+		// If the sign bit is different between the two numbers, then we have finished our move.
+		moveFinished = std::signbit(m_InActionMove.y) != std::signbit(moveY);
+		finalPositionAdjustment.y = m_InActionMove.y;
+	} else if (moveZ != 0.0f) {
+		m_InActionMove.z -= diff.z;
+		// If the sign bit is different between the two numbers, then we have finished our move.
+		moveFinished = std::signbit(m_InActionMove.z) != std::signbit(moveZ);
+		finalPositionAdjustment.z = m_InActionMove.z;
+	}
+
+	// Once done, set the in action move & velocity to zero
+	if (moveFinished && m_InActionMove != NiPoint3Constant::ZERO) {
+		auto entityVelocity = entity.GetVelocity();
+		// Zero out only the velocity that was acted on
+		if (moveX != 0.0f) entityVelocity.x = 0.0f;
+		else if (moveY != 0.0f) entityVelocity.y = 0.0f;
+		else if (moveZ != 0.0f) entityVelocity.z = 0.0f;
+		modelComponent.SetVelocity(entityVelocity);
+
+		// Do the final adjustment so we will have moved exactly the requested units
+		entity.SetPosition(entity.GetPosition() + finalPositionAdjustment);
+		m_InActionMove = NiPoint3Constant::ZERO;
+	}
+
+	return moveFinished;
+}
+
 void Strip::Update(float deltaTime, ModelComponent& modelComponent) {
+	// No point in running a strip with only one action.
+	// Strips are also designed to have 2 actions or more to run.
+	if (!HasMinimumActions()) return;
+
+	// Return if this strip has an active movement action
+	if (!CheckMovement(deltaTime, modelComponent)) return;
+
+	// Don't run this strip if we're paused.
 	m_PausedTime -= deltaTime;
 	if (m_PausedTime > 0.0f) return;
 
 	m_PausedTime = 0.0f;
 
+	// Return here if we're waiting for external interactions to continue.
 	if (m_WaitingForAction) return;
 
 	auto& entity = *modelComponent.GetParent();
@@ -200,7 +297,7 @@ void Strip::Update(float deltaTime, ModelComponent& modelComponent) {
 
 	RemoveStates(modelComponent);
 
-	// Check for starting blocks and if not a starting block proc this blocks action
+	// Check for trigger blocks and if not a trigger block proc this blocks action
 	if (m_NextActionIndex == 0) {
 		if (nextAction.GetType() == "OnInteract") {
 			modelComponent.AddInteract();

dGame/dPropertyBehaviors/Strip.h

@@ -29,15 +29,23 @@ public:
 
 	void IncrementAction();
 	void Spawn(LOT object, Entity& entity);
+
+	// Checks the movement logic for whether or not to proceed
+	// Returns true if the movement can continue, false if it needs to wait more.
+	bool CheckMovement(float deltaTime, ModelComponent& modelComponent);
 	void Update(float deltaTime, ModelComponent& modelComponent);
 	void SpawnDrop(LOT dropLOT, Entity& entity);
 	void ProcNormalAction(float deltaTime, ModelComponent& modelComponent);
 	void RemoveStates(ModelComponent& modelComponent) const;
+
+	// 2 actions are required for strips to work
+	bool HasMinimumActions() const { return m_Actions.size() >= 2; }
 private:
 	// Indicates this Strip is waiting for an action to be taken upon it to progress to its actions
 	bool m_WaitingForAction{ false };
 
-	// The amount of time this strip is paused for.  Any interactions with this strip should be bounced if this is greater than 0.
+	// The amount of time this strip is paused for. Any interactions with this strip should be bounced if this is greater than 0.
+	// Actions that do not use time do not use this (ex. positions).
 	float m_PausedTime{ 0.0f };
 
 	// The index of the next action to be played. This should always be within range of [0, m_Actions.size()).
@@ -48,6 +56,13 @@ private:
 
 	// The location of this strip on the UGBehaviorEditor UI
 	StripUiPosition m_Position;
+
+	// The current actions remaining distance to the target
+	// Only 1 of these vertexs' will be active at once for any given strip.
+	NiPoint3 m_InActionMove{};
+
+	// The position of the parent model on the previous frame
+	NiPoint3 m_PreviousFramePosition{};
 };
 
 #endif  //!__STRIP__H__

dScripts/CppScripts.cpp

@@ -336,6 +336,7 @@
 #include "NsRaceServer.h"
 #include "TrialFactionArmorServer.h"
 #include "ImaginationBackPack.h"
+#include "NsWinterRaceServer.h"
 
 #include <map>
 #include <string>
@@ -656,6 +657,7 @@ namespace {
 		//FB
 		{"scripts\\ai\\NS\\WH\\L_ROCKHYDRANT_BROKEN.lua", []() {return new RockHydrantBroken();}},
 		{"scripts\\ai\\NS\\L_NS_WH_FANS.lua", []() {return new WhFans();}},
+		{"scripts\\ai\\RACING\\TRACK_NS_WINTER\\NS_WINTER_RACE_SERVER.lua", []() {return new NsWinterRaceServer();}},
 
 		//WBL
 		{"scripts\\zone\\LUPs\\WBL_generic_zone.lua", []() {return new WblGenericZone();}},

dScripts/ai/RACING/CMakeLists.txt

@@ -13,6 +13,12 @@ foreach(file ${DSCRIPTS_SOURCES_AI_RACING_TRACK_NS})
 	set(DSCRIPTS_SOURCES_AI_RACING ${DSCRIPTS_SOURCES_AI_RACING} "TRACK_NS/${file}")
 endforeach()
 
+add_subdirectory(TRACK_NS_WINTER)
+
+foreach(file ${DSCRIPTS_SOURCES_AI_RACING_TRACK_NS_WINTER})
+	set(DSCRIPTS_SOURCES_AI_RACING ${DSCRIPTS_SOURCES_AI_RACING} "TRACK_NS_WINTER/${file}")
+endforeach()
+
 add_subdirectory(TRACK_GF)
 
 foreach(file ${DSCRIPTS_SOURCES_AI_RACING_TRACK_GF})
@@ -26,5 +32,5 @@ foreach(file ${DSCRIPTS_SOURCES_AI_RACING_TRACK_FV})
 endforeach()
 
 add_library(dScriptsAiRacing OBJECT ${DSCRIPTS_SOURCES_AI_RACING})
-target_include_directories(dScriptsAiRacing PUBLIC "." "OBJECTS" "TRACK_NS" "TRACK_GF" "TRACK_FV")
+target_include_directories(dScriptsAiRacing PUBLIC "." "OBJECTS" "TRACK_NS" "TRACK_NS_WINTER" "TRACK_GF" "TRACK_FV")
 target_precompile_headers(dScriptsAiRacing REUSE_FROM dScriptsBase)

dScripts/ai/RACING/TRACK_NS_WINTER/CMakeLists.txt

@@ -0,0 +1,3 @@
+set(DSCRIPTS_SOURCES_AI_RACING_TRACK_NS_WINTER
+	"NsWinterRaceServer.cpp"
+	PARENT_SCOPE)

dScripts/ai/RACING/TRACK_NS_WINTER/NsWinterRaceServer.cpp

@@ -0,0 +1,53 @@
+#include "NsWinterRaceServer.h"
+#include "GameMessages.h"
+#include "RacingControlComponent.h"
+
+using std::unique_ptr;
+using std::make_unique;
+
+void NsWinterRaceServer::OnStartup(Entity* self) {
+	GameMessages::ConfigureRacingControl config;
+	auto& raceSet = config.racingSettings;
+
+	raceSet.push_back(make_unique<LDFData<std::u16string>>("GameType", u"Racing"));
+	raceSet.push_back(make_unique<LDFData<std::u16string>>("GameState", u"Starting"));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Number_Of_PlayersPerTeam", 6));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Minimum_Players_to_Start", 2));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Minimum_Players_for_Group_Achievments", 2));
+
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Car_Object", 7703));
+	raceSet.push_back(make_unique<LDFData<std::u16string>>("Race_PathName", u"MainPath"));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Current_Lap", 1));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Number_of_Laps", 3));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("activityID", 42));
+
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Place_1", 100));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Place_2", 90));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Place_3", 80));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Place_4", 70));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Place_5", 60));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Place_6", 50));
+
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Num_of_Players_1", 15));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Num_of_Players_2", 25));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Num_of_Players_3", 50));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Num_of_Players_4", 85));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Num_of_Players_5", 90));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Num_of_Players_6", 100));
+
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Number_of_Spawn_Groups", 1));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Red_Spawners", 4847));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Blue_Spawners", 4848));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Blue_Flag", 4850));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Red_Flag", 4851));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Red_Point", 4846));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Blue_Point", 4845));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Red_Mark", 4844));
+	raceSet.push_back(make_unique<LDFData<int32_t>>("Blue_Mark", 4843));
+
+	const auto racingControllers = Game::entityManager->GetEntitiesByComponent(eReplicaComponentType::RACING_CONTROL);
+	for (auto* const racingController : racingControllers) {
+		auto* const racingComponent = racingController->GetComponent<RacingControlComponent>();
+		if (racingComponent) racingComponent->MsgConfigureRacingControl(config);
+	}
+}

dScripts/ai/RACING/TRACK_NS_WINTER/NsWinterRaceServer.h

@@ -0,0 +1,15 @@
+// Darkflame Universe
+// Copyright 2025
+
+#ifndef NSWINTERRACESERVER_H
+#define NSWINTERRACESERVER_H
+
+#include "CppScripts.h"
+#include "RaceImaginationServer.h"
+
+class NsWinterRaceServer : public RaceImaginationServer {
+public:
+	void OnStartup(Entity* self) override;
+};
+
+#endif //!NSWINTERRACESERVER_H

dWorldServer/WorldServer.cpp

@@ -713,12 +713,12 @@ void HandleMasterPacket(Packet* packet) {
 			//Create our user and send them in:
 			UserManager::Instance()->CreateUser(it->second.sysAddr, username.GetAsString(), userHash);
 
-			auto zone = Game::zoneManager->GetZone();
-			if (zone) {
+			if (Game::zoneManager->HasZone()) {
 				float x = 0.0f;
 				float y = 0.0f;
 				float z = 0.0f;
 
+				auto zone = Game::zoneManager->GetZone();
 				if (zone->GetZoneID().GetMapID() == 1100) {
 					auto pos = zone->GetSpawnPos();
 					x = pos.x;

dZoneManager/dZoneManager.h

@@ -29,6 +29,7 @@ public:
 	/* Gets a pointer to the currently loaded zone. */
 	Zone* GetZoneMut() const;
 	const Zone* GetZone() const { return GetZoneMut(); };
+	bool HasZone() const { return m_pZone != nullptr; };
 	void LoadZone(const LWOZONEID& zoneID); //Discard the current zone (if any) and loads a new zone.
 
 	/* Adds a spawner to the zone with the specified ID. */