Fix read write lua binding definitions for iterator returns (ie can't be written to without access to C++ data structure construction methods for various types) by making them read only. Made AEmitter and PEmitter Emissions individually Lua writable, added getter and setter for Emission accumulator.

Author: Bit-Crust

Source/Entities/AEmitter.cpp

@@ -64,8 +64,8 @@ int AEmitter::Create(const AEmitter& reference) {
 		SetFlash(dynamic_cast<Attachable*>(reference.m_pFlash->Clone()));
 	}
 
-	for (auto itr = reference.m_EmissionList.begin(); itr != reference.m_EmissionList.end(); ++itr) {
-		m_EmissionList.push_back(*itr);
+	for (const Emission* emission: reference.m_EmissionList) {
+		m_EmissionList.push_back(dynamic_cast<Emission*>(emission->Clone()));
 	}
 	if (reference.m_EmissionSound) {
 		m_EmissionSound = dynamic_cast<SoundContainer*>(reference.m_EmissionSound->Clone());
@@ -105,9 +105,12 @@ int AEmitter::ReadProperty(const std::string_view& propName, Reader& reader) {
 	StartPropertyList(return Attachable::ReadProperty(propName, reader));
 
 	MatchProperty("AddEmission", {
-		Emission emission;
-		reader >> emission;
-		m_EmissionList.push_back(emission);
+		Entity* readerEntity = g_PresetMan.ReadReflectedPreset(reader);
+		if (Emission* readerEmission = dynamic_cast<Emission*>(readerEntity)) {
+			m_EmissionList.push_back(readerEmission);
+		} else {
+			reader.ReportError("Tried to AddEmission a non-Emission type!");
+		}
 	});
 	MatchProperty("EmissionSound", {
 		m_EmissionSound = new SoundContainer;
@@ -128,8 +131,8 @@ int AEmitter::ReadProperty(const std::string_view& propName, Reader& reader) {
 		float ppm;
 		reader >> ppm;
 		// Go through all emissions and set the rate so that it emulates the way it used to work, for mod backwards compatibility.
-		for (Emission& emission: m_EmissionList) {
-			emission.m_PPM = ppm / static_cast<float>(m_EmissionList.size());
+		for (Emission* emission: m_EmissionList) {
+			emission->SetRate(ppm / static_cast<float>(m_EmissionList.size()));
 		}
 	});
 	MatchProperty("NegativeThrottleMultiplier", { reader >> m_NegativeThrottleMultiplier; });
@@ -140,8 +143,8 @@ int AEmitter::ReadProperty(const std::string_view& propName, Reader& reader) {
 		int burstSize;
 		reader >> burstSize;
 		// Go through all emissions and set the rate so that it emulates the way it used to work, for mod backwards compatibility.
-		for (Emission& emission: m_EmissionList) {
-			emission.m_BurstSize = std::ceil(static_cast<float>(burstSize) / static_cast<float>(m_EmissionList.size()));
+		for (Emission* emission: m_EmissionList) {
+			emission->SetBurstSize(std::ceil(static_cast<float>(burstSize) / static_cast<float>(m_EmissionList.size())));
 		}
 	});
 	MatchProperty("BurstScale", { reader >> m_BurstScale; });
@@ -233,6 +236,10 @@ void AEmitter::Destroy(bool notInherited) {
 		m_EmissionSound->Stop();
 	}
 
+	for (auto eItr = m_EmissionList.begin(); eItr != m_EmissionList.end(); ++eItr) {
+		delete (*eItr);
+	}
+
 	delete m_EmissionSound;
 	delete m_BurstSound;
 	delete m_EndSound;
@@ -246,8 +253,8 @@ void AEmitter::Destroy(bool notInherited) {
 
 void AEmitter::ResetEmissionTimers() {
 	m_LastEmitTmr.Reset();
-	for (auto eItr = m_EmissionList.begin(); eItr != m_EmissionList.end(); ++eItr)
-		(*eItr).ResetEmissionTimers();
+	for (Emission* emission: m_EmissionList)
+		emission->ResetEmissionTimers();
 }
 
 void AEmitter::EnableEmission(bool enable) {
@@ -268,22 +275,22 @@ float AEmitter::EstimateImpulse(bool burst) {
 		float velMin, velMax, velRange, spread;
 
 		// Go through all emissions and emit them according to their respective rates
-		for (auto eItr = m_EmissionList.begin(); eItr != m_EmissionList.end(); ++eItr) {
+		for (const Emission* emission: m_EmissionList) {
 			// Only check emissions that push the emitter
-			if ((*eItr).PushesEmitter()) {
-				float emissions = ((*eItr).GetRate() / 60.0f) * g_TimerMan.GetDeltaTimeSecs();
+			if (emission->PushesEmitter()) {
+				float emissions = (emission->GetRate() / 60.0f) * g_TimerMan.GetDeltaTimeSecs();
 				float scale = 1.0F;
 				if (burst) {
-					emissions *= (*eItr).GetBurstSize();
+					emissions *= emission->GetBurstSize();
 					scale = m_BurstScale;
 				}
 
-				velMin = (*eItr).GetMinVelocity() * scale;
-				velRange = ((*eItr).GetMaxVelocity() - (*eItr).GetMinVelocity()) * 0.5F * scale;
-				spread = (std::max(static_cast<float>(c_PI) - (*eItr).GetSpread(), 0.0F) / c_PI) * scale; // A large spread will cause the forces to cancel eachother out
+				velMin = emission->GetMinVelocity() * scale;
+				velRange = (emission->GetMaxVelocity() - emission->GetMinVelocity()) * 0.5F * scale;
+				spread = (std::max(static_cast<float>(c_PI) - emission->GetSpread(), 0.0F) / c_PI) * scale; // A large spread will cause the forces to cancel eachother out
 
 				// Add to accumulative recoil impulse generated, F = m * a.
-				impulse += (velMin + velRange) * spread * (*eItr).m_pEmission->GetMass() * emissions;
+				impulse += (velMin + velRange) * spread * emission->m_pEmission->GetMass() * emissions;
 			}
 		}
 
@@ -305,16 +312,16 @@ float AEmitter::EstimateImpulse(bool burst) {
 
 float AEmitter::GetTotalParticlesPerMinute() const {
 	float totalPPM = 0;
-	for (const Emission& emission: m_EmissionList) {
-		totalPPM += emission.m_PPM;
+	for (const Emission* emission: m_EmissionList) {
+		totalPPM += emission->GetRate();
 	}
 	return totalPPM;
 }
 
 int AEmitter::GetTotalBurstSize() const {
 	int totalBurstSize = 0;
-	for (const Emission& emission: m_EmissionList) {
-		totalBurstSize += emission.m_BurstSize;
+	for (const Emission* emission: m_EmissionList) {
+		totalBurstSize += emission->GetBurstSize();
 	}
 	return totalBurstSize;
 }
@@ -382,8 +389,8 @@ void AEmitter::Update() {
 			}
 
 			// Reset the timers of all emissions so they will start/stop at the correct relative offsets from now
-			for (Emission& emission: m_EmissionList)
-				emission.ResetEmissionTimers();
+			for (Emission* emission: m_EmissionList)
+				emission->ResetEmissionTimers();
 		}
 		// Update the distance attenuation
 		else if (m_EmissionSound) {
@@ -415,11 +422,11 @@ void AEmitter::Update() {
 		MovableObject* pParticle = 0;
 		Vector parentVel, emitVel, pushImpulses;
 		// Go through all emissions and emit them according to their respective rates
-		for (Emission& emission: m_EmissionList) {
+		for (Emission* emission: m_EmissionList) {
 			// Make sure the emissions only happen between the start time and end time
-			if (emission.IsEmissionTime()) {
+			if (emission->IsEmissionTime()) {
 				// Apply the throttle factor to the emission rate
-				currentPPM = emission.GetRate() * throttleFactor;
+				currentPPM = emission->GetRate() * throttleFactor;
 				int emissionCount = 0;
 
 				// Only do all this if the PPM is actually above zero
@@ -428,72 +435,72 @@ void AEmitter::Update() {
 					SPE = 60.0 / currentPPM;
 
 					// Add the last elapsed time to the accumulator
-					emission.m_Accumulator += m_LastEmitTmr.GetElapsedSimTimeS();
+					emission->SetAccumulator(emission->GetAccumulator() + m_LastEmitTmr.GetElapsedSimTimeS());
 
 					// Now figure how many full emissions can fit in the current accumulator
-					emissionCount = std::floor(emission.m_Accumulator / SPE);
+					emissionCount = std::floor(emission->GetAccumulator() / SPE);
 					// Deduct the about to be emitted emissions from the accumulator
-					emission.m_Accumulator -= emissionCount * SPE;
+					emission->SetAccumulator(emission->GetAccumulator() - emissionCount * SPE);
 
-					RTEAssert(emission.m_Accumulator >= 0, "Emission accumulator negative!");
+					RTEAssert(emission->GetAccumulator() >= 0, "Emission accumulator negative!");
 				} else {
-					emission.m_Accumulator = 0;
+					emission->SetAccumulator(0);
 				}
 				float scale = 1.0F;
 				// Add extra emissions if bursting.
 				if (m_BurstTriggered) {
-					emissionCount += emission.GetBurstSize() * std::floor(throttleFactor);
+					emissionCount += emission->GetBurstSize() * std::floor(throttleFactor);
 					scale = m_BurstScale;
 				}
 				emissionCountTotal += emissionCount;
 				if (emissionCount > 0) {
-					int extraEmissions = emission.GetParticleCount() - 1;
+					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();
+				Vector rotationalVel = (((RotateOffset(emission->GetOffset()) + (m_Pos - pRootParent->GetPos())) * pRootParent->GetAngularVel()).GetPerpendicular() / c_PPM) * emission->InheritsVelocity();
+				parentVel = pRootParent->GetVel() * emission->InheritsVelocity();
 
 				for (int i = 0; i < emissionCount; ++i) {
-					velMin = emission.GetMinVelocity() * scale;
-					velRange = (emission.GetMaxVelocity() - emission.GetMinVelocity()) * scale;
-					spread = emission.GetSpread() * scale;
+					velMin = emission->GetMinVelocity() * scale;
+					velRange = (emission->GetMaxVelocity() - emission->GetMinVelocity()) * scale;
+					spread = emission->GetSpread() * scale;
 					// Make a copy after the reference particle
-					pParticle = dynamic_cast<MovableObject*>(emission.GetEmissionParticlePreset()->Clone());
+					pParticle = dynamic_cast<MovableObject*>(emission->GetEmissionParticlePreset()->Clone());
 					// Set up its position and velocity according to the parameters of this.
 					// Emission point offset not set
 
-					if (emission.GetOffset().IsZero()) {
+					if (emission->GetOffset().IsZero()) {
 						if (m_EmissionOffset.IsZero()) {
 							pParticle->SetPos(m_Pos);
 						} else {
 							pParticle->SetPos(m_Pos + RotateOffset(m_EmissionOffset));
 						}
 					} else {
-						pParticle->SetPos(m_Pos + RotateOffset(emission.GetOffset()));
+						pParticle->SetPos(m_Pos + RotateOffset(emission->GetOffset()));
 					}
 					// TODO: Optimize making the random angles!")
 					emitVel.SetXY(velMin + RandomNum(0.0F, velRange), 0.0F);
 					emitVel.RadRotate(m_EmitAngle.GetRadAngle() + spread * RandomNormalNum());
 					emitVel = RotateOffset(emitVel);
 					pParticle->SetVel(parentVel + rotationalVel + emitVel);
 					pParticle->SetRotAngle(emitVel.GetAbsRadAngle() + (m_HFlipped ? -c_PI : 0));
-					pParticle->SetAngularVel(pRootParent->GetAngularVel() * emission.InheritsAngularVelocity());
+					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
 					if (pParticle->GetLifetime() != 0) {
-						pParticle->SetLifetime(std::max(static_cast<int>(static_cast<float>(pParticle->GetLifetime()) * (1.0F + (emission.GetLifeVariation() * RandomNormalNum()))), 1));
+						pParticle->SetLifetime(std::max(static_cast<int>(static_cast<float>(pParticle->GetLifetime()) * (1.0F + (emission->GetLifeVariation() * RandomNormalNum()))), 1));
 						pParticle->SetLifetime(std::max(static_cast<int>(pParticle->GetLifetime() * throttleFactor), 1));
 					}
 					pParticle->SetTeam(m_Team);
 					pParticle->SetIgnoresTeamHits(true);
 
 					// Add to accumulative recoil impulse generated, F = m * a
 					// If enabled, that is
-					if (emission.PushesEmitter() && (GetParent() || GetMass() > 0)) {
-						pushImpulses -= emitVel * pParticle->GetMass();
+					if (emission->PushesEmitter() && (GetParent() || GetMass() > 0)) {
+						pushImpulses += -emitVel * pParticle->GetMass();
 					}
 
 					// Set the emitted particle to not hit this emitter's parent, if applicable

Source/Entities/AEmitter.h

@@ -77,6 +77,10 @@ namespace RTE {
 		/// @return The combined burst size of all Emissions in this AEmitter.
 		int GetTotalBurstSize() const;
 
+		/// Gets the list of Emissions of this AEmitter.
+		/// @return The list of Emissions of this AEmitter.
+		const std::vector<Emission*>& GetEmissionList() const { return m_EmissionList; }
+
 		/// Gets the scale factor that will be applied to the regular spread and
 		/// emission velocity to get the burst particle parameters.
 		/// @return The scale factor.
@@ -366,8 +370,8 @@ namespace RTE {
 		// Member variables
 		static Entity::ClassInfo m_sClass;
 
-		// The list of MO instances that get emitted
-		std::vector<Emission> m_EmissionList;
+		// The list of pointers to MO emission objects
+		std::vector<Emission*> m_EmissionList;
 		// Sounds
 		SoundContainer* m_EmissionSound;
 		SoundContainer* m_BurstSound;

Source/Entities/Emission.h

@@ -146,6 +146,14 @@ namespace RTE {
 		/// @param newParticleCount The new number of particles emitted per emission.
 		void SetParticleCount(int newParticleCount) { m_ParticleCount = newParticleCount; }
 
+		/// Returns the current time accumulation of this emitter.
+		/// @return the current time accumulation of this emitter.
+		double GetAccumulator() const { return m_Accumulator; }
+
+		/// Changes time accumulation of this emitter.
+		/// @param increment The time to be added to the accumulation.
+		void SetAccumulator(double increment) { m_Accumulator += increment; }
+
 		/// Protected member variable and method declarations
 	protected:
 		// Member variables

Source/Entities/MOSRotating.h

@@ -163,7 +163,7 @@ namespace RTE {
 
 		/// Returns whether this MOSprite is currently under the effects of
 		/// recoil.
-		bool IsRecoiled() { return m_Recoiled; }
+		bool IsRecoiled() const { return m_Recoiled; }
 
 		/// Sets whether or not this MOSRotating should check for deep penetrations
 		/// the terrain or not.
@@ -230,10 +230,6 @@ namespace RTE {
 		/// Gathers, clears and applies this MOSRotating's accumulated impulse forces, gibbing if appropriate.
 		void ApplyImpulses() override;
 
-		/// Gets the list of Attachables on this MOSRotating.
-		/// @return The list of Attachables on this MOSRotating.
-		const std::list<Attachable*>& GetAttachables() const { return m_Attachables; }
-
 		/// Gets whether or not the given Attachable is a hardcoded Attachable (e.g. an Arm, Leg, Turret, etc.)
 		/// @param attachableToCheck The Attachable to check.
 		/// @return Whether or not the Attachable is hardcoded.