Merge pull request #153 from cortex-command-community/emissionparticlecount

Add ParticleCount to emissions, updates to InheritsVel

Author: Causeless

CHANGELOG.md

@@ -73,6 +73,12 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 - Allow lua scripts to use LuaJIT's BitOp module (see https://bitop.luajit.org/api.html)
 
+- New `Emission` INI and Lua (R/W) property `ParticleCount` which sets how many particles the Emission spawns per emission. Defaults to 1.
+
+- New `Gib` and `Emission` INI and Lua (R/W) property `InheritsAngularVel`, which determines how much of the parent MO's angular velocity they inherit. Defaults to 1 for gibs, 0 for emissions.
+
+- New `Attachable` INI and Lua (R/W) properties `InheritsVelWhenDetached` and `InheritsAngularVelWhenDetached`, which determine how much of these velocities an attachable inherits from its parent when detached. Defaults to 1.
+
 </details>
 
 <details><summary><b>Changed</b></summary>
@@ -109,7 +115,11 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 - Almost all ctrl+* special inputs functionality (i.e restarting activity, world dumps, showing performance stats) are now mapped to right alt, to not interfere with default crouching inputs. The only exception is ctrl+arrow keys for changing console size.
 
-- Gibs and detached Attachables now inherit the parent's angular velocity, as well as velocity derived from the angular velocity of the parent MO and their offset from the parent's centre. On gibs, this is scaled by `InheritsVel`.
+- `Gib`s and detached `Attachable`s now inherit the parent's angular velocity by default.
+
+- `InheritsVel` now accounts for the angular velocity of the parent MO, resulting in offset gibs and emissions being flung further away.
+
+- `InheritsVel` and its ilk have been uncapped, allowing users to set them outside of 0-1.
 
 </details>
 

Source/Entities/AEmitter.cpp

@@ -446,9 +446,14 @@ void AEmitter::Update() {
 					scale = m_BurstScale;
 				}
 				emissionCountTotal += emissionCount;
+				if (emissionCount > 0) {
+					int extraEmissions = emission.GetParticleCount() - 1;
+					emissionCount += extraEmissions;
+				}
 				pParticle = 0;
 				emitVel.Reset();
 				parentVel = pRootParent->GetVel() * emission.InheritsVelocity();
+				Vector rotationalVel = (((RotateOffset(emission.GetOffset()) + (m_Pos - pRootParent->GetPos())) * pRootParent->GetAngularVel()).GetPerpendicular() / c_PPM) * emission.InheritsVelocity();
 
 				for (int i = 0; i < emissionCount; ++i) {
 					velMin = emission.GetMinVelocity() * scale;
@@ -472,8 +477,9 @@ void AEmitter::Update() {
 					emitVel.SetXY(velMin + RandomNum(0.0F, velRange), 0.0F);
 					emitVel.RadRotate(m_EmitAngle.GetRadAngle() + spread * RandomNormalNum());
 					emitVel = RotateOffset(emitVel);
-					pParticle->SetVel(parentVel + emitVel);
+					pParticle->SetVel(parentVel + rotationalVel + emitVel);
 					pParticle->SetRotAngle(emitVel.GetAbsRadAngle() + (m_HFlipped ? -c_PI : 0));
+					pParticle->SetAngularVel(pRootParent->GetAngularVel() * emission.InheritsAngularVelocity());
 					pParticle->SetHFlipped(m_HFlipped);
 
 					// Scale the particle's lifetime based on life variation and throttle, as long as it's not 0

Source/Entities/Attachable.cpp

@@ -48,6 +48,8 @@ void Attachable::Clear() {
 	m_InheritedRotAngleOffset = 0;
 	m_MountedRotAngleOffset = 0.0F;
 	m_InheritsFrame = false;
+	m_InheritsVelWhenDetached = 1.0F;
+	m_InheritsAngularVelWhenDetached = 1.0F;
 
 	m_AtomSubgroupID = -1L;
 	m_CollidesWithTerrainWhileAttached = true;
@@ -98,6 +100,8 @@ int Attachable::Create(const Attachable& reference) {
 	m_InheritedRotAngleOffset = reference.m_InheritedRotAngleOffset;
 	m_MountedRotAngleOffset = reference.m_MountedRotAngleOffset;
 	m_InheritsFrame = reference.m_InheritsFrame;
+	m_InheritsVelWhenDetached = reference.m_InheritsVelWhenDetached;
+	m_InheritsAngularVelWhenDetached = reference.m_InheritsAngularVelWhenDetached;
 
 	m_AtomSubgroupID = GetUniqueID();
 	m_CollidesWithTerrainWhileAttached = reference.m_CollidesWithTerrainWhileAttached;
@@ -147,6 +151,8 @@ int Attachable::ReadProperty(const std::string_view& propName, Reader& reader) {
 	MatchProperty("InheritedRotAngleDegOffset", { m_InheritedRotAngleOffset = DegreesToRadians(std::stof(reader.ReadPropValue())); });
 	MatchProperty("MountedRotAngleOffset", { reader >> m_MountedRotAngleOffset; });
 	MatchProperty("InheritsFrame", { reader >> m_InheritsFrame; });
+	MatchProperty("InheritsVelWhenDetached", { reader >> m_InheritsVelWhenDetached; });
+	MatchProperty("InheritsAngularVelWhenDetached", { reader >> m_InheritsAngularVelWhenDetached; });
 	MatchProperty("CollidesWithTerrainWhileAttached", { reader >> m_CollidesWithTerrainWhileAttached; });
 	MatchProperty("IgnoresParticlesWhileAttached", { reader >> m_IgnoresParticlesWhileAttached; });
 	MatchProperty("AddPieSlice", { m_PieSlices.emplace_back(std::unique_ptr<PieSlice>(dynamic_cast<PieSlice*>(g_PresetMan.ReadReflectedPreset(reader)))); });
@@ -173,7 +179,9 @@ int Attachable::Save(Writer& writer) const {
 	writer.NewPropertyWithValue("InheritsHFlipped", ((m_InheritsHFlipped == 0 || m_InheritsHFlipped == 1) ? m_InheritsHFlipped : 2));
 	writer.NewPropertyWithValue("InheritsRotAngle", m_InheritsRotAngle);
 	writer.NewPropertyWithValue("InheritedRotAngleOffset", m_InheritedRotAngleOffset);
-	writer.NewPropertyWithValue("MountedRotAngleOffset", m_MountedRotAngleOffset);
+  writer.NewPropertyWithValue("MountedRotAngleOffset", m_MountedRotAngleOffset);
+	writer.NewPropertyWithValue("InheritsVelWhenDetached", m_InheritsVelWhenDetached);
+	writer.NewPropertyWithValue("InheritsAngularVelWhenDetached", m_InheritsAngularVelWhenDetached);
 
 	writer.NewPropertyWithValue("CollidesWithTerrainWhileAttached", m_CollidesWithTerrainWhileAttached);
 	writer.NewPropertyWithValue("IgnoresParticlesWhileAttached", m_IgnoresParticlesWhileAttached);

Source/Entities/Attachable.h

@@ -276,6 +276,23 @@ namespace RTE {
 		/// Sets whether or not this Attachable inherits its Frame from its parent, if attached.
 		/// @param inheritsFrame Whether or not to inherit its parent's Frame.
 		void SetInheritsFrame(bool inheritsFrame) { m_InheritsFrame = inheritsFrame; }
+
+		/// How much of the root parent's velocity this attachable inherits when detached
+		/// @return The proportion of the velocity inherited. 0.1 = 10% inheritance.
+		float InheritsVelocityWhenDetached() const { return m_InheritsVelWhenDetached; }
+
+		/// How much of the root parent's angular velocity this attachable inherits when detached
+		/// @return The proportion of the angular velocity inherited. 0.1 = 10% inheritance.
+		float InheritsAngularVelocityWhenDetached() const { return m_InheritsAngularVelWhenDetached; }
+
+		/// Sets how much of the root parent's velocity this attachable inherits when detached
+		/// @param The proportion of the velocity inherited. 0.1 = 10% inheritance.
+		void SetInheritsVelocityWhenDetached(float newValue) { m_InheritsVelWhenDetached = newValue; }
+
+		/// Sets how much of the root parent's angular velocity this attachable inherits when detached
+		/// @param The proportion of the angular velocity inherited. 0.1 = 10% inheritance.
+		void SetInheritsAngularVelocityWhenDetached(float newValue) { m_InheritsAngularVelWhenDetached = newValue; }
+
 #pragma endregion
 
 #pragma region Collision Management
@@ -447,6 +464,9 @@ namespace RTE {
 		float m_MountedRotAngleOffset; //!< A relative offset angle (in radians) of this Attachable's rotation that should only be set by Turrets. Defaults to 0.
 		bool m_InheritsFrame; //!< Whether this Attachable should inherit its parent's Frame. Defaults to false.
 
+		float m_InheritsVelWhenDetached; //!< How much of the parents velocity this attachable inherits when detached
+		float m_InheritsAngularVelWhenDetached; //!< How much of the parents angular velocity this attachable inherits when detached
+
 		long m_AtomSubgroupID; //!< The Atom IDs this' atoms will have when attached and added to a parent's AtomGroup.
 		bool m_CollidesWithTerrainWhileAttached; //!< Whether this attachable currently has terrain collisions enabled while it's attached to a parent.
 		bool m_IgnoresParticlesWhileAttached; //!< Whether this Attachable should ignore collisions with single-atom MOs while attached.

Source/Entities/Emission.cpp

@@ -17,12 +17,14 @@ void Emission::Clear() {
 	m_MaxVelocity = 0;
 	m_LifeVariation = 0.1;
 	m_PushesEmitter = true;
-	m_InheritsVel = 0;
+	m_InheritsVel = 0.0F;
+	m_InheritsAngularVel = 0.0F;
 	m_StartTimer.SetSimTimeLimitMS(0);
 	m_StartTimer.Reset();
 	m_StopTimer.SetSimTimeLimitMS(1000000);
 	m_StopTimer.Reset();
 	m_Offset.Reset();
+	m_ParticleCount = 1;
 }
 
 /*
@@ -46,9 +48,11 @@ int Emission::Create(const Emission& reference) {
 	m_LifeVariation = reference.m_LifeVariation;
 	m_PushesEmitter = reference.m_PushesEmitter;
 	m_InheritsVel = reference.m_InheritsVel;
+	m_InheritsAngularVel = reference.m_InheritsAngularVel;
 	m_StartTimer = reference.m_StartTimer;
 	m_StopTimer = reference.m_StopTimer;
 	m_Offset = reference.m_Offset;
+	m_ParticleCount = reference.m_ParticleCount;
 
 	return 0;
 }
@@ -69,11 +73,9 @@ int Emission::ReadProperty(const std::string_view& propName, Reader& reader) {
 	MatchProperty("LifeVariation", { reader >> m_LifeVariation; });
 	MatchProperty("PushesEmitter", { reader >> m_PushesEmitter; });
 	MatchProperty("Offset", { reader >> m_Offset; });
-	MatchProperty("InheritsVel",
-	              {
-		              reader >> m_InheritsVel;
-		              Clamp(m_InheritsVel, 1, 0);
-	              });
+	MatchProperty("ParticleCount", { reader >> m_ParticleCount; });
+	MatchProperty("InheritsVel", { reader >> m_InheritsVel; });
+	MatchProperty("InheritsAngularVel", { reader >> m_InheritsAngularVel; });
 	MatchProperty("StartTimeMS",
 	              {
 		              double startTime;
@@ -111,12 +113,16 @@ int Emission::Save(Writer& writer) const {
 	writer << m_PushesEmitter;
 	writer.NewProperty("InheritsVel");
 	writer << m_InheritsVel;
+	writer.NewProperty("InheritsAngularVel");
+	writer << m_InheritsAngularVel;
 	writer.NewProperty("Offset");
 	writer << m_Offset;
 	writer.NewProperty("StartTimeMS");
 	writer << m_StartTimer.GetSimTimeLimitMS();
 	writer.NewProperty("StopTimeMS");
 	writer << m_StopTimer.GetSimTimeLimitMS();
+	writer.NewProperty("ParticleCount");
+	writer << m_ParticleCount;
 
 	return 0;
 }

Source/Entities/Emission.h

@@ -114,9 +114,21 @@ namespace RTE {
 			m_StopTimer.Reset();
 		}
 
-		/// How much of the root parent's velocity this emission inherit
+		/// How much of the root parent's velocity this emission inherits
 		/// @return The proportion of the velocity inherited. 0.1 = 10% inheritance.
-		float InheritsVelocity() { return m_InheritsVel; }
+		float InheritsVelocity() const { return m_InheritsVel; }
+
+		/// How much of the root parent's angular velocity this emission inherits
+		/// @return The proportion of the angular velocity inherited. 0.1 = 10% inheritance.
+		float InheritsAngularVelocity() const { return m_InheritsAngularVel; }
+
+		/// Sets how much of the root parent's velocity this emission inherits
+		/// @param The proportion of the velocity inherited. 0.1 = 10% inheritance.
+		void SetInheritsVelocity(float newValue) { m_InheritsVel = newValue; }
+
+		/// Sets how much of the root parent's angular velocity this emission inherits
+		/// @param The proportion of the angular velocity inherited. 0.1 = 10% inheritance.
+		void SetInheritsAngularVelocity(float newValue) { m_InheritsAngularVel = newValue; }
 
 		/// Gets offset of the emission point from Emitter's sprite center, which gets rotated with owner Emitter
 		/// @return Returns emission offset.
@@ -126,6 +138,14 @@ namespace RTE {
 		/// @param offset New offset value.
 		void SetOffset(Vector offset) { m_Offset = offset; }
 
+		/// Returns number of particles emitted per emission.
+		/// @return Number of particles emitted per emission.
+		int GetParticleCount() const { return m_ParticleCount; }
+
+		/// Sets number of particles emitted per emission.
+		/// @param newParticleCount The new number of particles emitted per emission.
+		void SetParticleCount(int newParticleCount) { m_ParticleCount = newParticleCount; }
+
 		/// Protected member variable and method declarations
 	protected:
 		// Member variables
@@ -157,11 +177,15 @@ namespace RTE {
 		bool m_PushesEmitter;
 		// How much of the parents velocity this emission inherits
 		float m_InheritsVel;
+		// How much of the parents angular velocity this emission inherits
+		float m_InheritsAngularVel;
 		// Timers for measuring when to start and stop this emission the actual times are the set time limits of these
 		Timer m_StartTimer;
 		Timer m_StopTimer;
 		// Offset of the emission point from Emitter's sprite center, which gets rotated with owner Emitter
 		Vector m_Offset;
+		// The number of particles emitted per emission
+		int m_ParticleCount;
 
 		/// Private member variable and method declarations
 	private:

Source/Entities/Gib.cpp

@@ -23,6 +23,7 @@ void Gib::Clear() {
 	m_MaxVelocity = 0;
 	m_LifeVariation = 0.1F;
 	m_InheritsVel = 1.0F;
+	m_InheritsAngularVel = 1.0F;
 	m_IgnoresTeamHits = false;
 	m_SpreadMode = SpreadMode::SpreadRandom;
 }
@@ -36,6 +37,7 @@ int Gib::Create(const Gib& reference) {
 	m_MaxVelocity = reference.m_MaxVelocity;
 	m_LifeVariation = reference.m_LifeVariation;
 	m_InheritsVel = reference.m_InheritsVel;
+	m_InheritsAngularVel = reference.m_InheritsAngularVel;
 	m_IgnoresTeamHits = reference.m_IgnoresTeamHits;
 	m_SpreadMode = reference.m_SpreadMode;
 
@@ -56,6 +58,7 @@ int Gib::ReadProperty(const std::string_view& propName, Reader& reader) {
 	MatchProperty("MaxVelocity", { reader >> m_MaxVelocity; });
 	MatchProperty("LifeVariation", { reader >> m_LifeVariation; });
 	MatchProperty("InheritsVel", { reader >> m_InheritsVel; });
+	MatchProperty("InheritsAngularVel", { reader >> m_InheritsAngularVel; });
 	MatchProperty("IgnoresTeamHits", { reader >> m_IgnoresTeamHits; });
 	MatchProperty("SpreadMode", { m_SpreadMode = static_cast<SpreadMode>(std::stoi(reader.ReadPropValue())); });
 
@@ -89,6 +92,8 @@ int Gib::Save(Writer& writer) const {
 	writer << m_LifeVariation;
 	writer.NewProperty("InheritsVel");
 	writer << m_InheritsVel;
+	writer.NewProperty("InheritsAngularVel");
+	writer << m_InheritsAngularVel;
 	*/
 
 	return 0;

Source/Entities/Gib.h

@@ -86,6 +86,10 @@ namespace RTE {
 		/// @return The proportion of inherited velocity as a scalar from 0 to 1.
 		float InheritsVelocity() const { return m_InheritsVel; }
 
+		/// Gets how much of the gibbing parent's angular velocity this Gib's GibParticles should inherit.
+		/// @return The proportion of inherited velocity as a scalar from 0 to 1.
+		float InheritsAngularVelocity() const { return m_InheritsAngularVel; }
+
 		/// Gets whether this Gib's GibParticles should ignore hits with the team of the gibbing parent.
 		/// @return Whether this Gib's GibParticles should ignore hits with the team of the gibbing parent.
 		bool IgnoresTeamHits() const { return m_IgnoresTeamHits; }
@@ -108,6 +112,7 @@ namespace RTE {
 		float m_MaxVelocity; //!< The maximum velocity a GibParticle object can have when spawned.
 		float m_LifeVariation; //!< The per-Gib variation in Lifetime, in percentage of the existing Lifetime of the gib.
 		float m_InheritsVel; //!< How much of the exploding parent's velocity this Gib should inherit.
+		float m_InheritsAngularVel; //!< How much of the exploding parent's angular velocity this Gib should inherit.
 		bool m_IgnoresTeamHits; //!< Whether this Gib should ignore hits with the team of the exploding parent or not.
 		SpreadMode m_SpreadMode; //!< Determines what kind of logic is used when applying velocity to the GibParticle objects.
 

Source/Entities/MOSRotating.cpp

@@ -943,12 +943,10 @@ void MOSRotating::CreateGibsWhenGibbing(const Vector& impactImpulse, MovableObje
 				Vector gibVelocity(radius * scale + minVelocity, 0);
 				gibVelocity.RadRotate(randAngle + RandomNum(0.0F, spread) + static_cast<float>(i) * goldenAngle);
 
-				if (gibSettingsObject.InheritsVelocity() > 0) {
-					Vector offsetFromRootParent = m_Pos - GetRootParent()->GetPos() + rotatedGibOffset;
-					Vector rotationalVelocity = (offsetFromRootParent.GetPerpendicular() * GetRootParent()->GetAngularVel() * gibSettingsObject.InheritsVelocity()) / c_PPM;
-					gibVelocity += rotationalVelocity;
-					gibParticleClone->SetAngularVel(gibParticleClone->GetAngularVel() + GetRootParent()->GetAngularVel() * gibSettingsObject.InheritsVelocity());
-				}
+				Vector offsetFromRootParent = m_Pos - GetRootParent()->GetPos() + rotatedGibOffset;
+				Vector rotationalVelocity = (offsetFromRootParent.GetPerpendicular() * GetRootParent()->GetAngularVel() * gibSettingsObject.InheritsVelocity()) / c_PPM;
+				gibVelocity += rotationalVelocity;
+				gibParticleClone->SetAngularVel(gibParticleClone->GetAngularVel() + GetRootParent()->GetAngularVel() * gibSettingsObject.InheritsAngularVelocity());
 
 				if (lifetime != 0) {
 					gibParticleClone->SetLifetime(std::max(static_cast<int>(static_cast<float>(lifetime) * (1.0F - lifeVariation * ((radius / maxRadius) * 0.75F + RandomNormalNum() * 0.25F))), 1));
@@ -1007,12 +1005,10 @@ void MOSRotating::CreateGibsWhenGibbing(const Vector& impactImpulse, MovableObje
 					gibVelocity.RadRotate(gibSpread * RandomNormalNum());
 				}
 
-				if (gibSettingsObject.InheritsVelocity() > 0) {
-					Vector offsetFromRootParent = m_Pos - GetRootParent()->GetPos() + rotatedGibOffset;
-					Vector rotationalVelocity = (offsetFromRootParent.GetPerpendicular() * GetRootParent()->GetAngularVel() * gibSettingsObject.InheritsVelocity()) / c_PPM;
-					gibVelocity += rotationalVelocity;
-					gibParticleClone->SetAngularVel(gibParticleClone->GetAngularVel() + GetRootParent()->GetAngularVel() * gibSettingsObject.InheritsVelocity());
-				}
+				Vector offsetFromRootParent = m_Pos - GetRootParent()->GetPos() + rotatedGibOffset;
+				Vector rotationalVelocity = (offsetFromRootParent.GetPerpendicular() * GetRootParent()->GetAngularVel() * gibSettingsObject.InheritsVelocity()) / c_PPM;
+				gibVelocity += rotationalVelocity;
+				gibParticleClone->SetAngularVel(gibParticleClone->GetAngularVel() + GetRootParent()->GetAngularVel() * gibSettingsObject.InheritsAngularVelocity());
 
 				gibParticleClone->SetVel(gibVelocity + ((m_PrevVel + m_Vel) / 2) * gibSettingsObject.InheritsVelocity());
 
@@ -1478,9 +1474,9 @@ Attachable* MOSRotating::RemoveAttachable(Attachable* attachable, bool addToMova
 	}
 	RTEAssert(attachable->IsAttachedTo(this), "Tried to remove Attachable " + attachable->GetPresetNameAndUniqueID() + " from presumed parent " + GetPresetNameAndUniqueID() + ", but it had a different parent (" + (attachable->GetParent() ? attachable->GetParent()->GetPresetNameAndUniqueID() : "ERROR") + "). This should never happen!");
 
-	Vector rotationalVelocity = ((attachable->GetPos() - GetRootParent()->GetPos()).GetPerpendicular() * GetRootParent()->GetAngularVel()) / c_PPM;
-	attachable->SetAngularVel(attachable->GetAngularVel() + GetRootParent()->GetAngularVel());
-	attachable->SetVel(attachable->GetVel() + rotationalVelocity); // Attachables have already had their velocity updated by ApplyImpulses(), no need to add impactImpulse again
+	Vector rotationalVelocity = ((attachable->GetPos() - GetRootParent()->GetPos()).GetPerpendicular() * GetRootParent()->GetAngularVel() * attachable->InheritsVelocityWhenDetached()) / c_PPM;
+	attachable->SetAngularVel(attachable->GetAngularVel() + GetRootParent()->GetAngularVel() * attachable->InheritsAngularVelocityWhenDetached());
+	attachable->SetVel(attachable->GetVel() * attachable->InheritsVelocityWhenDetached() + rotationalVelocity); // Attachables have already had their velocity updated by ApplyImpulses(), no need to add impactImpulse again
 
 	if (!m_Attachables.empty()) {
 		m_Attachables.remove(attachable);