Added effects "Time Based Timer" and "Distance Based Timer"

ChaosMod/Components/EffectDispatchTimer.cpp

@@ -26,9 +26,13 @@ void EffectDispatchTimer::UpdateTimer(int deltaTime)
 	if (!m_EnableTimer || (ComponentExists<MetaModifiers>() && GetComponent<MetaModifiers>()->DisableChaos))
 		return;
 
+	int effectSpawnTime = ComponentExists<MetaModifiers>() && GetComponent<MetaModifiers>()->TimeToDispatchEffect > 0
+	                        ? GetComponent<MetaModifiers>()->TimeToDispatchEffect
+	                        : m_EffectSpawnTime;
+
 	m_TimerPercentage += deltaTime
 	                   * (!ComponentExists<MetaModifiers>() ? 1.f : GetComponent<MetaModifiers>()->TimerSpeedModifier)
-	                   / m_EffectSpawnTime / 1000.f;
+	                   / effectSpawnTime / 1000.f;
 
 	if (m_TimerPercentage >= 1.f && m_DispatchEffectsOnTimer && ComponentExists<EffectDispatcher>())
 	{
@@ -66,14 +70,22 @@ void EffectDispatchTimer::UpdateTravelledDistance()
 		return;
 	}
 
+	int effectSpawnDistance =
+	    ComponentExists<MetaModifiers>() && GetComponent<MetaModifiers>()->DistanceToDispatchEffect > 0
+	        ? GetComponent<MetaModifiers>()->DistanceToDispatchEffect
+	        : m_DistanceChaosState.DistanceToActivateEffect;
+
 	auto distance =
 	    GET_DISTANCE_BETWEEN_COORDS(position.x, position.y, position.z, m_DistanceChaosState.SavedPosition.x,
 	                                m_DistanceChaosState.SavedPosition.y, m_DistanceChaosState.SavedPosition.z, true);
 
 	if (m_DistanceChaosState.DistanceType == DistanceChaosState::TravelledDistanceType::Displacement)
 	{
-		if (distance * (ComponentExists<MetaModifiers>() ? GetComponent<MetaModifiers>()->TimerSpeedModifier : 1.f)
-		    >= m_DistanceChaosState.DistanceToActivateEffect)
+		m_TimerPercentage =
+		    (distance * (ComponentExists<MetaModifiers>() ? GetComponent<MetaModifiers>()->TimerSpeedModifier : 1.f))
+		    / effectSpawnDistance;
+
+		if (m_TimerPercentage >= 1.f)
 		{
 			if (m_DispatchEffectsOnTimer && ComponentExists<EffectDispatcher>())
 			{
@@ -86,17 +98,13 @@ void EffectDispatchTimer::UpdateTravelledDistance()
 
 			m_DistanceChaosState.SavedPosition = position;
 		}
-
-		m_TimerPercentage =
-		    (distance * (ComponentExists<MetaModifiers>() ? GetComponent<MetaModifiers>()->TimerSpeedModifier : 1.f))
-		    / m_DistanceChaosState.DistanceToActivateEffect;
 	}
 	else if (m_DistanceChaosState.DistanceType == DistanceChaosState::TravelledDistanceType::Distance)
 	{
 		m_DistanceChaosState.SavedPosition = position;
 		m_TimerPercentage +=
 		    (distance * (ComponentExists<MetaModifiers>() ? GetComponent<MetaModifiers>()->TimerSpeedModifier : 1.f))
-		    / m_DistanceChaosState.DistanceToActivateEffect;
+		    / effectSpawnDistance;
 
 		if (m_TimerPercentage >= 1.f && m_DispatchEffectsOnTimer && ComponentExists<EffectDispatcher>())
 		{
@@ -121,6 +129,21 @@ void EffectDispatchTimer::SetTimerEnabled(bool state)
 	m_EnableTimer = state;
 }
 
+int EffectDispatchTimer::GetDefaultEffectSpawnTime() const
+{
+	return m_EffectSpawnTime;
+}
+
+int EffectDispatchTimer::GetDefaultEffectSpawnDistance() const
+{
+	return m_DistanceChaosState.DistanceToActivateEffect;
+}
+
+void EffectDispatchTimer::ResetSavedPosition()
+{
+	m_DistanceChaosState.SavedPosition = GET_ENTITY_COORDS(PLAYER_PED_ID(), false);
+}
+
 std::uint64_t EffectDispatchTimer::GetTimer() const
 {
 	return m_Timer;
@@ -204,10 +227,24 @@ void EffectDispatchTimer::OnRun()
 
 	if (!m_PauseTimer)
 	{
-		if (m_DistanceChaosState.EnableDistanceBasedEffectDispatch)
-			UpdateTravelledDistance();
-		else
+		const TimerMode modeOverride =
+		    ComponentExists<MetaModifiers>() ? GetComponent<MetaModifiers>()->TimerModeOverride : TimerMode::None;
+
+		switch (modeOverride)
+		{
+		case TimerMode::Time:
 			UpdateTimer(deltaTime);
+			break;
+		case TimerMode::Distance:
+			UpdateTravelledDistance();
+			break;
+		default:
+			if (m_DistanceChaosState.EnableDistanceBasedEffectDispatch)
+				UpdateTravelledDistance();
+			else
+				UpdateTimer(deltaTime);
+			break;
+		}
 	}
 
 	m_Timer = curTime;

ChaosMod/Components/EffectDispatchTimer.h

@@ -38,6 +38,11 @@ class EffectDispatchTimer : public Component
 	bool IsTimerEnabled() const;
 	void SetTimerEnabled(bool state);
 
+	int GetDefaultEffectSpawnTime() const;
+	int GetDefaultEffectSpawnDistance() const;
+
+	void ResetSavedPosition();
+
 	std::uint64_t GetTimer() const;
 	void ResetTimer();
 

ChaosMod/Components/LuaScripts.cpp

@@ -555,6 +555,11 @@ void LuaScripts::SetupGlobalState()
 	                                    "Integer", LuaNativeReturnType::Int, "String", LuaNativeReturnType::String,
 	                                    "Float", LuaNativeReturnType::Float, "Vector3", LuaNativeReturnType::Vector3);
 
+	m_GlobalState.new_enum("TimerMode", "None", TimerMode::None, "Time", TimerMode::Time, "Distance", TimerMode::Distance);
+
+	m_GlobalState.new_enum("VotingMode", "None", VotingMode::None, "Majority", VotingMode::Majority, "Percentage",
+	                       VotingMode::Percentage, "Antimajority", VotingMode::Antimajority);
+
 	if (ComponentExists<MetaModifiers>())
 	{
 		auto getMetaModFactory = []<typename T>(T &modifier)
@@ -580,7 +585,9 @@ void LuaScripts::SetupGlobalState()
 		auto metaModifiersMetaTable = m_GlobalState.create_table_with(
 		    "EffectDurationModifier", P(EffectDurationModifier), "TimerSpeedModifier", P(TimerSpeedModifier),
 		    "AdditionalEffectsToDispatch", P(AdditionalEffectsToDispatch), "HideChaosUI", P(HideChaosUI),
-		    "DisableChaos", P(DisableChaos), "FlipChaosUI", P(FlipChaosUI));
+		    "DisableChaos", P(DisableChaos), "FlipChaosUI", P(FlipChaosUI), "VotingModeOverride", P(VotingModeOverride),
+		    "TimerModeOverride", P(TimerModeOverride), "TimeToDispatchEffect", P(TimeToDispatchEffect),
+		    "DistanceToDispatchEffect", P(DistanceToDispatchEffect));
 #undef P
 		metaModifiersMetaTable[sol::meta_function::new_index] = [] {};
 		metaModifiersMetaTable[sol::meta_function::index] = metaModifiersMetaTable;

ChaosMod/Components/MetaModifiers.h

@@ -2,6 +2,7 @@
 
 #include "Components/Component.h"
 #include "Util/VotingMode.h"
+#include "Util/TimerMode.h"
 
 #include <cstdint>
 
@@ -15,4 +16,7 @@ class MetaModifiers : public Component
 	bool DisableChaos                        = false;
 	bool FlipChaosUI                         = false;
 	VotingMode VotingModeOverride            = VotingMode::None;
+	TimerMode TimerModeOverride              = TimerMode::None;
+	int TimeToDispatchEffect                 = 0;
+	int DistanceToDispatchEffect             = 0;
 };

ChaosMod/Effects/Condition/ConditionUsingDistanceTimer.cpp

@@ -0,0 +1,11 @@
+#include <stdafx.h>
+
+#include "Components/EffectDispatchTimer.h"
+#include "Effects/Condition/EffectCondition.h"
+
+static bool OnCondition()
+{
+	return ComponentExists<EffectDispatchTimer>() && GetComponent<EffectDispatchTimer>()->IsUsingDistanceBasedDispatch();
+}
+
+REGISTER_EFFECT_CONDITION(EffectConditionType::UsingDistanceTimer, OnCondition);

ChaosMod/Effects/Condition/ConditionUsingTimeTimer.cpp

@@ -0,0 +1,11 @@
+#include <stdafx.h>
+
+#include "Components/EffectDispatchTimer.h"
+#include "Effects/Condition/EffectCondition.h"
+
+static bool OnCondition()
+{
+	return ComponentExists<EffectDispatchTimer>() && !GetComponent<EffectDispatchTimer>()->IsUsingDistanceBasedDispatch();
+}
+
+REGISTER_EFFECT_CONDITION(EffectConditionType::UsingTimeTimer, OnCondition);

ChaosMod/Effects/Condition/EffectCondition.h

@@ -7,7 +7,9 @@ enum class EffectConditionType
 {
 	None,
 	VotingEnabled, // Voting is enabled
-	ProportionalVotingEnabled
+	ProportionalVotingEnabled,
+	UsingDistanceTimer,
+	UsingTimeTimer,
 };
 
 #define REGISTER_EFFECT_CONDITION(conditionType, condition)                           \

ChaosMod/Effects/db/Meta/MetaTimerMode.cpp

@@ -0,0 +1,77 @@
+/*
+    Effects by Regynate
+*/
+
+#include <stdafx.h>
+
+#include "Components/MetaModifiers.h"
+#include "Effects/Register/RegisterEffect.h"
+#include <Components/EffectDispatchTimer.h>
+
+static void OnStop()
+{
+	if (!ComponentExists<MetaModifiers>())
+		return;
+
+	GetComponent<MetaModifiers>()->TimerModeOverride = TimerMode::None;
+	GetComponent<MetaModifiers>()->DistanceToDispatchEffect = 0;
+	GetComponent<MetaModifiers>()->TimeToDispatchEffect = 0;
+	if (ComponentExists<EffectDispatchTimer>())
+		GetComponent<EffectDispatchTimer>()->ResetSavedPosition();
+}
+
+static void OnTick_Time()
+{
+	if (!ComponentExists<MetaModifiers>())
+		return;
+
+	GetComponent<MetaModifiers>()->TimerModeOverride = TimerMode::Time;
+
+	int defaultDistance = ComponentExists<EffectDispatchTimer>()
+	                    ? GetComponent<EffectDispatchTimer>()->GetDefaultEffectSpawnDistance()
+	                    : 0;
+	GetComponent<MetaModifiers>()->TimeToDispatchEffect = defaultDistance ? defaultDistance / 10 : 30;
+}
+
+// clang-format off
+REGISTER_EFFECT(nullptr, OnStop, OnTick_Time,
+	{
+		.Name = "Time Based Timer",
+		.Id = "meta_timer_timebased",
+		.IsTimed = true,
+		.IncompatibleWith = { "meta_timer_distancebased" },
+		.ExecutionType = EffectExecutionType::Meta,
+		.ConditionType = EffectConditionType::UsingDistanceTimer
+	}
+);
+// clang-format on
+
+static void OnTick_Distance()
+{
+	if (!ComponentExists<MetaModifiers>())
+		return;
+
+	GetComponent<MetaModifiers>()->TimerModeOverride = TimerMode::Distance;
+	int defaultTime =
+	    ComponentExists<EffectDispatchTimer>() ? GetComponent<EffectDispatchTimer>()->GetDefaultEffectSpawnTime() : 0;
+	GetComponent<MetaModifiers>()->DistanceToDispatchEffect = defaultTime ? defaultTime * 10 : 300;
+}
+
+static void OnStart_Distance()
+{
+	if (ComponentExists<EffectDispatchTimer>())
+		GetComponent<EffectDispatchTimer>()->ResetSavedPosition();
+}
+
+// clang-format off
+REGISTER_EFFECT(OnStart_Distance, OnStop, OnTick_Distance,
+	{
+		.Name = "Distance Based Timer",
+		.Id = "meta_timer_distancebased",
+		.IsTimed = true,
+		.IncompatibleWith = { "meta_timer_timebased" },
+		.ExecutionType = EffectExecutionType::Meta,
+		.ConditionType = EffectConditionType::UsingTimeTimer
+	}
+);
+// clang-format on

ChaosMod/Util/TimerMode.h

@@ -0,0 +1,6 @@
+enum class TimerMode
+{
+	None,
+	Time,
+	Distance
+};

ConfigApp/Effects.cs

@@ -416,6 +416,8 @@ public enum EffectTimedType
             { "player_tptowaypointopposite", new EffectInfo("Teleport To The Opposite Side Of Waypoint", EffectCategory.Player) },
             { "meta_votingmode_majority", new EffectInfo("Majority Voting", EffectCategory.Meta, true) },
             { "meta_votingmode_antimajority", new EffectInfo("Minority Voting", EffectCategory.Meta, true) },
+            { "meta_timer_distancebased", new EffectInfo("Distance Based Timer", EffectCategory.Meta, true) },
+            { "meta_timer_timebased", new EffectInfo("Time Based Timer", EffectCategory.Meta, true) },
         };
     }
 }