Archive/TombEngine
0
0
Fork 0
mirror of https://github.com/TombEngine/TombEngine.git synced 2025-05-07 19:23:49 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add room properties to savegame, fixes

Browse source
This commit is contained in:
Lwmte 2022-12-17 01:25:37 +02:00
parent 52db25a98b
commit 0ce6d12f97
7 changed files with 242 additions and 47 deletions
Download patch file Download diff file Expand all files Collapse all files

1
TombEngine/Game/control/volumeactivator.h
View file

@ -1,6 +1,5 @@
#pragma once
#include <variant>
#include "Game/control/volume.h"
struct CAMERA_INFO;
struct MESH_INFO;

2
TombEngine/Game/debug/debug.cpp
View file

@ -18,7 +18,7 @@ void InitTENLog()
spdlog::initialize_logger(logger);
logger->set_level(spdlog::level::info);
logger->flush_on(spdlog::level::info);
logger->flush_on(spdlog::level::info);
logger->set_pattern("[%Y-%b-%d %T] [%^%l%$] %v");
}

26
TombEngine/Game/savegame.cpp
View file

@ -151,7 +151,7 @@ bool SaveGame::Save(int slot)
ItemInfo itemToSerialize{};
FlatBufferBuilder fbb{};
std::vector<flatbuffers::Offset< Save::Item>> serializedItems{};
std::vector<flatbuffers::Offset<Save::Item>> serializedItems{};
// Savegame header
auto levelNameOffset = fbb.CreateString(g_GameFlow->GetString(g_GameFlow->GetLevel(CurrentLevel)->NameStringKey.c_str()));
@ -450,6 +450,19 @@ bool SaveGame::Save(int slot)
lara.add_wet(wetOffset);
auto laraOffset = lara.Finish();
std::vector<flatbuffers::Offset<Save::Room>> rooms;
for (auto& room : g_Level.Rooms)
{
Save::RoomBuilder serializedInfo{ fbb };
serializedInfo.add_name(fbb.CreateString(room.name));
serializedInfo.add_reverb_type((int)room.reverbType);
serializedInfo.add_flags(room.flags);
auto serializedInfoOffset = serializedInfo.Finish();
rooms.push_back(serializedInfoOffset);
}
auto roomOffset = fbb.CreateVector(rooms);
int currentItemIndex = 0;
for (auto& itemToSerialize : g_Level.Items)
{
@ -699,7 +712,6 @@ bool SaveGame::Save(int slot)
currentItemIndex++;
}
auto serializedItemsOffset = fbb.CreateVector(serializedItems);
// TODO: In future, we should save only active FX, not whole array.
@ -1143,6 +1155,7 @@ bool SaveGame::Save(int slot)
sgb.add_level(levelStatisticsOffset);
sgb.add_game(gameStatisticsOffset);
sgb.add_lara(laraOffset);
sgb.add_rooms(roomOffset);
sgb.add_next_item_free(NextItemFree);
sgb.add_next_item_active(NextItemActive);
sgb.add_items(serializedItemsOffset);
@ -1236,6 +1249,15 @@ bool SaveGame::Load(int slot)
Statistics.Level.Secrets = s->level()->secrets();
Statistics.Level.Timer = s->level()->timer();
// Rooms
for (int i = 0; i < s->rooms()->size(); i++)
{
auto room = s->rooms()->Get(i);
g_Level.Rooms[i].name = room->name()->str();
g_Level.Rooms[i].flags = room->flags();
g_Level.Rooms[i].reverbType = (ReverbType)room->reverb_type();
}
// Flipmaps
for (int i = 0; i < s->flip_stats()->size(); i++)
{

1
TombEngine/Scripting/Internal/TEN/Objects/Moveable/MoveableObject.cpp
View file

@ -470,7 +470,6 @@ ScriptReserved_GetSlotHP, & Moveable::GetSlotHP,
ScriptReserved_AnimFromObject, &Moveable::AnimFromObject);
}
void Moveable::Init()
{
bool cond = IsPointInRoom(m_item->Pose.Position, m_item->RoomNumber);

2
TombEngine/Specific/level.cpp
View file

@ -804,7 +804,7 @@ void ReadRooms()
room.flippedRoom = ReadInt32();
room.flags = ReadInt32();
room.meshEffect = ReadInt32();
room.reverbType = ReadInt32();
room.reverbType = (ReverbType)ReadInt32();
room.flipNumber = ReadInt32();
room.itemNumber = NO_ITEM;

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

@ -13,6 +13,10 @@ namespace Save {
struct RoomVector;
struct Room;
struct RoomBuilder;
struct RoomT;
struct Item;
struct ItemBuilder;
struct ItemT;
@ -421,6 +425,100 @@ struct KeyValPair::Traits {
using type = KeyValPair;
};
struct RoomT : public flatbuffers::NativeTable {
typedef Room TableType;
std::string name{};
int32_t flags = 0;
int32_t reverb_type = 0;
};
struct Room FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef RoomT NativeTableType;
typedef RoomBuilder Builder;
struct Traits;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NAME = 4,
VT_FLAGS = 6,
VT_REVERB_TYPE = 8
};
const flatbuffers::String *name() const {
return GetPointer<const flatbuffers::String *>(VT_NAME);
}
int32_t flags() const {
return GetField<int32_t>(VT_FLAGS, 0);
}
int32_t reverb_type() const {
return GetField<int32_t>(VT_REVERB_TYPE, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
VerifyField<int32_t>(verifier, VT_FLAGS) &&
VerifyField<int32_t>(verifier, VT_REVERB_TYPE) &&
verifier.EndTable();
}
RoomT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(RoomT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Room> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RoomT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct RoomBuilder {
typedef Room Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
fbb_.AddOffset(Room::VT_NAME, name);
}
void add_flags(int32_t flags) {
fbb_.AddElement<int32_t>(Room::VT_FLAGS, flags, 0);
}
void add_reverb_type(int32_t reverb_type) {
fbb_.AddElement<int32_t>(Room::VT_REVERB_TYPE, reverb_type, 0);
}
explicit RoomBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<Room> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Room>(end);
return o;
}
};
inline flatbuffers::Offset<Room> CreateRoom(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::String> name = 0,
int32_t flags = 0,
int32_t reverb_type = 0) {
RoomBuilder builder_(_fbb);
builder_.add_reverb_type(reverb_type);
builder_.add_flags(flags);
builder_.add_name(name);
return builder_.Finish();
}
struct Room::Traits {
using type = Room;
static auto constexpr Create = CreateRoom;
};
inline flatbuffers::Offset<Room> CreateRoomDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const char *name = nullptr,
int32_t flags = 0,
int32_t reverb_type = 0) {
auto name__ = name ? _fbb.CreateString(name) : 0;
return TEN::Save::CreateRoom(
_fbb,
name__,
flags,
reverb_type);
}
flatbuffers::Offset<Room> CreateRoom(flatbuffers::FlatBufferBuilder &_fbb, const RoomT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ItemT : public flatbuffers::NativeTable {
typedef Item TableType;
int32_t active_state = 0;
@ -5222,6 +5320,7 @@ struct VolumeT : public flatbuffers::NativeTable {
typedef Volume TableType;
int32_t number = 0;
int32_t room_number = 0;
std::string name{};
bool enabled = false;
std::unique_ptr<TEN::Save::Vector3> position{};
std::unique_ptr<TEN::Save::Vector4> rotation{};
@ -5236,11 +5335,12 @@ struct Volume FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NUMBER = 4,
VT_ROOM_NUMBER = 6,
VT_ENABLED = 8,
VT_POSITION = 10,
VT_ROTATION = 12,
VT_SCALE = 14,
VT_QUEUE = 16
VT_NAME = 8,
VT_ENABLED = 10,
VT_POSITION = 12,
VT_ROTATION = 14,
VT_SCALE = 16,
VT_QUEUE = 18
};
int32_t number() const {
return GetField<int32_t>(VT_NUMBER, 0);
@ -5248,6 +5348,9 @@ struct Volume FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
int32_t room_number() const {
return GetField<int32_t>(VT_ROOM_NUMBER, 0);
}
const flatbuffers::String *name() const {
return GetPointer<const flatbuffers::String *>(VT_NAME);
}
bool enabled() const {
return GetField<uint8_t>(VT_ENABLED, 0) != 0;
}
@ -5267,6 +5370,8 @@ struct Volume FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_NUMBER) &&
VerifyField<int32_t>(verifier, VT_ROOM_NUMBER) &&
VerifyOffset(verifier, VT_NAME) &&
verifier.VerifyString(name()) &&
VerifyField<uint8_t>(verifier, VT_ENABLED) &&
VerifyField<TEN::Save::Vector3>(verifier, VT_POSITION) &&
VerifyField<TEN::Save::Vector4>(verifier, VT_ROTATION) &&
@ -5291,6 +5396,9 @@ struct VolumeBuilder {
void add_room_number(int32_t room_number) {
fbb_.AddElement<int32_t>(Volume::VT_ROOM_NUMBER, room_number, 0);
}
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
fbb_.AddOffset(Volume::VT_NAME, name);
}
void add_enabled(bool enabled) {
fbb_.AddElement<uint8_t>(Volume::VT_ENABLED, static_cast<uint8_t>(enabled), 0);
}
@ -5321,6 +5429,7 @@ inline flatbuffers::Offset<Volume> CreateVolume(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t number = 0,
int32_t room_number = 0,
flatbuffers::Offset<flatbuffers::String> name = 0,
bool enabled = false,
const TEN::Save::Vector3 *position = 0,
const TEN::Save::Vector4 *rotation = 0,
@ -5331,6 +5440,7 @@ inline flatbuffers::Offset<Volume> CreateVolume(
builder_.add_scale(scale);
builder_.add_rotation(rotation);
builder_.add_position(position);
builder_.add_name(name);
builder_.add_room_number(room_number);
builder_.add_number(number);
builder_.add_enabled(enabled);
@ -5346,16 +5456,19 @@ inline flatbuffers::Offset<Volume> CreateVolumeDirect(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t number = 0,
int32_t room_number = 0,
const char *name = nullptr,
bool enabled = false,
const TEN::Save::Vector3 *position = 0,
const TEN::Save::Vector4 *rotation = 0,
const TEN::Save::Vector3 *scale = 0,
const std::vector<flatbuffers::Offset<TEN::Save::VolumeState>> *queue = nullptr) {
auto name__ = name ? _fbb.CreateString(name) : 0;
auto queue__ = queue ? _fbb.CreateVector<flatbuffers::Offset<TEN::Save::VolumeState>>(*queue) : 0;
return TEN::Save::CreateVolume(
_fbb,
number,
room_number,
name__,
enabled,
position,
rotation,
@ -6213,6 +6326,7 @@ struct SaveGameT : public flatbuffers::NativeTable {
std::unique_ptr<TEN::Save::SaveGameStatisticsT> game{};
std::unique_ptr<TEN::Save::SaveGameStatisticsT> level{};
std::unique_ptr<TEN::Save::LaraT> lara{};
std::vector<std::unique_ptr<TEN::Save::RoomT>> rooms{};
std::vector<std::unique_ptr<TEN::Save::ItemT>> items{};
int32_t next_item_free = 0;
int32_t next_item_active = 0;
@ -6260,42 +6374,43 @@ struct SaveGame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
VT_GAME = 6,
VT_LEVEL = 8,
VT_LARA = 10,
VT_ITEMS = 12,
VT_NEXT_ITEM_FREE = 14,
VT_NEXT_ITEM_ACTIVE = 16,
VT_ROOM_ITEMS = 18,
VT_FXINFOS = 20,
VT_NEXT_FX_FREE = 22,
VT_NEXT_FX_ACTIVE = 24,
VT_FIXED_CAMERAS = 26,
VT_SINKS = 28,
VT_STATIC_MESHES = 30,
VT_FLYBY_CAMERAS = 32,
VT_PARTICLES = 34,
VT_RATS = 36,
VT_SPIDERS = 38,
VT_SCARABS = 40,
VT_BATS = 42,
VT_FLIP_MAPS = 44,
VT_FLIP_STATS = 46,
VT_FLIP_EFFECT = 48,
VT_FLIP_TIMER = 50,
VT_FLIP_STATUS = 52,
VT_CURRENT_FOV = 54,
VT_ACTION_QUEUE = 56,
VT_AMBIENT_TRACK = 58,
VT_AMBIENT_POSITION = 60,
VT_ONESHOT_TRACK = 62,
VT_ONESHOT_POSITION = 64,
VT_CD_FLAGS = 66,
VT_ROPE = 68,
VT_PENDULUM = 70,
VT_ALTERNATE_PENDULUM = 72,
VT_VOLUMES = 74,
VT_CALL_COUNTERS = 76,
VT_SCRIPT_VARS = 78,
VT_CALLBACKS_PRE_CONTROL = 80,
VT_CALLBACKS_POST_CONTROL = 82
VT_ROOMS = 12,
VT_ITEMS = 14,
VT_NEXT_ITEM_FREE = 16,
VT_NEXT_ITEM_ACTIVE = 18,
VT_ROOM_ITEMS = 20,
VT_FXINFOS = 22,
VT_NEXT_FX_FREE = 24,
VT_NEXT_FX_ACTIVE = 26,
VT_FIXED_CAMERAS = 28,
VT_SINKS = 30,
VT_STATIC_MESHES = 32,
VT_FLYBY_CAMERAS = 34,
VT_PARTICLES = 36,
VT_RATS = 38,
VT_SPIDERS = 40,
VT_SCARABS = 42,
VT_BATS = 44,
VT_FLIP_MAPS = 46,
VT_FLIP_STATS = 48,
VT_FLIP_EFFECT = 50,
VT_FLIP_TIMER = 52,
VT_FLIP_STATUS = 54,
VT_CURRENT_FOV = 56,
VT_ACTION_QUEUE = 58,
VT_AMBIENT_TRACK = 60,
VT_AMBIENT_POSITION = 62,
VT_ONESHOT_TRACK = 64,
VT_ONESHOT_POSITION = 66,
VT_CD_FLAGS = 68,
VT_ROPE = 70,
VT_PENDULUM = 72,
VT_ALTERNATE_PENDULUM = 74,
VT_VOLUMES = 76,
VT_CALL_COUNTERS = 78,
VT_SCRIPT_VARS = 80,
VT_CALLBACKS_PRE_CONTROL = 82,
VT_CALLBACKS_POST_CONTROL = 84
};
const TEN::Save::SaveGameHeader *header() const {
return GetPointer<const TEN::Save::SaveGameHeader *>(VT_HEADER);
@ -6309,6 +6424,9 @@ struct SaveGame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
const TEN::Save::Lara *lara() const {
return GetPointer<const TEN::Save::Lara *>(VT_LARA);
}
const flatbuffers::Vector<flatbuffers::Offset<TEN::Save::Room>> *rooms() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TEN::Save::Room>> *>(VT_ROOMS);
}
const flatbuffers::Vector<flatbuffers::Offset<TEN::Save::Item>> *items() const {
return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TEN::Save::Item>> *>(VT_ITEMS);
}
@ -6427,6 +6545,9 @@ struct SaveGame FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
verifier.VerifyTable(level()) &&
VerifyOffset(verifier, VT_LARA) &&
verifier.VerifyTable(lara()) &&
VerifyOffset(verifier, VT_ROOMS) &&
verifier.VerifyVector(rooms()) &&
verifier.VerifyVectorOfTables(rooms()) &&
VerifyOffset(verifier, VT_ITEMS) &&
verifier.VerifyVector(items()) &&
verifier.VerifyVectorOfTables(items()) &&
@ -6527,6 +6648,9 @@ struct SaveGameBuilder {
void add_lara(flatbuffers::Offset<TEN::Save::Lara> lara) {
fbb_.AddOffset(SaveGame::VT_LARA, lara);
}
void add_rooms(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TEN::Save::Room>>> rooms) {
fbb_.AddOffset(SaveGame::VT_ROOMS, rooms);
}
void add_items(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TEN::Save::Item>>> items) {
fbb_.AddOffset(SaveGame::VT_ITEMS, items);
}
@ -6652,6 +6776,7 @@ inline flatbuffers::Offset<SaveGame> CreateSaveGame(
flatbuffers::Offset<TEN::Save::SaveGameStatistics> game = 0,
flatbuffers::Offset<TEN::Save::SaveGameStatistics> level = 0,
flatbuffers::Offset<TEN::Save::Lara> lara = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TEN::Save::Room>>> rooms = 0,
flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TEN::Save::Item>>> items = 0,
int32_t next_item_free = 0,
int32_t next_item_active = 0,
@ -6724,6 +6849,7 @@ inline flatbuffers::Offset<SaveGame> CreateSaveGame(
builder_.add_next_item_active(next_item_active);
builder_.add_next_item_free(next_item_free);
builder_.add_items(items);
builder_.add_rooms(rooms);
builder_.add_lara(lara);
builder_.add_level(level);
builder_.add_game(game);
@ -6743,6 +6869,7 @@ inline flatbuffers::Offset<SaveGame> CreateSaveGameDirect(
flatbuffers::Offset<TEN::Save::SaveGameStatistics> game = 0,
flatbuffers::Offset<TEN::Save::SaveGameStatistics> level = 0,
flatbuffers::Offset<TEN::Save::Lara> lara = 0,
const std::vector<flatbuffers::Offset<TEN::Save::Room>> *rooms = nullptr,
const std::vector<flatbuffers::Offset<TEN::Save::Item>> *items = nullptr,
int32_t next_item_free = 0,
int32_t next_item_active = 0,
@ -6779,6 +6906,7 @@ inline flatbuffers::Offset<SaveGame> CreateSaveGameDirect(
flatbuffers::Offset<TEN::Save::UnionVec> script_vars = 0,
const std::vector<flatbuffers::Offset<flatbuffers::String>> *callbacks_pre_control = nullptr,
const std::vector<flatbuffers::Offset<flatbuffers::String>> *callbacks_post_control = 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;
auto fxinfos__ = fxinfos ? _fbb.CreateVector<flatbuffers::Offset<TEN::Save::FXInfo>>(*fxinfos) : 0;
@ -6807,6 +6935,7 @@ inline flatbuffers::Offset<SaveGame> CreateSaveGameDirect(
game,
level,
lara,
rooms__,
items__,
next_item_free,
next_item_active,
@ -6847,6 +6976,38 @@ inline flatbuffers::Offset<SaveGame> CreateSaveGameDirect(
flatbuffers::Offset<SaveGame> CreateSaveGame(flatbuffers::FlatBufferBuilder &_fbb, const SaveGameT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline RoomT *Room::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::make_unique<RoomT>();
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void Room::UnPackTo(RoomT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = name(); if (_e) _o->name = _e->str(); }
{ auto _e = flags(); _o->flags = _e; }
{ auto _e = reverb_type(); _o->reverb_type = _e; }
}
inline flatbuffers::Offset<Room> Room::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RoomT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateRoom(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Room> CreateRoom(flatbuffers::FlatBufferBuilder &_fbb, const RoomT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RoomT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _name = _o->name.empty() ? _fbb.CreateSharedString("") : _fbb.CreateString(_o->name);
auto _flags = _o->flags;
auto _reverb_type = _o->reverb_type;
return TEN::Save::CreateRoom(
_fbb,
_name,
_flags,
_reverb_type);
}
inline ItemT *Item::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::make_unique<ItemT>();
UnPackTo(_o.get(), _resolver);
@ -8304,6 +8465,7 @@ inline void Volume::UnPackTo(VolumeT *_o, const flatbuffers::resolver_function_t
(void)_resolver;
{ auto _e = number(); _o->number = _e; }
{ auto _e = room_number(); _o->room_number = _e; }
{ auto _e = name(); if (_e) _o->name = _e->str(); }
{ auto _e = enabled(); _o->enabled = _e; }
{ auto _e = position(); if (_e) _o->position = std::unique_ptr<TEN::Save::Vector3>(new TEN::Save::Vector3(*_e)); }
{ auto _e = rotation(); if (_e) _o->rotation = std::unique_ptr<TEN::Save::Vector4>(new TEN::Save::Vector4(*_e)); }
@ -8321,6 +8483,7 @@ inline flatbuffers::Offset<Volume> CreateVolume(flatbuffers::FlatBufferBuilder &
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const VolumeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _number = _o->number;
auto _room_number = _o->room_number;
auto _name = _o->name.empty() ? _fbb.CreateSharedString("") : _fbb.CreateString(_o->name);
auto _enabled = _o->enabled;
auto _position = _o->position ? _o->position.get() : 0;
auto _rotation = _o->rotation ? _o->rotation.get() : 0;
@ -8330,6 +8493,7 @@ inline flatbuffers::Offset<Volume> CreateVolume(flatbuffers::FlatBufferBuilder &
_fbb,
_number,
_room_number,
_name,
_enabled,
_position,
_rotation,
@ -8652,6 +8816,7 @@ inline void SaveGame::UnPackTo(SaveGameT *_o, const flatbuffers::resolver_functi
{ auto _e = game(); if (_e) _o->game = std::unique_ptr<TEN::Save::SaveGameStatisticsT>(_e->UnPack(_resolver)); }
{ auto _e = level(); if (_e) _o->level = std::unique_ptr<TEN::Save::SaveGameStatisticsT>(_e->UnPack(_resolver)); }
{ auto _e = lara(); if (_e) _o->lara = std::unique_ptr<TEN::Save::LaraT>(_e->UnPack(_resolver)); }
{ auto _e = rooms(); if (_e) { _o->rooms.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->rooms[_i] = std::unique_ptr<TEN::Save::RoomT>(_e->Get(_i)->UnPack(_resolver)); } } }
{ auto _e = items(); if (_e) { _o->items.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->items[_i] = std::unique_ptr<TEN::Save::ItemT>(_e->Get(_i)->UnPack(_resolver)); } } }
{ auto _e = next_item_free(); _o->next_item_free = _e; }
{ auto _e = next_item_active(); _o->next_item_active = _e; }
@ -8702,6 +8867,7 @@ inline flatbuffers::Offset<SaveGame> CreateSaveGame(flatbuffers::FlatBufferBuild
auto _game = _o->game ? CreateSaveGameStatistics(_fbb, _o->game.get(), _rehasher) : 0;
auto _level = _o->level ? CreateSaveGameStatistics(_fbb, _o->level.get(), _rehasher) : 0;
auto _lara = _o->lara ? CreateLara(_fbb, _o->lara.get(), _rehasher) : 0;
auto _rooms = _fbb.CreateVector<flatbuffers::Offset<TEN::Save::Room>> (_o->rooms.size(), [](size_t i, _VectorArgs *__va) { return CreateRoom(*__va->__fbb, __va->__o->rooms[i].get(), __va->__rehasher); }, &_va );
auto _items = _fbb.CreateVector<flatbuffers::Offset<TEN::Save::Item>> (_o->items.size(), [](size_t i, _VectorArgs *__va) { return CreateItem(*__va->__fbb, __va->__o->items[i].get(), __va->__rehasher); }, &_va );
auto _next_item_free = _o->next_item_free;
auto _next_item_active = _o->next_item_active;
@ -8744,6 +8910,7 @@ inline flatbuffers::Offset<SaveGame> CreateSaveGame(flatbuffers::FlatBufferBuild
_game,
_level,
_lara,
_rooms,
_items,
_next_item_free,
_next_item_active,

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

@ -6,6 +6,12 @@ struct RoomVector {
y_location: uint32;
}
table Room {
name: string;
flags: int32;
reverb_type: int32;
}
table Item {
active_state: int32;
anim_number: int32;
@ -375,6 +381,7 @@ table VolumeState {
table Volume {
number: int32;
room_number: int32;
name: string;
enabled: bool;
position: Vector3;
rotation: Vector4;
@ -454,6 +461,7 @@ table SaveGame {
game: SaveGameStatistics;
level: SaveGameStatistics;
lara: Lara;
rooms: [Room];
items: [Item];
next_item_free: int32;
next_item_active: int32;