Add room properties to savegame, fixes

TombEngine/Game/control/volumeactivator.h

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

TombEngine/Game/debug/debug.cpp

@@ -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");
 }
 

TombEngine/Game/savegame.cpp

@@ -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++)
 	{

TombEngine/Scripting/Internal/TEN/Objects/Moveable/MoveableObject.cpp

@@ -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);

TombEngine/Specific/level.cpp

@@ -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;

TombEngine/Specific/savegame/flatbuffers/ten_savegame_generated.h

@@ -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_NAME = 8,
-    VT_POSITION = 10,
+    VT_ENABLED = 10,
-    VT_ROTATION = 12,
+    VT_POSITION = 12,
-    VT_SCALE = 14,
+    VT_ROTATION = 14,
-    VT_QUEUE = 16
+    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_ROOMS = 12,
-    VT_NEXT_ITEM_FREE = 14,
+    VT_ITEMS = 14,
-    VT_NEXT_ITEM_ACTIVE = 16,
+    VT_NEXT_ITEM_FREE = 16,
-    VT_ROOM_ITEMS = 18,
+    VT_NEXT_ITEM_ACTIVE = 18,
-    VT_FXINFOS = 20,
+    VT_ROOM_ITEMS = 20,
-    VT_NEXT_FX_FREE = 22,
+    VT_FXINFOS = 22,
-    VT_NEXT_FX_ACTIVE = 24,
+    VT_NEXT_FX_FREE = 24,
-    VT_FIXED_CAMERAS = 26,
+    VT_NEXT_FX_ACTIVE = 26,
-    VT_SINKS = 28,
+    VT_FIXED_CAMERAS = 28,
-    VT_STATIC_MESHES = 30,
+    VT_SINKS = 30,
-    VT_FLYBY_CAMERAS = 32,
+    VT_STATIC_MESHES = 32,
-    VT_PARTICLES = 34,
+    VT_FLYBY_CAMERAS = 34,
-    VT_RATS = 36,
+    VT_PARTICLES = 36,
-    VT_SPIDERS = 38,
+    VT_RATS = 38,
-    VT_SCARABS = 40,
+    VT_SPIDERS = 40,
-    VT_BATS = 42,
+    VT_SCARABS = 42,
-    VT_FLIP_MAPS = 44,
+    VT_BATS = 44,
-    VT_FLIP_STATS = 46,
+    VT_FLIP_MAPS = 46,
-    VT_FLIP_EFFECT = 48,
+    VT_FLIP_STATS = 48,
-    VT_FLIP_TIMER = 50,
+    VT_FLIP_EFFECT = 50,
-    VT_FLIP_STATUS = 52,
+    VT_FLIP_TIMER = 52,
-    VT_CURRENT_FOV = 54,
+    VT_FLIP_STATUS = 54,
-    VT_ACTION_QUEUE = 56,
+    VT_CURRENT_FOV = 56,
-    VT_AMBIENT_TRACK = 58,
+    VT_ACTION_QUEUE = 58,
-    VT_AMBIENT_POSITION = 60,
+    VT_AMBIENT_TRACK = 60,
-    VT_ONESHOT_TRACK = 62,
+    VT_AMBIENT_POSITION = 62,
-    VT_ONESHOT_POSITION = 64,
+    VT_ONESHOT_TRACK = 64,
-    VT_CD_FLAGS = 66,
+    VT_ONESHOT_POSITION = 66,
-    VT_ROPE = 68,
+    VT_CD_FLAGS = 68,
-    VT_PENDULUM = 70,
+    VT_ROPE = 70,
-    VT_ALTERNATE_PENDULUM = 72,
+    VT_PENDULUM = 72,
-    VT_VOLUMES = 74,
+    VT_ALTERNATE_PENDULUM = 74,
-    VT_CALL_COUNTERS = 76,
+    VT_VOLUMES = 76,
-    VT_SCRIPT_VARS = 78,
+    VT_CALL_COUNTERS = 78,
-    VT_CALLBACKS_PRE_CONTROL = 80,
+    VT_SCRIPT_VARS = 80,
-    VT_CALLBACKS_POST_CONTROL = 82
+    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,

TombEngine/Specific/savegame/schema/ten_savegame.fbs

@@ -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;