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

Complete short -> int conversions for Lua

Browse source
This commit is contained in:
Sezz 2025-02-06 01:22:59 +11:00
parent 237ceca0f4
commit 437ce7c139
13 changed files with 146 additions and 149 deletions
Download patch file Download diff file Expand all files Collapse all files

2
TombEngine/Game/control/event.h
View file

@ -8,7 +8,7 @@ namespace TEN::Control::Volumes
{ {
using Activator = std::variant< using Activator = std::variant<
std::nullptr_t, std::nullptr_t,
short, int,
MESH_INFO*, MESH_INFO*,
CAMERA_INFO*>; CAMERA_INFO*>;

13
TombEngine/Game/control/volume.cpp
View file

@ -17,7 +17,7 @@ namespace TEN::Control::Volumes
constexpr auto CAM_SIZE = 32; constexpr auto CAM_SIZE = 32;
constexpr auto EVENT_STATE_MASK = SHRT_MAX; constexpr auto EVENT_STATE_MASK = SHRT_MAX;
bool TestVolumeContainment(const TriggerVolume& volume, const BoundingOrientedBox& box, short roomNumber) bool TestVolumeContainment(const TriggerVolume& volume, const BoundingOrientedBox& box, int roomNumber)
{ {
float color = !volume.StateQueue.empty() ? 1.0f : 0.4f; float color = !volume.StateQueue.empty() ? 1.0f : 0.4f;
@ -129,7 +129,7 @@ namespace TEN::Control::Volumes
return true; return true;
} }
void TestVolumes(short roomNumber, const BoundingOrientedBox& box, ActivatorFlags activatorFlag, Activator activator) void TestVolumes(int roomNumber, const BoundingOrientedBox& box, ActivatorFlags activatorFlag, Activator activator)
{ {
if (g_GameFlow->CurrentFreezeMode != FreezeMode::None) if (g_GameFlow->CurrentFreezeMode != FreezeMode::None)
return; return;
@ -152,7 +152,7 @@ namespace TEN::Control::Volumes
if (!volume.DetectInAdjacentRooms && currentRoomIndex != roomNumber) if (!volume.DetectInAdjacentRooms && currentRoomIndex != roomNumber)
continue; continue;
if (volume.EventSetIndex == NO_EVENT_SET) if (volume.EventSetIndex == NO_VALUE)
continue; continue;
auto& set = g_Level.VolumeEventSets[volume.EventSetIndex]; auto& set = g_Level.VolumeEventSets[volume.EventSetIndex];
@ -233,18 +233,17 @@ namespace TEN::Control::Volumes
TestVolumes(camera->pos.RoomNumber, box, ActivatorFlags::Flyby, camera); TestVolumes(camera->pos.RoomNumber, box, ActivatorFlags::Flyby, camera);
} }
void TestVolumes(short roomNumber, MESH_INFO* mesh) void TestVolumes(int roomNumber, MESH_INFO* mesh)
{ {
auto box = GetBoundsAccurate(*mesh, false).ToBoundingOrientedBox(mesh->pos); auto box = GetBoundsAccurate(*mesh, false).ToBoundingOrientedBox(mesh->pos);
TestVolumes(roomNumber, box, ActivatorFlags::Static, mesh); TestVolumes(roomNumber, box, ActivatorFlags::Static, mesh);
} }
void TestVolumes(short itemNumber, const CollisionSetupData* coll) void TestVolumes(int itemNumber, const CollisionSetupData* coll)
{ {
auto& item = g_Level.Items[itemNumber]; auto& item = g_Level.Items[itemNumber];
auto box = (coll != nullptr) ? auto box = (coll != nullptr) ? ConstructRoughBox(item, *coll) : GameBoundingBox(&item).ToBoundingOrientedBox(item.Pose);
ConstructRoughBox(item, *coll) : GameBoundingBox(&item).ToBoundingOrientedBox(item.Pose);
DrawDebugBox(box, Vector4(1.0f, 1.0f, 0.0f, 1.0f), RendererDebugPage::CollisionStats); DrawDebugBox(box, Vector4(1.0f, 1.0f, 0.0f, 1.0f), RendererDebugPage::CollisionStats);

10
TombEngine/Game/control/volume.h
View file

@ -8,8 +8,6 @@ struct CollisionSetupData;
namespace TEN::Control::Volumes namespace TEN::Control::Volumes
{ {
constexpr auto NO_EVENT_SET = -1;
constexpr auto VOLUME_BUSY_TIMEOUT = 10; constexpr auto VOLUME_BUSY_TIMEOUT = 10;
constexpr auto VOLUME_LEAVE_TIMEOUT = 5; constexpr auto VOLUME_LEAVE_TIMEOUT = 5;
@ -33,14 +31,14 @@ namespace TEN::Control::Volumes
struct VolumeState struct VolumeState
{ {
VolumeStateStatus Status = VolumeStateStatus::Outside; VolumeStateStatus Status = VolumeStateStatus::Outside;
Activator Activator = nullptr; Activator Activator = nullptr;
int Timestamp = 0; int Timestamp = 0;
}; };
void TestVolumes(short roomNumber, const BoundingOrientedBox& box, ActivatorFlags activatorFlag, Activator activator); void TestVolumes(int roomNumber, const BoundingOrientedBox& box, ActivatorFlags activatorFlag, Activator activator);
void TestVolumes(short itemNumber, const CollisionSetupData* coll = nullptr); void TestVolumes(int itemNumber, const CollisionSetupData* coll = nullptr);
void TestVolumes(short roomNumber, MESH_INFO* mesh); void TestVolumes(int roomNumber, MESH_INFO* mesh);
void TestVolumes(CAMERA_INFO* camera); void TestVolumes(CAMERA_INFO* camera);
bool HandleEvent(Event& event, Activator& activator); bool HandleEvent(Event& event, Activator& activator);

10
TombEngine/Game/savegame.cpp
View file

@ -1046,16 +1046,20 @@ const std::vector<byte> SaveGame::Build()
{ {
auto& currVolume = room->TriggerVolumes[j]; auto& currVolume = room->TriggerVolumes[j];
std::vector<flatbuffers::Offset<Save::VolumeState>> queue; auto queue = std::vector<flatbuffers::Offset<Save::VolumeState>>{};
for (int k = 0; k < currVolume.StateQueue.size(); k++) for (int k = 0; k < currVolume.StateQueue.size(); k++)
{ {
auto& entry = currVolume.StateQueue[k]; auto& entry = currVolume.StateQueue[k];
int activator = NO_VALUE; int activator = NO_VALUE;
if (std::holds_alternative<short>(entry.Activator)) if (std::holds_alternative<int>(entry.Activator))
activator = std::get<short>(entry.Activator); {
activator = std::get<int>(entry.Activator);
}
else else
{
continue; continue;
}
Save::VolumeStateBuilder volstate{ fbb }; Save::VolumeStateBuilder volstate{ fbb };
volstate.add_status((int)entry.Status); volstate.add_status((int)entry.Status);

12
TombEngine/Scripting/Include/Objects/ScriptInterfaceObjectsHandler.h
View file

@ -1,6 +1,4 @@
#pragma once #pragma once
#include <functional>
#include <string>
#include "Scripting/Include/VarMapVal.h" #include "Scripting/Include/VarMapVal.h"
#include "Specific/level.h" #include "Specific/level.h"
@ -12,14 +10,14 @@ class ScriptInterfaceObjectsHandler
public: public:
virtual ~ScriptInterfaceObjectsHandler() = default; virtual ~ScriptInterfaceObjectsHandler() = default;
[[nodiscard]] virtual short GetIndexByName(const std::string& name) const = 0; virtual int GetIndexByName(const std::string& name) const = 0;
virtual bool AddName(const std::string& key, VarMapVal val) = 0; virtual bool AddName(const std::string& key, VarMapVal val) = 0;
virtual bool NotifyKilled(ItemInfo*) = 0; virtual bool NotifyKilled(ItemInfo* item) = 0;
virtual void FreeEntities() = 0; virtual void FreeEntities() = 0;
virtual void AssignLara() = 0; virtual void AssignPlayer() = 0;
virtual bool TryAddColliding(short id) = 0; virtual bool TryAddColliding(int id) = 0;
virtual bool TryRemoveColliding(short id, bool force = false) = 0; virtual bool TryRemoveColliding(int id, bool force = false) = 0;
virtual void TestCollidingObjects() = 0; virtual void TestCollidingObjects() = 0;
}; };

1
TombEngine/Scripting/Include/VarMapVal.h
View file

@ -10,7 +10,6 @@ struct ROOM_INFO;
using VarMapVal = std::variant< using VarMapVal = std::variant<
int, int,
short,
std::reference_wrapper<MESH_INFO>, std::reference_wrapper<MESH_INFO>,
std::reference_wrapper<LevelCameraInfo>, std::reference_wrapper<LevelCameraInfo>,
std::reference_wrapper<SinkInfo>, std::reference_wrapper<SinkInfo>,

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

@ -959,9 +959,9 @@ void LogicHandler::ExecuteFunction(const std::string& name, short idOne, short i
void LogicHandler::ExecuteFunction(const std::string& name, TEN::Control::Volumes::Activator activator, const std::string& arguments) void LogicHandler::ExecuteFunction(const std::string& name, TEN::Control::Volumes::Activator activator, const std::string& arguments)
{ {
sol::protected_function func = (*m_handler.GetState())[ScriptReserved_LevelFuncs][name.c_str()]; sol::protected_function func = (*m_handler.GetState())[ScriptReserved_LevelFuncs][name.c_str()];
if (std::holds_alternative<short>(activator)) if (std::holds_alternative<int>(activator))
{ {
func(std::make_unique<Moveable>(std::get<short>(activator), true), arguments); func(std::make_unique<Moveable>(std::get<int>(activator), true), arguments);
} }
else else
{ {

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

@ -26,7 +26,7 @@ using namespace TEN::Effects::Items;
using namespace TEN::Math; using namespace TEN::Math;
/// Represents a moveable object in the game world. /// Represents a moveable object in the game world.
// Examples include traps, enemies, doors, pickups, and the player. See also @{Objects.LaraObject} for player-specific features. // Examples include the player, traps, enemies, doors, and pickups. See also @{Objects.LaraObject} for player-specific features.
// //
// @tenclass Objects.Moveable // @tenclass Objects.Moveable
// pragma nostrip // pragma nostrip
@ -41,14 +41,14 @@ most can just be ignored (see usage).
@function Moveable @function Moveable
@tparam Objects.ObjID object ID @tparam Objects.ObjID object ID
@tparam string name Lua name of the item @tparam string name Lua name.
@tparam Vec3 position position in level @tparam Vec3 position position in level
@tparam Rotation rotation rotation rotation about x, y, and z axes (default Rotation(0, 0, 0)) @tparam Rotation rotation rotation rotation about x, y, and z axes (default Rotation(0, 0, 0))
@tparam int roomNumber the room number the moveable is in (default: calculated automatically). @tparam int roomNumber the room number the moveable is in (default: calculated automatically).
@tparam int animNumber animation number @tparam int animNumber animation number
@tparam int frameNumber frame number @tparam int frameNumber frame number
@tparam int hp HP of item @tparam int hp Hit points.
@tparam int OCB ocb of item @tparam int OCB Object code bits.
@tparam table AIBits table with AI bits (default { 0, 0, 0, 0, 0, 0 }) @tparam table AIBits table with AI bits (default { 0, 0, 0, 0, 0, 0 })
@treturn Moveable A new Moveable object (a wrapper around the new object) @treturn Moveable A new Moveable object (a wrapper around the new object)
@ -58,8 +58,8 @@ most can just be ignored (see usage).
"test", -- name "test", -- name
Vec3(18907, 0, 21201)) -- position Vec3(18907, 0, 21201)) -- position
*/ */
static std::unique_ptr<Moveable> Create(GAME_OBJECT_ID objID, const std::string& name, const Vec3& pos, const TypeOrNil<Rotation>& rot, TypeOrNil<short> room, static std::unique_ptr<Moveable> Create(GAME_OBJECT_ID objID, const std::string& name, const Vec3& pos, const TypeOrNil<Rotation>& rot, TypeOrNil<int> room,
TypeOrNil<int> animNumber, TypeOrNil<int> frameNumber, TypeOrNil<short> hp, TypeOrNil<short> ocb, const TypeOrNil<aiBitsType>& aiBits) TypeOrNil<int> animNumber, TypeOrNil<int> frameNumber, TypeOrNil<int> hp, TypeOrNil<int> ocb, const TypeOrNil<aiBitsType>& aiBits)
{ {
int movID = CreateItem(); int movID = CreateItem();
auto scriptMov = std::make_unique<Moveable>(movID, false); auto scriptMov = std::make_unique<Moveable>(movID, false);
@ -70,10 +70,10 @@ static std::unique_ptr<Moveable> Create(GAME_OBJECT_ID objID, const std::string&
scriptMov->SetObjectID(objID); scriptMov->SetObjectID(objID);
if (std::holds_alternative<short>(room)) if (std::holds_alternative<int>(room))
{ {
scriptMov->SetPosition(pos, false); scriptMov->SetPosition(pos, false);
scriptMov->SetRoomNumber(std::get<short>(room)); scriptMov->SetRoomNumber(std::get<int>(room));
} }
else else
{ {
@ -89,12 +89,12 @@ static std::unique_ptr<Moveable> Create(GAME_OBJECT_ID objID, const std::string&
scriptMov->SetFrameNumber(USE_IF_HAVE(int, frameNumber, 0)); scriptMov->SetFrameNumber(USE_IF_HAVE(int, frameNumber, 0));
} }
if (std::holds_alternative<short>(hp)) if (std::holds_alternative<int>(hp))
{ {
scriptMov->SetHP(std::get<short>(hp)); scriptMov->SetHP(std::get<int>(hp));
} }
scriptMov->SetOcb(USE_IF_HAVE(short, ocb, 0)); scriptMov->SetOcb(USE_IF_HAVE(int, ocb, 0));
scriptMov->SetAIBits(USE_IF_HAVE(aiBitsType, aiBits, aiBitsType{})); scriptMov->SetAIBits(USE_IF_HAVE(aiBitsType, aiBits, aiBitsType{}));
scriptMov->SetColor(ScriptColor(Vector4::One)); scriptMov->SetColor(ScriptColor(Vector4::One));
mov.CarriedItem = NO_VALUE; mov.CarriedItem = NO_VALUE;
@ -115,7 +115,7 @@ void Moveable::Register(sol::state& state, sol::table& parent)
sol::call_constructor, Create, sol::call_constructor, Create,
sol::meta_function::index, IndexError, sol::meta_function::index, IndexError,
sol::meta_function::new_index, NewIndexError, sol::meta_function::new_index, NewIndexError,
sol::meta_function::equal_to, std::equal_to<Moveable const>(), sol::meta_function::equal_to, std::equal_to<const Moveable>(),
ScriptReserved_GetName, &Moveable::GetName, ScriptReserved_GetName, &Moveable::GetName,
ScriptReserved_GetObjectID, &Moveable::GetObjectID, ScriptReserved_GetObjectID, &Moveable::GetObjectID,

102
TombEngine/Scripting/Internal/TEN/Objects/ObjectsHandler.cpp
View file

@ -19,17 +19,15 @@
#include "Scripting/Internal/TEN/Objects/SoundSource/SoundSourceObject.h" #include "Scripting/Internal/TEN/Objects/SoundSource/SoundSourceObject.h"
#include "Scripting/Internal/TEN/Objects/Volume/VolumeObject.h" #include "Scripting/Internal/TEN/Objects/Volume/VolumeObject.h"
/*** /// Objects including moveables, statics, cameras, and others.
Moveables, statics, cameras, and so on. // @tentable Objects
@tentable Objects // @pragma nostrip
@pragma nostrip
*/
ObjectsHandler::ObjectsHandler(sol::state* lua, sol::table& parent) : ObjectsHandler::ObjectsHandler(sol::state* lua, sol::table& parent) :
m_handler(lua), _handler(lua),
m_table_objects(sol::table(m_handler.GetState()->lua_state(), sol::create)) _table_objects(sol::table(_handler.GetState()->lua_state(), sol::create))
{ {
parent.set(ScriptReserved_Objects, m_table_objects); parent.set(ScriptReserved_Objects, _table_objects);
/*** /***
Get a moveable by its name. Get a moveable by its name.
@ -37,7 +35,7 @@ ObjectsHandler::ObjectsHandler(sol::state* lua, sol::table& parent) :
@tparam string name the unique name of the Moveable as set in, or generated by, Tomb Editor @tparam string name the unique name of the Moveable as set in, or generated by, Tomb Editor
@treturn Moveable a non-owning Moveable referencing the item. @treturn Moveable a non-owning Moveable referencing the item.
*/ */
m_table_objects.set_function(ScriptReserved_GetMoveableByName, &ObjectsHandler::GetByName<Moveable, ScriptReserved_Moveable>, this); _table_objects.set_function(ScriptReserved_GetMoveableByName, &ObjectsHandler::GetByName<Moveable, ScriptReserved_Moveable>, this);
/*** /***
Get a Static by its name. Get a Static by its name.
@ -45,7 +43,7 @@ ObjectsHandler::ObjectsHandler(sol::state* lua, sol::table& parent) :
@tparam string name the unique name of the mesh as set in, or generated by, Tomb Editor @tparam string name the unique name of the mesh as set in, or generated by, Tomb Editor
@treturn Static a non-owning Static referencing the mesh. @treturn Static a non-owning Static referencing the mesh.
*/ */
m_table_objects.set_function(ScriptReserved_GetStaticByName, &ObjectsHandler::GetByName<Static, ScriptReserved_Static>, this); _table_objects.set_function(ScriptReserved_GetStaticByName, &ObjectsHandler::GetByName<Static, ScriptReserved_Static>, this);
/*** /***
Get moveables by its slot. Get moveables by its slot.
@ -53,7 +51,7 @@ ObjectsHandler::ObjectsHandler(sol::state* lua, sol::table& parent) :
@tparam Objects.ObjID slot the unique slot of the Moveable, e.g. `Objects.ObjID.ANIMATING1` @tparam Objects.ObjID slot the unique slot of the Moveable, e.g. `Objects.ObjID.ANIMATING1`
@treturn table table of Moveables referencing the given slot. @treturn table table of Moveables referencing the given slot.
*/ */
m_table_objects.set_function(ScriptReserved_GetMoveablesBySlot, &ObjectsHandler::GetMoveablesBySlot<Moveable>, this); _table_objects.set_function(ScriptReserved_GetMoveablesBySlot, &ObjectsHandler::GetMoveablesBySlot<Moveable>, this);
/*** /***
Get statics by its slot. Get statics by its slot.
@ -61,7 +59,7 @@ ObjectsHandler::ObjectsHandler(sol::state* lua, sol::table& parent) :
@tparam int slot the unique slot of the mesh like 10 @tparam int slot the unique slot of the mesh like 10
@treturn table table of Statics referencing the given slot ID. @treturn table table of Statics referencing the given slot ID.
*/ */
m_table_objects.set_function(ScriptReserved_GetStaticsBySlot, &ObjectsHandler::GetStaticsBySlot<Static>, this); _table_objects.set_function(ScriptReserved_GetStaticsBySlot, &ObjectsHandler::GetStaticsBySlot<Static>, this);
/*** /***
Get rooms by tag. Get rooms by tag.
@ -69,7 +67,7 @@ ObjectsHandler::ObjectsHandler(sol::state* lua, sol::table& parent) :
@tparam string tag to select rooms by @tparam string tag to select rooms by
@treturn table table of Rooms containing the given tag. @treturn table table of Rooms containing the given tag.
*/ */
m_table_objects.set_function(ScriptReserved_GetRoomsByTag, &ObjectsHandler::GetRoomsByTag<Room>, this); _table_objects.set_function(ScriptReserved_GetRoomsByTag, &ObjectsHandler::GetRoomsByTag<Room>, this);
/*** /***
Get a Camera by its name. Get a Camera by its name.
@ -77,7 +75,7 @@ ObjectsHandler::ObjectsHandler(sol::state* lua, sol::table& parent) :
@tparam string name the unique name of the camera as set in, or generated by, Tomb Editor @tparam string name the unique name of the camera as set in, or generated by, Tomb Editor
@treturn Camera a non-owning Camera referencing the camera. @treturn Camera a non-owning Camera referencing the camera.
*/ */
m_table_objects.set_function(ScriptReserved_GetCameraByName, &ObjectsHandler::GetByName<CameraObject, ScriptReserved_Camera>, this); _table_objects.set_function(ScriptReserved_GetCameraByName, &ObjectsHandler::GetByName<CameraObject, ScriptReserved_Camera>, this);
/*** /***
Get a Sink by its name. Get a Sink by its name.
@ -85,7 +83,7 @@ ObjectsHandler::ObjectsHandler(sol::state* lua, sol::table& parent) :
@tparam string name the unique name of the sink as set in, or generated by, Tomb Editor @tparam string name the unique name of the sink as set in, or generated by, Tomb Editor
@treturn Sink a non-owning Sink referencing the sink. @treturn Sink a non-owning Sink referencing the sink.
*/ */
m_table_objects.set_function(ScriptReserved_GetSinkByName, &ObjectsHandler::GetByName<Sink, ScriptReserved_Sink>, this); _table_objects.set_function(ScriptReserved_GetSinkByName, &ObjectsHandler::GetByName<Sink, ScriptReserved_Sink>, this);
/*** /***
Get a SoundSource by its name. Get a SoundSource by its name.
@ -93,7 +91,7 @@ ObjectsHandler::ObjectsHandler(sol::state* lua, sol::table& parent) :
@tparam string name the unique name of the sound source as set in, or generated by, Tomb Editor @tparam string name the unique name of the sound source as set in, or generated by, Tomb Editor
@treturn SoundSource a non-owning SoundSource referencing the sound source. @treturn SoundSource a non-owning SoundSource referencing the sound source.
*/ */
m_table_objects.set_function(ScriptReserved_GetSoundSourceByName, &ObjectsHandler::GetByName<SoundSource, ScriptReserved_SoundSource>, this); _table_objects.set_function(ScriptReserved_GetSoundSourceByName, &ObjectsHandler::GetByName<SoundSource, ScriptReserved_SoundSource>, this);
/*** /***
Get an AIObject by its name. Get an AIObject by its name.
@ -101,7 +99,7 @@ ObjectsHandler::ObjectsHandler(sol::state* lua, sol::table& parent) :
@tparam string name the unique name of the AIObject as set in, or generated by, Tomb Editor @tparam string name the unique name of the AIObject as set in, or generated by, Tomb Editor
@treturn AIObject a non-owning SoundSource referencing the AI moveable. @treturn AIObject a non-owning SoundSource referencing the AI moveable.
*/ */
m_table_objects.set_function(ScriptReserved_GetAIObjectByName, &ObjectsHandler::GetByName<AIObject, ScriptReserved_AIObject>, this); _table_objects.set_function(ScriptReserved_GetAIObjectByName, &ObjectsHandler::GetByName<AIObject, ScriptReserved_AIObject>, this);
/*** /***
Get a Volume by its name. Get a Volume by its name.
@ -109,7 +107,7 @@ ObjectsHandler::ObjectsHandler(sol::state* lua, sol::table& parent) :
@tparam string name the unique name of the volume as set in, or generated by, Tomb Editor @tparam string name the unique name of the volume as set in, or generated by, Tomb Editor
@treturn Volume a non-owning Volume referencing the room. @treturn Volume a non-owning Volume referencing the room.
*/ */
m_table_objects.set_function(ScriptReserved_GetVolumeByName, &ObjectsHandler::GetByName<Volume, ScriptReserved_Volume>, this); _table_objects.set_function(ScriptReserved_GetVolumeByName, &ObjectsHandler::GetByName<Volume, ScriptReserved_Volume>, this);
/*** /***
Get a Room by its name. Get a Room by its name.
@ -117,68 +115,68 @@ ObjectsHandler::ObjectsHandler(sol::state* lua, sol::table& parent) :
@tparam string name the unique name of the room as set in Tomb Editor @tparam string name the unique name of the room as set in Tomb Editor
@treturn Room a non-owning Room referencing the room. @treturn Room a non-owning Room referencing the room.
*/ */
m_table_objects.set_function(ScriptReserved_GetRoomByName, &ObjectsHandler::GetByName<Room, ScriptReserved_Room>, this); _table_objects.set_function(ScriptReserved_GetRoomByName, &ObjectsHandler::GetByName<Room, ScriptReserved_Room>, this);
LaraObject::Register(m_table_objects); LaraObject::Register(_table_objects);
Moveable::Register(*lua, m_table_objects); Moveable::Register(*lua, _table_objects);
Moveable::SetNameCallbacks( Moveable::SetNameCallbacks(
[this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); }, [this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); },
[this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); }); [this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); });
Static::Register(m_table_objects); Static::Register(_table_objects);
Static::SetNameCallbacks( Static::SetNameCallbacks(
[this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); }, [this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); },
[this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); }); [this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); });
CameraObject::Register(m_table_objects); CameraObject::Register(_table_objects);
CameraObject::SetNameCallbacks( CameraObject::SetNameCallbacks(
[this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); }, [this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); },
[this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); }); [this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); });
Sink::Register(m_table_objects); Sink::Register(_table_objects);
Sink::SetNameCallbacks( Sink::SetNameCallbacks(
[this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); }, [this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); },
[this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); }); [this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); });
AIObject::Register(m_table_objects); AIObject::Register(_table_objects);
AIObject::SetNameCallbacks( AIObject::SetNameCallbacks(
[this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); }, [this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); },
[this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); } ); [this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); } );
SoundSource::Register(m_table_objects); SoundSource::Register(_table_objects);
SoundSource::SetNameCallbacks( SoundSource::SetNameCallbacks(
[this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); }, [this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); },
[this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); }); [this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); });
Room::Register(m_table_objects); Room::Register(_table_objects);
Room::SetNameCallbacks( Room::SetNameCallbacks(
[this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); }, [this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); },
[this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); } [this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); }
); );
Volume::Register(m_table_objects); Volume::Register(_table_objects);
Volume::SetNameCallbacks( Volume::SetNameCallbacks(
[this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); }, [this](auto && ... param) { return AddName(std::forward<decltype(param)>(param)...); },
[this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); }); [this](auto && ... param) { return RemoveName(std::forward<decltype(param)>(param)...); });
m_handler.MakeReadOnlyTable(m_table_objects, ScriptReserved_ObjID, kObjIDs); _handler.MakeReadOnlyTable(_table_objects, ScriptReserved_ObjID, kObjIDs);
m_handler.MakeReadOnlyTable(m_table_objects, ScriptReserved_RoomFlagID, ROOM_FLAG_IDS); _handler.MakeReadOnlyTable(_table_objects, ScriptReserved_RoomFlagID, ROOM_FLAG_IDS);
m_handler.MakeReadOnlyTable(m_table_objects, ScriptReserved_RoomReverb, ROOM_REVERB_TYPES); _handler.MakeReadOnlyTable(_table_objects, ScriptReserved_RoomReverb, ROOM_REVERB_TYPES);
m_handler.MakeReadOnlyTable(m_table_objects, ScriptReserved_WeaponType, WEAPON_TYPES); _handler.MakeReadOnlyTable(_table_objects, ScriptReserved_WeaponType, WEAPON_TYPES);
m_handler.MakeReadOnlyTable(m_table_objects, ScriptReserved_AmmoType, AMMO_TYPES); _handler.MakeReadOnlyTable(_table_objects, ScriptReserved_AmmoType, AMMO_TYPES);
m_handler.MakeReadOnlyTable(m_table_objects, ScriptReserved_HandStatus, HandStatusMap); _handler.MakeReadOnlyTable(_table_objects, ScriptReserved_HandStatus, HandStatusMap);
m_handler.MakeReadOnlyTable(m_table_objects, ScriptReserved_MoveableStatus, MOVEABLE_STATUSES); _handler.MakeReadOnlyTable(_table_objects, ScriptReserved_MoveableStatus, MOVEABLE_STATUSES);
} }
void ObjectsHandler::TestCollidingObjects() void ObjectsHandler::TestCollidingObjects()
{ {
// Remove items which can't collide. // Remove items which can't collide.
for (int itemNumber : m_collidingItemsToRemove) for (int itemNumber : _collidingItemsToRemove)
m_collidingItems.erase(itemNumber); _collidingItems.erase(itemNumber);
m_collidingItemsToRemove.clear(); _collidingItemsToRemove.clear();
for (int itemNumber0 : m_collidingItems) for (int itemNumber0 : _collidingItems)
{ {
auto& item = g_Level.Items[itemNumber0]; auto& item = g_Level.Items[itemNumber0];
if (!item.Callbacks.OnObjectCollided.empty()) if (!item.Callbacks.OnObjectCollided.empty())
@ -198,17 +196,17 @@ void ObjectsHandler::TestCollidingObjects()
} }
} }
void ObjectsHandler::AssignLara() void ObjectsHandler::AssignPlayer()
{ {
m_table_objects.set(ScriptReserved_Lara, LaraObject(LaraItem->Index, true)); _table_objects.set(ScriptReserved_Lara, LaraObject(LaraItem->Index, true));
} }
bool ObjectsHandler::NotifyKilled(ItemInfo* key) bool ObjectsHandler::NotifyKilled(ItemInfo* key)
{ {
auto it = moveables.find(key); auto it = _moveables.find(key);
if (it != std::end(moveables)) if (it != std::end(_moveables))
{ {
for (auto* movPtr : moveables[key]) for (auto* movPtr : _moveables[key])
movPtr->Invalidate(); movPtr->Invalidate();
return true; return true;
@ -221,28 +219,28 @@ bool ObjectsHandler::AddMoveableToMap(ItemInfo* key, Moveable* mov)
{ {
std::unordered_set<Moveable*> movVec; std::unordered_set<Moveable*> movVec;
movVec.insert(mov); movVec.insert(mov);
auto it = moveables.find(key); auto it = _moveables.find(key);
if (std::end(moveables) == it) if (std::end(_moveables) == it)
{ {
return moveables.insert(std::pair{ key, movVec }).second; return _moveables.insert(std::pair{ key, movVec }).second;
} }
else else
{ {
moveables[key].insert(mov); _moveables[key].insert(mov);
return true; return true;
} }
} }
bool ObjectsHandler::RemoveMoveableFromMap(ItemInfo* key, Moveable* mov) bool ObjectsHandler::RemoveMoveableFromMap(ItemInfo* key, Moveable* mov)
{ {
auto it = moveables.find(key); auto it = _moveables.find(key);
if (std::end(moveables) != it) if (std::end(_moveables) != it)
{ {
auto& set = moveables[key]; auto& set = _moveables[key];
bool isErased = static_cast<bool>(set.erase(mov)); bool isErased = static_cast<bool>(set.erase(mov));
if (isErased && set.empty()) if (isErased && set.empty())
isErased = isErased && static_cast<bool>(moveables.erase(key)); isErased = isErased && static_cast<bool>(_moveables.erase(key));
return isErased; return isErased;
} }

108
TombEngine/Scripting/Internal/TEN/Objects/ObjectsHandler.h
View file

@ -17,83 +17,86 @@ public:
bool AddMoveableToMap(ItemInfo* key, Moveable* mov); bool AddMoveableToMap(ItemInfo* key, Moveable* mov);
bool RemoveMoveableFromMap(ItemInfo* key, Moveable* mov); bool RemoveMoveableFromMap(ItemInfo* key, Moveable* mov);
bool TryAddColliding(short id) override bool TryAddColliding(int id) override
{ {
ItemInfo* item = &g_Level.Items[id]; const auto& item = g_Level.Items[id];
bool hasName = !(item->Callbacks.OnObjectCollided.empty() && item->Callbacks.OnRoomCollided.empty());
if (hasName && item->Collidable && (item->Status != ITEM_INVISIBLE)) bool hasName = !(item.Callbacks.OnObjectCollided.empty() && item.Callbacks.OnRoomCollided.empty());
return m_collidingItems.insert(id).second; if (hasName && item.Collidable && item.Status != ITEM_INVISIBLE)
return _collidingItems.insert(id).second;
return false; return false;
} }
bool TryRemoveColliding(short id, bool force = false) override bool TryRemoveColliding(int id, bool force = false) override
{ {
ItemInfo* item = &g_Level.Items[id]; const auto& item = g_Level.Items[id];
bool hasName = !(item->Callbacks.OnObjectCollided.empty() && item->Callbacks.OnRoomCollided.empty());
if(!force && hasName && item->Collidable && (item->Status != ITEM_INVISIBLE)) bool hasName = !(item.Callbacks.OnObjectCollided.empty() && item.Callbacks.OnRoomCollided.empty());
if (!force && hasName && item.Collidable && item.Status != ITEM_INVISIBLE)
return false; return false;
return m_collidingItemsToRemove.insert(id).second; return _collidingItemsToRemove.insert(id).second;
} }
void TestCollidingObjects() override; void TestCollidingObjects() override;
private: private:
LuaHandler m_handler; LuaHandler _handler;
// A map between moveables and the engine entities they represent. This is needed
// so that something that is killed by the engine can notify all corresponding
// Lua variables which can then become invalid.
std::unordered_map<ItemInfo *, std::unordered_set<Moveable*>> moveables{};
std::unordered_map<std::string, VarMapVal> m_nameMap{};
std::unordered_map<std::string, short> m_itemsMapName{};
// A set of items that are visible, collidable, and have Lua OnCollide callbacks.
std::unordered_set<short> m_collidingItems{};
std::unordered_set<short> m_collidingItemsToRemove{};
sol::table m_table_objects;
// Map between Lua moveables and engine moveables. Needed so that when something is killed,
// TEN can notify all corresponding Lua variables to become invalid.
void AssignLara() override; std::unordered_map<ItemInfo*, std::unordered_set<Moveable*>> _moveables = {};
std::unordered_map<std::string, VarMapVal> _nameMap = {};
std::unordered_map<std::string, int> _itemsMapName = {};
template <typename R, char const* S> // Map of moveables that are visible, collidable, and have Lua OnCollide callbacks.
std::unordered_set<int> _collidingItems = {};
std::unordered_set<int> _collidingItemsToRemove = {};
sol::table _table_objects = {};
void AssignPlayer() override;
template <typename R, const char* S>
std::unique_ptr<R> GetByName(const std::string& name) std::unique_ptr<R> GetByName(const std::string& name)
{ {
if (!ScriptAssertF(m_nameMap.find(name) != m_nameMap.end(), "{} name not found: {}", S, name)) if (!ScriptAssertF(_nameMap.find(name) != _nameMap.end(), "{} name not found: {}", S, name))
return nullptr; return nullptr;
else
return std::make_unique<R>(std::get<R::IdentifierType>(m_nameMap.at(name))); return std::make_unique<R>(std::get<R::IdentifierType>(_nameMap.at(name)));
} }
template <typename R> template <typename R>
std::vector <std::unique_ptr<R>> GetMoveablesBySlot(GAME_OBJECT_ID objID) std::vector <std::unique_ptr<R>> GetMoveablesBySlot(GAME_OBJECT_ID objectID)
{ {
std::vector<std::unique_ptr<R>> items = {}; auto movs = std::vector<std::unique_ptr<R>>{};
for (auto& [key, val] : m_nameMap) for (const auto& [key, val] : _nameMap)
{ {
if (!std::holds_alternative<short>(val)) if (!std::holds_alternative<int>(val))
continue; continue;
auto& item = g_Level.Items[GetIndexByName(key)]; const auto& item = g_Level.Items[GetIndexByName(key)];
if (objectID == item.ObjectNumber)
if (objID == item.ObjectNumber) movs.push_back(GetByName<Moveable, ScriptReserved_Moveable>(key));
items.push_back(GetByName<Moveable, ScriptReserved_Moveable>(key));
} }
return items; return movs;
} }
template <typename R> template <typename R>
std::vector <std::unique_ptr<R>> GetStaticsBySlot(int slot) std::vector <std::unique_ptr<R>> GetStaticsBySlot(int slot)
{ {
std::vector<std::unique_ptr<R>> items = {}; auto items = std::vector<std::unique_ptr<R>>{};
for (auto& [key, val] : m_nameMap) for (const auto& [key, value] : _nameMap)
{ {
if (!std::holds_alternative<std::reference_wrapper<MESH_INFO>>(val)) if (!std::holds_alternative<std::reference_wrapper<MESH_INFO>>(value))
continue; continue;
auto meshInfo = std::get<std::reference_wrapper<MESH_INFO>>(val).get(); auto staticObj = std::get<std::reference_wrapper<MESH_INFO>>(value).get();
if (meshInfo.staticNumber == slot) if (staticObj.staticNumber == slot)
items.push_back(GetByName<Static, ScriptReserved_Static>(key)); items.push_back(GetByName<Static, ScriptReserved_Static>(key));
} }
@ -103,16 +106,15 @@ private:
template <typename R> template <typename R>
std::vector <std::unique_ptr<R>> GetRoomsByTag(std::string tag) std::vector <std::unique_ptr<R>> GetRoomsByTag(std::string tag)
{ {
std::vector<std::unique_ptr<R>> rooms = {}; auto rooms = std::vector<std::unique_ptr<R>>{};
for (auto& [key, val] : m_nameMap) for (const auto& [key, value] : _nameMap)
{ {
if (!std::holds_alternative<std::reference_wrapper<ROOM_INFO>>(val)) if (!std::holds_alternative<std::reference_wrapper<ROOM_INFO>>(value))
continue; continue;
auto room = std::get<std::reference_wrapper<ROOM_INFO>>(val).get(); auto room = std::get<std::reference_wrapper<ROOM_INFO>>(value).get();
if (std::any_of(room.Tags.begin(), room.Tags.end(), if (std::any_of(room.Tags.begin(), room.Tags.end(), [&tag](const std::string& value) { return value == tag; }))
[&tag](const std::string& value) { return value == tag; }))
{ {
rooms.push_back(GetByName<Room, ScriptReserved_Room>(key)); rooms.push_back(GetByName<Room, ScriptReserved_Room>(key));
} }
@ -121,9 +123,9 @@ private:
return rooms; return rooms;
} }
[[nodiscard]] short GetIndexByName(std::string const& name) const override int GetIndexByName(std::string const& name) const override
{ {
return std::get<short>(m_nameMap.at(name)); return std::get<int>(_nameMap.at(name));
} }
bool AddName(const std::string& key, VarMapVal val) override bool AddName(const std::string& key, VarMapVal val) override
@ -132,18 +134,18 @@ private:
return false; return false;
auto p = std::pair<const std::string&, VarMapVal>(key, val); auto p = std::pair<const std::string&, VarMapVal>(key, val);
return m_nameMap.insert(p).second; return _nameMap.insert(p).second;
} }
bool RemoveName(const std::string& key) bool RemoveName(const std::string& key)
{ {
return m_nameMap.erase(key); return _nameMap.erase(key);
} }
void FreeEntities() override void FreeEntities() override
{ {
m_nameMap.clear(); _nameMap.clear();
m_collidingItemsToRemove.clear(); _collidingItemsToRemove.clear();
m_collidingItems.clear(); _collidingItems.clear();
} }
}; };

2
TombEngine/Scripting/Internal/TEN/Objects/Static/StaticObject.h
View file

@ -44,5 +44,5 @@ public:
void Shatter(); void Shatter();
private: private:
MESH_INFO & m_mesh; MESH_INFO& m_mesh;
}; };

5
TombEngine/Scripting/Internal/TEN/Objects/Volume/VolumeObject.cpp
View file

@ -145,10 +145,9 @@ bool Volume::IsMoveableInside(const Moveable& mov)
{ {
for (const auto& entry : _volume.StateQueue) for (const auto& entry : _volume.StateQueue)
{ {
// TODO: Use int, not short. if (std::holds_alternative<int>(entry.Activator))
if (std::holds_alternative<short>(entry.Activator))
{ {
int id = std::get<short>(entry.Activator); int id = std::get<int>(entry.Activator);
auto& mov2 = std::make_unique<Moveable>(id); auto& mov2 = std::make_unique<Moveable>(id);
if (mov2.get()->GetName() == mov.GetName()) if (mov2.get()->GetName() == mov.GetName())

2
TombEngine/Specific/level.cpp
View file

@ -1393,7 +1393,7 @@ bool LoadLevel(const std::string& path, bool partial)
InitializeNeighborRoomList(); InitializeNeighborRoomList();
GetCarriedItems(); GetCarriedItems();
GetAIPickups(); GetAIPickups();
g_GameScriptEntities->AssignLara(); g_GameScriptEntities->AssignPlayer();
UpdateProgress(90, partial); UpdateProgress(90, partial);
if (!partial) if (!partial)