


* Skeletal Mesh Tangible

* Implement Interactive Temporary Variables

* Object-Oriented Lua Support

* Investigate whether "delayed_invocations_" in lpxclient/lpxserver is really necessary.
Is it just a performance optimization, or does it need to be that way?  In particular,
I'm thinking lpxserver can do without.

* Consider targeted difference transmission for just one tangible,
meant to be used for rapid update after the player invokes a thread on that one tangible.

* Do we really need can_be_controlled?

* Think about terrain / backgrounds

* Think about downloading assets


Secret / semi-secret variables

Secret functions

Blockchain integration

More sophisticated passage of time

Little game demos:

The monopoly game (Errands where you pass thru land owned by others with voronoi diagram)

The Spectra game

Heroes of Rock,Paper,Scissors



probes should never modify the state of the world. Currently, there is no protection to guarantee this, except for something in lpxclient where it does a snapshot and rollback before and after the probe. We should come up with a more comprehensive mechanism.

### Questionable Design Choices

When we delete a tangible, we currently leave the LUA_TT_TANGIBLE flag on the table, and we leave the metatable in place with the tangible ID in it. Is this the right thing to do? Should we turn it into a truly blank normal table?

### Hard Problems without Solutions

**Using Multi-Core CPUs**: We want to do difference transmission in parallel (one thread per connected client). This may be possible because each synchronous model is a separate lua interpreter. However, the master world model is shared. It may be possible to access it in a read-only manner in multiple threads.

**Nonsortable Keys:** what to do about table keys that are other tables, closures, or coroutines?

**Collision Detection**: In the old engine, people could walk through walls. I don't know if that is okay in 2020. But the separation of world-model and graphics engine makes this hard.

**Dealing with Infinite Loops:** if the script goes into an infinite loop, there's no easy way to deal with that. The lua interpreter does have hooks where you theoretically could count cycles.

**Module-Level Locals:** module-level locals are useful to store constants. However, when they're used as variables, they create pseudoglobal state that gets reset every time you edit a source file, and which is unfindable by the difference transmitter.
