Archive/TombEngine
0
0
Fork 0
mirror of https://github.com/TombEngine/TombEngine.git synced 2025-04-28 15:57:59 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Rename OnControlPhase to OnLoop, fix bug with post-loop callbacks (#1283)

Browse source
This commit is contained in:
Lwmte 2023-12-20 22:12:47 +02:00 • committed by GitHub
parent 958e56642e
commit 6a3ede73eb
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
10 changed files with 112 additions and 102 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Scripts/Engine/Timer.lua
View file

@ -1,7 +1,7 @@
-----
--- Basic timer - after a specified number of seconds, the specified thing happens.
--
-- Timers are updated automatically every frame before OnControlPhase.
-- Timers are updated automatically every frame before OnLoop.
--
-- Example usage:
-- local Timer = require("Engine.Timer")
@ -307,7 +307,7 @@ LevelFuncs.Engine.Timer.UpdateAll = function(dt)
end
end
TEN.Logic.AddCallback(TEN.Logic.CallbackPoint.PRECONTROLPHASE, LevelFuncs.Engine.Timer.UpdateAll)
TEN.Logic.AddCallback(TEN.Logic.CallbackPoint.PRELOOP, LevelFuncs.Engine.Timer.UpdateAll)
return Timer

9
TombEngine/Game/control/control.cpp
View file

@ -151,12 +151,12 @@ GameStatus ControlPhase(int numFrames)
for (framesCount += numFrames; framesCount > 0; framesCount -= 2)
{
// Controls are polled before OnControlPhase, so input data could be
// Controls are polled before OnLoop, so input data could be
// overwritten by script API methods.
HandleControls(isTitle);
// Handle loop functions and node events.
g_GameScript->OnControlPhase(DELTA_TIME);
// Pre-loop script and event handling.
g_GameScript->OnLoop(DELTA_TIME, false); // TODO: Don't use DELTA_TIME constant with variable framerate
HandleAllGlobalEvents(EventType::Loop, (Activator)LaraItem->Index);
// Control lock is processed after handling scripts, because builder may want to
@ -245,6 +245,9 @@ GameStatus ControlPhase(int numFrames)
PlaySoundSources();
DoFlipEffect(FlipEffect, LaraItem);
// Post-loop script and event handling.
g_GameScript->OnLoop(DELTA_TIME, true);
// Clear savegame loaded flag.
JustLoaded = false;

24
TombEngine/Game/savegame.cpp
View file

@ -1355,8 +1355,8 @@ bool SaveGame::Save(int slot)
std::vector<std::string> callbackVecPreLoad;
std::vector<std::string> callbackVecPostLoad;
std::vector<std::string> callbackVecPreControl;
std::vector<std::string> callbackVecPostControl;
std::vector<std::string> callbackVecPreLoop;
std::vector<std::string> callbackVecPostLoop;
g_GameScript->GetCallbackStrings(
callbackVecPreStart,
@ -1367,8 +1367,8 @@ bool SaveGame::Save(int slot)
callbackVecPostSave,
callbackVecPreLoad,
callbackVecPostLoad,
callbackVecPreControl,
callbackVecPostControl);
callbackVecPreLoop,
callbackVecPostLoop);
auto stringsCallbackPreStart = fbb.CreateVectorOfStrings(callbackVecPreStart);
auto stringsCallbackPostStart = fbb.CreateVectorOfStrings(callbackVecPostStart);
@ -1378,8 +1378,8 @@ bool SaveGame::Save(int slot)
auto stringsCallbackPostSave = fbb.CreateVectorOfStrings(callbackVecPostSave);
auto stringsCallbackPreLoad = fbb.CreateVectorOfStrings(callbackVecPreLoad);
auto stringsCallbackPostLoad = fbb.CreateVectorOfStrings(callbackVecPostLoad);
auto stringsCallbackPreControl = fbb.CreateVectorOfStrings(callbackVecPreControl);
auto stringsCallbackPostControl = fbb.CreateVectorOfStrings(callbackVecPostControl);
auto stringsCallbackPreLoop = fbb.CreateVectorOfStrings(callbackVecPreLoop);
auto stringsCallbackPostLoop = fbb.CreateVectorOfStrings(callbackVecPostLoop);
Save::SaveGameBuilder sgb{ fbb };
@ -1438,8 +1438,8 @@ bool SaveGame::Save(int slot)
sgb.add_callbacks_pre_load(stringsCallbackPreLoad);
sgb.add_callbacks_post_load(stringsCallbackPostLoad);
sgb.add_callbacks_pre_control(stringsCallbackPreControl);
sgb.add_callbacks_post_control(stringsCallbackPostControl);
sgb.add_callbacks_pre_loop(stringsCallbackPreLoop);
sgb.add_callbacks_post_loop(stringsCallbackPostLoop);
auto sg = sgb.Finish();
fbb.Finish(sg);
@ -2343,8 +2343,8 @@ bool SaveGame::Load(int slot)
auto callbacksPreLoadVec = populateCallbackVecs(&Save::SaveGame::callbacks_pre_load);
auto callbacksPostLoadVec = populateCallbackVecs(&Save::SaveGame::callbacks_post_load);
auto callbacksPreControlVec = populateCallbackVecs(&Save::SaveGame::callbacks_pre_control);
auto callbacksPostControlVec = populateCallbackVecs(&Save::SaveGame::callbacks_post_control);
auto callbacksPreLoopVec = populateCallbackVecs(&Save::SaveGame::callbacks_pre_loop);
auto callbacksPostLoopVec = populateCallbackVecs(&Save::SaveGame::callbacks_post_loop);
g_GameScript->SetCallbackStrings(
callbacksPreStartVec,
@ -2355,8 +2355,8 @@ bool SaveGame::Load(int slot)
callbacksPostSaveVec,
callbacksPreLoadVec,
callbacksPostLoadVec,
callbacksPreControlVec,
callbacksPostControlVec);
callbacksPreLoopVec,
callbacksPostLoopVec);
return true;
}

10
TombEngine/Scripting/Include/ScriptInterfaceGame.h
View file

@ -54,7 +54,7 @@ public:
virtual void OnStart() = 0;
virtual void OnLoad() = 0;
virtual void OnControlPhase(float deltaTime) = 0;
virtual void OnLoop(float deltaTime, bool postLoop) = 0;
virtual void OnSave() = 0;
virtual void OnEnd(GameStatus reason) = 0;
virtual void ShortenTENCalls() = 0;
@ -78,8 +78,8 @@ public:
std::vector<std::string>& postSave,
std::vector<std::string>& preLoad,
std::vector<std::string>& postLoad,
std::vector<std::string>& preControl,
std::vector<std::string>& postControl) const = 0;
std::vector<std::string>& preLoop,
std::vector<std::string>& postLoop) const = 0;
virtual void SetCallbackStrings(
const std::vector<std::string>& preStart,
@ -90,8 +90,8 @@ public:
const std::vector<std::string>& postSave,
const std::vector<std::string>& preLoad,
const std::vector<std::string>& postLoad,
const std::vector<std::string>& preControl,
const std::vector<std::string>& postControl) = 0;
const std::vector<std::string>& preLoop,
const std::vector<std::string>& postLoop) = 0;
};
extern ScriptInterfaceGame* g_GameScript;

7
TombEngine/Scripting/Internal/ReservedScriptNames.h
View file

@ -57,7 +57,8 @@ static constexpr char ScriptReserved_DisplaySpriteDraw[] = "Draw";
// Built-in LevelFuncs
static constexpr char ScriptReserved_OnStart[] = "OnStart";
static constexpr char ScriptReserved_OnLoad[] = "OnLoad";
static constexpr char ScriptReserved_OnControlPhase[] = "OnControlPhase";
static constexpr char ScriptReserved_OnLoop[] = "OnLoop";
static constexpr char ScriptReserved_OnControlPhase[] = "OnControlPhase"; // DEPRECATED
static constexpr char ScriptReserved_OnSave[] = "OnSave";
static constexpr char ScriptReserved_OnEnd[] = "OnEnd";
@ -76,8 +77,8 @@ static constexpr char ScriptReserved_PreSave[] = "PRESAVE";
static constexpr char ScriptReserved_PostSave[] = "POSTSAVE";
static constexpr char ScriptReserved_PreLoad[] = "PRELOAD";
static constexpr char ScriptReserved_PostLoad[] = "POSTLOAD";
static constexpr char ScriptReserved_PreControlPhase[] = "PRECONTROLPHASE";
static constexpr char ScriptReserved_PostControlPhase[] = "POSTCONTROLPHASE";
static constexpr char ScriptReserved_PreLoop[] = "PRELOOP";
static constexpr char ScriptReserved_PostLoop[] = "POSTLOOP";
// Event types
static constexpr char ScriptReserved_EventOnEnter[] = "ENTER";

70
TombEngine/Scripting/Internal/TEN/Logic/LogicHandler.cpp
View file

@ -31,8 +31,8 @@ enum class CallbackPoint
PostStart,
PreLoad,
PostLoad,
PreControl,
PostControl,
PreLoop,
PostLoop,
PreSave,
PostSave,
PreEnd,
@ -45,8 +45,8 @@ static const std::unordered_map<std::string, CallbackPoint> CALLBACK_POINTS
{ ScriptReserved_PostStart, CallbackPoint::PostStart },
{ ScriptReserved_PreLoad, CallbackPoint::PreLoad },
{ ScriptReserved_PostLoad, CallbackPoint::PostLoad },
{ ScriptReserved_PreControlPhase, CallbackPoint::PreControl },
{ ScriptReserved_PostControlPhase, CallbackPoint::PostControl },
{ ScriptReserved_PreLoop, CallbackPoint::PreLoop },
{ ScriptReserved_PostLoop, CallbackPoint::PostLoop },
{ ScriptReserved_PostSave, CallbackPoint::PostSave },
{ ScriptReserved_PreSave, CallbackPoint::PreSave },
{ ScriptReserved_PreEnd, CallbackPoint::PreEnd },
@ -180,8 +180,8 @@ LogicHandler::LogicHandler(sol::state* lua, sol::table & parent) : m_handler{ lu
m_callbacks.insert(std::make_pair(CallbackPoint::PostStart, &m_callbacksPostStart));
m_callbacks.insert(std::make_pair(CallbackPoint::PreLoad, &m_callbacksPreLoad));
m_callbacks.insert(std::make_pair(CallbackPoint::PostLoad, &m_callbacksPostLoad));
m_callbacks.insert(std::make_pair(CallbackPoint::PreControl, &m_callbacksPreControl));
m_callbacks.insert(std::make_pair(CallbackPoint::PostControl, &m_callbacksPostControl));
m_callbacks.insert(std::make_pair(CallbackPoint::PreLoop, &m_callbacksPreLoop));
m_callbacks.insert(std::make_pair(CallbackPoint::PostLoop, &m_callbacksPostLoop));
m_callbacks.insert(std::make_pair(CallbackPoint::PreSave, &m_callbacksPreSave));
m_callbacks.insert(std::make_pair(CallbackPoint::PostSave, &m_callbacksPostSave));
m_callbacks.insert(std::make_pair(CallbackPoint::PreEnd, &m_callbacksPreEnd));
@ -222,11 +222,11 @@ Possible values for CallbackPoint:
POSTEND -- will be called immediately after OnEnd
-- These take functions which accepts a deltaTime argument
PRECONTROLPHASE -- will be called immediately before OnControlPhase
POSTCONTROLPHASE -- will be called immediately after OnControlPhase
PRELOOP -- will be called in the beginning of game loop
POSTLOOP -- will be called at the end of game loop
The order in which two functions with the same CallbackPoint are called is undefined.
i.e. if you register `MyFunc` and `MyFunc2` with `PRECONTROLPHASE`, both will be called before `OnControlPhase`, but there is no guarantee that `MyFunc` will be called before `MyFunc2`, or vice-versa.
i.e. if you register `MyFunc` and `MyFunc2` with `PRELOOP`, both will be called in the beginning of game loop, but there is no guarantee that `MyFunc` will be called before `MyFunc2`, or vice-versa.
Any returned value will be discarded.
@ -235,7 +235,7 @@ Any returned value will be discarded.
@tparam LevelFunc func The function to be called (must be in the `LevelFuncs` hierarchy). Will receive, as an argument, the time in seconds since the last frame.
@usage
LevelFuncs.MyFunc = function(dt) print(dt) end
TEN.Logic.AddCallback(TEN.Logic.CallbackPoint.PRECONTROLPHASE, LevelFuncs.MyFunc)
TEN.Logic.AddCallback(TEN.Logic.CallbackPoint.PRELOOP, LevelFuncs.MyFunc)
*/
void LogicHandler::AddCallback(CallbackPoint point, const LevelFunc& levelFunc)
{
@ -264,7 +264,7 @@ Will have no effect if the function was not registered as a callback
@tparam CallbackPoint point The callback point the function was registered with. See @{AddCallback}
@tparam LevelFunc func The function to remove; must be in the LevelFuncs hierarchy.
@usage
TEN.Logic.RemoveCallback(TEN.Logic.CallbackPoint.PRECONTROLPHASE, LevelFuncs.MyFunc)
TEN.Logic.RemoveCallback(TEN.Logic.CallbackPoint.PRELOOP, LevelFuncs.MyFunc)
*/
void LogicHandler::RemoveCallback(CallbackPoint point, const LevelFunc& levelFunc)
{
@ -440,7 +440,7 @@ void LogicHandler::FreeLevelScripts()
ResetLevelTables();
m_onStart = sol::nil;
m_onLoad = sol::nil;
m_onControlPhase = sol::nil;
m_onLoop = sol::nil;
m_onSave = sol::nil;
m_onEnd = sol::nil;
m_handler.GetState()->collect_garbage();
@ -760,8 +760,8 @@ void LogicHandler::GetCallbackStrings(
std::vector<std::string>& postSave,
std::vector<std::string>& preLoad,
std::vector<std::string>& postLoad,
std::vector<std::string>& preControl,
std::vector<std::string>& postControl) const
std::vector<std::string>& preLoop,
std::vector<std::string>& postLoop) const
{
auto populateWith = [](std::vector<std::string>& dest, const std::unordered_set<std::string>& src)
{
@ -781,8 +781,8 @@ void LogicHandler::GetCallbackStrings(
populateWith(preLoad, m_callbacksPreLoad);
populateWith(postLoad, m_callbacksPostLoad);
populateWith(preControl, m_callbacksPreControl);
populateWith(postControl, m_callbacksPostControl);
populateWith(preLoop, m_callbacksPreLoop);
populateWith(postLoop, m_callbacksPostLoop);
}
void LogicHandler::SetCallbackStrings(
@ -794,8 +794,8 @@ void LogicHandler::SetCallbackStrings(
const std::vector<std::string>& postSave,
const std::vector<std::string>& preLoad,
const std::vector<std::string>& postLoad,
const std::vector<std::string>& preControl,
const std::vector<std::string>& postControl)
const std::vector<std::string>& preLoop,
const std::vector<std::string>& postLoop)
{
auto populateWith = [](std::unordered_set<std::string>& dest, const std::vector<std::string>& src)
{
@ -815,8 +815,8 @@ void LogicHandler::SetCallbackStrings(
populateWith(m_callbacksPreLoad, preLoad);
populateWith(m_callbacksPostLoad, postLoad);
populateWith(m_callbacksPreControl, preControl);
populateWith(m_callbacksPostControl, postControl);
populateWith(m_callbacksPreLoop, preLoop);
populateWith(m_callbacksPostLoop, postLoop);
}
template <typename R, char const * S, typename mapType>
@ -922,17 +922,22 @@ void LogicHandler::OnLoad()
CallLevelFuncByName(name);
}
void LogicHandler::OnControlPhase(float deltaTime)
void LogicHandler::OnLoop(float deltaTime, bool postLoop)
{
for (auto& name : m_callbacksPreControl)
CallLevelFuncByName(name, deltaTime);
if (!postLoop)
{
for (auto& name : m_callbacksPreLoop)
CallLevelFuncByName(name, deltaTime);
lua_gc(m_handler.GetState()->lua_state(), LUA_GCCOLLECT, 0);
if (m_onControlPhase.valid())
CallLevelFunc(m_onControlPhase, deltaTime);
for (auto& name : m_callbacksPostControl)
CallLevelFuncByName(name, deltaTime);
lua_gc(m_handler.GetState()->lua_state(), LUA_GCCOLLECT, 0);
if (m_onLoop.valid())
CallLevelFunc(m_onLoop, deltaTime);
}
else
{
for (auto& name : m_callbacksPostLoop)
CallLevelFuncByName(name, deltaTime);
}
}
void LogicHandler::OnSave()
@ -1073,11 +1078,11 @@ __The order of loading is as follows:__
2. The level script itself is run (i.e. any code you put outside the `LevelFuncs` callbacks is executed).
3. Save data is loaded, if saving from a saved game (will empty `LevelVars` and `GameVars` and repopulate them with what they contained when the game was saved).
4. If loading from a save, `OnLoaded` will be called. Otherwise, `OnStart` will be called.
5. The control loop, in which `OnControlPhase` will be called once per frame, begins.
5. The control loop, in which `OnLoop` will be called once per frame, begins.
@tfield function OnStart Will be called when a level is entered by completing a previous level or by selecting it in the menu. Will not be called when loaded from a saved game.
@tfield function OnLoad Will be called when a saved game is loaded, just *after* data is loaded
@tfield function(float) OnControlPhase Will be called during the game's update loop,
@tfield function(float) OnLoop Will be called during the game's update loop,
and provides the delta time (a float representing game time since last call) via its argument.
@tfield function OnSave Will be called when the player saves the game, just *before* data is saved
@tfield function OnEnd(EndReason) Will be called when leaving a level. This includes finishing it, exiting to the menu, or loading a save in a different level. It can take an `EndReason` arg:
@ -1124,7 +1129,8 @@ void LogicHandler::InitCallbacks()
assignCB(m_onStart, ScriptReserved_OnStart);
assignCB(m_onLoad, ScriptReserved_OnLoad);
assignCB(m_onControlPhase, ScriptReserved_OnControlPhase);
assignCB(m_onLoop, ScriptReserved_OnControlPhase);
assignCB(m_onLoop, ScriptReserved_OnLoop);
assignCB(m_onSave, ScriptReserved_OnSave);
assignCB(m_onEnd, ScriptReserved_OnEnd);
}

16
TombEngine/Scripting/Internal/TEN/Logic/LogicHandler.h
View file

@ -53,7 +53,7 @@ private:
sol::protected_function m_onStart{};
sol::protected_function m_onLoad{};
sol::protected_function m_onControlPhase{};
sol::protected_function m_onLoop{};
sol::protected_function m_onSave{};
sol::protected_function m_onEnd{};
@ -65,8 +65,8 @@ private:
std::unordered_set<std::string> m_callbacksPostStart;
std::unordered_set<std::string> m_callbacksPreEnd;
std::unordered_set<std::string> m_callbacksPostEnd;
std::unordered_set<std::string> m_callbacksPreControl;
std::unordered_set<std::string> m_callbacksPostControl;
std::unordered_set<std::string> m_callbacksPreLoop;
std::unordered_set<std::string> m_callbacksPostLoop;
std::unordered_map<CallbackPoint, std::unordered_set<std::string> *> m_callbacks;
@ -150,8 +150,8 @@ public:
const std::vector<std::string>& postSave,
const std::vector<std::string>& preLoad,
const std::vector<std::string>& postLoad,
const std::vector<std::string>& preControl,
const std::vector<std::string>& posControl) override;
const std::vector<std::string>& preLoop,
const std::vector<std::string>& postLoop) override;
void GetCallbackStrings(std::vector<std::string>& preStart,
std::vector<std::string>& postStart,
@ -161,13 +161,13 @@ public:
std::vector<std::string>& postSave,
std::vector<std::string>& preLoad,
std::vector<std::string>& postLoad,
std::vector<std::string>& preControl,
std::vector<std::string>& postControl) const override;
std::vector<std::string>& preLoop,
std::vector<std::string>& postLoop) const override;
void InitCallbacks() override;
void OnStart() override;
void OnLoad() override;
void OnControlPhase(float deltaTime) override;
void OnLoop(float deltaTime, bool postLoop) override;
void OnSave() override;
void OnEnd(GameStatus reason) override;
};

2
TombEngine/Scripting/Internal/TEN/View/ViewHandler.cpp
View file

@ -150,7 +150,7 @@ namespace TEN::Scripting::View
//@function GetCameraType
//@treturn View.CameraType value used by the Main Camera.
//@usage
//LevelFuncs.OnControlPhase = function()
//LevelFuncs.OnLoop = function()
// if (View.GetCameraType() == CameraType.Combat) then
// --Do your Actions here.
// end

68
TombEngine/Specific/savegame/flatbuffers/ten_savegame_generated.h
View file

@ -6962,8 +6962,8 @@ struct SaveGameT : public flatbuffers::NativeTable {
std::vector<std::string> callbacks_post_save{};
std::vector<std::string> callbacks_pre_load{};
std::vector<std::string> callbacks_post_load{};
std::vector<std::string> callbacks_pre_control{};
std::vector<std::string> callbacks_post_control{};
std::vector<std::string> callbacks_pre_loop{};
std::vector<std::string> callbacks_post_loop{};
};
struct SaveGame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@ -7017,8 +7017,8 @@ struct SaveGame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_CALLBACKS_POST_SAVE = 90,
VT_CALLBACKS_PRE_LOAD = 92,
VT_CALLBACKS_POST_LOAD = 94,
VT_CALLBACKS_PRE_CONTROL = 96,
VT_CALLBACKS_POST_CONTROL = 98
VT_CALLBACKS_PRE_LOOP = 96,
VT_CALLBACKS_POST_LOOP = 98
};
const TEN::Save::SaveGameHeader *header() const {
return GetPointer<const TEN::Save::SaveGameHeader *>(VT_HEADER);
@ -7158,11 +7158,11 @@ struct SaveGame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *callbacks_post_load() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_CALLBACKS_POST_LOAD);
}
const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *callbacks_pre_control() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_CALLBACKS_PRE_CONTROL);
const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *callbacks_pre_loop() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_CALLBACKS_PRE_LOOP);
}
const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *callbacks_post_control() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_CALLBACKS_POST_CONTROL);
const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *callbacks_post_loop() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_CALLBACKS_POST_LOOP);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
@ -7273,12 +7273,12 @@ struct SaveGame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VerifyOffset(verifier, VT_CALLBACKS_POST_LOAD) &&
verifier.VerifyVector(callbacks_post_load()) &&
verifier.VerifyVectorOfStrings(callbacks_post_load()) &&
VerifyOffset(verifier, VT_CALLBACKS_PRE_CONTROL) &&
verifier.VerifyVector(callbacks_pre_control()) &&
verifier.VerifyVectorOfStrings(callbacks_pre_control()) &&
VerifyOffset(verifier, VT_CALLBACKS_POST_CONTROL) &&
verifier.VerifyVector(callbacks_post_control()) &&
verifier.VerifyVectorOfStrings(callbacks_post_control()) &&
VerifyOffset(verifier, VT_CALLBACKS_PRE_LOOP) &&
verifier.VerifyVector(callbacks_pre_loop()) &&
verifier.VerifyVectorOfStrings(callbacks_pre_loop()) &&
VerifyOffset(verifier, VT_CALLBACKS_POST_LOOP) &&
verifier.VerifyVector(callbacks_post_loop()) &&
verifier.VerifyVectorOfStrings(callbacks_post_loop()) &&
verifier.EndTable();
}
SaveGameT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@ -7428,11 +7428,11 @@ struct SaveGameBuilder {
void add_callbacks_post_load(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> callbacks_post_load) {
fbb_.AddOffset(SaveGame::VT_CALLBACKS_POST_LOAD, callbacks_post_load);
}
void add_callbacks_pre_control(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> callbacks_pre_control) {
fbb_.AddOffset(SaveGame::VT_CALLBACKS_PRE_CONTROL, callbacks_pre_control);
void add_callbacks_pre_loop(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> callbacks_pre_loop) {
fbb_.AddOffset(SaveGame::VT_CALLBACKS_PRE_LOOP, callbacks_pre_loop);
}
void add_callbacks_post_control(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> callbacks_post_control) {
fbb_.AddOffset(SaveGame::VT_CALLBACKS_POST_CONTROL, callbacks_post_control);
void add_callbacks_post_loop(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> callbacks_post_loop) {
fbb_.AddOffset(SaveGame::VT_CALLBACKS_POST_LOOP, callbacks_post_loop);
}
explicit SaveGameBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
@ -7493,11 +7493,11 @@ inline flatbuffers::Offset<SaveGame> CreateSaveGame(
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> callbacks_post_save = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> callbacks_pre_load = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> callbacks_post_load = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> callbacks_pre_control = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> callbacks_post_control = 0) {
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> callbacks_pre_loop = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> callbacks_post_loop = 0) {
SaveGameBuilder builder_(_fbb);
builder_.add_callbacks_post_control(callbacks_post_control);
builder_.add_callbacks_pre_control(callbacks_pre_control);
builder_.add_callbacks_post_loop(callbacks_post_loop);
builder_.add_callbacks_pre_loop(callbacks_pre_loop);
builder_.add_callbacks_post_load(callbacks_post_load);
builder_.add_callbacks_pre_load(callbacks_pre_load);
builder_.add_callbacks_post_save(callbacks_post_save);
@ -7600,8 +7600,8 @@ inline flatbuffers::Offset<SaveGame> CreateSaveGameDirect(
const std::vector<flatbuffers::Offset<flatbuffers::String>> *callbacks_post_save = nullptr,
const std::vector<flatbuffers::Offset<flatbuffers::String>> *callbacks_pre_load = nullptr,
const std::vector<flatbuffers::Offset<flatbuffers::String>> *callbacks_post_load = nullptr,
const std::vector<flatbuffers::Offset<flatbuffers::String>> *callbacks_pre_control = nullptr,
const std::vector<flatbuffers::Offset<flatbuffers::String>> *callbacks_post_control = nullptr) {
const std::vector<flatbuffers::Offset<flatbuffers::String>> *callbacks_pre_loop = nullptr,
const std::vector<flatbuffers::Offset<flatbuffers::String>> *callbacks_post_loop = nullptr) {
auto rooms__ = rooms ? _fbb.CreateVector<flatbuffers::Offset<TEN::Save::Room>>(*rooms) : 0;
auto items__ = items ? _fbb.CreateVector<flatbuffers::Offset<TEN::Save::Item>>(*items) : 0;
auto room_items__ = room_items ? _fbb.CreateVector<int32_t>(*room_items) : 0;
@ -7631,8 +7631,8 @@ inline flatbuffers::Offset<SaveGame> CreateSaveGameDirect(
auto callbacks_post_save__ = callbacks_post_save ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*callbacks_post_save) : 0;
auto callbacks_pre_load__ = callbacks_pre_load ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*callbacks_pre_load) : 0;
auto callbacks_post_load__ = callbacks_post_load ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*callbacks_post_load) : 0;
auto callbacks_pre_control__ = callbacks_pre_control ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*callbacks_pre_control) : 0;
auto callbacks_post_control__ = callbacks_post_control ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*callbacks_post_control) : 0;
auto callbacks_pre_loop__ = callbacks_pre_loop ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*callbacks_pre_loop) : 0;
auto callbacks_post_loop__ = callbacks_post_loop ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*callbacks_post_loop) : 0;
return TEN::Save::CreateSaveGame(
_fbb,
header,
@ -7681,8 +7681,8 @@ inline flatbuffers::Offset<SaveGame> CreateSaveGameDirect(
callbacks_post_save__,
callbacks_pre_load__,
callbacks_post_load__,
callbacks_pre_control__,
callbacks_post_control__);
callbacks_pre_loop__,
callbacks_post_loop__);
}
flatbuffers::Offset<SaveGame> CreateSaveGame(flatbuffers::FlatBufferBuilder &_fbb, const SaveGameT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@ -9783,8 +9783,8 @@ inline void SaveGame::UnPackTo(SaveGameT *_o, const flatbuffers::resolver_functi
{ auto _e = callbacks_post_save(); if (_e) { _o->callbacks_post_save.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->callbacks_post_save[_i] = _e->Get(_i)->str(); } } }
{ auto _e = callbacks_pre_load(); if (_e) { _o->callbacks_pre_load.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->callbacks_pre_load[_i] = _e->Get(_i)->str(); } } }
{ auto _e = callbacks_post_load(); if (_e) { _o->callbacks_post_load.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->callbacks_post_load[_i] = _e->Get(_i)->str(); } } }
{ auto _e = callbacks_pre_control(); if (_e) { _o->callbacks_pre_control.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->callbacks_pre_control[_i] = _e->Get(_i)->str(); } } }
{ auto _e = callbacks_post_control(); if (_e) { _o->callbacks_post_control.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->callbacks_post_control[_i] = _e->Get(_i)->str(); } } }
{ auto _e = callbacks_pre_loop(); if (_e) { _o->callbacks_pre_loop.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->callbacks_pre_loop[_i] = _e->Get(_i)->str(); } } }
{ auto _e = callbacks_post_loop(); if (_e) { _o->callbacks_post_loop.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->callbacks_post_loop[_i] = _e->Get(_i)->str(); } } }
}
inline flatbuffers::Offset<SaveGame> SaveGame::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SaveGameT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@ -9841,8 +9841,8 @@ inline flatbuffers::Offset<SaveGame> CreateSaveGame(flatbuffers::FlatBufferBuild
auto _callbacks_post_save = _fbb.CreateVectorOfStrings(_o->callbacks_post_save);
auto _callbacks_pre_load = _fbb.CreateVectorOfStrings(_o->callbacks_pre_load);
auto _callbacks_post_load = _fbb.CreateVectorOfStrings(_o->callbacks_post_load);
auto _callbacks_pre_control = _fbb.CreateVectorOfStrings(_o->callbacks_pre_control);
auto _callbacks_post_control = _fbb.CreateVectorOfStrings(_o->callbacks_post_control);
auto _callbacks_pre_loop = _fbb.CreateVectorOfStrings(_o->callbacks_pre_loop);
auto _callbacks_post_loop = _fbb.CreateVectorOfStrings(_o->callbacks_post_loop);
return TEN::Save::CreateSaveGame(
_fbb,
_header,
@ -9891,8 +9891,8 @@ inline flatbuffers::Offset<SaveGame> CreateSaveGame(flatbuffers::FlatBufferBuild
_callbacks_post_save,
_callbacks_pre_load,
_callbacks_post_load,
_callbacks_pre_control,
_callbacks_post_control);
_callbacks_pre_loop,
_callbacks_post_loop);
}
inline bool VerifyVarUnion(flatbuffers::Verifier &verifier, const void *obj, VarUnion type) {

4
TombEngine/Specific/savegame/schema/ten_savegame.fbs
View file

@ -545,8 +545,8 @@ table SaveGame {
callbacks_post_save: [string];
callbacks_pre_load: [string];
callbacks_post_load: [string];
callbacks_pre_control: [string];
callbacks_post_control: [string];
callbacks_pre_loop: [string];
callbacks_post_loop: [string];
}
root_type TEN.Save.SaveGame;