Differences

This shows you the differences between two versions of the page.

--- en:toolworks:docs:apparatus:deferred [2022/05/29 15:33] – vladius
+++ en:toolworks:docs:apparatus:deferred [2022/06/01 20:05] – vladius
@@ Line 3: / Line 3: @@
 It's no secret and if fact by design, that you can't execute methods that change a Subject's structure when using the Solid semantics. That essentially means you can only change the state of the individual Traits themselves, but not add nor remove the Traits themselves. The main advantage of the Solid enchaining is that it provides for the concurrent Operating and it would certainly be great to have more flexibility while evaluating the multi-threaded processing.
-So there come handy the deferred operations (or //Deferreds// for short). Like the naming implies, those are not executed immediately but are instead delayed for a later, more suitable occasion.
+So there come handy the deferred operations (or //Deferreds// for short). Like the naming implies, those are not executed immediately but are instead delayed for a later, more suitable occasion. Please note, that the Deferreds API is available for C++ only, since the whole Solid semantics is also C++-based and it's not possible to Enchain into a Solid Chain in Blueprints.
 ====== Setting Traits ======
@@ Line 12: / Line 12: @@
 SolidChain->OperateConcurrently([Destination](FSolidSubjectHandle Unit) // Process the selected units in a parallel fashion.
 {
-	Unit.SetTraitDeferred(FMoveToPointOrder{Destination}); // Defer-assign a trait that's telling the unit to move to the needed point.
+	Unit.SetTraitDeferred(FMoveToPointOrder{Destination}); // Defer-assign a Trait that's telling the unit to move to the needed point.
 });
 </code>
+====== Removing Traits ======
+Removing Traits can also be deferred in a quite similar fashion. Here's an [[appi>struct_t_subject_handle.html#a56e0ae342a44051765f2a784718c188d|API]] usage example which removes a "buffed" status from the units, when it's expiring:<code cpp>
+SolidChain->OperateConcurrently([DeltaSeconds](FSolidSubjectHandle Unit, FBuffed& Buffed) // Process the selected units in a parallel fashion.
+{
+	Buffed.Timeout -= DeltaSeconds; // Decrease the initially allocated timeout using the current Tick's delta time period.
+	if (Buffed.Timeout <= 0.0f)
+	{
+		Unit.RemoveTraitDeferred<FBuffed>(); // Defer-remove the Trait when it's no longer viable.
+	}
+});
+</code>
+There is also a possibility to remove all the traits altogether. In a deferred fashion of course. This is just a matter of calling the corresponding [[appi>struct_t_subject_handle.html#a71c1b5b8374a70ed9371d102241533a2|method]] as in here:<code cpp>
+Unit.RemoveAllTraitsDeferred();
+</code>
+====== Spawning Subjects ======
+Not only traits can be added or removed in a deferred fashion but the whole Subjects can be spawned and despawned this way. So, if you have multiple units spawning a projectile when they're charged, you could do it like so:<code cpp>
+SolidChain->OperateConcurrently([Mechanism, DeltaSeconds](FSolidSubjectHandle Unit, FCharging& Charging, FDamageDealer& DamageDealer)
+{
+	Charging.Timeout -= DeltaSeconds;
+	if (Charging.Timeout <= 0.0f)
+	{
+		Mechanism->SpawnDeferred(FProjectile{DamageDealer.Power}); // Spawn a new subject with an FProjectile trait.
+	}
+});
+</code>
+====== Despawning Subjects ======
+The process of destroying a Subject is quite analogous. Kill all units once their health is zero or below. Just do something like:<code cpp>
+SolidChain->OperateConcurrently([](FSolidSubjectHandle Unit, FHealth& Health)
+{
+	if (Health.Level <= 0.0f)
+	{
+		Unit.DespawnDeferred();
+	}
+});
+</code>