How games delete an object in the database but animate it out at the same time

Question

I am wondering about how async actions like animations work when you do actions like delete an item, and so came up with this sort of thought process and would like feedback to see if it makes sense from an industry best practice perspective.

There are two layers:

• The reactive layer.
• The rendering layer.

The reactive layer occurs instantly and can be done with traditional event dispatching.

This is where you create and delete data and it all happens instantaneously.

The state machine gets notified of these instant reactive changes.

Then the state machine "transitions". This process occurs over a period of time, assuming there are some async things that occur (animations, network requests, etc.). This is what people mean when they say "action queue".

Then the rendering layer pics up stuff off the action queue and renders it. This way there is sort of a delayed reaction to the underlying instant reactive layer.

My question is if the reactive layer needs to handle async as well. For example, deleting something.

Say an item is deleted, and you want to animate it out. There are a few ways to do this:

1. Queue up a delete action, then animate it out first. When animation is complete, then do the actual delete. If animation is interrupted (cancel the delete), then the delete is never performed.
2. Delete the item instantly (reactive layer). The animation layer keeps a reference to the item around, so can still do its animation even though from the global place it is deleted. If the animation is cancelled, then you would have to do an "undo" sort of thing which is more complex.

If (1) is the way to go, then there is no reactive layer, and everything is implemented with a sort of action queue in mind. This makes it harder to make reusable code because everything is tied to the action-queue idea.

If (2) is the way to go, then there are two copies of the data, the global copy, and the local copy, which is kept in sync asynchronously. This makes it easier to have reusable code but makes it more complicated to reason about.

Wondering if any of this makes sense, and if any of these approaches is better practice in the industry (or if there is an alternative I didn't address that makes more sense).

Put another way, there are two main ways to do it:

1. Eager: Delete it now, okay everyone we've deleted it, time to come back inside. And wait for everything to trinkle back in to call it "done".
2. Cautious: Announce "we are going to delete it", then wait til everything is done and comes back inside to actually do the delete.

Wondering how games and apps and such handle this sort of thing.

Update

After thinking about it a different way, maybe it would be more like the swaying of kelp in the ocean:

https://www.youtube.com/watch?v=gIeLCzR8EgA

By that I mean, there is a base layer that is immediate (does the create/delete), then there are some intermediate layers with copies of all the transactions that occurred (create/delete), that the rendering layer uses to animate create/delete. So the original data is always in sync, but the rendering layer uses a sort of older version of the data with a chain of all the changes taking place.

reactive layer -> transaction layer -> rendering layer.

Another option is flagging as delete, then only after animations are complete actually do the delete, but that seems hacky.

Update

Another version:

• Reactive version
  • Always has the latest data. (a)
• Rendering version
  • Has the last data (b), plus a chain of changes leading to (a).
  • As rendering completes, it applies the changes to (b), so eventually it is like (a).

Answer 1

from my experiece as Unity Game Developer the right decision is in the middle, as for the physics in game engine are approximated because the sensation of a things semi-perfect is pretty like a perfect one.

The explanation is because the more realistic and real-life like is your goal the more you need resources, not only CPU and GPU but cash too.

after this strange preamble I quote for the flag options, the method applicated is not much different than a normal Garbade Collector, you mark a no more usefull item and when the Garbage collector come he free the ram space used by this object, so this new space can be reused.

The same process is done by a lot of engine, and the destroy operation appens before the rendering calculations.

The final goal is always to reach a good in-between solution.

There is the possibility to force the instant destruction in every moment of the engine computation process, but this solution is always deprecated.

With the animation the way u typically use is to Destroy (setting flag to be destructed) at the end of the animation or in the last few frames. At least you can use some tricks to make the fade more enjoyable (like particles).

The real problem is when you have to destroy object over the net (multiplayer games), in this case you have to establish what is the more attendible machine and pick that to calculate physics and interaction, this machine is always the server or the at least the host(depending on the game type).

I know that the question was marked as javascript question, but i couldn't resist to answer.

I enclose also a page from the unity documentation about the Destruct function were explain how they menage to remove item from a game enviroment:

https://docs.unity3d.com/ScriptReference/Object.Destroy.html

Have a nice day! and good coding.