Hello forum!
Currently all my logic is done within Lua (rest is in C++). However, I'm looking for user-friendly implementations.
For every enemy and other object, there is one Lua-file.
They provide functions which will be triggered on a mouse click or collision.
Additionally, there is a main file per level, which owns all the tables. It owns the event-triggers as well. If the player clicked something and the clicked target is an actual grid element of the level, C++ will call this function and provide the coordinates that has been clicked.
Now, I thought about moving all these into an more C++ entity driven approach in order to ease scripting for the modder.
At the moment, the user or modder would have to copy a Lua class template and then customise it.
Which is pretty terrible for people who have barely any knowledge. Yes, of course, there will always be people who lose their interest on all kinds of possible difficulties. Nonetheless, I would like to ease the pain and lower the chance of causing crashes.
Therefore, I thought about creating C++ entities instead Lua objects and just add needed components to it. Nonetheless, this leaves me open on saving the game.
It will cost some time to move the current implementation to a component system that just suits my needs (and the modder's).
Sadly, saving my C++ entities seems to be quite a possible neck breaker. As saving complex functions to a savegame Lua table from C++ entities seems.. a bit difficult. Maybe using raw strings?
The C++ entities would be instantiated from a Lua table and shall be saved with all their changes during runtime back into a Lua table.
These entities will have different collide-functions (defined in the savegame Lua table) that shall be written back into the table.
An example for (in my opinion) clearer and easier approach.
monster = {
Collision = {
coordinates = {0, 0}
clicked = function(this)
this:change_colour()
end
}
Graphics = {
-- ...
}
}
In the end, I'm really curious on what kind of popular approaches are being done for Lua/C++ modding-friendly approaches.
